7
Nous avons déjà parlé de la saisie des textes dans le chapitre 5 à propos des événements liés au clavier. Dans ce chapitre, nous allons détailler les fonctions permettant de dessiner des chaînes de caractères dans une fonte donnée. Dans le chapitre suivant, nous présenterons les notions introduites à partir de la Release 5 qui permettent la lecture et l'écriture de textes dans une langue internationale où l'interprétation des caractères des chaînes et des fontes peut varier en fonction de la configuration locale.
Les fontes sont les polices de caractères utilisées pour dessiner les textes dans les langues dont l'écriture est basée sur un alphabet. Ce sont des ressources susceptibles d’être utilisées par plusieurs clients. Les informations sur les fontes sont stockées dans des fichiers qui sont placés dans un répertoire dont le chemin d’accès est habituellement[1] /usr/lib/X11/fonts sous Unix.
Le nom d’une fonte n'est cependant pas le nom d'un fichier. Le nom d'une fonte est une chaîne spécifiée par une propriété de la fonte appelée FONT. Ce nom doit originairement figurer dans un fichier appelé fonts.dir du répertoire de fontes.
Le fichier fonts.dir permet de lister les associations entre les noms des fichiers et les noms des fontes[2]. Un répertoire de fontes peut également contenir un fichier appelé fonts.alias permettant de définir des alias pour les noms des fontes stockées dans ce répertoire.
Les noms de fontes peuvent donc être quelconques. Il existe cependant une syntaxe pour les noms de fontes qui permet d’en déduire les principales caractéristiques. Les conventions décrivant cette syntaxe s'appellent les conventions XLFD, pour X Logical Font Description.
Selon ces conventions, un nom de fonte est réalisé par la concaténation des caractéristiques suivantes permettant de spécifier :
la provenance La fonderie qui a digitalisé et fourni la fonte. Par exemple Adobe.
la famille Qui indique le style général de la fonte. Par exemple Charter, Courier, Helvetica, Symbol ou Times.
le poids Qui renseigne sur l’épaisseur des caractères. Par exemple medium ou bold.
l'écriture Par exemple r pour romain, i pour italique, et o pour oblique.
l'épaisseur d'ensemble Une valeur décrivant une épaisseur relative aux autres fontes produites dans la même fonderie. Par exemple normal, condensed, narrow, ou double.
les tailles La hauteur en pixel (par exemple 10) et celle en dixième de point (par exemple 100 pour 10 points). L'unité de mesure de référence est normalement le point (indépendant de l'écran). La taille en pixel dépend de la résolution de l'écran.
les résolutions Les résolutions horizontale et verticale sont données en unité dpi pour dots per inch.(i.e. point par pouce où 1 pouce ª 2,54 cm).
l'espacement Soit m (mono espace), ou p (pour proportionnel).
la largeur moyenne Exprimée en dixième de pixel. Par exemple pour 6 pixels de large (en moyenne sur tous les caractères), on aura une largeur de 60.
le jeu de caractères L'organisation des standards internationaux ISO a défini des jeux de caractères standards. Par exemple, ISO8859-1 ou JISX0208.1983.
Ainsi, le nom suivant est un nom complet de police de caractères :
-adobe-times-bold-r-normal--10-100-75-75-m-60-iso8859-1
La commande xfontsel permet de rechercher une fonte interactivement en faisant varier son nom selon les paramètres des conventions XLFD. Cette commande permet de visualiser une fonte dont le nom vérifie un patron général dans lequel le symbole ? est utilisé pour remplacer n'importe quel caractère et le symbole * pour remplacer une suite de caractères. De même, dans les fichiers de ressources ou d'alias comme dans la plupart des fonctions manipulant des noms de fontes, on pourra utiliser un patron général au lieu d'un nom complet. Par exemple, les lignes qui suivent pourront être placées dans le fichier fonts.alias du répertoire de fontes. Ces trois lignes permettront de définir des alias pour des noms de fontes times de taille 12, 14 et 18 — alias qui seront plus simples à utiliser pour le lancement du programme xterm :
xterm12 *times-medium-r-*-120*
xterm14 *times-medium-r-*-140*
xterm18 *times-medium-r-*-180*
Pour que le serveur prenne connaissance de ce fichier, on lancera d'abord la commande
% xset fp rehash
et on pourra ensuite lancer le programme xterm avec la ligne de commande
% xterm -fn xterm12 -fb xterm12 &
La première fonte dont le nom vérifiera le motif *times-medium-r-*-120* sera alors chargée par xterm[3].
Lorsque l’on dessine un texte, on indique les coordonnées de l'origine du dessin. Le texte est alors dessiné sur une ligne passant par cette origine selon une direction horizontale qui fait partie des caractéristiques de la fonte. On appelle cette ligne la ligne de base.
Chaque caractère est représenté dans la fonte par un bitmap possédant une origine. Une structure C de type XCharStruct est associée à chaque caractère de la fonte pour indiquer les dimensions des caractères relativement à la ligne de base (cf. figure 7.1. et 7.2.).
typedef struct {
short lbearing;
/*
distance (origine, pt de gauche) */
short rbearing;
/*
distance (origine, pt de droite) */ short width; /* distance à l'origine suivante
*/
short ascent;
/*
distance (origine, pt du haut) */
short descent;
/*
distance (origine, pt du bas) */
unsigned short attributes;
} XCharStruct;
fig. 7.1. La structure XCharStruct
fig. 7.2. Les dimensions des caractères et de
la fonte
lbearing Le champ lbearing (left bearing) donne la distance de l’origine du caractère au point le plus à gauche dans le dessin. C'est la marge gauche.
rbearing Le champ rbearing (right bearing) donne la distance de l’origine au point du caractère le plus à droite. C'est la marge droite.
width Le champ width indique la distance de l’origine du caractère à l’origine du caractère suivant. Cette longueur est constante pour les fontes à espacement non proportionnel.
ascent, descent Les champs ascent et descent fournissent les espacement verticaux par rapport à la ligne de base (respectivement au dessus et en dessous).
La plus petite boîte englobant un caractère dont l'origine est située en (x,y) est un rectangle dont les dimensions sont les suivantes :
coin supérieur gauche = (x + lbearing, y - ascent )
largeur = rbearing - lbearing
hauteur = ascent + descent
origine du caractère suivant = (x + width, y)
La structure décrivant les fontes a le type XFontStruct (cf. figure 7.3. page suivante). Les principaux membres de cette structure sont les suivants :
fid L’identificateur de la fonte (qui est de type Font).
direction Ce champ indique la direction principale dans laquelle le texte est écrit.
ascent Le champ ascent donne l’espace maximal (en points d'écran) des caractères situés au-dessus de la ligne de base.
typedef struct {
XExtData *ext_data;
/*
pour réaliser des extensions */
Font fid;
/*
l'identificateur de la fonte */
unsigned direction;
/*
FontLeftToRight ou FontRightToLeft */
unsigned min_char_or_byte2;
/*
premier caractère */
unsigned max_char_or_byte2;
/*
dernier caractère */
unsigned min_byte1; /*
première rangée existante (fontes 2-byte)
*/
unsigned max_byte1; /* dernière rangée existante (fontes 2-byte) */
Bool
all_chars_exist; /*
True si tous les caractères ont une
taille
non nulle */
unsigned default_char;
/*
index du caractère à imprimer pour les
indéfinis */
int
n_properties;
/*
nb de propriétés associées */
XFontProp
*properties;
/*
pointeur vers la table des propriétés */
XCharStruct
min_bounds; /*
bornes minimales sur tous les caract. */
XCharStruct
max_bounds; /*
bornes maximales sur tous les
caract. */
XCharStruct
*per_char; /*
tableau des infos sur chaque caractère */
/*
NULL si tous les caractères ont les mêmes infos
*/
int
ascent;
/*
maximum au dessus de la ligne de base */
int
descent;
/*
minimum au dessous de la ligne de base */
} XFontStruct;
fig. 7.3. La structure XFontStruct
descent |
Le champ descent donne l’espacement maximal occupé par tous les caractères en dessous de la ligne de base. |
min_bounds max_bounds |
Ces champs fournissent les dimensions minimales et maximales des caractères. Ils permettent de calculer les dimensions de la plus petite boîte englobant n’importe quel caractère de la fonte. |
La plus petite boîte englobant l'un quelconque des caractères de la fonte au point de coordonnées (x,y) a en effet les dimensions suivantes :
coin supérieur gauche = (x + min_bounds.lbearing, y - max_bounds.ascent)
largeur = max_bounds.rbearing - min_bounds.lbearing
hauteur = max_bounds.ascent + min_bounds.descent
La somme ascent+descent (appelée souvent hauteur de la fonte ou font height) est utilisée pour calculer l’espacement vertical entre deux lignes écrites dans la même fonte.
La structure XFontStruct contient également un tableau (per_char) fournissant les informations relatives à tous les caractères de la fonte quand les dimensions des caractères varient. Ces informations ne sont présentes que pour les fontes dites proportionnelles — i.e. celles dont l’espacement entre les caractères est proportionnel aux dimensions des caractères. On ne consulte cependant qu'assez rarement ces informations car on dispose des minima et maxima sur tous les caractères dans les champs ascent, descent, min_bounds et max_bounds de la structure XFontStruct. En outre il existe des fonctions permettant de calculer l’espacement occupé par une chaîne donnée (cf. section 7.6).
Dans la Release 4 il y a plusieurs types de fontes : les fontes de moins de 256 caractères, appelées fontes 8‑bit ou fontes 1-byte et les fontes de plus de 256 caractères (qui codent les caractères sur plusieurs bytes). Les fontes codant les caractères sur 16 bits sont fréquemment utilisées dans les langues orientales et sont appelées fontes 2-byte ou 16-bit. Les caractères peuvent alors être considérés comme formant une matrice carrée de bytes dont les indices sont bornés par les champs min_byte1, max_byte1, min_char_or_byte2 et max_char_or_byte2 de la structure XFontStruct.
fig. 7.4. Les index des fontes 2-bytes
Les champs min_byte1 et max_byte1 sont toujours nuls pour les fontes 1-byte et min_char_or_byte2 et max_char_or_byte2 spécifient alors l’index des premier et dernier éléments du tableau per_char. Pour les fontes 2-bytes, les champs min_byte1 et max_byte1 ne sont pas tous deux nuls. Ils représentent les indices de la première et dernière rangée existante dans la matrice de caractères (cf. figure 7.4. page précédente). Le rang N d'un caractère dans le tableau per_char se déduit des deux indices byte1 et byte2 dans la matrice par la formule :
N = (max_char_or_byte2 - min_char_or_byte2 + 1) x (byte1 - min_byte1)
+ (byte2 - min_char_or_byte2)
Les fonctions de dessin de chaînes de caractères stockés sur 2 bytes utilisent une structure de type XChar2b pour indiquer les indices des deux octets codant le caractère dans la matrice. Ces procédures portent le même nom que leurs homologues pour les fontes 1-byte mais finissent par le suffixe 16 pour rappeler que les caractères sont stockés sur 16 bits. Ainsi par exemple, il existe une primitive de dessin de chaînes de caractères 8‑bits appelée XDrawString et son homologue pour les chaînes de caractères codés 16‑bits s'appelle XDrawString16.
La Release 5 distingue aussi les fonctions de dessin de texte selon qu'elles utilisent des chaînes de caractères 8-bits dites chaînes multi-bytes (type char *) ou des chaînes de caractères étendus (type wchar_t * pour wide character).
Les informations sur les fontes contiennent les bitmaps correspondant à chaque caractère de la fonte et prennent beaucoup de place en mémoire. Le serveur ne les charge donc pas systématiquement. A partir de la Release 5, on utilise des ensembles de fontes pour dessiner les chaînes de caractères dans un environnement local. Dans ce cas, on ne procède pas directement aux chargements des fontes, mais simplement à l’initialisation d’un ensemble de fontes dont le chargement sera géré par le serveur (cf. chapitre suivant).
Cependant, dans les versions antérieures, et en général, pour pouvoir utiliser une fonte donnée, il faut préalablement en demander le chargement au serveur[4]. On associe ensuite la fonte à un contexte graphique et on la libérera quand on aura terminé d’écrire dans cette fonte.
Il y a plusieurs façons de spécifier une fonte et il faudra prendre garde à utiliser l’argument du bon type dans les fonctions manipulant des fontes. Par exemple, certaines fonctions récupérant les informations sur les fontes existent en deux versions selon qu’elles utilisent un identificateur de fonte ou un nom de fonte. Dans la librairie, une fonte peut être référencée par :
• un nom (char* fontname)
• un identificateur de fonte (Font fid)
• l'adresse d'une structure de données contenant des informations sur la fonte (XFontStruct* fontstruct).
• un
XID (identificateur de fonte ou
contexte graphique) utilisé par la fonction XQueryFont.
• En outre, à partir de la Release 5 on pourra écrire avec un ensemble de fontes (type XFontSet).
On peut demander au serveur de charger une fonte à partir d'un nom de fonte à l'aide des fonctions suivantes :
Font XLoadFont (dpy, fontname)
XFontStruct* XLoadQueryFont (dpy, fontname)
char * fontname ;
La première fonction charge la fonte en mémoire et retourne un identificateur de fonte alors que la seconde permet de charger la fonte et de récupérer la structure contenant les informations sur la fonte. Pour récupérer les informations sur les fontes à partir d'un identificateur de fonte, on utilisera la fonction XQueryFont
XFontStruct* XQueryFont (dpy, font_ID)
XID font_ID ; /* Font ou GContext ID */
Un appel à XLoadFont suivi d'un appel à XQueryFont est équivalent à un appel à XLoadQueryFont. Cependant la fonction XQueryFont permet d'obtenir les informations sur la fonte d'un contexte graphique donné en passant directement l'identificateur du contexte graphique. Cette fonction (comme toutes celles en XQuery) force la communication avec le serveur[5].
Les fontes chargées avec XLoadFont seront libérées par XUnloadFont et celles chargées avec XQueryFont ou XLoadQueryFont par XFreeFont.
XFreeFont (dpy, fontstruct)
XUnloadFont (dpy, fid)
Sous shell, on peut modifier le chemin d'accès aux répertoires de fontes avec la commande xset. On peut également lister les fontes disponibles[6] grâce à la commande xlsfonts. Ces opérations peuvent également figurer dans un programme grâce aux fonctions qui suivent, en général utilisées par les window manager :
XSetFontPath (dpy, directories, ndirs)
char ** directories ; /* tableau de chaînes */
int ndirs ;
char ** XGetFontPath (dpy, &ndirs_return)
int ndirs_return ;
char ** XListFonts (dpy, pattern, n_max, &n_return)
const char* pattern ;
int n_max, n_return ;
L'intérêt de XListFonts est d’admettre un motif en argument. Ce motif, ou pattern, permet de spécifier la fonte par une chaîne, contenant éventuellement les symboles * et ? pour remplacer respectivement une suite de caractères quelconques ou un caractère isolé. La fonction retourne l’adresse d’un tableau contenant les noms des fontes satisfaisant le pattern, à concurrence de n_max noms. La mémoire est allouée par le serveur et pourra être libérée par XFreeFontNames.
On peut également charger des fontes à partir d'un motif avec la fonction :
char **XListFontsWithInfo (dpy, pattern, nmax, &n_return, info_return)
const char* pattern ;
int nmax, n_return ;
XFontStruct** info_return ;
Cette fonction retourne elle aussi un tableau de noms de fontes satisfaisant le motif indiqué dans pattern. L'argument nmax spécifie le nombre maximal de noms de fontes à retourner et l'argument n_return indique le nombre effectivement retourné. Cette fonction permet en outre de charger simultanément les fontes et info_return est un tableau contenant les adresses des XFontStruct correspondant à chacune des fontes du tableau.
Pour libérer la mémoire allouée par le serveur, on utilisera les fonctions
XFreeFontInfo (names, free_info, ninfo)
char** names ;
XFontStruct* free_info ;
int ninfo ;
XFreeFontNames (liste)
char ** liste ;
XFreeFontInfo libère le tableau de pointeurs sur les XFontStruct retourné par XListFontsWithInfo sans fermer les fontes. XFreeFontNames libère les tableaux et chaînes retournées par XListFonts et XListFontsWithInfo.
Le dessin des caractères s’effectue à l’aide d’une primitive graphique qui utilise un contexte graphique dans lequel on aura préalablement positionné le champ foreground (pour la couleur des caractères), le champ background (si l’on dessine avec XDrawImageString) et le champ font. On pourra également utiliser les attributs tile et stipple (par exemple, pour écrire en gris dans un menu sur une machine noir et blanc). Pour les chaînes de caractères 8‑bit (type char *), le dessin s'effectue à partir d'une position initiale (x,y) à l’aide de l'une des trois primitives suivantes :
XDrawImageString (dpy, draw, gc, x, y, string, string_length)
XDrawString (dpy, draw, gc, x, y, string, string_length)
Drawable draw ;
GC gc ;
int x, y ;
const char* string ;
int string_length ; /* calculable avec strlen */
XDrawText (dpy, draw, gc, x, y, items, nb_items)
Drawable draw ;
GC gc ;
int x, y ;
XTextItem items [] ;
int nb_items ; /*nb d'items du tableau */
L'argument draw spécifie la fenêtre ou le Pixmap sur lequel on veut dessiner. Les deux premières requêtes permettent de dessiner une chaîne dans la fonte indiquée par le contexte graphique, respectivement avec ou sans fond autour des caractères. La troisième requête (XDrawText) permet d'afficher une ligne de texte plus complexe, composée de plusieurs items dans lesquels la fonte peut varier (cf. figure 7.5.). Pour cette dernière requête, la fonte du contexte graphique n'est consultée que pour servir de défaut quand le champ font d'un item est à None.
fig.
7.5. L'affichage d'items dans des fontes
différentes avec XDrawText
XDrawText prend en argument un tableau d'items de type XTextItem représenté figure 7.6.
typedef struct {
char* chars;
/*
pointeur sur une chaîne de caractères */
int nchars;
/*
le nombre de caractères de la chaîne */
int delta;
/*
espacement entre les items */
Font font;
/*
fonte à utiliser */
} XTextItem;
fig.
7.6. La structure XTextItem utilisée
par XDrawText
Les fonctions équivalentes pour les caractères stockés sur 16 bits utilisent des structures XChar2b et un tableau d’items de type XTextItem16 (cf. figure 7.7.).
XDrawString16 (dpy, draw, gc, x, y, 2b_string, length)
XDrawImageString16 (dpy, draw, gc, x, y, 2b_string, length)
Drawable draw ;
GC gc ;
int x, y ;
const XChar2b* 2b_string ;
int length ;
XDrawText16 (dpy, draw, gc, x, y, items16, nitems)
XTextItem16 items16 [ ] ;
int nitems ;
typedef struct {
unsigned char byte1;
unsigned char byte2;
} XChar2b;
typedef struct {
XChar2b *chars;
int nchars;
int delta;
Font font;
} XTextItem16;
fig. 7.7. Les structures utilisées pour les
fontes 16 bits
On verra dans le chapitre suivant qu’il existe des fonctions analogues dans la Release 5 permettant de dessiner des chaînes interprétées par une méthode locale[7].
Pour savoir où afficher et comment couper les lignes d’un texte, on va devoir récupérer les informations concernant la taille prise par les chaînes dans la fonte considérée.
Pour positionner des chaînes de caractères 8-bit on aura recours aux fonctions suivantes[8] :
int XTextWidth (fontstruct, string, length)
XFontStruct* fontstruct ;
XTextExtents (fontstruct, string, nchars, &direction_return,
&font_ascent_return, &font_descent_return,
&allchars_size_return)
XFontStruct* fontsrtuct ;
XQueryTextExtents (dpy, font_ID, string, nchars, &direction_return,
&font_ascent_return, &font_descent_return,
&allchars_size_return)
XID font_ID ;
int direction_return, font_ascent_return,
font_descent_return ;
XCharStruct allchars_size_return ;
XTextWidth retourne en pixel la longueur prise par une chaîne de caractères à l'écran. Ce calcul est local à la Xlib et il n'y a pas besoin d'indiquer la connexion au serveur. La structure allchars_size_return retournée par les fonctions XTextExtents et XQueryTextExtents permet de récupérer la boîte englobant tous les caractères de la chaîne ; cela permettra en particulier de déterminer l'espacement horizontal minimum. Les arguments font_ascent_return et font_descent_return permettent de déterminer l’espacement entre les lignes.
La différence entre XTextExtents et XQueryTextExtents est importante. XQueryTextExtents est beaucoup plus coûteuse que XTextExtents car elle interroge le serveur alors que XTextExtents est exécutée localement, sans utiliser le réseau. Cependant, XTextExtents requiert un argument de type pointeur sur un XFontStruct alors que XQueryTextExtents n'utilise qu'un XID.
On se méfiera pour le calcul de l'espacement vertical des cas de changements de fontes où l’espace à laisser entre deux lignes n’est égal à aucune des hauteurs de fontes, comme le montre la figure 7.8.
A partir de la Release 5, on utilisera de manière analogue des fonctions permettant de calculer la taille prise par des chaînes dessinées avec un ensemble de fontes dans une localité donnée (cf. chapitre suivant, les fonctions XmbTextExtents et XwcTextExtents).
fig. 7.8. La hauteur des fontes
Les
fonctions importantes
Font XLoadFont (dpy, fontname)
XFontStruct* XLoadQueryFont (dpy, fontname)
int XTextWidth (fontstruct, string, length)
XTextExtents (fontstruct, string, nchars, &direction_return,
&font_ascent_return, &font_descent_return,
&allchars_size_return)
XDrawString (dpy, draw, gc, x, y, string, string_length)
XDrawImageString (dpy, draw, gc, x, y, string, string_length)
XDrawText (dpy, draw, gc, x, y, items, nb_items)
Les corrigés de ces exercices sont regroupés pages 309 et suivantes.
Exercice 15 : (lire les entrées tapées au clavier)
Faire une fenêtre dans laquelle on affichera plusieurs items de texte sur une même ligne avec XDrawText. Au centre, une petite fenêtre permettra d'entrer des touches lues sur le clavier et affichera les caractères lus sur une ligne. Les caractères BackSpace et la touche Del permettront de reculer. Le retour chariot effacera la ligne courante.
: (Un petit logiciel de dessin)
Exercice 16Faire une fenêtre comportant quatre boutons placés en bas à gauche sur une horizontale (comme des boutons de télévision) ; au-dessus, une grande fenêtre (appelée zone) servira de cadre aux dessins. Les quatre boutons seront étiquetés par :
• <QUIT> pour quitter le programme
• <INVERT> pour afficher en inverse un rectangle sélectionné
• <CLEAR> pour effacer le contenu du rectangle sélectionné
• <NEW> pour effacer tout le contenu de la zone de dessin
Pour sélectionner un rectangle, on cliquera sur un point de la zone d'affichage; on maintiendra ensuite le bouton de souris enfoncé, puis on relâchera le bouton sur le point diamétralement opposé du rectangle. Pendant toute cette opération, un tracé du rectangle suivra le mouvement de la souris.
Variante (ex. 16) : on change l'organisation du programme précédent pour mettre des handlers d'événements.
Exercice 17 : (fontes, événements et contexte d'association)
Modifier l'exercice sur le pop-up menu de pattern pour en faire un menu d'item de texte. La fonte utilisée pour les items pourra être passée en argument au programme. Pour capter les déplacements de la souris sur le menu, utiliser des fenêtres transparentes, et afficher les textes des items dans la fenêtre de fond du menu. Un contexte d'association pourra permettre de sauvegarder l’endroit où l'on doit afficher la chaîne, ainsi que la taille du fond d’item. Cette fois, un item sur lequel on passe s’affichera en inverse vidéo. (On ne sélectionne cependant l’item que si l’utilisateur relâche le bouton dessus.) Imprimer la chaîne de caractères associée à l'item sélectionné.
Exercice 18 : (fontes, événements, contextes)
Faire un jeu de pousse-pousse de 16 cases, dont 15 cases numérotées (belle fonte, assez grande et bien centrée) et une case vide noircie. Comme pour le menu de l'exercice précédent, on se servira d'un contexte d’association pour sauvegarder l’endroit où afficher le texte dans la fenêtre. (On pourra aussi organiser le contrôle des événements avec des contextes pour chaque type d'événements et des handlers d'événements.) Quand on clique sur une case, elle est sélectionnée (de façon interne) et si l'on relâche le bouton sur la case vide, le programme vérifie s'il peut ou non procéder à l'échange de la case vide avec la case sélectionnée. Quand l'échange est autorisé (même ligne ou même colonne et cases voisines), il est effectué à l'écran.
[1] Pour modifier le chemin d'accès aux répertoires de fontes on utilisera la commande xset.
[2] Ce fichier est créé automatiquement par la commande mkfontdir au moment où le serveur est installé.
[3] On pourra bien entendu utiliser ensuite ces noms pour n'importe quel autre programme.
[4] Cette opération aura lieu de préférence en début de programme.
[5] Une fois obtenu le pointeur sur la structure XFontstruct, on évitera de rappeler les fonctions procédant à partir d'un identificateur de fonte car elles sont généralement moins rapides que leurs homologues utilisant une structure XFontStruct.
[6] On pourra les visualiser à l'écran grâce à l'utilitaire xfd (X font displayer).
[7] Il s'agit des requêtes XmbDrawString, XwcDrawString, XmbDrawImageString, XwcDrawImageString, XmbDrawText et XwcDrawText.
[8] Il y a également XTextWidth16, XTextExtents16 et XQueryTextExtents16 pour les caractères stockés sur deux octets.