Schriftgrößen im TExtmodus [ERLEDIGT]

[Manfred]

Hallo,

ich bin gerade dabei eine CLipperanwendung auf Xbase zu portieren, bzw. zum Teil neu zu programmieren. Aus bedienerfreundlichen Gründen soll die Programmoberfläche zunächst weiter im Textmodus bleiben.
Jetzt ist es natürlich prima, das man unter Xbase++ im Textmodus wesentlich mehr des Bildschirms ausnutzen kann. Allerdings stehe ich im Moment auf dem Schlauch, wenn es darum geht die Schriften etwas zu vergrößern, weil bei einer Auflösung von Ca 1000x700 stehen mir zwar 43 Zeilen und 125 Spalten zur Verfügung, aber der Text erscheint ein wenig klein.
Habe ich eigentlich ohne viel Aufwand die Möglichkeit die Schriftgröße zu verändern, sodaß sie größer wird? Meine ersten Versuche in die Richtung erzeugten nur für unförmige Bildschirmverteilungen.

Hat irgendjemand eine Idee, oder evtl. sich damit schon näher beschäftigt?

Danke im voraus

Gruß

Manfred

[andreas]

Hallo Manfred,

ich musste auch vor ein paar Jahren eine Anwendung umstellen, die aber im Textmodus bleiben sollte. Damals habe ich irgendwo Code gefunden, der mir weiter geholfen hat. Hier ist von mir an verschiedene Auflösungen noch angepasster Code:

Code: Alles auswählen

