Protokolle

XAcc

XSSI-Protokoll

15.14 xFSL-Schnittstelle

Spätestens seit der Einführung von Vektorfonts erfreut sich das GDOS, das jahrelang auf dem Atari ein Schattendasein führte, steigender Beliebtheit. Immer mehr Programme bieten die Möglichkeit, für die Ausgabe (und teilweise auch für die Eingabe) einen anderen Font als den Systemfont zu verwenden.

Um nun einen Font auswählen zu können, benötigt man einen Fontselektor. Und damit nicht jeder Programmierer sein eigenes Süppchen kocht und im Sinne einer einheitlichen Bedienung entstand der Wunsch nach einer Systemerweiterung, die einen Fontselektor — ähnlich wie einen Fileselektor — für alle Programme zur Verfügung stellt.

Das erste derartige Programm war der UFSL von Michael Thänitz. Er stellt über einen Cookie Routinen zum Aufruf eines Fontselektors zur Verfügung. Diese Schnittstelle wird bereits von einer Reihe von Programmen 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 aufrufen, 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 ursprüngliche einfache UFSL-Schnittstelle zur Verfügung 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 für das Programm einen neuen Fontselektor zu schreiben. Etwas überspitzt formuliert wird hier also die Idee eines externen Fontselektors ad absurdum geführt …

Durch den Wildwuchs an der UFSL-Schnittstelle erschien es sinnvoller, 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.

• 15.14.1 Die xFSL–Schnittstelle
• 15.14.2 xFSL Tips und Hinweise
• 15.14.3 Revisions–History
• 15.14.4 Programmübersicht
• 15.14.5 Die UFSL–Schnittstelle
• 15.14.6 Hinweise für Autoren anderer Fontselektoren

15.14.1 Die xFSL–Schnittstelle

Über die xFSL–Schnittstelle hat der Aufrufer (d.h. das Programm, das den Fontselektor aufruft) wesentlich mehr Einfluß auf den Fontselektor, sein Verhalten und auf die zur Auswahl angebotenen Fonts.

Bei der Konzeption der neuen Schnittstelle wurde versucht, auf die Möglichkeiten der verschiedenen Programmiersprachen Rücksicht zu nehmen (z.B. Vermeidung von Zeigern auf Funktionen) und gleichzeitig für mögliche Erweiterungen der Schnittstelle gerüstet zu sein.

Die Anpassung eines Programms an die xFSL–Schnittstelle sollte eine Sache von wenigen Minuten sein, zumal Beispielaufrufe in verschiedenen Programmiersprachen mitgeliefert werden. Die Umsetzung spezieller Wünsche ist natürlich 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 …

• 15.14.1.1 Der xFSL–Cookie
• 15.14.1.2 Der vereinfachte Aufruf (xfsl_input)
• 15.14.1.3 Der erweiterte Aufruf
• 15.14.1.4 Die Fontflags
• 15.14.1.5 xFSL Returncodes
• 15.14.1.6 Die Pure-C-Event-Struktur

15.14.1.1 Der xFSL–Cookie

Wenn ein Fontselektor installiert ist, der die xFSL–Schnittstelle unterstützt, 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:

15.14.1.2 Der vereinfachte Aufruf (xfsl_input)

xfsl_input ist der Einsprungpunkt für einen vereinfachten Aufruf. Der Fontselektor kann darüber 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:

Rückgaben

xfsl_input liefert eine negative Zahl zurück, wenn ein Fehler aufgetreten ist. Eine 0 wird zurückgegeben, wenn Abbruch angewählt wurde. Wird eine 1 zurück geliefert, dann wurde ein neuer Font ausgewählt.

Die Rückgabewerte sind für alle xFSL–Funktionen gleich und aufwärtskompatibel zu den Rückgabewerten des UFSL.

15.14.1.3 Der erweiterte Aufruf

