Le premier regard sur GEM et le VDI

Dans la pager Structures en boucle et entrée/sortie de fichiers, nous avons jeté un bref coup d'oeil sur ce qu'est vraiment GEM. Nous avons indiqué que GEM (Graphics Environment Manager) est composé de nombreuses bibliothèques de fonctions, dont chacune gère certaines parties des activités du système. Ces bibliothèques sont regroupées en deux grandes unités, appelées AES (Applications Environment Services) et VDI (Virtual Device Interface). L'AES contient les fonctions dont nous avons besoin pour gérer les fenêtres, les boîtes de dialogue, les barres de menus et le traitement des événements. Le VDI contrôle la plupart des capacités graphiques du Atari ST, ainsi que certaines fonctions de contrôle de la souris et du curseur.

Présentation du VDI

Le VDI joue un rôle important pour faire fonctionner vos programmes graphiques sur de nombreux appareils différents. Malheureusement, l'un des éléments cruciaux de l'interface graphique, GDOS (Graphics Device Operating System) n'est pas intégré au système d'exploitation actuel. Le GDOS est la partie du VDI reliant les fonctions graphiques aux pilotes nécessaires pour garantir que les graphiques fonctionnent correctement sur tous les périphériques graphiques. Le GDOS permet également de charger différentes polices de caractères dans votre Atari ST, en utilisant les fonctions VDI standard. Pour le moment, cependant, nous ne nous intéressons qu'à un seul périphérique : l'écran.

Les fonctions VDI

Le VDI fournit au programmeur une série de fonctions lui permettant de dessiner rapidement de nombreuses formes graphiques. Cela rend le développement de programmes s'appuyant fortement sur les graphiques un jeu d'enfant. Si vous avez programmé un Atari 8 bits, pensez à tout le travail nécessaire pour dessiner un cercle. Le VDI fournit une fonction dessinant n'importe quel cercle de taille que nous voulons - avec un seul appel. Il existe également des fonctions pour dessiner des ellipses, des lignes, des rectangles, des rectangles arrondis, des arcs, des tranches de tarte et un certain nombre d'autres graphiques utiles.

Et ça ne s'arrête pas là. Chaque fonction graphique a un groupe d'attributs associés pouvant être définis avant que le graphique ne soit dessiné, permettant différents types de lignes, de motifs de remplissage et de couleurs. Lorsque le programme est exécuté, le premier écran affiche les différents types de styles de ligne disponibles via le VDI. Chaque fois que vous appuyez sur une touche, le programme affiche un autre ensemble de graphiques générés par une fonction VDI.

Un exemple de programme

La première chose que nous devons faire lors de l'écriture d'un programme GEM est d'initialiser l'application. Nous le faisons avec l'appel :

Cela informe l'AES de notre application et met de côté les ressources dont l'AES a besoin pour fonctionner. Ensuite, nous devons faire l'appel :

Cela renvoie le handle du périphérique ou du poste de travail actuellement ouvert, ainsi que la taille de la police de caractères système. Parce que GEM est capable d'avoir de nombreux programmes en mémoire à la fois, chacun nécessite une certaine identification, pour empêcher les commandes d'un programme d'en perturber un autre. Ceci est accompli en attribuant à chaque programme un handle. Le handle de variable dans l'appel ci-dessus est une valeur entière identifiant le poste de travail actuel. L'appel graf_handle() renvoie également des informations sur la police de caractères système. Nous devons déclarer quatre variables de type entier pour contenir ces informations, puis passer leurs adresses à la fonction. Dans l'appel ci-dessus, gr_hwchar obtiendra la largeur d'une cellule de caractère en pixels ; gr_hhchar obtiendra la hauteur d'une cellule de caractère en pixels ; gr_hwbox obtiendra la largeur, en pixels, d'une boîte suffisamment grande pour contenir un seul caractère ; et gr_hhbox obtiendra la hauteur, en pixels, d'une boîte suffisamment grande pour contenir un seul caractère.

Le virtuel

L'appel graf_handle() renvoie le handle au poste de travail physique. Ce dont nous avons vraiment besoin pour notre programme, c'est d'un accès à un poste de travail virtuel. Un périphérique particulier peut avoir de nombreux postes de travail virtuels, mais un seul poste de travail physique. Le poste de travail physique est directement associé au périphérique lui-même, généralement l'écran. Vous pouvez considérer un poste de travail virtuel comme un périphérique "simulé". Il possède sa propre section de mémoire et conserve ses données et son état complètement séparés de tous les autres postes de travail virtuels. Lorsque vous activez une application (comme cliquer sur un accessoire de bureau), elle est liée au poste de travail physique. En un sens, il devient le poste de travail physique. Nous obtenons le handle de notre poste de travail virtuel avec l'appel :