PROCEDURE AppSys()

	#define DEF_ROWS       25
	#define DEF_COLS       80
	//#define DEF_FONTHEIGHT 28        // 28 für Aufl. 1024    20 für Aufl. 800     16 für Aufl. 640
	//#define DEF_FONTWIDTH  12         // 12 für Aufl. 1024     9 für Aufl. 800      8 für Aufl. 640
	#define DEF_FONTH640 16                      // 16 für Aufl. 640
	#define DEF_FONTW640  8                      // 8 für Aufl. 640
	#define DEF_FONTH800 20                      // 20 für Aufl. 800
	#define DEF_FONTW800  9                      //  9 für Aufl. 800
	#define DEF_FONTH1024 28                     // 28 für Aufl. 1024
	#define DEF_FONTW1024 12                     // 12 für Aufl. 1024
	#define DEF_FONTH1152 29                     // 30 für Aufl. 1152x864
	#define DEF_FONTW1152 13                     // 14 für Aufl. 1152x864
	#define DEF_FONTH1280 31                     // 31 für Aufl. 1280x1024
	#define DEF_FONTW1280 15                     // 15 für Aufl. 1280x1024

	LOCAL oCrt, nAppType := AppType()
	LOCAL aSizeDesktop, aPos

	DO CASE

		// Anwendung wurde im PM Modus gelinkt, eine XbpCrt Instanz
		// ist zu erzeugen.
	CASE nAppType == APPTYPE_PM

		// Bestimmen der Fensterposition (Anordnen in der Mitte
		// des Desktop-Fensters)
		aSizeDesktop    := AppDesktop():currentSize()
			/*
						 	aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTWIDTH))  /2, ;
				                           (aSizeDesktop[2]-(DEF_ROWS * DEF_FONTHEIGHT)) /2  }
			*/
		// Bildschirmauflösung überprüfen und Fenstergrösse einstellen
		do case
		case aSizeDesktop[1] == 640               // Aufl. 640
			aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTW640))  /2, ;
				(aSizeDesktop[2]-(DEF_ROWS * DEF_FONTH640)) /2  }
			// XbpCRT-Fenster erzeugen
			oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			oCrt:FontWidth  := DEF_FONTW640
			oCrt:FontHeight := DEF_FONTH640
			oCrt:title      := "Lagerverwaltung" //AppName()

		case aSizeDesktop[1] == 800               // Aufl. 800
			aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTW800))  /2, ;
				(aSizeDesktop[2]-(DEF_ROWS * DEF_FONTH800)) /2  }
			// XbpCRT-Fenster erzeugen
			oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			oCrt:FontWidth  := DEF_FONTW800
			oCrt:FontHeight := DEF_FONTH800
			oCrt:title      := "Lagerverwaltung" //AppName()

		case aSizeDesktop[1] == 1152              // Aufl. 1152
			aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTW1152))  /2, ;
				(aSizeDesktop[2]-(DEF_ROWS * DEF_FONTH1152)) /2  }
			// XbpCRT-Fenster erzeugen
			oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			oCrt:FontWidth  := DEF_FONTW1152
			oCrt:FontHeight := DEF_FONTH1152
			oCrt:title      := "Lagerverwaltung" //AppName()

		case aSizeDesktop[1] == 1280              // Aufl. 1280
			aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTW1280))  /2, ;
				(aSizeDesktop[2]-(DEF_ROWS * DEF_FONTH1280)) /2  }
			// XbpCRT-Fenster erzeugen
			oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			oCrt:FontWidth  := DEF_FONTW1280
			oCrt:FontHeight := DEF_FONTH1280
			oCrt:title      := "Lagerverwaltung" //AppName()

		otherwise                                 // Aufl. 1024
			aPos            := { (aSizeDesktop[1]-(DEF_COLS * DEF_FONTW1024))  /2, ;
				(aSizeDesktop[2]-(DEF_ROWS * DEF_FONTH1024)) /2  }
			// XbpCRT-Fenster erzeugen
			oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			oCrt:FontWidth  := DEF_FONTW1024
			oCrt:FontHeight := DEF_FONTH1024
			oCrt:title      := "Lagerverwaltung" //AppName()

		endcase
			/*
			      // XbpCRT-Fenster erzeugen
			      oCrt := XbpCrt():New ( NIL, NIL, aPos, DEF_ROWS, DEF_COLS )
			      oCrt:FontWidth  := DEF_FONTWIDTH
			      oCrt:FontHeight := DEF_FONTHEIGHT
			      oCrt:title      := AppName()
			 */
			/*#ifdef __OS2__
			      oCrt:FontName   := "System VIO"
			#endif
			 */
		#ifdef __WIN32__
		oCrt:FontName   := "Lucida Console"
		oCrt:icon:=110
		//oCrt:FontName   := "Alaska Crt"
		#endif
		oCrt:close := {|| AppQuit() }
		oCrt:Create()

		// Presentation Space initialisieren
		oCrt:PresSpace()

		// XbpCrt wird aktives Fenster und Ausgabeger„t
		SetAppWindow ( oCrt )

		// Anwendung wurde im VIO oder NOVIO Modus gelinkt, eine RootCrt
		// Instanz ist zu erzeugen.
	CASE nAppType == APPTYPE_VIO .OR. nAppType == APPTYPE_NOVIO

		// RootCrt Instanz erzeugen.
		//
		// Die IVar :CreateBuffer bestimmt wie sich das RootCrt verhaelt
		// wenn es in einem Shell Fenster erzeugt wird.
		//
		//   :CreateBuffer == .T. : Das RootCrt wird einen eigenen Bildschirm
		//                          Puffer erzeugen der dann fuer die Darstellung
		//                          verwendet wird. Dies hat zur Folge das
		//                          Ausgaben mit OutStd() nicht mit anderen
		//                          Text Ausgaben (z.B: Qout(), Dispbox() gemischt
		//                          werden koennen.
		//   :CreateBuffer == .F. : Es wird kein eigener Bildschirm Puffer erzeugt
		//                          und der des Shell Fensters verwendet. OutStd()
		//                          Ausgaben werden nun gleichzeitig dargestellt.
		oCrt := RootCrt():New()
		oCrt:CreateBuffer := .T.
		oCrt:Create()

		// RootCrt wird aktives Fenster und Ausgabeger„t.
		SetAppWindow ( oCrt )

	ENDCASE

RETURN

Ich habe den ohne auzuräumen eingefügt. Vielleicht hilft es dir weiter.

[Manfred]

Hallo Andreas,

Danke erstmal für den Tipp..

das geht schon sehr in die Richtung, die ich haben wollte. Jetzt muß nur noch ein wenig getüftelt werden. Mein Problem war und ist, wie muß denn das Verhältnis Heigth zu Width sein, damit der endgültige Bildschirmaufbau auch entsprechend von der Größe her paßt?

Ich meine 16:8 ist klar, aber 20:9 oder 28:12. Ich sehe da keine Schema drin. Oder bin ich auf dem falschen Weg?

Ich habe Anfangs mehr oder weniger experimentiert und es kamen schon recht wilde Bildschirmverhältnisse heraus. mal zu breit, mal zu hoch usw. Ich würde ganz gerne die Schriften noch etwas größer machen, oder gibt es da irgendwie und wo Grenzen, die ein mehr oder weniger freies Gestalten verhindern? Interessant wäre die Breite zu behalten, aber die Höhe etwas zu verändern, aber dann in der jeweiligen Auflösung bleiben zu können. Weißt Du, oder ein anderer etwas darüber?