Der erweiterte xFSL–Aufruf besteht aus drei einzelnen Funktionsaufrufen:

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 Funktionen übergeben werden müssen (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.

15.14.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:

Für die Returncodes der Funktion gilt wieder: Ein negativer Rückgabewert deutet auf einen Fehler hin. Positive Werte haben hier eine etwas abweichende Bedeutung: Eine 0 heißt, der Fontselektor wurde (erfolgreich) als modaler Dialog geöffnet. Andere positive Werte entsprechen dem Fensterhandle des geöffneten Fontselektors. Somit können Sie das Fenster des Fontselektors beispielsweise bei einem AV–Server anmelden.

Im Erfolgsfalle (Rückgabe größer oder gleich 0) sollten Sie sich das Handle in einer Variablen merken, da es für 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 wenigstens als Dialog darzustellen (Kontrollflag CC_WINDOW löschen und nochmals xfsl_init aufrufen).

Merke: Der Anwender will einen Fontselektor, keine Fehlermeldung.

15.14.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:

Die möglichen Rückgabewerte von xfsl_event:

15.14.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 ausgewählt oder Abbruch angewählt wurde, oder daß xfsl_event einen Fehler meldete. Wenn schon der xfsl_init–Aufruf fehlgeschlagen ist, darf xfsl_exit nicht aufgerufen werden (logisch, da man ja auch kein gültiges Handle hat).

Der Aufruf von xfsl_exit sollte auch bei Eintreffen der Nachrichten AC_CLOSE und AP_TERM nicht vergessen werden!

15.14.1.3.4 Der Info–Aufruf (xfsl_info)

Über diesen Aufruf können einige der Features des installierten Fontselektors abgefragt werden:

long xfsl_info (void);

Wenn der Rückgabewert positiv ist, dann stehen die folgenden Flags für vorhandene Features (negative Rückgabewerte sind, wie üblich, Fehlermeldungen):

Weitere Features des Fontselektors lassen sich indirekt über das Element `control' der xFSL_PAR–Struktur abfragen: Bei einem erfolgreichen xfsl_init–Aufruf werden diejenigen Kontrollflags gelöscht, die der Fontselektor nicht kennt.

15.14.1.3.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 Workstation oder einfach eine Null übergibt, hängt das weitere Verhalten des Fontselektors ab:

Übergibt man ein gültiges Handle, so wird der Fontselektor versuchen, den auf der entsprechenden Workstation gerade aktuellen Font zu ermitteln 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 Fontselektor 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 Workstation 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 für diese Workstation auch vst_load_fonts() aufrufen (sofern ein GDOS installiert ist). Dies kann zu unerwarteten Resultaten führen, 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 Verfügung 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 Parametern bzw. der xFSL_PAR–Struktur zurückgegeben und der Aufrufer muß ihn dann selbst einstellen.

15.14.1.3.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 ausfüllen können, worauf der Fontselektor dann sinnvolle Defaultwerte annehmen wird.

Die Felder im einzelnen:

Um es nochmals zu betonen: Felder, die sie nicht benötigen oder noch nicht verstehen, können Sie zunächst einfach auf Null setzen. Ausnahmen 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
   

15.14.1.3.7 Die Kontrollflags

Über die Kontrollflags kann das Verhalten des Fontselektors beeinflußt werden.

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 versetzt wird, in dem nur noch der Fontselektor bearbeitet werden kann. Im wesentlichen bedeutet das, daß der Fontselektor alle WM_TOPPED–Nachrichten für andere Fenster des aufrufenden Programms abfängt und nicht weiterleitet, sondern sich stattdessen selbst zum obersten Fenster macht. Damit soll dem Anwender signalisiert werden, daß er zuerst den Fontselektor bearbeiten soll, bevor er eine andere Aktion im Programm auslösen kann.
   
  Der Aufrufer sollte in diesem Modus natürlich 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 Fontselektor mit einem Closer versehen, während der OK– und der Abbruch–Button versteckt werden. Gedacht ist dies für 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 Programm verhindern wollen, daß die Größe eines Zeichensatzes geändert 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 gültigen Wert übergeben müssen. 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 unterstützen auch alle Kontrollflags! Wenn ein Fontselektor ein Flag nicht unterstützt, 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.

15.14.1.3.8 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:

Fehlen noch die beiden Parameter `validtype' und `validchars':

Manchmal ist es wichtig, sicherzustellen, daß der Font bestimmte Zeichen enthält. Dafür gibt es zwei Möglichkeiten:

Wenn `validchars' Null ist, kann man mit `validtype' eine der folgenden vier Gruppen von Zeichen auswählen:

Diese vier Gruppen dürften 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 ungültigen Werten in `validtype'.

Wenn die vier Gruppen einmal nicht ausreichen, so kann man stattdessen über `validtype' und `validchars' auch genauer angeben, welche Zeichen benötigt werden:

Zukünftige GDOSse werden wahrscheinlich weitere Mappings unterstützen (BICS, Unicode, …). Durch die verwendete Codierung wird der Fontselektor auch diese korrekt beherrschen: Das in `validtype' übergebene Mapping wird einfach eingestellt und dann das Vorhandensein der Zeichen 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.

15.14.1.3.9 Das User-Popup

Für das benutzerdefinierte Popup (kurz User-Popup) existieren die folgenden Felder in der xFSL_PAR–Struktur:

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 für HuGo! */
} xFSL_PENTRY;

Die Bedeutung der Elemente dieser Struktur sollte nach den vorangegangenen Ausführungen klar sein. Die Funktionsflags entsprechen den Kontrollflags, bis auf die Flags, die das globale Verhalten des Fontselektors 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 entsprechende Eintrag disabled (in heller Schrift und nicht anwählbar) dargestellt. Dies ist in erster Linie für Trennlinien zwischen den Einträgen gedacht.

Verwendung

Im Prinzip kann man drei Einsatzgebiete für das User-Popup sehen:

1. Jeder Popup-Eintrag stellt den Font für einen bestimmten Programmteil ein. Beispielsweise könnte man in einem bestimmten Fenster eines Programms nur nicht–proportionale Fonts zulassen wollen, 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 konstruiert werden.
    

3. Das Popup kann aber auch für etwas ganz anderes verwendet werden. Man könnte hier noch eine Information unterbringen, die zwar nichts mit Fonts, aber mit dem Fenster zu tun hat, für das man einen Font einstellen will. Beispielsweise könnte für ein Consolen–Fenster die Art, wie inverse Zeichen darzustellen sind, in Form eines Popups mit den Einträgen invers, fett, unterstrichen zur Auswahl angeboten werden.
    
   Will man das Popup so zweckentfremden, so muß man bei der Meldung xFS_POPUP den geänderten Font (der sich am gesetzten FF_CHANGED–Flag erkennen läßt) in alle anderen Popup-Einträge übertragen, da sich sonst der im Fontselektor angezeigte Font ändern würde!
    

15.14.1.4 Die Fontflags

Über die Fontflags können die zur Auswahl gestellten Fonts eingeschränkt werden:

Die Werte sind so gewählt, daß die einzelnen Flags miteinander verodert werden können. Setzt man für die Fontflags also beispielsweise FF_MONOSPACED|FF_VECTOR ein, so werden nur unproportionale Vektorfonts 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 gesetzt.
   
  Dies gilt analog für 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 unterstützt!
   

• 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.
   

15.14.1.5 xFSL Returncodes

Alle xFSL–Aufrufe liefern einheitliche Returncodes (Rückgabewerte) zurück. Dabei steht eine negative Zahl für einen Fehler, eine positive Zahl (oder Null) bedeutet Erfolg bzw. ein Ereignis.

Diese Werte wurden aufwärtskompatibel zum Fontselektor UFSL gewählt (dieser kennt die Returncodes -4, -3, -2, -1, 0 und 1).

Darüber 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 unterstützt.

Beim Aufruf xfsl_init entsprechen positive Rückgabewerte dem Fensterhandle des Fontselektors (0 bedeutet, daß der Fontselektor als modaler 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 berücksichtigt werden: Bei unbekannten Fehlern sollte abgebrochen, unbekannte Ereignisse sollten ignoriert werden.

15.14.1.6 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'.

15.14.2 xFSL Tips und Hinweise

In den folgenden Abschnitten soll versucht werden, noch einige Tips und Hinweise zur xFSL–Schnittstelle zu geben.

15.14.2.1 Ein einfacher Aufruf

Angesichts der Vielzahl der Parameter und Einstellmöglichkeiten erscheint folgender Hinweis angebracht:

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 <stdio.h>
#include <aes.h>
#include <vdi.h>
#include <xfsl.h>

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 übergeben wird. War dieser Aufruf erfolgreich (`xhandle' ist größer oder gleich Null), so befindet sich der Fontselektor bereits auf dem Bildschirm. 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 Rückgabewerte werden hier einfach ignoriert). Mit dem Aufruf von xfsl_exit wird der Fontselektor wieder vom Bildschirm entfernt und anschließend der Rückgabewert ausgewertet.

Das war doch gar nicht so kompliziert, oder? Von hier aus können Sie nun mit den diversen Parametern und Flags weiter experimentieren.

15.14.2.2 Fragen und Antworten

Wie kann ich feststellen, welche Features der Fontselektor bietet?

Direkt kann dies für 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 gewünschte Feature nicht unterstützt?

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 entsprechenden Hinweis informieren, aber trotzdem den Fontselektor aufrufen. Auch wenn die Auswahl dann nicht mit dem gewünschten Komfort geschehen kann, ist dies für den Anwender immer noch weniger frustrierend, als überhaupt keinen Font auswählen zu können.

Einige Beispiele: Sollte über das Popup der Font für bestimmte Fenster des Programms eingestellt werden, so sollte er bei fehlendem Popup für das oberste Fenster des Programms übernommen werden. Unterstützt der Fontselektor das Sperren der Größenänderung nicht, so sollte die zurückgelieferte Größe einfach ignoriert werden und — wenn sie von der gewünschten 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 unterstützt! 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 Zeichen, 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 ansprechen. Als zweites Mapping steht daher das direkte Mapping zur Verfügung. Hier hat man nun Zugriff auf alle Zeichen eines Fonts. Allerdings muß man dazu auch wissen, um welche Art von Font es sich handelt 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 gültigen Zeichenindex.

Das direkte Mapping ist für normale Anwendungen nur eingeschränkt brauchbar. Im Gegensatz zum ASCII–Mapping, das ein einheitliches Mapping für 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. für den Großteil der Programme uninteressant. Künftige 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 bestimmten Position auch immer das gleiche Zeichen liegt (ähnlich wie beim ASCII–Mapping, nur eben auch bei Positionen größer 255).

15.14.2.3 xFLS Programmiertechnische Hinweise

Die Beschreibung der xFSL–Schnittstelle in diesem Text erfolgt in Pure C. In den folgenden Abschnitten werden die Datentypen und Besonderheiten von Pure C näher beschrieben, damit xFSL–Aufrufe auch aus anderen Programmiersprachen und C–Dialekten gelingen.

15.14.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 Zeigertyp 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 gültig ist, ergibt sich aus dem Kontext bzw. bleibt dem Programmierer überlassen.

Beispiel: In der Struktur PFONTINFO wird für 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ößenangabe 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 für 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 vergessen. Zitat aus dem NVDI–Guide:

Man darf nie, nie, niemals den Nachkommateil einfach abschneiden!

15.14.2.3.2 xFSL Parameterübergabe

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 weitesten links stehende Parameter zum Schluß, d.h. beim Einsprung in den Fontselektor, obenauf liegt.

15.14.2.3.3 Pure C und `cdecl'

Pure C übergibt die Parameter an Funktionen normalerweise in Registern. Für eine Übergabe über den Stack muß entweder das Schlüsselwort cdecl verwendet werden (wie im Includefile XFSL.H geschehen) oder der Compilerschalter -H gesetzt werden.

Das Schlüsselwort cdecl ist eine Pure–C–spezifische Erweiterung und wird daher bei gesetztem Compilerschalter -A (ANSI-Konformität) angemahnt.

15.14.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 Aufrufe 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 enthalten soll (`validtype' und `validchars')
     