Cette fonction s'attend à ce que les attributs système soient dans le tableau work_in[].

Polylignes

Maintenant que nous avons configuré notre poste de travail, nous pouvons nous mettre au travail. Le premier graphique que nous allons expérimenter s'appelle les polylignes. Ceux d'entre vous maîtrisant la linguistique savent que le préfixe poly signifie beaucoup. Les polylignes sont une ou plusieurs lignes connectées d'un point à un autre, permettant au programmeur de dessiner des formes complexes avec un seul appel de fonction. L'appel de fonction ressemble à ceci :

Le handle de la variable est, bien sûr, le handle renvoyé par l'appel v_opnvwk(). Chaque fonction que nous utilisons nécessite ce handle. De cette façon, nous sommes sûrs de ne pas jouer avec une autre application pouvant être en mémoire en même temps. Si nous écrivons un accessoire de bureau à utiliser avec un traitement de texte, par exemple, nous voulons être sûrs de ne rien changer à l'application de traitement de texte. Sinon, nous risquons d'avoir un utilisateur irrité, c'est le moins qu'on puisse dire.

Le paramètre pxy est un pointeur vers un tableau d'entiers contenant chacune des extrémités de notre polyligne en paires X,Y. Par exemple, si nous voulions dessiner une boîte, pxy[] pourrait ressembler à ceci :

Le paramètre entier num_pairs est le nombre de paires de coordonnées dans le tableau pxy. Au fait, les valeurs pxy sont des valeurs de pixel ; en d'autres termes, dans un écran à faible résolution, nous aurions des valeurs possibles de 0 à 319 pour les coordonnées X et 0 à 199 pour les coordonnées Y. Il existe un certain nombre d'attributs que nous pouvons définir pour chacune des fonctions graphiques VDI. Pour les polylignes, nous pouvons définir la couleur, le type et la largeur, ainsi que le style de fin. Nous définissons la couleur avec :

Ici, la couleur est un entier compris entre 0 et le maximum du périphérique (basse résolution = 15, résolution moyenne = 3 et haute résolution = 1). Si nous utilisons un nombre supérieur au maximum, la fonction passera par défaut à la couleur 1. Sur l'Atari ST, la palette de couleurs par défaut, commençant par 0 et se terminant par 15, est blanc, noir, rouge, vert, bleu, cyan, jaune, magenta, blanc, noir, rouge clair, vert clair, bleu clair, cyan clair, jaune clair et magenta clair. La fonction renverra la valeur de couleur choisie. Si nous dessinons une ligne à la plus petite largeur, nous pouvons choisir entre six types de lignes système avec :

Ici, type est une valeur entière de 1 à 7 comme suit :

Le type 7 vous permet de configurer vos propres types de lignes. Lorsque vous dessinez des lignes, vous pouvez également choisir un style de fin avec l'appel :

Dans ce cas, end1 et end2 sont des valeurs entières de 0 à 2. Une valeur de 0 donnera une extrémité carrée, 1 vous donnera une flèche et 2 entraînera une extrémité arrondie. La variable end1 est le style de début et end2 est le style de fin. Enfin, nous pouvons définir l'épaisseur de nos lignes avec l'appel :

La variable largeur doit être un entier positif impair. La ligne sera définie sur la largeur la plus proche inférieure ou égale à la valeur de largeur. La valeur choisie est renvoyée par la fonction.

Rectangles arrondis

Nous pouvons utiliser v_pline() pour dessiner une boîte standard à coins carrés, mais le VDI fournit également une fonction nous permettant de dessiner des rectangles aux coins arrondis. La fonction est appelée de cette manière :

Encore une fois, nous indiquons à GEM où dessiner notre rectangle avec le tableau pxy, sauf que cette fois nous ne devons fournir que les coordonnées en pixels des coins inférieur gauche et supérieur droit. Les attributs de ligne (couleur, style et largeur) sont utilisés avec v_rbox(), permettant une grande variété de rectangles.

Rectangles arrondis remplis

Si vous voulez un rectangle solide et arrondi, vous pouvez appeler cette fonction :

