7

Les textes

 

                   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.

 

 

7.1. Les noms de fontes

                  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.

 

 

Les conventions XLFD

 

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

7.2. La géométrie du dessin d’un caractère

                  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)

 

 

7.3. Les informations sur les fontes

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

 

 

7.4. Le chargement des fontes

                  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.

 

 

7.5. Le dessin de textes dans une fonte donnée

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

 

 

 

 

7.6. La place prise par une ligne de texte

                  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)

 

 

 

 

Exercices sur les textes, les fontes et les dessins

.

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.

 

i.Exercices:sur les textes et les fontes;Exercice 16 : (Un petit logiciel de dessin)

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