• die PFONTINFO–Struktur wird auch bei Rückgabe xFS_STOP mit den Werten des zuletzt im Fontselektor ausgewählten Fonts gefüllt
   

• Codierung der Fontflags geändert (feinere Unterscheidung der Vektorformate)
   

Revision 3

• die erste öffentlich verfügbare Schnittstellen–Revision
   

ältere Revisionen

• ältere Revisionen können getrost ignoriert werden, da diese niemals in einem für eine größere Öffentlichkeit verfügbaren Programm in Erscheinung getreten sind
   

15.14.4 Programmübersicht

Es folgt eine Übersicht über alle z.Z. erhältlichen Fontselektoren, die über eine UFSL– oder eine xFSL–Schnittstelle (oder beides) verfügen.

Desweiteren folgt eine Liste von Programmen, die einen Fontselektor mit einer der beiden Schnittstellen verwenden.

15.14.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 Quelltexte 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 wird auch die xFSL-Schnittstelle unterstützt.
 

xUFSL

von Stefan Rogel
Der xUFSL bietet gegenüber 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, vorsichtig ausgedrückt, umstritten. Letzte veröffentlichte Version: 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 unterstützt, nicht aber die speziellen Erweiterungen des xUFSL an der UFSL–Schnittstelle). Die Namensänderung wurde vollzogen, um Verwechslungen zu vermeiden.
 