Le tableau pxy est utilisé de la même manière que dans v_rbox(), fournissant à la fonction les coins inférieur gauche et supérieur droit. Le corps du rectangle est rempli avec le motif de remplissage actif, que nous verrons comment définir plus tard. La valeur par défaut est un remplissage uni.

Cercles

Pour dessiner un cercle, vous pouvez simplement utiliser cet appel de fonction :

Les paramètres entiers x et y sont les coordonnées en pixels du centre du cercle, et le rayon est, évidemment, le rayon du cercle (également un entier). La fonction v_circle(), comme v_rfbox(), utilise les attributs de remplissage actuels.

Polymarqueurs

Les polymarqueurs sont un certain nombre de formes prédéfinies que vous pouvez utiliser dans vos graphiques. Vous appelez la fonction de cette façon :

Le numéro de paramètre entier est le nombre de marqueurs que vous souhaitez dessiner. Les coordonnées de chaque marqueur sont entreposées dans le tableau pxy, une paire X,Y pour chaque marqueur. Mais à quoi ressemblent ces marqueurs ? Vous avez le choix entre six formes prédéfinies qui (respectivement de 1 à 6) sont le point, le signe plus, l'astérisque, le carré, la croix diagonale) et le losange.

Pour définir le type de polymarqueur, appelez :

Ici, type est un entier compris entre 1 et 6. Si vous devez choisir une valeur hors de cette intervalle, la fonction sélectionnera l'astérisque par défaut. La valeur choisie sera renvoyée par la fonction. Deux autres attributs affectent les polymarqueurs : la couleur et la hauteur. La couleur est définie avec l'appel :

Ici, la couleur est un nombre entier compris entre 0 et le maximum du périphérique. Toutes les règles de l'appel vsl_color() s'appliquent dans ce cas. Vous pouvez modifier la taille de tous les polymarqueurs, à l'exception du point (apparaissant toujours dans la plus petite taille), avec l'appel :

Ici, la hauteur du paramètre entier est la taille du polymarqueur sur l'axe Y. La hauteur réelle sera la plus grande hauteur disponible sur le périphérique, inférieure ou égale au paramètre de hauteur.

Rectangles remplis

Des rectangles pleins peuvent être dessinés avec l'appel :

Comme d'habitude, les coins inférieur gauche et supérieur droit sont entreposés dans le tableau pxy. Les attributs de remplissage actifs sont utilisés pour colorer le corps du rectangle.

Ellipses

Une ellipse ressemble à un cercle écrasé ou à un ovale solide. Vous pouvez le dessiner avec l'appel :

Arcs

Les arcs sont simples à dessiner, avec cet appel :

Les nombres entiers x, y et radius sont les coordonnées X,Y du centre et du rayon, respectivement. Les nombres entiers bang et eang sont les angles de début et de fin de l'arc, en dixièmes de degré. Le schéma suivant illustre les valeurs d'angle possibles :

Tranches de tarte

Voici une fonction pratique vous aidant à dessiner ces graphiques circulaires fantaisistes. Pour dessiner une part de tarte, utilisez l'appel :

Les paramètres sont les mêmes que ceux de la fonction arc. Le corps du secteur sera coloré par le motif de remplissage actif.

Motifs de remplissage

Le GEM vous fournit de nombreux modèles que nous pouvons utiliser pour remplir nos chiffres. Il existe une série de fonctions pour vous permettre de configurer ces modèles comme nous le voulons. La première étape est l'appel de la fonction :

Ici, le style est un entier compris entre 0 et 4. Les valeurs sont interprétées comme suit :

Si vous choisissez le style 0 ou 1, vous n'avez pas besoin d'aller plus loin, mais le style 2 vous permet de choisir entre 24 motifs différents et le style 3 propose 12 styles de hachures. Vous choisissez le motif que vous souhaitez utiliser, avec l'appel :

Ici, le style est une valeur entière comprise entre 0 et 23. La couleur de votre remplissage est sélectionnée avec l'appel :

Toutes les règles de la fonction vsl_color() s'appliquent également ici. Enfin, vous pouvez choisir entre une bordure visible ou invisible pour votre remplissage, avec l'appel :

Ici, vis est n'importe quel nombre entier. Une valeur de 0 vous donnera une bordure invisible ; toute autre valeur entraînera le dessin de la bordure dans la couleur de remplissage actuelle.