Beschreibung der xFSL-Schnittstelle Revision 4 21.07.1995 von Dirk Haun Europastr. 8 D-64569 Nauheim Dirk Haun @ WI2 Inhaltsverzeichnis ================== 0 Einleitung 1 Die xFSL-Schnittstelle 1.1 Der xFSL-Cookie 1.2 Der vereinfachte Aufruf (xfsl_input) 1.3 Der erweiterte Aufruf 1.3.1 xfsl_init 1.3.2 xfsl_event 1.3.3 xfsl_exit 1.4 Der Info-Aufruf (xfsl_info) 1.5 Die VDI-Workstation 1.6 Die xFSL_PAR-Struktur 1.6.1 Die Kontrollflags 1.6.2 Die PFONTINFO-Struktur 1.6.3 Das User-Popup 1.7 Die Fontflags 1.8 Returncodes 1.9 Die Pure-C-Event-Struktur 2 Tips und Hinweise 2.1 Ein einfacher Aufruf 2.2 Fragen und Antworten 2.3 Programmiertechnische Hinweise 2.3.1 Datentypen 2.3.2 Parameterbergabe 2.3.3 Pure C und 'cdecl' 3 Revisions-History 4 Programmbersicht 4.1 Fontselektor-šbersicht 4.2 Programme, die einen Fontselektor untersttzen Anhang ====== A Das Font-Protokoll B Die UFSL-Schnittstelle C Hinweise fr Autoren anderer Fontselektoren D Kontaktadressen 0 Einleitung ============ Sp„testens seit der Einfhrung von Vektorfonts erfreut sich das GDOS, das jahrelang auf dem Atari ein Schattendasein fhrte, steigender Be- liebtheit. Immer mehr Programme bieten die M”glichkeit, fr die Ausga- be (und teilweise auch fr die Eingabe) einen anderen Font als den Systemfont zu verwenden. Um nun einen Font ausw„hlen zu k”nnen, ben”tigt man einen Fontselek- tor. Und damit nicht jeder Programmierer sein eigenes Sppchen kocht und im Sinne einer einheitlichen Bedienung entstand der Wunsch nach einer Systemerweiterung, die einen Fontselektor - „hnlich wie einen Fileselektor - fr alle Programme zur Verfgung stellt. Das erste derartige Programm war der UFSL von Michael Th„nitz. Er stellt ber einen Cookie Routinen zum Aufruf eines Fontselektors zur Verfgung. Diese Schnittstelle wird bereits von einer Reihe von Pro- grammen verwendet und es gibt auch bereits weitere Fontselektoren, die ber diese Schnittstelle aufgerufen werden k”nnen. Zwar l„žt sich nun ber die UFSL-Schnittstelle ein Fontselektor auf- rufen, doch hat diese Schnittstelle bereits eine Reihe von - zum Teil inkompatiblen - Žnderungen und Erweiterungen hinter sich. Daher gehen die meisten Programme heute davon aus, daž sie nur die ursprngliche einfache UFSL-Schnittstelle zur Verfgung haben. Im Endeffekt bleiben also die Erweiterungen ungenutzt und wenn in einem Programm dann doch einmal ein etwas leistungsf„higerer Fontselektor ben”tigt wird, dann geht man doch wieder dazu ber, extra fr das Programm einen neuen Fontselektor zu schreiben. Etwas berspitzt formuliert wird hier also die Idee eines externen Fontselektors ad absurdum gefhrt ... Durch den "Wildwuchs" an der UFSL-Schnittstelle erschien es sinn- voller, einen klaren Trennstrich zu ziehen und eine komplett neue Schnittstelle zu entwickeln, die dann auch ber einen neuen Cookie angeboten wird. Dieser Text beschreibt diese neue Schnittstelle, ber die nicht nur einfach ein Fontselektor aufgerufen, sondern auch in vielf„ltiger Weise Einfluž auf diesen genommen werden kann. 1 Die xFSL-Schnittstelle ======================== šber die xFSL-Schnittstelle hat der Aufrufer (d.h. das Programm, das den Fontselektor aufruft) wesentlich mehr Einfluž auf den Fontselek- tor, sein Verhalten und auf die zur Auswahl angebotenen Fonts. Bei der Konzeption der neuen Schnittstelle wurde versucht, auf die M”glichkeiten der verschiedenen Programmiersprachen Rcksicht zu neh- men (z.B. Vermeidung von Zeigern auf Funktionen) und gleichzeitig fr m”gliche Erweiterungen der Schnittstelle gerstet zu sein. Die Anpassung eines Programms an die xFSL-Schnittstelle sollte eine Sache von wenigen Minuten sein, zumal Beispielaufrufe in verschiede- nen Programmiersprachen mitgeliefert werden. Die Umsetzung spezieller Wnsche ist natrlich u.U. etwas aufwendiger, sollte aber auch kein unl”sbares Problem darstellen. Es folgt die Beschreibung des xFSL-Cookies sowie der verschiedenen xFSL-Aufrufe und Parameter ... 1.1 Der xFSL-Cookie ------------------- Wenn ein Fontselektor installiert ist, der die xFSL-Schnittstelle un- tersttzt, dann existiert ein Cookie "xFSL", dessen Wert ein Zeiger auf die folgende Struktur ist: typedef struct { unsigned long xfsl; /* Magic 'xFSL' */ unsigned int revision; /* Schnittstellen-Revision */ unsigned long product; /* Kennung des Fontselektors */ unsigned int version; /* Version des Fontselektors */ xFSL_INPUT xfsl_input; /* einfacher Aufruf */ xFSL_INIT xfsl_init; /* Init-Aufruf */ xFSL_EVENT xfsl_event; /* Event-Aufruf */ xFSL_EXIT xfsl_exit; /* Exit-Aufruf */ xFSL_INFO xfsl_info; /* Info-Aufruf */ } xFSL; Die Komponenten der Struktur im einzelnen: xfsl Hier steht, nur zur Sicherheit, nochmals die ASCII-Zeichenfolge "xFSL" (entspricht hexadezimal $7846534C). revision Dies ist die Revisionsnummer der xFSL-Schnittstelle, sie enth„lt z.Z. den Wert 4. Sollte die Schnittstelle erweitert wer- den, so werden dort entsprechend h”here Werte zu finden sein. product Hier findet sich eine Kennung fr den tats„chlich installier- ten Fontselektor. Diese Angabe ist jedoch nur als zus„tzliche Information gedacht und sollte von Anwendungsprogrammen, die den Fontselektor aufrufen wollen, nicht ausgewertet werden! Bisher verwendete Kennungen: Kennung Fontselektor ---------------------- CLVN Calvino FSEL FontSel HUGO HuGo! Die Kennung (wie auch die folgende Versionsnummer) wurde nur fr Programme eingefhrt, die eine Information ber den installierten Fontselektor ausgeben wollen (z.B. das Programm SysInfo). version Die Versionsnummer des installierten Fontselektors als BCD- Zahl (z.B. hexadezimal $100 fr Version 1.00). Hier gelten sinnge- m„ž die Anmerkungen zum Feld 'product'. xfsl_input Dies ist der Einsprungpunkt fr einen vereinfachten Auf- ruf des Fontselektors. Der Fontselektor erscheint dann immer als modaler Dialog und die meisten zus„tzlichen Features der xFSL- Schnittstelle k”nnen nicht angesprochen werden. xfsl_init, xfsl_event, xfsl_exit Diese drei Funktionen bilden zusam- men den erweiterten Fontselektor-Aufruf. Hierber k”nnen alle neuen Features angesprochen werden. Die Vorgehensweise entspricht dem Darstellen eines GEM-Dialogs: a) Fontselektor darstellen (xfsl_init) b) Eventbehandlung in einer Schleife, bis "OK" oder "Abbruch" angew„hlt wurde (xfsl_event) c) Fontselektor vom Bildschirm entfernen (xfsl_exit) xfsl_info šber diese Aufruf k”nnen einige der Features des instal- lierten Fontselektors abgefragt werden, z.B. Drag&Drop-Unter- sttzung. 1.2 Der vereinfachte Aufruf (xfsl_input) ---------------------------------------- xfsl_input ist der Einsprungpunkt fr einen vereinfachten Aufruf. Der Fontselektor kann darber nur als modaler Dialog aufgerufen werden. Aužerdem kann eine šberschrift angegeben und eingeschr„nkt werden, welche Arten von Fonts der Selektor zur Auswahl stellen soll. int xfsl_input(int vdihandle, unsigned int fontflags, const char *headline, int *id, int *size ); Die Parameter im einzelnen: vdihandle Hier bergeben Sie das Handle einer von Ihrem Programm be- reits ge”ffneten virtuellen VDI-Workstation (wenn Sie in Ihrem Programm einen Font einstellen wollen, mssen Sie ja ohnehin eine solche VDI-Workstation ”ffnen). Der Font- selektor bernimmt dann den auf dieser Workstation gerade eingestellten Font als aktuellen Font (vorausgesetzt, er wird durch die Fontflags berhaupt zur Auswahl gestellt). Statt eines gltigen Handles k”nnen Sie aber auch einfach eine Null bergeben, dann wird der Fontselektor den Font anzeigen, den Sie in den Parametern 'id' und 'size' ber- geben. Wenn Sie ein VDI-Workstation-Handle bergeben, wird der ausgew„hlte Font auf dieser Workstation auch gleich einge- stellt. fontflags šber die Fontflags k”nnen Sie festlegen, welche Fonts berhaupt zur Auswahl gestellt werden. headline Hier k”nnen Sie eine šberschrift angeben, die dann im Fontselektor erscheint. Fehlt die šberschrift (šbergabe von 0L), dann wird ein Defaulttext ("Fontauswahl" o.„.) eingesetzt. id In dieser Variablen wird die ID des ausgew„hlten Zeichen- satzes zurckgeliefert (natrlich nur, wenn auch wirklich ein Zeichensatz ausgew„hlt wurde). Dieser Zeichensatz kann nun direkt mit der VDI-Funktion vst_font() einge- stellt werden. Wenn Sie in 'vdihandle' eine Null bergeben, wird der Fontselektor den in 'id' angegebenen Font anzeigen. size In dieser Variablen wird die Gr”že des ausgew„hlten Fonts in Punkt zurckgegeben (auch nur, wenn wirklich ein neuer Zeichensatz ausgew„hlt wurde). Wenn es sich um einen Bit- mapfont handelt, kann diese Gr”že mit der VDI-Funktion vst_point() eingestellt werden. Fr Vektorfonts sollte die Funktion vst_arbpt() aufgerufen werden. Wenn Sie in 'vdihandle' eine Null bergeben, wird der Fontselektor den in 'id' angegebenen Font in der in 'size' angegebenen Gr”že anzeigen. Rckgaben xfsl_input liefert eine negative Zahl zurck, wenn ein Fehler aufge- treten ist. Eine 0 wird zurckgegeben, wenn "Abbruch" angew„hlt wur- de. Wird eine 1 zurck geliefert, dann wurde ein neuer Font ausgew„hlt. Die Rckgabewerte sind fr alle xFSL-Funktionen gleich und aufw„rts- kompatibel zu den Rckgabewerten des UFSL. 1.3 Der erweiterte Aufruf ------------------------- Der erweiterte xFSL-Aufruf besteht aus drei einzelnen Funktionsauf- rufen: xfsl_init Stellt den Fontselektor auf dem Bildschirm dar. Aužerdem werden hier die Parameter bergeben. xfsl_event Diese Funktion wird solange immer wieder aufgerufen, bis im Fontselektor ein Font ausgew„hlt, oder "Abbruch" ange- w„hlt wurde. xfsl_exit Entfernt den Fontselektor wieder vom Bildschirm. In C kann das dann beispielsweise so ausssehen: xhandle=xfsl->xfsl_init(vdihandle,&xpar); if(xhandle>=0) { do { ret=xfsl->xfsl_event(xhandle,0L); if(ret==xFS_HELP) ...; /* Hilfefunktion aufrufen */ else if(ret==xFS_POPUP) ...; /* Popup behandeln */ else if(ret==xFS_EVENT) ...; /* AES-Event bearbeiten */ } while(ret!=xFS_OK && ret!=xFS_STOP); xfsl->xfsl_exit(xhandle); } Diese "Dreiteilung" hat u.a. den Vorteil, daž zur Bearbeitung der Ereignisse (Hilfe-Button, Popup, AES-Events) keine Zeiger auf Funk- tionen bergeben werden mssen (was in einigen Programmiersprachen nur schwer zu realisieren ist). Auch l„žt sich die Schnittstelle so leicht um weitere Ereignisse erweitern, falls dies einmal n”tig sein sollte. 1.3.1 xfsl_init Dieser Aufruf bringt nicht nur den Fontselektor auf den Bildschirm, er bestimmt auch, welche Fonts angezeigt werden sollen, ob ein User- Popup verwendet wird und einiges mehr. int xsfl_init(int vdihandle, xFSL_PAR *xpar ); Die beiden Parameter bedeuten: vdihandle Hier bergeben Sie, wie schon beim vereinfachten Aufruf, das Handle einer von Ihrem Programm bereits ge”ffneten virtuellen VDI-Workstation oder einfach eine Null. Wenn Sie ein gltiges Workstation-Handle bergeben, wird der Fontselektor den auf dieser Workstation aktuellen Font bernehmen und anzeigen - sofern er duch die Font- flags (in der xFSL_PAR-Struktur) berhaupt zur Auswahl gestellt wird. Ist dies nicht der Fall, wird der Fontse- lektor einen Font aus den zur Verfgung stehenden aus- w„hlen und anzeigen. šbergeben Sie als Workstation-Handle eine Null, dann wird der Font aus der PFONTINFO-Struktur (auf die ein Zeiger in der xFSL_PAR-Struktur zeigt) bernommen und angezeigt. Wenn Sie ein VDI-Workstation-Handle bergeben, wird der ausgew„hlte Font auf dieser Workstation auch gleich eingestellt. xpar Dies ist ein Zeiger (d.h. die Adresse) auf eine xFSL_PAR- Struktur, die alle weiteren Angaben fr den Fontselektor enth„lt. Wegen der Vielzahl der M”glichkeiten wurde dieser Struk- tur ein eigener Abschnitt gewidmet. Fr die Returncodes der Funktion gilt wieder: Ein negativer Rckgabe- wert deutet auf einen Fehler hin. Positive Werte haben hier eine et- was abweichende Bedeutung: Eine 0 heižt, der Fontselektor wurde (er- folgreich) als modaler Dialog ge”ffnet. Andere positive Werte ent- sprechen dem Fensterhandle des ge”ffneten Fontselektors. Somit k”nnen Sie das Fenster des Fontselektors beispielsweise bei einem AV-Server anmelden. Im Erfolgsfalle (Rckgabe gr”žer oder gleich 0) sollten Sie sich das Handle in einer Variablen merken, da es fr die folgenden Aufrufe (xfsl_event und xfsl_exit) noch ben”tigt wird. Hinweis: Wenn der Fontselektor als Fenster dargestellt werden sollte, xfsl_init aber den Fehler xFS_NO_WINDOW liefert (kein Fenster mehr frei), dann sollte m”glichst versucht werden, den Fontselektor wenig- stens als Dialog darzustellen (Kontrollflag CC_WINDOW l”schen und nochmals xfsl_init aufrufen). Merke: Der Anwender will einen Fontselektor, keine Fehlermeldung. 1.3.2 xfsl_event Wenn der Fontselektor initialisiert und auf den Bildschirm gebracht wurde, bernimmt xfsl_event die Hauptarbeit. int xfsl_event(int xhandle, EVENT *event ); Die beiden Parameter bedeuten: xhandle Das Handle des Fontselektors, wie es von xfsl_init gelie- fert wurde. event Zeiger auf eine EVENT-Struktur, wie sie von Pure C verwen- det wird. In dieser Struktur liefert der Fontselektor AES- Events zurck, die er nicht selbst bearbeiten konnte. Aužer- dem k”nnen Sie ber die Eingabeparameter dem Fontselektor auch mitteilen, ber welche Ereignisse sie berhaupt unter- richtet werden wollen. Der Zeiger kann aber auch einfach Null sein, wenn Sie keine (weiteren) Events auswerten wollen. Soll der Fontselektor als Fensterdialog betrieben werden und der Aufrufer (d.h. Ihr Programm) hat noch weitere Fenster offen, dann mssen Sie aber zumindest die Redraw-Meldungen auswerten! Beispiel: Wenn Sie in 'ev_mflags' das Flag MU_MESAG setzen, wird der Fontselektor alle eintreffenden AES-Nachrichten, die er nicht selbst bearbeiten kann, an den Aufrufer zurck- liefern. Hinweis: Es ist natrlich auch m”glich, Timer-Events zu be- kommen. Diese sollten aber sparsam eingesetzt werden und nicht zu kurz sein, da der Fontselektor dazu jedesmal erst seine eigene Event-Schleife verlassen muž. 250 ms m”gen als - unverbindliche - untere Grenze gelten. Die m”glichen Rckgabewerte von xfsl_event: xFS_STOP Im Fontselektor wurde der Button "Abbruch" oder (so vor- handen) der Closer des Fensterdialogs angew„hlt. Wenn das Kontrollflag CC_CLOSER gesetzt ist und der Closer angeklickt wurde, enth„lt die PFONTINFO-Struktur, auf die der Zeiger in der xFSL_PAR-Struktur zeigt, aber trotzdem Angaben darber, welcher Font zuletzt im Fontse- lektor angew„hlt worden war. Anders w„re diese Informati- on sonst ja nicht zu erhalten. xFS_OK Es wurde ein Font ausgew„hlt und "OK" angew„hlt. Welcher Font ausgew„hlt wurde, beschreibt die PFONTINFO-Struktur, auf die der Zeiger in der xFSL_PAR-Struktur zeigt. Wenn bei xfsl_init ein gltiges VDI-Handle bergeben wurde, dann wird der ausgew„hlte Font auch gleich auf dieser VDI- Workstation eingestellt. xFS_HELP Der Hilfe-Button wurde angew„hlt (kann natrlich nur auf- treten, wenn Sie ihn haben einblenden lassen). Es liegt nun am Aufrufer, wie er darauf reagiert. Im Normalfall wird man wohl eine Hilfe geben, z.B. indem man eine Hilfs- seite anzeigt oder anzeigen l„žt. xFS_EVENT Ein AES-Event ist aufgetreten, den der Fontselektor nicht bearbeiten konnte (z.B. eine Redraw-Meldung fr ein ande- res Fenster). Welcher Event es genau war, k”nnen Sie dem Feld 'ev_mwich' der EVENT-Struktur entnehmen. Accessories sollten bei Eintreffen der Nachricht AC_CLOSE den Aufruf von xfsl_exit nicht vergessen! Gleiches gilt analog fr die Nachricht AP_TERM. xFS_POPUP Am User-Popup (sofern vorhanden) wurde ein Ver„nderung vorgenommen. Bei dem Popup-Eintrag, der ge„ndert wurde, ist im Element 'fontflags' das Bit FF_CHANGED gesetzt. Der Popup-Eintrag, der jetzt angew„hlt wurde und bei Rckkehr in den Fontselektor (beim n„chsten xfsl_event- Aufruf) der aktuelle des Popups sein wird, steht im Ele- ment 'sel_entry'. Sie haben jetzt noch die M”glichkeit, Žnderungen an den Popup-Eintr„gen vorzunehmen, beispielsweise die Fontflags zu „ndern oder den ge„nderten Font in alle anderen Popup- Eintr„ge zu bernehmen (auf diese Weise ist es auch m”g- lich, das Popup fr eine andere Information zu verwenden, die mit den ausgew„hlten Fonts nichts zu tun hat). Die Texte und die Anzahl der Popup-Eintr„ge drfen aber nicht ver„ndert werden! andere Werte: Andere positive Werte sollten ignoriert werden. Es ist m”glich, daž die Schnittstelle um weitere Rckgabewerte (Ereignisse) erweitert wird. Negative Werte zeigen einen Fehler an, der Fontselektor sollte dann abgebrochen werden. Dazu muž aber unbedingt noch xfsl_exit aufgerufen werden! 1.3.3 xfsl_exit Mit dem xfsl_exit-Aufruf wird der Fontselektor wieder vom Bildschirm entfernt: void xfsl_exit(int xhandle); Dabei ist 'xhandle' wieder das Handle des Fontselektors, wie es von xfsl_init geliefert wurde. xfsl_exit muž immer dann aufgerufen werden, wenn die Behandlung des Fontselektors beendet werden soll. Sei es dadurch, daž ein Font ausge- w„hlt oder "Abbruch" angew„hlt wurde, oder daž xfsl_event einen Feh- ler meldete. Wenn schon der xfsl_init-Aufruf fehlgeschlagen ist, darf xfsl_exit nicht aufgerufen werden (logisch, da man ja auch kein gl- tiges Handle hat). Der Aufruf von xfsl_exit sollte auch bei Eintreffen der Nachrichten AC_CLOSE und AP_TERM nicht vergessen werden! 1.4 Der Info-Aufruf (xfsl_info) ------------------------------- šber diesen Aufruf k”nnen einige der Features des installierten Font- selektors abgefragt werden: long xfsl_info(void); Wenn der Rckgabewert positiv ist, dann stehen die folgenden Flags fr vorhandene Features (negative Rckgabewerte sind, wie blich, Fehlermeldungen): Name Wert Bedeutung -------------------------------------------------------- XF_SIZE 0x0001 Gr”žen„nderung m”glich XF_COLOR 0x0002 Farb„nderung m”glich XF_ATTR 0x0004 Attribut„nderung m”glich XF_WIDTH 0x0008 Breiten„nderung m”glich XF_KERN 0x0010 Kerning„nderung m”glich XF_SKEW 0x0020 Neigungs„nderung m”glich XF_ALIGN 0x0040 Žnderung der Ausrichtung m”glich XF_ROTATION 0x0080 Textrotation m”glich XF_FIX31 0x0100 fix31-Untersttzung XF_POPUP 0x0200 Popup-Untersttzung XF_DRAGDROP 0x0400 Drag&Drop-Untersttzung XF_MAPPING 0x0800 beherrscht Mapping Weitere Features des Fontselektors lassen sich indirekt ber das Ele- ment 'control' der xFSL_PAR-Struktur abfragen: Bei einem erfolg- reichen xfsl_init-Aufruf werden diejenigen Kontrollflags gel”scht, die der Fontselektor nicht kennt. 1.5 Die VDI-Workstation ----------------------- Bei den Aufrufen xfsl_input und xfsl_init kann jeweils das Handle einer vom Aufrufer bereits ge”ffneten virtuellen VDI-Workstation bergeben werden. Davon, ob man tats„chlich ein Handle einer Work- station oder einfach eine Null bergibt, h„ngt das weitere Verhalten des Fontselektors ab: šbergibt man ein gltiges Handle, so wird der Fontselektor versuchen, den auf der entsprechenden Workstation gerade aktuellen Font zu er- mitteln und diesen dann - sofern er zu den bergebenen Fontflags pažt - auch einstellen und zur Auswahl anbieten. Pažt der aktuelle Font nicht zu den Fontflags (wenn z.B. nur Vektorfonts angeboten werden sollen, der aktuelle Font aber ein Bitmapfont ist), so wird der Font- selektor einen Font aus den tats„chlich angebotenen ausw„hlen und als aktuellen Font pr„sentieren. W„hlt der Anwender nun einen Font aus und beendet den Fontselektor mit "OK", so wird dieser Font auch gleich auf der bergebenen Work- station eingestellt, so daž das aufrufende Programm dies nicht mehr bernehmen muž. Dabei gilt es zu beachten, daž der Fontselektor ebenfalls eine eigene VDI-Workstation ”ffnet und diese intern und zur Auswahl der Fonts verwendet. U.a. wird er fr diese Workstation auch vst_load_fonts() aufrufen (sofern ein GDOS installiert ist). Dies kann zu unerwarteten Resultaten fhren, wenn auf der bergebenen Workstation noch kein vst_load_fonts() aufgerufen wurde und der Anwender im Fontselektor einen Font ausw„hlt, der erst nach einem vst_load_fonts()-Aufruf zur Verfgung steht! Statt eines Workstation-Handles kann man aber auch einfach eine Null bergeben. Der Fontselektor wird den aktuellen Font dann aus den bergebenen Parametern (beim xfsl_input-Aufruf) bzw. aus der xFSL_PAR- Struktur (beim xfsl_init-Aufruf) ermitteln. Der ausgew„hlte Font wird dann (logischerweise) auch nur in den Para- metern bzw. der xFSL_PAR-Struktur zurckgegeben und der Aufrufer muž ihn dann selbst einstellen. 1.6 Die xFSL_PAR-Struktur ------------------------- šber diese Struktur haben Sie weitgehenden Einfluž auf das Verhalten des Fontselektors und die Art der dargestellten Fonts. Daher f„llt die Beschreibung der M”glichkeiten auch etwas l„nger aus ... typedef struct { int par_size; /* Gr”že der xFSL_PAR-Struktur */ int pfi_size; /* Gr”že der PFONTINFO-Struktur */ unsigned long control; /* Kontrollflags */ const char *headline; /* šberschrift oder 0L */ const char *example; /* Beispieltext oder 0L */ const char *helptext; /* Text des Hilfe-Buttons od. 0L */ PFONTINFO *font; /* Zeiger auf Fontinfo-Struktur */ unsigned int fontflags; /* erlaubte Fontarten */ const char *poptext; /* Text vor dem Popup oder 0L */ int num_entries; /* Anzahl der Eintr„ge (0..n) */ int sel_entry; /* Selektierter Eintrag (0..n-1) */ xFSL_PENTRY *popup; /* Zeiger auf ein Popup oder 0L */ char *helpinfo; /* Zeiger auf Hilfedatei/-seite */ } xFSL_PAR; Trotz der Vielzahl der Eintr„ge ist eigentlich alles ganz einfach, zumal Sie Felder, die Sie nicht ben”tigen oder deren Bedeutung Ihnen noch nicht klar ist, einfach mit Null ausfllen k”nnen, worauf der Fontselektor dann sinnvolle Defaultwerte annehmen wird. Die Felder im einzelnen: par_size Dieses Feld darf nicht auf Null gesetzt werden, hier wird die Gr”že der xFSL_PAR-Struktur in Bytes eingetragen, weshalb man in C einfach schreiben kann xpar.par_size=sizeof(xFSL_PAR); Die Gr”že der Struktur betr„gt z.Z. 42 Bytes. Sollte die Struktur erweitert werden, kann der Fontselektor an der Gr”ženangabe erkennen, ob er es mit einer neuen oder einer alten Struktur zu tun hat. pfi_size Auch dieses Feld darf nicht Null sein, hier muž die Gr”že der PFONTINFO-Struktur eingetragen werden, also xpar.pfi_size=sizeof(PFONTINFO); Die aktuelle Gr”že der PFONTINFO-Struktur betr„gt 38 Bytes und k”nnte ebenfalls in Zukunft erweitert werden. control Dies sind die sogenannten Kontrollflags, ber die das Ver- halten des Fontselektors beeinflužt werden kann (z.B. ob er als Fenster oder als Dialog erscheinen soll). Diesen Flags wurde ein eigener Abschnitt gewidmet. headline Dies ist, wie schon vom einfachen Aufruf her bekannt, ein Zeiger auf eine šberschrift fr den Fontselektor. Fehlt diese (d.h. 'headline' enth„lt Null), dann wird der Font- selektor eine Default-šberschrift einsetzen. Die L„nge der šberschrift sollte sich in dem noch vom UFSL vorgegebenen Rahmen (34 Zeichen) bewegen, der Fontse- lektor wird l„ngere šberschriften aber ggfs. krzen. example Ein Zeiger auf einen Beispieltext. Der Fontselektor zeigt fr den jeweils eingestellten Font ein Schriftbeispiel an, dessen Text hiermit vorgegeben werden kann. Fehlt dieser Text (d.h. 'example' enth„lt Null), wird der Font- selektor einen Defaulttext anzeigen (z.B. den Namen des jeweiligen Zeichensatzes). helptext Dies ist der Text fr einen Button, der links unten im Fontselektor eingeblendet werden kann. Im Normalfall wird man dort einen Button mit der Aufschrift "Hilfe" oder "Help" einblenden wollen, um dem Anwender die Funktion des Fontselektors zu erkl„ren, und wofr der ausgew„hlte Font verwendet wird. Fehlt dieser Text (d.h. 'helptext' enth„lt Null), wird auch kein Hilfe-Button eingeblendet. Dann wird xfsl_event auch nicht den Rckgabewert xFS_HELP liefern. Man sollte einen kurzen Text w„hlen (etwa 8 Zeichen), der Fontselektor wird l„ngere Texte aber ggfs. krzen. font Dies ist ein Zeiger auf eine Struktur (PFONTINFO), die einen Font beschreibt. Die Struktur wird sowohl zur šber- gabe von Werten an den Fontselektor als auch zur Rckgabe des ausgew„hlten Fonts verwendet. Auch dieser Struktur ist ein eigener Abschnitt gewidmet. fontflags Dies sind wieder die vom einfachen Aufruf bekannten Font- flags, mit denen Sie die zur Auswahl gestellten Fonts beeinflužen k”nnen. poptext, num_entries, sel_entry, popup: Mit diesen vier Parametern k”nnen Sie ein zus„tzliches Popup in den Fontselektor einblenden lassen. Wegen der vielf„ltigen M”glichkeiten gibt's dafr auch wieder einen eigenen Abschnitt. Wollen Sie kein Popup, so setzen Sie diese vier Werte einfach auf Null. helpinfo Dies ist ein reiner Ausgabeparameter: Wenn der Hilfe- Button angew„hlt wurde (sofern vorhanden, siehe 'help- text'), dann steht hier ein Zeiger auf einen Dateinamen einer Hilfedatei und den Namen einer Seite, die angezeigt werden kann. Der Dateiname wird ohne Pfad und Extension angegeben, der Seitenname folgt direkt dahinter, durch ein Komma getrennt. Der String darf nur gelesen, aber nicht ver„ndert werden! Wenn Sie bei xFS_HELP nicht selbst eine Hilfe anzeigen wollen, dann k”nnen Sie mit diesen Informationen ein Hilfesystem (z.B. ST-Guide) aufrufen. Beispiel: xfsl_event gibt xFS_HELP zurck, in 'helpinfo' findet sich ein Zeiger auf den String toll,Der tollste Fontselektor aller Zeiten Daraus l„žt sich dann folgender Aufruf fr ST-Guide erstellen: *:\toll.hyp Der tollste Fontselektor aller Zeiten Man h„ngt also an den Dateinamen die Extension fr das jeweilige Hilfesystem an und bergibt den Teil nach dem ersten Komma als Seitenname. Um es nochmals zu betonen: Felder, die sie nicht ben”tigen oder noch nicht verstehen, k”nnen Sie zun„chst einfach auf Null setzen. Aus- nahmen sind nur ù 'par_size', die Gr”že der xFSL_PAR-Struktur selbst ù 'pfi_size', die Gr”že der PFONTINFO-Struktur ù 'font', der Zeiger auf die PFONTINFO-Struktur 1.6.1 Die Kontrollflags šber die Kontrollflags kann das Verhalten des Fontselektors beein- flužt werden. Name Wert Bedeutung -------------------------------------------------------------- CC_WINDOW 0x0001 Fontselektor als Fenster CC_APPMODAL 0x0002 Fontselektor ist applikationsmodal CC_FIX31 0x0004 alle Gr”ženangaben in 1/65536 Punkt CC_FAKESTYLE 0x0008 Schnitte simulieren (nur Bitmapfonts) CC_CLOSER 0x0010 Fenster mit Closer, kein OK-Button CC_NOSIZE 0x0100 Gr”že nicht „ndern CC_NOCOLOR 0x0200 Farbe nicht „ndern CC_NOATTR 0x0400 Attribute nicht „ndern CC_NOWIDTH 0x0800 Breite nicht „ndern CC_NOKERN 0x1000 Kerning nicht „ndern CC_NOSKEW 0x2000 Skewing nicht „ndern CC_NOALIGN 0x4000 Ausrichtung nicht „ndern CC_NOROTATION 0x8000 Textrotation nicht „ndern CC_DFLTSIZE 0x10000 Schriftgr”že "Default" CC_INVSTYLE 0x20000 Attribut "Invers" Die Funktion der einzelnen Flags sollte sich schon aus den Namen und den Kurzbeschreibungen ergeben. Hier noch einige Anmerkungen: ù CC_APPMODAL "Applikationsmodal" heižt, daž das Programm in einen Modus ver- setzt wird, in dem nur noch der Fontselektor bearbeitet werden kann. Im wesentlichen bedeutet das, daž der Fontselektor alle WM_TOPPED-Nachrichten fr andere Fenster des aufrufenden Pro- gramms abf„ngt und nicht weiterleitet, sondern sich stattdessen selbst zum obersten Fenster macht. Damit soll dem Anwender signa- lisiert werden, daž er zuerst den Fontselektor bearbeiten soll, bevor er eine andere Aktion im Programm ausl”sen kann. Der Aufrufer sollte in diesem Modus natrlich darauf verzichten, eigene Fenster selbst mit wind_set(WF_TOP) zum obersten Fenster zu machen. ù CC_FAKESTYLE Dies ist eine Spezialit„t, die z.Z. nur Calvino anbietet: Bei denjenigen Bitmapfonts, bei denen keine leichten, kursiven bzw. fetten Schnitte vorliegen, werden die jeweils fehlenden Schnitte mit der VDI-Funktion vst_effects() simuliert. ù CC_CLOSER Wenn dieses Flag und CC_WINDOW gesetzt sind, wird der Fontselek- tor mit einem Closer versehen, w„hrend der OK- und der Abbruch- Button versteckt werden. Gedacht ist dies fr die F„lle, in denen der Fontselektor als reiner Drag&Drop-Selektor eingesetzt werden soll. ù CC_NO... šber diese Flags kann bestimmt werden, welche Einstellungen nicht ver„ndert werden sollen. Beispielsweise k”nnte ein Pro- gramm verhindern wollen, daž die Gr”že eines Zeichensatzes ge„n- dert wird, w„hrend eine Žnderung des Fonts selbst erm”glicht werden soll. Dann muž der Aufrufer nur das Flag CC_NOSIZE setzen. Beachten Sie aber, daž Sie trotz gesetztem CC_NO...-Flag immer einen gltigen Wert bergeben mssen. Die Bedeutung dieser Flags ist also, daž die vorgegebenen Werte nicht ver„ndert werden k”nnen und nicht, daž die Werte nicht von Interesse sind. Bitte beachten: Nicht alle Fontselektoren untersttzen auch alle Kontrollflags! Wenn ein Fontselektor ein Flag nicht untersttzt, so wird er es einfach ignorieren. Bei einem erfolgreichen(!) xfsl_init- Aufruf wird der Fontselektor diejenigen Flags im Element 'control' der xFSL_PAR-Struktur l”schen, die er nicht versteht. 1.6.2 Die PFONTINFO-Struktur Diese Struktur beschreibt einen Font. Sie enth„lt nach dem Aufruf des Fontselektors den ausgew„hlten Font. Zudem werden diese Angaben vom Fontselektor schon beim Aufruf ausgewertet (und der so beschriebene Font angezeigt), wenn als VDI-Handle eine Null bergeben wird. typedef struct { int fontid; /* ID des Fonts */ int fonttype; /* Typ des Fonts */ char *fontname; /* Name des Fonts */ union fsize fontsize; /* Fontgr”že in pt oder fix31 */ union fsize fontwidth; /* Breite in pt oder fix31 */ char trackkern; /* Track-Kerning */ char pairkern; /* Paar-Kerning */ int fontattr; /* Attribute */ int fontskew; /* Neigung */ int fontcol; /* Farbe */ int backcol; /* Text-Hintergrundfarbe */ int halign; /* horizontale Textausrichtung */ int valign; /* vertikale Textausrichtung */ int rotation; /* Textrotation in 1/10 Grad */ int validtype; /* Typ (V_CHAR_...) oder Mapping */ int *validchars; /* ben”tigte Zeichen oder 0L */ } PFONTINFO; Die Elemente im einzelnen: fontid Die ID des Fonts, wie sie auch von der VDI-Funktion vqt_name() zurckgegegeben wird. Die Font-ID ist eine Zahl ungleich Null (kann also auch negativ sein). fonttype Der Typ des Fonts, wie er ab Speedo 5 bzw. NVDI 3 verwen- det wird: Name Wert Fontart ------------------------------------------ BITMAP_FONT 0x0001 Pixel SPEEDO_FONT 0x0002 Speedo TT_FONT 0x0004 TrueType PFB_FONT 0x0008 Type 1 (Postscript) Diese Angaben sind z.Z. nur zur Information, aber ohne Bedeutung fr den Fontselektor. Allerdings wird es knf- tig m”glich sein, einen Font nicht nur anhand seiner ID, sondern auch anhand seines Namens zu setzen, wobei dann noch zus„tzlich der Fonttyp ben”tigt wird. Der Fonttyp ist aber auch von Interesse, wenn man die Gr”že des Fonts „ndern will: Bei Bitmapfonts geschieht dies mit der VDI-Funktion vst_point(), bei allen anderen Typen (Vektorfonts) mit der Funktion vst_arbpt(). fontname Der Name des Fonts, wie er von vqt_name() geliefert wurde (m”glicherweise wurden mehrfache Leerzeichen entfernt). Der Aufrufer muž selbst gengend Platz fr den Fontnamen zur Verfgung stellen, also fr 32 Zeichen und ein Null- byte! Wenn Sie den Fontnamen nicht ben”tigen, k”nnen Sie den Zeiger auch einfach auf Null setzen. fontsize Die Gr”že des Fonts in Punkt (pt) oder 1/65536 Punkt (Typ "fix31"): union fsize { int size; /* Fontgr”že in Punkt */ fix31 size31; /* Fontgr”že in 1/65536 Punkt */ }; Welche der beiden Angaben gltig ist, wird global ber das Kontrollflag CC_FIX31 geregelt. fontwidth Breite des Fonts in Punkt (pt) oder 1/65536 Punkt (Typ "fix31"): union fsize { int size; /* Fontgr”že in Punkt */ fix31 size31; /* Fontgr”že in 1/65536 Punkt */ }; Welche der beiden Angaben gltig ist, wird global ber das Kontrollflag CC_FIX31 geregelt. Die Breite kann mit den VDI-Funktionen vst_width() in Punkt und mit vst_setsize() in fix31 eingestellt werden. trackkern Dieser Parameter gibt die Art des Track-Kernings fr vst_kern() an. Gltige Werte sind: Wert Kerning ------------------------- 0 kein Kerning 1 normales Kerning 2 enges Kerning 3 sehr enges Kerning pairkern Mit diesem Parameter kann das Pair-Kerning aus- (0) oder eingeschaltet (1) werden, vgl. vst_kern(). fontattr Dies sind die Fontattribute (Texteffekte), wie sie auch von der VDI-Funktion vst_effects() verwendet werden. Calvino verwendet dieses Feld nur dann, wenn das Kontroll- flag CC_FAKESTYLE gesetzt ist. fontskew Die Neigung des Fonts in 1/10 Grad, vgl. vst_skew(). fontcol Die Farbe des Fonts. Es werden die VDI-Farben verwendet, d.h. 0 = Weiž, 1 = Schwarz, usw., vgl. vst_color(). backcol Die Hintergrundfarbe des Textes. Es werden die VDI-Farben verwendet, d.h. 0 = Weiž, 1 = Schwarz, usw. Das Setzen einer Text-Hintergrundfarbe wird vom VDI nicht direkt untersttzt, es obliegt daher dem Aufrufer, ob und wie dieser Parameter verwendet wird. halign Hierber kann die horizontale Textausrichtung angegeben werden: Der Text soll linksbndig, rechtsbndig oder zentriert ausgegeben werden. Name Wert Ausrichtung ------------------------------- THA_LEFT 0 linksbndig THA_CENTER 1 zentriert THA_RIGHT 2 rechtsbndig Diese Werte entsprechen dem Parameter fr die horizontale Ausrichtung beim VDI-Aufruf vst_alignment(). valign Hierber kann die vertikale Textausrichtung angegeben werden: Der Text soll an der Oberkante oder der Unterkan- te ausgerichtet oder (vertikal) zentriert ausgegeben wer- den. Name Wert Ausrichtung ----------------------------------------- TVA_BOTTOM 0 an der Text-Unterkante TVA_CENTER 1 vertikal zentriert TVA_TOP 2 an der Text-Oberkante Diese Werte entsprechen absichtlich nicht dem Parameter zur vertikalen Ausrichtung bei vst_alignment()! Die dort verwendeten Werte ("Zeichenunterkante", "Zeichenzellen- unterkante") sind fr den normalen Anwender wenig intui- tiv und sollten daher nicht Teil des User-Interfaces sein (was sie bei der Auswahl im Fontselektor aber w„ren). Die Ausrichtung muž daher vom aufrufenden Programm in die "richtigen" Werte konvertiert werden. rotation Textrotation in 1/10 Grad, wie sie auch von der VDI-Funk- tion vst_rotation() verwendet wird. Fehlen noch die beiden Parameter 'validtype' und 'validchars': Manchmal ist es wichtig, sicherzustellen, daž der Font bestimmte Zei- chen enth„lt. Dafr gibt es zwei M”glichkeiten: Wenn 'validchars' Null ist, kann man mit 'validtype' eine der folgen- den vier Gruppen von Zeichen ausw„hlen: Name Wert Bereich Kommentar -------------------------------------------------------- V_CHAR_IND -1 - "egal" V_CHAR_ASC -2 32-126 alle druckbaren ASCII-Zeichen V_CHAR_PRT -3 32-255 alle druckbaren Zeichen V_CHAR_ALL -4 0-255 wirklich alle Zeichen Diese vier Gruppen drften die h„ufigsten Anwendungsf„lle abdecken. Wenn sowohl 'validtype' als auch 'validchars' Null sind, wird der Fontselektor dies wie V_CHAR_IND behandeln, ebenso bei anderen ungl- tigen Werten in 'validtype'. Wenn die vier Gruppen einmal nicht ausreichen, so kann man statt- dessen ber 'validtype' und 'validchars' auch genauer angeben, welche Zeichen ben”tigt werden: validtype enth„lt dann einen Wert fr das vom GDOS zu verwendende Mapping (vgl. vst_charmap()). Die freie Wahl des Mappings steht nur mit einem entsprechenden GDOS (SpeedoGDOS oder NVDI ab Version 3) zur Verfgung. Z.Z. sind folgende Mappings definiert: Name Wert Bedeutung ----------------------------------------- MAP_DIRECT 0 "direktes Mapping" MAP_ASCII 1 ASCII-Mapping (Default) Wenn das GDOS kein Mapping beherrscht, wird der Fontselektor nur MAP_ASCII akzeptieren, alle anderen Mappings werden dann igno- riert und ein Test auf Vorhandensein bestimmter Zeichen wird nicht durchgefhrt. validchars ist ein Zeiger auf ein Array von Integers (Words), ber das angegeben werden kann, welche Zeichen der Font unbedingt enthalten soll. Das Array besteht aus einer Folge von Von-Bis-Paaren: - zwei aufeinanderfolgende Werte geben einen Bereich (von-bis) an - einzelne Zeichen werden durch Verdopplung angegeben - das Ende der Liste wird durch ein Von-Bis-Paar angegeben, bei dem 'bis' kleiner ist als 'von' Beispiel: Es sollen nur Fonts angeboten werden, die alle druck- baren ASCII-Zeichen sowie die deutschen Umlaute enthalten. xFSL_PAR xpar; int chars[] = { ' ', '~', /* ASCII 32..126 */ '„','„', '”','”', '','', 'Ž','Ž', '™','™', 'š','š', 'ž','ž', 1,0 /* Ende der Liste */ }; xpar.font->validtype=MAP_ASCII; xpar.font->validchars=chars; Zuknftige GDOSse werden wahrscheinlich weitere Mappings untersttzen (BICS, Unicode, ...). Durch die verwendete Codierung wird der Fontse- lektor auch diese korrekt beherrschen: Das in 'validtype' bergebene Mapping wird einfach eingestellt und dann das Vorhandensein der Zei- chen aus 'validchars' abgetestet. Anmerkung: Die diversen M”glichkeiten mit den Parametern 'validtype' und 'validchars' sollten sparsam und mit Bedacht verwendet werden, da das notwendige Testen der Zeichen je nach GDOS recht lange dauern kann. 1.6.3 Das User-Popup Fr das benutzerdefinierte Popup (kurz User-Popup) existieren die fol- genden Felder in der xFSL_PAR-Struktur: poptext Zeiger auf einen Text, der vor dem Popup erscheinen soll oder 0L. Dem Fontselektor steht es frei, diesen Text zu ignorieren. num_entries Anzahl Eintr„ge (d.h. Zeilen) im Popup. Steht hier eine Null, so wird kein Popup angezeigt. Es sollten nicht mehr als 16 Eintr„ge verwendet werden, auch wenn einzel- ne Fontselektoren u.U. auch mehr Eintr„ge untersttzen. sel_entry Der selektierte Eintrag im Popup (gez„hlt wird ab 0). Der Fontselektor legt hier die Nummer des angew„hlten Popup-Eintrags ab und liest den Wert bei jedem Aufruf von xfsl_event wieder neu aus. Somit k”nnen Sie den Fontselektor z.B. auch zwingen, statt dem angew„hlten Eintrag Nummer 3 den mit der Nummer 5 zu aktivieren (bei xFS_POPUP meldet der Fontselektor nur, welcher Eintrag angew„hlt wurde, aktiviert wird dieser erst beim Rcksprung in den Fontselektor). popup Dies ist ein Zeiger auf ein Array von xFSL_PENTRY-Ele- menten. An der angegebenen Adresse mssen genau so viele Elemente stehen, wie in 'num_entries' angegeben wurden. Ein Eintrag im Popup ist wie folgt aufgebaut: typedef struct { char *entry; /* Text des Popup-Eintrags */ PFONTINFO *fontinfo; /* Zeiger auf Fontinfo-Struktur */ unsigned int fontflags; /* erlaubte Fontarten */ long funcflags; /* Funktionsflags, nur fr HuGo! */ } xFSL_PENTRY; Die Bedeutung der Elemente dieser Struktur sollte nach den vorangegan- genen Ausfhrungen klar sein. Die Funktionsflags entsprechen den Kontrollflags, bis auf die Flags, die das globale Verhalten des Font- selektors beeinflužen (CC_WINDOW etc.). Diese werden hier ignoriert. Wichtig: Der Zeiger auf die PFONTINFO-Struktur darf nicht Null sein! Wenn der Text eines Eintrags mit einem '-' beginnt, wird der ent- sprechende Eintrag disabled (in heller Schrift und nicht anw„hlbar) dargestellt. Dies ist in erster Linie fr Trennlinien zwischen den Eintr„gen gedacht. Verwendung Im Prinzip kann man drei Einsatzgebiete fr das User-Popup sehen: 1. Jeder Popup-Eintrag stellt den Font fr einen bestimmten Pro- grammteil ein. Beispielsweise k”nnte man in einem bestimmten Fen- ster eines Programms nur nicht-proportionale Fonts zulassen wol- len, in einem anderen keine Vektorfonts, in einem dritten alle Fonts. 2. Jeder Eintrag stellt eine gewisse Gruppe von Fonts zur Verf- gung. Braucht man beispielsweise oft Vektorfonts, k”nnte ein Popup mit den Eintr„gen "nur Vektorfonts" und "alle Fonts" kon- struiert werden. 3. Das Popup kann aber auch fr etwas ganz anderes verwendet wer- den. Man k”nnte hier noch eine Information unterbringen, die zwar nichts mit Fonts, aber mit dem Fenster zu tun hat, fr das man einen Font einstellen will. Beispielsweise k”nnte fr ein Consolen-Fenster die Art, wie inverse Zeichen darzustellen sind, in Form eines Popups mit den Eintr„gen "invers", "fett", "unter- strichen" zur Auswahl angeboten werden. Will man das Popup so zweckentfremden, so muž man bei der Mel- dung xFS_POPUP den ge„nderten Font (zu erkennen am gesetzten FF_CHANGED-Flag) in alle anderen Popup-Eintr„ge bertragen, da sich sonst der im Fontselektor angezeigte Font „ndern wrde! 1.7 Die Fontflags ----------------- šber die Fontflags k”nnen die zur Auswahl gestellten Fonts einge- schr„nkt werden: Name Wert Bedeutung ----------------------------------------------------------- FF_SYSTEM 0x0001 Systemfont (zus„tzlich) anzeigen FF_MONOSPACED 0x0002 monospaced Fonts anzeigen FF_PROPORTIONAL 0x0004 proportionale Fonts anzeigen FF_BITMAP 0x0008 Bitmapfonts anzeigen FF_SPD 0x0010 Speedofonts anzeigen FF_TTF 0x0020 TrueType-Fonts anzeigen FF_PFB 0x0040 Type-1-Fonts anzeigen FF_CFN 0x0080 Calamusfonts anzeigen (n.i.) FF_VECTOR 0x00F0 alle Vektorfonts anzeigen FF_ALL 0x00FE alle Fonts anzeigen FF_CHANGED 0x8000 Žnderung erfolgt (nur im Popup) Die Werte sind so gew„hlt, daž die einzelnen Flags miteinander ver- odert werden k”nnen. Setzt man fr die Fontflags also beispielsweise FF_MONOSPACED|FF_VECTOR ein, so werden nur unproportionale Vektor- fonts zur Auswahl gestellt. Zudem gilt: ù FF_SYSTEM hat Vorrang, d.h. wenn dieses Flag gesetzt ist, wird der Systemfont auf jeden Fall mit zur Auswahl gestellt. ù Wenn FF_SYSTEM nicht gesetzt ist, wird der Systemfont genau dann zur Auswahl gestellt, wenn seine Eigenschaften den gesetzten Flags entsprechen. ù Wenn weder FF_MONOSPACED noch FF_PROPORTIONAL gesetzt sind, werden die Fontflags so behandelt, als seien beide Flags ge- setzt. Dies gilt analog fr FF_VECTOR und FF_BITMAP. ù Wenn FF_VECTOR gesetzt wird, werden automatisch alle Vektorfont- Formate angeboten. Eine feinere Unterteilung ist aber auf Wunsch durch die Flags FF_SPD, ..., FF_CFN m”glich. Bitte beachten: Calamus-Fonts (und somit das Flag FF_CFN) werden z.Z. noch von keinem GDOS untersttzt! ù Das Flag FF_CHANGED wird nur dazu verwendet, um im User-Popup die Einstellungen zu markieren, die sich ge„ndert haben. Der Fontselektor setzt dieses Flag nur, wertet es aber selbst nicht aus. 1.8 Returncodes --------------- Alle xFSL-Aufrufe liefern einheitliche Returncodes (Rckgabewerte) zurck. Dabei steht eine negative Zahl fr einen Fehler, eine posi- tive Zahl (oder Null) bedeutet Erfolg bzw. ein Ereignis. Name Wert Bedeutung ---------------------------------------------------------------- xFS_PARERROR -9 Parameterfehler, z.B. Aufruf nach Rev. 3 xFS_LOADERROR -8 Fehler beim Nachladen des xFSL-Moduls xFS_RES_ERROR -7 Aufl”sung zu klein (mind. 640x400 Punkte) xFS_NO_HANDLE -6 Kein VDI-Handle frei xFS_NO_WINDOW -5 Kein Fenster(handle) frei xFS_NO_FONTS -4 Keine Fonts geladen xFS_NO_FONTSIZE -3 Fontgr”že nicht identifizierbar xFS_ACTIVE -2 Fontselektor ist bereits aktiv xFS_ERROR -1 allgemeiner Fehler (Speichermangel o.„.) xFS_STOP 0 gew„hlt xFS_OK 1 gew„hlt xFS_HELP 2 Hilfe-Button angew„hlt xFS_EVENT 3 AES-Event aufgetreten xFS_POPUP 4 Žnderung am User-Popup Diese Werte wurden aufw„rtskompatibel zum Fontselektor UFSL gew„hlt (dieser kennt die Returncodes -4, -3, -2, -1, 0 und 1). Darber hinaus k”nnen auch Gemdos-Fehlermeldungen (Werte kleiner oder gleich -32) auftreten, insbesondere kann xfsl_init auch den Wert EINVFN (-32) liefern, wenn der Fontselektor den erweiterten Aufruf nicht untersttzt. Beim Aufruf xfsl_init entsprechen positive Rckgabewerte dem Fenster- handle des Fontselektors (0 bedeutet, daž der Fontselektor als mo- daler Dialog ge”ffnet wurde). Es ist m”glich, daž die Liste der Returncodes in Zukunft um weitere Fehler (Werte kleiner -9) oder Ereignisse (Werte gr”žer 4) erweitert wird. Dies sollte beim Programmentwurf bercksichtigt werden: Bei un- bekannten Fehlern sollte abgebrochen, unbekannte Ereignisse sollten ignoriert werden. 1.9 Die Pure-C-Event-Struktur ----------------------------- Die GEM-Bibliothek von Pure C verwendet eine spezielle Struktur, in der die Parameter der AES-Funktion evnt_multi() zusammengefažt sind. Diese Struktur wird auch von xfsl_event verwendet. typedef struct /* Special type for EventMulti */ { /* Eingabeparameter */ int ev_mflags, ev_mbclicks, ev_bmask, ev_mbstate, ev_mm1flags, ev_mm1x, ev_mm1y, ev_mm1width, ev_mm1height, ev_mm2flags, ev_mm2x, ev_mm2y, ev_mm2width, ev_mm2height, ev_mtlocount, ev_mthicount; /* Ausgabeparameter */ int ev_mwich, ev_mmox, ev_mmoy, ev_mmobutton, ev_mmokstate, ev_mkreturn, ev_mbreturn; /* Message-Buffer */ int ev_mmgpbuf[8]; } EVENT; Die Elemente der Struktur entsprechen denen des evnt_multi()-Aufrufs. Auch die Reihenfolge der Parameter ist - bis auf wenige Ausnahmen - identisch. Das Feld 'ev_mwich' enth„lt die aufgetretenen Events in der gleichen Kodierung wie 'ev_mflags'. 2 Tips und Hinweise =================== In den folgenden Abschnitten soll versucht werden, noch einige Tips und Hinweise zur xFSL-Schnittstelle zu geben. 2.1 Ein einfacher Aufruf ------------------------ Angesichts der Vielzahl der Parameter und Einstellm”glichkeiten er- scheint folgender Hinweis angebracht: Keine Panik! Ein xFSL-Aufruf ist einfacher als es zun„chst scheint. Insbesondere kann hier die Strategie der "schrittweisen Verfeinerung" angewendet werden, da man (fast) alle Parameter zun„chst einmal auf Null setzen kann. Ein m”glichst einfacher xFSL-Aufruf kann z.B. so aussehen: #include #include #include #include void call_xfsl(void) { int xhandle, xret; xFSL_PAR xpar; PFONTINFO pfont; xFSL *xfsl; memset(&xpar,0,sizeof(xFSL_PAR)); memset(&pfont,0,sizeof(PFONTINFO)); xpar.par_size=sizeof(xFSL_PAR); xpar.pfi_size=sizeof(PFONTINFO); xpar.font=&pfont; xpar.font->fontcol=BLACK; if(get_cookie('xFSL',&xfsl)) { xhandle=xfsl->xfsl_init(0,&xpar); if(xhandle>=0) { do xret=xfsl->xfsl_event(xhandle,0L); while(xret>xFS_OK); xfsl->xfsl_exit(xhandle); if(xret==xFS_STOP) printf("Abbruch\n"); else if(xret==xFS_OK) printf("Font mit ID %d ausgew„hlt\n",xpar.font->fontid); else if(xret<0) printf("Fehler %d\n",xret); } else printf("Fehler %d\n",xhandle); } else printf("Cookie nicht gefunden!\n"); } Mit den beiden memset-Aufrufen werden alle Elemente der Strukturen xFSL_PAR und PFONTINFO auf Null gesetzt. Anschliežend werden einige unbedingt n”tige Werte eingetragen: ù die Gr”žen der beiden Strukturen xFSL_PAR und PFONTINFO ù die Adresse der PFONTINFO-Struktur wird in der xFSL_PAR-Struktur eingetragen ù die Schriftfarbe wird auf schwarz gesetzt (dies k”nnte man auch weglassen, aber normalerweise wird man ja in schwarzer Schrift auf weižem Grund schreiben wollen) Mehr ist an Vorbereitungen nicht n”tig, es folgt nun der eigentliche Aufruf. Zun„chst wird der xFSL-Cookie gesucht. Im Erfolgsfall wird nun der Fontselektor initialisiert, indem die xFSL_PAR-Struktur ber- geben wird. War dieser Aufruf erfolgreich ('xhandle' ist gr”žer oder gleich Null), so befindet sich der Fontselektor bereits auf dem Bild- schirm. In der Hauptschleife wird nun gewartet, bis der Fontselektor entweder mit xFS_STOP oder xFS_OK vom Anwender beendet wird oder bis ein Fehler auftritt (andere positive Rckgabewerte werden hier ein- fach ignoriert). Mit dem Aufruf von xfsl_exit wird der Fontselektor wieder vom Bildschirm entfernt und anschliežend der Rckgabewert aus- gewertet. Das war doch gar nicht so kompliziert, oder? Von hier aus k”nnen Sie nun mit den diversen Parametern und Flags weiter experimentieren. 2.2 Fragen und Antworten ------------------------ Wie kann ich feststellen, welche Features der Fontselektor bietet? Direkt kann dies fr einige Features ber die Funktion xfsl_info geschehen. Indirekt k”nnen weitere Features ber das Feld 'control' in der xFSL_PAR-Struktur abgefragt werden: Nach einem erfolgreichen xfsl_init-Aufruf wird der Fontselektor diejenigen Kontrollflags l”- schen, die er nicht versteht. Wie soll sich mein Programm verhalten, wenn es feststellt, daž der Fontselektor das gewnschte Feature nicht untersttzt? Wenn berhaupt ein Fontselektor installiert ist, sollte dieser auch auf jeden Fall verwendet werden. Je nachdem, wie wichtig das vermižte Feature ist, k”nnte sich Ihr Programm nach Alternativen umsehen (z.B. ber das Font-Protokoll) oder versuchen, das fehlende Feature zu kompensieren. Auch hier gilt wieder: Der Anwender wollte einen Fontselektor, keine Fehlermeldung. Wenn das fehlende Feature nur schwer zu kompensieren ist, dann sollten Sie den Anwender einmalig(!) mit einem entsprechen- den Hinweis informieren, aber trotzdem den Fontselektor aufrufen. Auch wenn die Auswahl dann nicht mit dem gewnschten Komfort gesche- hen kann, ist dies fr den Anwender immer noch weniger frustrierend, als berhaupt keinen Font ausw„hlen zu k”nnen. Einige Beispiele: Sollte ber das Popup der Font fr bestimmte Fen- ster des Programms eingestellt werden, so sollte er bei fehlendem Popup fr das oberste Fenster des Programms bernommen werden. Unter- sttzt der Fontselektor das Sperren der Gr”žen„nderung nicht, so sollte die zurckgelieferte Gr”že einfach ignoriert werden und - wenn sie von der gewnschten Gr”že abweicht - der Anwender durch einen Hinweis davon in Kenntnis gesetzt werden. Man sollte sich brigens nicht darauf verlassen, daž der Fontselektor beim n„chsten Aufruf noch der gleiche ist bzw. die gleichen Features untersttzt! Die Fontselektoren, die mit einem Overlay (XFSL.OVL) arbeiten k”nnen durch einfaches Umkopieren des Overlays jederzeit ohne Reset ausgewechselt werden. Was hat es mit diesem "Mapping" auf sich? Vektorfonts enthalten meist wesentlich mehr als die blichen 256 Zei- chen, noch dazu normalerweise nicht in der gewohnten ASCII-Codierung (beispielsweise k”nnte das Leerzeichen auf Position 0 statt auf 32 liegen). Daher werden die entsprechenden Zeichen aus dem Font auf die "normalen" 256 Zeichen "gemappt" (d.h. abgebildet), so daž sich das Leerzeichen wie gewohnt an Position 32 befindet, unabh„ngig davon, welche Position es innerhalb des Fonts hat. Dieses bezeichnet man als ASCII-Mapping. Per Default ist das ASCII-Mapping aktiv. Dadurch kann man aber die Zeichen, die aužerhalb des ASCII-Zeichensatzes liegen, nicht anspre- chen. Als zweites Mapping steht daher das "direkte Mapping" zur Verf- gung. Hier hat man nun Zugriff auf alle Zeichen eines Fonts. Aller- dings muž man dazu auch wissen, um welche Art von Font es sich han- delt und wieviele Zeichen der Font enth„lt: Speedofonts haben meist 564 Zeichen, TrueType-Fonts k”nnen (theoretisch) bis zu 65536 Zeichen enthalten. Diese Information erh„lt man nach dem Umschalten auf das direkte Mapping mit der VDI-Funktion vqt_fontinfo(): int minADE, maxADE; vst_charmap(handle,0); vqt_fontinfo(handle,&minADE,&maxADE,dumarray,&dummy,dumarray); In 'minADE' erh„lt man den kleinsten, in 'maxADE' den gr”žten glti- gen Zeichenindex. Das direkte Mapping ist fr normale Anwendungen nur eingeschr„nkt brauchbar. Im Gegensatz zum ASCII-Mapping, das ein einheitliches Mapping fr alle Arten von Fonts darstellt, muž man hier n„mlich ganz genau wissen, um welche Art von Font es sich handelt. So haben z.B. die Speedo-Symbolfonts eine andere Codierung als die "normalen" Speedofonts. D.h. daž man an Position 64 eines solchen Symbolfonts nicht das gleiche Zeichen vorfinden wird wie bei einem "normalen" Speedofont. Andere Mappings als ASCII sind daher z.Z. fr den Grožteil der Pro- gramme uninteressant. Knftige GDOSse werden aber m”glicherweise noch andere einheitliche Mappings (z.B. Unicode oder BICS) anbieten, bei denen man sich dann wieder darauf verlassen kann, daž an einer be- stimmten Position auch immer das gleiche Zeichen liegt („hnlich wie beim ASCII-Mapping, nur eben auch bei Positionen gr”žer 255). (to be continued ...) 2.3 Programmiertechnische Hinweise ---------------------------------- Die Beschreibung der xFSL-Schnittstelle in diesem Text erfolgt in Pure C. In den folgenden Abschnitten werden die Datentypen und Beson- derheiten von Pure C n„her beschrieben, damit xFSL-Aufrufe auch aus anderen Programmiersprachen und C-Dialekten gelingen. 2.3.1 Datentypen In diesem Text werden die folgenden Datentypen verwendet: Name Gr”že ---------------------------------------- int 16 Bit mit Vorzeichen unsigned int 16 Bit ohne Vorzeichen long 32 Bit mit Vorzeichen unsigned long 32 Bit ohne Vorzeichen Der Datentyp char ist ein (ASCII-)Zeichen und wird hier nur als Zei- gertyp verwendet, d.h. als Zeiger auf einen C-String (eine Folge von Zeichen, die mit einem Nullbyte abgeschložen sind). Union Eine Union entspricht einem varianten Record in Pascal. Es handelt sich um eine Struktur, deren einzelne Elemente "bereinander" liegen, d.h. denselben Speicherbereich belegen. Welches Element gerade gltig ist, ergibt sich aus dem Kontext bzw. bleibt dem Programmierer ber- lassen. Beispiel: In der Struktur PFONTINFO wird fr die Gr”ženangabe eine Union 'fsize' verwendet: union fsize { int size; /* Fontgr”že in Punkt */ fix31 size31; /* Fontgr”že in 1/65536 Punkt */ }; Der Speicherbedarf dieser Union betr„gt vier Bytes, da der Typ fix31 vier Bytes grož ist. Man k”nnte nun dem Element 'size31' eine Gr”žen- angabe in 1/65536 Punkt zuweisen und dann den Wert in ganzen Punkt aus dem Element 'size' auslesen - dies ist aber nicht empfehlenswert, da bei der Umrechnung fix31 nach pt immer gerundet werden sollte, s.u. fix31 Der Datentyp fix31 ist eine Festkommazahl, bei dem die oberen 16 Bit den vorzeichenbehafteten Vorkomma-Anteil darstellen und die unteren 16 Bit den vorzeichenlosen Nachkomma-Anteil. Er wird ausschliežlich fr Gr”ženangaben von Fonts verwendet, die damit auf 1/65536 Punkt genau angegeben werden k”nnen. Bei der Umrechnung von fix31 nach pt darf man das Runden nicht ver- gessen. Zitat aus dem NVDI-Guide: Man darf nie, nie, niemals den Nachkommateil einfach abschneiden! 2.3.2 Parameterbergabe Die šbergabe der Parameter bei allen xFSL-Aufrufen geschieht ber den Stack nach C-Konvention. D.h. daž der beim Aufruf am weitesten rechts stehende Parameter zuerst auf den Stack gelegt wird und der am wei- testen links stehende Parameter zum Schluž, d.h. beim Einsprung in den Fontselektor, obenauf liegt. 2.3.3 Pure C und 'cdecl' Pure C bergibt die Parameter an Funktionen normalerweise in Regi- stern. Fr eine šbergabe ber den Stack muž entweder das Schlssel- wort "cdecl" verwendet werden (wie im Includefile XFSL.H geschehen) oder der Compilerschalter "-H" gesetzt werden. Das Schlsselwort "cdecl" ist eine Pure-C-spezifische Erweiterung und wird daher bei gesetztem Compilerschalter "-A" (ANSI-Konformit„t) an- gemahnt. 3 Revisions-History =================== Revision 4 ù Aufgrund eines kleinen Designfehlers in den „lteren Revisionen, der die Erweiterbarkeit der Schnittstelle einschr„nkte, ist Revision 4 nicht kompatibel zu „lteren Revisionen. Dies sollte in der Praxis kein Problem darstellen, da der Fontselektor Auf- rufe nach dem alten Schema mit einem Fehler quittieren wird. Die alte Revision 3 wird im Laufe der Zeit verschwinden. ù neue Parameter in der PFONTINFO-Struktur: - Text-Hintergrundfarbe ('backcol') - Textausrichtung ('halign' und 'valign') - Textrotation ('rotation') - Angabe von Zeichen, die der ausgew„hlte Font unbedingt enthal- ten soll ('validtype' und 'validchars') ù die PFONTINFO-Struktur wird auch bei Rckgabe xFS_STOP mit den Werten des zuletzt im Fontselektor ausgew„hlten Fonts gefllt ù Codierung der Fontflags ge„ndert (feinere Unterscheidung der Vektorformate) Revision 3 ù die erste ”ffentlich verfgbare Schnittstellen-Revision „ltere Revisionen ù „ltere Revisionen k”nnen getrost ignoriert werden, da diese nie- mals in einem fr eine gr”žere ™ffentlichkeit verfgbaren Pro- gramm in Erscheinung getreten sind 4 Programmbersicht =================== Es folgt eine šbersicht ber alle z.Z. erh„ltlichen Fontselektoren, die ber eine UFSL- oder eine xFSL-Schnittstelle (oder beides) ver- fgen. Desweiteren folgt eine Liste von Programmen, die einen Fontselektor mit einer der beiden Schnittstellen verwenden. Erg„nzungen und Berichtigungen zu diesen Aufstellungen schicken Sie bitte an Dirk Haun (Adresse siehe unter "Kontaktadressen"). 4.1 Fontselektor-šbersicht -------------------------- Eine kleine šbersicht ber die existierenden Fontselektoren: UFSL von Michael Th„nitz Dies ist der Prototyp aller externen Fontselektoren. Die letzte ver”ffentliche Version ist 0.97, danach hat Michael leider die Entwicklung eingestellt. Dankenswerterweise hat er aber die Quell- texte ver”ffentlicht. FontSel von Holger Weets und Christoph Zwerschke Ein kleiner, aber auch etwas spartanischer Fontselektor von Holger Weets, der seit der Version 1.02 von Christoph Zwerschke weiterentwickelt wird. Ab der Version 1.02 werden auch Teile der xFSL-Schnittstelle untersttzt. xUFSL von Stefan Rogel Der xUFSL bietet gegenber den bisher genannten Fontselektoren viele zus„tzliche Features. Da diese ber die existierende UFSL- Schnittstelle nicht angesprochen werden konnten, hat Stefan die Schnittstelle erweitert. Das Design der ersten Version war, vor- sichtig ausgedrckt, "umstritten". Letzte ver”ffentlichte Versi- on: 1.05. Nachfolger des xUFSL ist ... HuGo! von Stefan Rogel HuGo! ist der an die xFSL-Schnittstelle angepažte Nachfolger des xUFSL (die UFSL-Schnittstelle wird ebenfalls noch untersttzt, nicht aber die speziellen Erweiterungen des xUFSL an der UFSL- Schnittstelle). Die Namens„nderung wurde vollzogen, um Verwechs- lungen zu vermeiden. Calvino von Dirk Haun Zusammen mit HuGo! der erste Fontselektor mit xFSL-Schnittstelle. Auch Calvino untersttzt noch die einfache UFSL-Schnittstelle. FONT_SEL und FONT_PAL von Christian Grunenberg Diese beiden Programme arbeiten auf Drag&Drop-Basis, sie unter- sttzen also weder die UFSL- noch die xFSL-Schnittstelle, dafr aber das Font-Protokoll. FONT_SEL ist ein Fontselektor, FONT_PAL eine Fontpalette (mit integriertem Fontselektor). 4.2 Programme, die einen Fontselektor untersttzen -------------------------------------------------- Folgende Programme untersttzen einen externen Fontselektor (Stand 21.07.1995): Programm Kategorie Autor UFSL xFSL ---------------------------------------------------------------------- 800XL-Deejay Laufwerksemulator Kolja Koischwitz + APP_List Systemutility Ralf Zimmermann @ OF2 + BibelST Bibel-Software Reinhard Bartel @ LU + Cat2Maus MausTausch Harald Sommerfeldt @ W + Chatwin Shell Dirk Haun @ WI2 +F +F CyPress Textverarbeitung Rene Bartholomay @ OL +F DB-Point Newsreader Michael Heng @ HH + Disk Cake Diskutility Christoph Zwerschke @ KA + + Egale Dateiutility David Reitter @ WI2 + Everest Editor Oliver Schmidt + GEMAR Backup Steffen Engel @ PE2 + GEM-Fontviewer Zeichensatz-Anzeige Reinhard Bartel @ LU + GEM-Plan Tabellenverwaltung Reiner Rosin @ WI2 +F Hitchcock Systemutility Thorsten Pohlmann @ WI2 + IdeaList ASCII-Druckprogramm Christoph Bartholme @ KA2 + Jedi GAL-Assembler Ralf Zimmermann @ OF2 + MasterBrowse Dateiviewer Michel Forget + MenuInfo Systemutility Dirk Hagedorn @ MK2 + Okami Newsreader Wolfram R”sler @ AC2 + QED Editor Christian Felsch @ HH + RoadRunner Autofahrtplanung Andreas Schrell @ RS +F SaugUtility dito Frank Rger @ OS2 + ST-Guide Hypertext Holger Weets @ OL + STJ-Oberon Programmiersprache Stephan Junker @ AC2 + + Texel Tabellenkalkulation Thomas Much @ KA2 + + UpToCASE CASE-Tool Michael Nolte @ K + VESAL Lernprogramm Peter Klasen @ KR + Zeig's mir Dateiviewer Reiner Rosin @ WI2 + +F ---------------------------------------------------------------------- (+: untersttzt, F: als Fensterdialog; e-mail-Adressen: MausNet) Autoren, die nicht ber's MausNet erreichbar sind: Kolja Koischwitz: joust@cs.tu-berlin.de Michel Forget: mforget@worldgate.edmonton.ab.ca Oliver Schmidt: ber Christian Dalichow @ KI (MausNet) A Das Font-Protokoll ==================== Beschreibung des Font-Protokolls, Revision 4 Eine minimale Untersttzung dieses Protokolls besteht in der Auswer- tung der Nachricht FONT_CHANGED. Programme, die eines der (GDOS-) At- tribute Textwinkel, -breite, -kerning, -neigung oder die Angabe der Textgr”že in 1/65536 Punkt untersttzen, sollten auch die Nachricht XFONT_CHANGED, die zus„tzliche Informationen anbietet, untersttzen. šber die Nachricht FONT_SELECT kann der Fontselektor auch von der Ap- plikation aufgerufen werden. Dabei k”nnen auch die aktuell eingestell- ten Attribute bergeben werden. Untersttzt die Anwendung auch das XAcc-2-Protokoll, so kann sie auch leicht die Untersttzung der Best„tigungsnachricht FONT_ACK offenle- gen und ohne Environment-Variable nach Fontselektoren im Speicher suchen. ù FONT_CHANGED-Nachricht: Nachricht des Fontselektors an eine Applikation, daž der Zeichen- satz und/oder die Zeichenattribute (Gr”že, Farbe und Effekte) in einem oder mehreren Fenstern der Applikation gewechselt werden sollen. Besitzt die Zielapplikation im erweiterten XAcc-Namen die Kennung "XFontAck", so muž diese Nachricht mit der Nachricht FONT_ACK beantwortet werden. Ansonsten ist die Untersttzung die- ser Nachricht optional. Negative Werte in msg[6/7] bzw. Null in msg[4/5] stehen fr keine Ver„nderung msg[0] = FONT_CHANGED (0x7a18) msg[1] = apID msg[2] = 0 msg[3] = Fenster-Handle oder negativer Wert, falls Font in allen Fenstern gewechselt werden soll msg[4] = Font-ID oder Null msg[5] = Font-Gr”že in Punkt (>0) oder Pixel (<0) bzw. Null fr keine Ver„nderung msg[6] = Font-Farbe msg[7] = Effekte: Bit 0: Fett Bit 1: Hell Bit 2: Kursiv Bit 3: Unterstrichen Bit 4: Umrandet Bit 5: Schattiert Bit 6: Invers (restliche Bits sind reserviert) ù XFONT_CHANGED-Nachricht: Erweiterte (GDOS-)Attribute bermitteln. Diese Nachricht ist op- tional und wird vor der Nachricht FONT_CHANGED verschickt, d.h. erst wenn die Nachricht FONT_CHANGED eintrifft und den gleichen Absender (msg[1] vergleichen!) hat, sollten diese Werte gesetzt werden! Dadurch werden doppelte Redraws und/oder Fehler vermie- den. Die Nachricht FONT_CHANGED enth„lt die auf Punkt gerundete Gr”- že, d.h. Programme, die XFONT_CHANGED nicht untersttzen, k”nnen diesen Wert benutzen. Fontselektoren versenden idR diese Nachricht nur, wenn eines der bermittelten Attribute vom Normalwert abweicht! msg[0] = XFONT_CHANGED (0x7a1b) msg[1] = apID msg[2] = 0 msg[3/4] = Gr”že in 1/65536-Punkt (fix31) msg[5] = Rotationswinkel in 1/10-Grad (0-3599) msg[6] = Neigung in 1/10-Grad (-1800 - 1800) msg[7] = Breite und Kerning: Bit 15: Paar-Kerning Bit 13/14: Track-Kerningmodus (0-3) Bit 0-12: Breite in Punkt in C: typedef struct { unsigned int pair : 1; unsigned int track : 2; unsigned int width : 13; } VECTOR_INFO; ù FONT_SELECT-Nachricht: Mit dieser Nachricht kann ein im Speicher vorhandener Fontselek- tor, der im erweiterten XAcc-Namen die Kennung "XFontSelect" be- sitzt, aufgerufen werden. Untersttzt die Anwendung und/oder der Fontselektor kein XAcc-2-Protokoll, so kann noch nach dem Inhalt der (AES-)Environment-Variablen "FONTSELECT" gesucht werden. Die- se Variable kann gegebenenfalls auch mehrere Namen (getrennt durch Semikolon) enthalten, wobei die Namen optional auch Pfad und Dateierweiterung besitzen k”nnen, so daž man den Fontselek- tor unter Multitasking bei Bedarf parallel nachladen kann. Beispiele: setenv FONTSELECT=FONT_PAL;FONT_SEL setenv FONTSELECT=C:\FONTSEL\FONT_SEL.APP;C:\FONTSEL\FONT_PAL.APP Zur passiven Untersttzung des Font-Protokolls gengt aber die Auswertung der o.g. Nachrichten FONT_CHANGED und XFONT_CHANGED. Negative Werte in msg[6/7] oder eine Null msg[4/5] bedeuten, daž dieser Parameter nicht ben”tigt wird, nicht eingestellt werden soll oder noch nicht gesetzt wurde msg[0] = FONT_SELECT (0x7a19) msg[1] = apID msg[2] = 0 msg[3] = Handle des Fensters, dessen Zeichensatz einge- stellt werden soll, oder ein negativer Wert, wenn der Zeichensatz in allen Fenstern der Applikation gewechselt werden soll msg[4] = Font-ID oder Null msg[5] = Font-Gr”že in Punkt (>0) oder Pixel (<0) bzw. Null, falls der Parameter nicht ben”tigt wird (s.o.) msg[6] = Farbe msg[7] = Effekte (s.o.) ù FONT_ACK-Nachricht: Fontselektor darber informieren, ob die FONT_CHANGED-Nachricht ausgewertet bzw. die Zeichensatz-Attribute eingestellt werden konnten msg[0] = FONT_ACK (0x7a1a) msg[1] = apID msg[2] = 0 msg[3] = TRUE (1): Nachricht wurde ausgewertet FALSE (0): Nachricht wurde ignoriert msg[4-7] = 0 (reserviert) B Die UFSL-Schnittstelle ======================== Der Vollst„ndigkeit halber folgt hier noch die Original-Beschreibung von Michael Th„nitz zur ursprnglichen UFSL-Schnittstelle: Programmierschnittstelle: UFSL ist eine Fontauswahlbox fr den Autoordner. Sie bietet dem Pro- grammierer eine einfache Programmierschnittstelle ber einen Cookie. Der Cookie lautet: "UFSL". Der Cookie liefert einen Zeiger auf folgende Struktur: typedef struct { unsigned long id; /* UFSL ID (UFSL) */ unsigned int version; /* Version (BCD-Format) */ int dialtyp; /* 0=Dialog, 1=Fenster */ int cdecl (*font_selinit)(void); int cdecl (*font_selinput)( int vdihandle, int dummy, char *text, /* eigener Text, max. 34 Zeichen */ int ftype, /* 1=nur monospaced Fonts, 0=alles */ int *fretid, /* eingestellte FontId */ int *fretsize /* eingestellte Fontgr”že */ ); OBJECT *helpbutton; /* Typ: BOXTEXT */ void cdecl (*helpfunc)(void); /* Benutzerdefinierte Helpfkt. */ /**** ab Version 0.91 ********************************************/ char *examplestr; /* Beispieltext fr Fontdarstellung */ /**** ab Version 0.96 ********************************************/ void cdecl (*msgfunc)(int event, int msgbuf[]);/* Redrawfunktion */ /**** ab Version 0.97 ********************************************/ int cdecl (*fontsel_exinput)( int vdihandle, int ftype, /* 1=nur monospaced Fonts, 0=alles */ char *text, /* eigener Text, max. 34 Zeichen */ int *fretid, /* eingestellte FontId */ int *fretsize /* eingestellte Fontgr”že */ ); } UFSL; Aufruf: UFSL *ufsl; ufsl=(UFSL *)get_cookie('UFSL'); ufsl->helpfunc= my_helpfunc; /* Hilfefunktion oder NULL */ ufsl->msgfunc = my_msghandler; /* Redrawfunktion oder NULL, Dialtyp beachten */ ufsl->fontsel_input(vdihandle,"Bitte Font ausw„hlen",0,&id,&size); oder ufsl->fontsel_input(vdihandle,NULL,0,&id,&size); Returncodes: 1 : Alles OK, Werte gltig. 0 : Abbruch gew„hlt. -1 : Out of memory. -2 : Unzul„ssiger Mehrfachaufruf. -3 : Fontgr”že konnte nicht identifiziert werden. -4 : Anzahl Fonts muž gr”žer null sein. Sonderfunktionen: void cdecl (*helpfunc)(void); /* Benutzerdefinierte Helpfkt. */ UFSL kann eine benutzerdefinierbare Hilfefunktion ber den ebenfalls optionalen Hilfebutton aufrufen. helpfunc() ben”tigt keine Parameter und liefert auch keinen Wert zurck. void cdecl (*msgfunc)(int event, int msgbuf[]); /* Redrawfunktion */ Bei Verwendung von UFSL als Fensterdialog ist es notwendig eine Re- drawfunktion zur Verfgung zu stellen. Sie schickt die anfallenden Events an das aufrufende Programm zurck, damit nach Verschieben des Dialogs die Hintergrundfenster restauriert werden k”nnen. msgfunc() liefert als ersten Parameter das Ergebnis von evnt_multi() und als zweiten Parameter die MsgPipe. Ein Returncode wird nicht ben”tigt. Das Anwenderprogramm muá die n”tigen Routinen zur Fensterbehandlung zur Verfgung stellen. wind_update(..._UPDATE) wird von UFSL nicht gesetzt, obliegt also dem rufenden Anwenderprogramm. Prinzipbedingt (?) ist die Memoryprotection von MTOS auszuschalten. Grunds„tzlich gilt es zu berlegen, ob tats„chlich alle Events ent- sprechend beantwortet werden sollen. Ein WM_TOPPED, das andere eigene Fenster nach vorn bringt, sollte wohl nicht beantwortet werden, da UFSL naturgem„á nur applikationsmodal sein kann, da UFSL ja in einem eigenen form_do() sprich evnt_multi() kreist. C Hinweise fr Autoren anderer Fontselektoren ============================================= Autoren anderer Fontselektoren sind dazu eingeladen, sich der xFSL- Schnittstelle anzuschliežen. Im Prinzip kann jeder Fontselektor, der als TSR konzipiert ist, mit der xFSL-Schnittstelle ausgerstet wer- den. Damit keine Mižverst„ndnisse entstehen: Die Overlay-Technik und die Reentranz, wie sie Calvino und HuGo! bieten, sind nicht Teil der ei- gentlichen Schnittstelle und mssen von anderen Fontselektoren daher auch nicht untersttzt werden. Allerdings ist auch die Schnittstelle zwischen dem residenten Teil ("Shell") und dem nachgeladenen Teil ("Overlay") genormt und kann daher auch von anderen Fontselektoren verwendet werden. Eine Beschreibung dieser internen Schnittstelle ist auf Anfrage erh„ltlich, siehe "Kontaktadressen". Da bereits eine Reihe von Programmen die alte UFSL-Schnittstelle un- tersttzen, erscheint es ratsam, auch in neuen Fontselektoren diese Schnittstelle noch zur Verfgung zu stellen. Jedoch zeigt ein kurzer Blick auf diese Programme, daž sie fast ausschliežlich den Fontselek- tor als modalen Dialog aufrufen. Die Empfehlung lautet daher, eine minimale UFSL-Untersttzung einzubauen (nur als modaler Dialog) und dafr die xFSL-Schnittstelle m”glichst weitgehend zu implementieren, da zu erwarten steht, daž gerade die - nun endlich genormten - Erwei- terungen gegenber der UFSL-Schnittstelle von den Programmen verwen- det werden sollen. Ein Fontselektor sollte m”glichst die folgenden zus„tzlichen Features bieten: ù Gr”žen„nderung m”glich Insbesondere ist damit gemeint, daž nicht nur eine Gr”že ausge- w„hlt, sondern bei Vektorfonts auch die Zwischengr”žen einge- stellt werden k”nnen. ù fix31-Untersttzung Fr einige Anwendungen reicht die Einstellung der Fontgr”že in Punkt nicht aus, daher sollte auch eine Einstellung in 1/65536 Punkt m”glich sein. ù User-Popup Durch das zus„tzliche Popup wird der Fontselektor flexibler ein- setzbar. ù Drag&Drop-Untersttzung Neben dem "traditionellen" Aufruf ber den Cookie kommen L”- sungen auf Drag&Drop-Basis immer mehr in Mode. Wenn der Fontse- lektor von sich aus schon Drag&Drop untersttzt, l„žt er sich leicht durch ein kleines "Frontend"-Programm in einen vollwerti- gen Drag&Drop-Selektor verwandeln. Folgende Konventionen wurden fr einen xFSL-Fontselektor vereinbart: ù Wenn der Fontselektor ber einen Closer verfgt, so wird dieser als "Abbruch" interpretiert, d.h. es wird xFS_STOP zurckgege- ben. Ist das Kontrollflag CC_CLOSER gesetzt, wird der gerade aktuelle Font aber trotzdem zurckgegeben (in der PFONTINFO- Struktur in xFSL_PAR). ù Wenn der erweiterte Aufruf (xfsl_init, xfsl_event und xfsl_exit) nicht untersttzt wird, muž zumindest eine Dummy-Funktion fr xfsl_init installiert werden, die immer -32 (Gemdos-Fehlermel- dung EINVFN, ungltige Funktionsnummer) zurckgibt. Es wird aber dringend empfohlen, den erweiterten Aufruf anzubie- ten, da dieser am h„ufigsten verwendet wird. ù Es ist legal, daž der Fontselektor beim erweiterten Aufruf nur als modaler Dialog erscheint. Bei gesetztem CC_WINDOW sollte xfsl_init dann aber xFS_NO_WINDOW zurckgeben, damit sich der Aufrufer darauf einstellen kann. D Kontaktadressen ================= Die xFSL-Schnittstelle wurde von Dirk Haun und Stefan Rogel unter tat- kr„ftiger Mithilfe von Reiner Rosin und einer Reihe fleižiger Beta- tester entwickelt. Wenn Sie Fragen und/oder Anmerkungen zur xFSL-Schnittstelle haben, dann wenden Sie sich doch einfach an Dirk Haun Europastr. 8 D-64569 Nauheim e-mail: Dirk Haun @ WI2 (MausNet) oder an Stefan Rogel K”hlerweg 1 D-67661 Kaiserslautern e-mail: Stefan Rogel @ LU (MausNet) Das Font-Protokoll stammt von Christian Grunenberg Traminerweg 5 D-71717 Beilstein e-mail: Christian Grunenberg @ LB (MausNet)