Calvino

von Dirk Haun
Zusammen mit HuGo! der erste Fontselektor mit xFSL–Schnittstelle. Auch Calvino unterstützt noch die einfache UFSL–Schnittstelle.
 

FONT_SEL und FONT_PAL

von Christian Grunenberg
Diese beiden Programme arbeiten auf Drag&Drop–Basis, sie unterstützen also weder die UFSL– noch die xFSL–Schnittstelle, dafür aber das Font–Protokoll. FONT_SEL ist ein Fontselektor, FONT_PAL eine Fontpalette (mit integriertem Fontselektor).
 

15.14.4.2 Programme, die einen Fontselektor unterstützen

Folgende Programme unterstützen einen externen Fontselektor (Stand 16.08.1998, alle Angaben und E-Mail-Adressen ohne Gewähr):

(+: unterstützt, F: als Fensterdialog; E-Mail-Adressen: MausNet)

15.14.5 Die UFSL–Schnittstelle

Der Vollständigkeit halber folgt hier noch die Original–Beschreibung von Michael Thänitz zur ursprünglichen UFSL-Schnittstelle:

Programmierschnittstelle:

UFSL ist eine Fontauswahlbox für den Autoordner. Sie bietet dem Programmierer 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 für 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 gültig.
 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 zurück.