Gruß

Manfred

[andreas]

Hallo Manfred,

mehr als ich schon gegeben habe, weiss ich nicht. Damals habe ich auch damit experementiret und für unterschiedliche auflösunfgen die Einstellungen gemacht, was du auch aus dem Code nachvollziehen kannst. Da sind auch die Einstellungen für die Schriftgrösse drin. Ich habe allerdings schon lange diesen Code nicht angefasst, aber wenn du mit diesen Einstellungen rumprobierst, kannst vielleicht das richtige rauskriegen.

[Manfred]

Hi Andreas,

ich werde mal in nächster Zeit ein bißchen probieren, vielleicht komme ich ja weiter.

Danke nochmals für den Quelltext. Weitergeholfen hat er mir auf jeden Fall..

Gruß Manfred

[boddy]

Hallo Manfred,

wenn Du im reinen TEXT-Modus arbeitest, dann brauchst Du nur ALT+ENTER zu drücken und schon ist der Bildschirm gefüllt.
Wie es aussieht arbeitest Du aber im HYBRID-Modus. Hier ergibt sich die Größe des Fensters aus der Größe der Schriftart (Plus etwas Rand und Titelleiste).
Das bedeutet, selbst wenn man die Schrift skaliert, wird bei verschiedenen Bildschirmauflösungen nie der gesamte Bildschirm gefüllt.
Z.B.
125 Spalten * 8 = 1000 und 43 Zeilen * 16 = 688 hier ist der Bildschirm fast gefüllt.
83 Spalten * 12 = 996 und 29 Zeilen * 24 = 696 Einige Infos weniger, dafür etwas besser zu lesen.
80 * 12 = 960 und 25 * 24 = 600 das Originale DOS – Verhältnis diesmal mit etwas mehr Rand.
80 * 12 = 960 und 25 * 28 = 700 das Originale DOS – Verhältnis ohne Rand, aber etwas verzehrt.
Bei einer anderen Bildschirmauflösung bzw. bei einer anderen Schrift, die z.B. im Verhältnis 10/17 steht, sieht es sofort wieder anders aus.

Zu Beachten sind also folgende Dinge:
- Bildschirmauflösung;
- Schriftart, Schriftgröße und Schriftgrößenverhältnis;
- Zeilen und Spaltenanzahl;
- Optimale Ausnutzung des Bildschirmes (bringt meistens einen Rand)
- Maximale Ausnutzung des Bildschirmes (bringt meistens eine Verzerrung)

Lange Rede, fast keinen Sinn, ich schicke Dir mal etwas Code aus meiner Sturm und Hybridzeit.

Code: Alles auswählen

//==============================================================
#include "XBP.CH"
//==============================================================
procedure main
local nZeilen := 30
local nSpalten := 30
local cFarbe := "N/W,W/N"
local lSichtbar := .T.
local cTitel := "Lagerverwaltung"
local i, j

setFontTyp(2)		// 1 bis 5 eventuell erweitern

* setFontMax()		// Verzerrte Schrift (Standard)
* setFontOpt()		// Etwas mehr Rand

OpenFenster(nZeilen,nSpalten,cFarbe,lSichtbar,cTitel)

for i = 1 to nZeilen
	@ i-1,0 say Replicate("A", nSpalten)
next

inkey(0)

return nil
//==============================================================
**************************************************
function getFont()
static aFonts := {   {"Alaska Crt"	, 08,16}, ;
                     {"Courier New", 10, 19}, ;
                     {"Lucida Console"	, 10, 17}, ;
                     {"MS Mincho Fett"	, 8, 16}, ;
                     {"SimSun" , 8, 16}, }
local out
out := aFonts[getFontType()]
return out
**************************************************
function setFontMax()
local out
out := isFontMax(.T.)
return out
**************************************************
function setFontOpt()
local out
out := isFontMax(.F.)
return out
**************************************************
function isFontMax(lWert)
static lFontMax := .T.
local out
out := lFontMax
if valtype(lWert) = "L"
	lFontMax := lWert
endif
return out
**************************************************
function setFontTyp(nWert)
local out
out := getFontType(nWert)
return out
**************************************************
function getFontType(nWert)
static nFontType := 1
local out
out := nFontType
if valtype(nWert) = "N"
	nFontType := nWert
endif
return out
**************************************************
function nFontWidth(aFont,nZeilen,nSpalten)
local out := 0
local aSizeDesktop