void cdecl (*msgfunc)(int event, int msgbuf[]); /* Redrawfunktion */

Bei Verwendung von UFSL als Fensterdialog ist es notwendig eine Redrawfunktion zur Verfügung zu stellen. Sie schickt die anfallenden Events an das aufrufende Programm zurück, 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 Verfügung 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 entsprechend 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.

15.14.6 Hinweise für 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 ausgerüstet werden.

Damit keine Mißverständnisse entstehen: Die Overlay–Technik und die Reentranz, wie sie Calvino und HuGo! bieten, sind nicht Teil der eigentlichen Schnittstelle und müssen von anderen Fontselektoren daher auch nicht unterstützt 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 unterstützen, erscheint es ratsam, auch in neuen Fontselektoren diese Schnittstelle noch zur Verfügung zu stellen. Jedoch zeigt ein kurzer Blick auf diese Programme, daß sie fast ausschließlich den Fontselektor als modalen Dialog aufrufen. Die Empfehlung lautet daher, eine minimale UFSL–Unterstützung einzubauen (nur als modaler Dialog) und dafür die xFSL–Schnittstelle möglichst weitgehend zu implementieren, da zu erwarten steht, daß gerade die — nun endlich genormten — Erweiterungen gegenüber der UFSL-Schnittstelle von den Programmen verwendet 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 ausgewählt, sondern bei Vektorfonts auch die Zwischengrößen eingestellt werden können.
   

• fix31–Unterstützung
  Für 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 einsetzbar.
   

• Drag&Drop–Unterstützung
  Neben dem traditionellen Aufruf über den Cookie kommen Lösungen auf Drag&Drop–Basis immer mehr in Mode. Wenn der Fontselektor von sich aus schon Drag&Drop unterstützt, läßt er sich leicht durch ein kleines Frontend-Programm in einen vollwertigen Drag&Drop–Selektor verwandeln.
   

Folgende Konventionen wurden für einen xFSL–Fontselektor vereinbart:

• Wenn der Fontselektor über einen Closer verfügt, so wird dieser als Abbruch interpretiert, d.h. es wird xFS_STOP zurückgegeben. Ist das Kontrollflag CC_CLOSER gesetzt, wird der gerade aktuelle Font aber trotzdem zurückgegeben (in der PFONTINFO–Struktur in xFSL_PAR).
   

• Wenn der erweiterte Aufruf (xfsl_init, xfsl_event und xfsl_exit) nicht unterstützt wird, muß zumindest eine Dummy–Funktion für xfsl_init installiert werden, die immer -32 (Gemdos–Fehlermeldung EINVFN, ungültige Funktionsnummer) zurückgibt.
   
  Es wird aber dringend empfohlen, den erweiterten Aufruf anzubieten, 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 zurückgeben, damit sich der Aufrufer darauf einstellen kann.
   

Protokolle

XAcc

XSSI-Protokoll