if aFont[1] = "Alaska Crt"
	out := aFont[2]
else
	aSizeDesktop    := AppDesktop():currentSize()
	if isFontMax()
		out := int(aSizeDesktop[1] / nSpalten)
		if (int(aSizeDesktop[1] / nSpalten)) == (aSizeDesktop[1] / nSpalten)
		endif
	else
		out	:=nFontOpt(aFont,.F.,nZeilen,nSpalten)
	endif
endif

return out
**************************************************
function nFontHeight(aFont,nZeilen,nSpalten)
local out := 0
local aSizeDesktop
local nZ

nZ := nZeilen + 2 

if aFont[1] = "Alaska Crt"
	out := aFont[3]
else
	aSizeDesktop    := AppDesktop():currentSize()
	if isFontMax()
		out := int(aSizeDesktop[2] / nZ)
		if  (int(aSizeDesktop[2] / nZ)) == (aSizeDesktop[2] / nZ)
		endif
	else
		out	:=nFontOpt(aFont,.T.,nZ,nSpalten)
	endif
endif

return out
**************************************************
function nFontOpt(aFont,lHoch,nZeilen,nSpalten)
local nHoch  := 16
local nBreit := 8
local out
local aSizeDesktop
aSizeDesktop    := AppDesktop():currentSize()

nBreit := int(aSizeDesktop[1] / nSpalten)
nHoch  := int(aSizeDesktop[2] / nZeilen)

if ((nBreit / aFont[2]) * aFont[3]) > nHoch
	nBreit := int((nHoch / aFont[3]) * aFont[2])
elseif	((nHoch / aFont[3]) * aFont[2]) > nBreit
	nHoch  := int((nBreit / aFont[2]) * aFont[3])
endif


out := iif(lHoch,nHoch,nBreit)
return out
**************************************************
//==================================================================

function OpenFenster(nZeilen,nSpalten,cFarbe,lSichtbar,cTitel)
local oWinneu
local aPos
local aSizeDesktop
LOCAL nFontHeight
LOCAL nFontWidth
LOCAl aFonts := getFont()

// Bestimmen der Fensterposition (Anordnen in der Mitte
// des Desktop-Fensters)
aSizeDesktop    := AppDesktop():currentSize()
nFontWidth			:= nFontWidth(getFont(),nZeilen,nSpalten)
nFontHeight			:= nFontHeight(getFont(),nZeilen,nSpalten)
aPos            := { ((aSizeDesktop[1]-(nSpalten * nFontWidth))  /2) - 3, ;
                           ((aSizeDesktop[2]-(nZeilen * nFontHeight)) /2) - 3  }

// XbpCRT-Fenster erzeugen
oWinneu := XbpCrt():new(AppDesktop() ,SetAppWindow() , ;
                        aPos, nZeilen, nSpalten, cTitel )

oWinneu:border  := XBPDLG_RECESSEDBORDERTHICK
oWinneu:border  := XBPDLG_RAISEDBORDERTHICK_FIXED
oWinneu:border  := XBPDLG_RECESSEDBORDERTHICK_FIXED

oWinneu:minmax 	:= .F.
oWinneu:sysmenu := .F.

oWinneu:FontWidth  := nFontWidth
oWinneu:FontHeight := nFontHeight
*	 oWinneu:titleBar		:= .F.
oWinneu:FontName   := aFonts[1]

oWinneu:create()
oWinneu:setModalState( XBP_DISP_APPMODAL )
SetAppWindow( oWinneu )

SetColor( cFarbe )
clear

return oWinneu
*-------------------------------------------------

Vielleicht kannst Du damit etwas anfangen.

Gruß
Armin

[Manfred]

Hallo Armin,

vielen Dank für Deine Hilfe. Ich bin gerade dabei einiges umzubauen und werde mir dabei auch Deinen Code näher ansehen. Für mich war es in erster Linie wichtig, zu verhindern, dass der Xbase Textbildschirm so klein ist beim Starten. Da habe ich wohl einige Tomaten auf den Augen gehabt, als ich mich Anfangs darüber hergemacht hatte.

Es ging auch nicht darum, den ganzen Bildschirm auszufüllen, sondern dass der Bildschirm größer wird, aber die Schrift evtl. nach logischen Prinzipien angepaßt wird. Wie schon erwähnt, es sah teilweise zum Piepen aus, was da an Seitenverhältnissen produziert wurde.

Gruß

Manfred