Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
Programmation : Assembleur - les écrans publics
(Article écrit par Frédéric Delacroix et extrait d'Amiga News - décembre 1994)
|
|
Suite et fin de notre saga sur les écrans publics avec ce mois-ci, après avoir vu la gestion de
ces écrans par leur possesseur, le point de vue d'une
application désirant ouvrir une fenêtre sur un écran public.
Rappels
Un écran public est un écran Intuition ouvert par une application et mis à la disposition
des autres programmes par l'attribution d'un nom. Ceux-ci peuvent alors ouvrir une fenêtre
sur un écran public désigné par son nom (comme "Workbench", "DEVPAC.1" ou "AmigaNews"
pour l'exemple du mois dernier, ou sur l'écran public par défaut, celui du Workbench en général).
Ouverture d'une fenêtre
Comme pour les fenêtres à l'ancienne mode, on peut ouvrir une fenétre sur un écran public
grâce à la fonction "OpenWindow()" d'intuition.library. Il est toutefois conseillé d'utiliser
"OpenWindowTagList()", qui prend en paramètre, en plus d'un pointeur sur une structure NewWindow
optionnelle en A0, un pointeur sur une liste de marqueurs en A1. Il y a deux façons d'ouvrir une
fenêtre sur un écran public. Dans tous les cas, le champ "nw_Type" de la structure NewWindow,
si elle existe, devra être PUBLICSCREEN et non pas CUSTOMSCREEN.
La première consiste à fournir le nom de l'écran public visé lors de l'ouverture de la fenêtre
grâce au marqueur "WA_PubScreenName". Dans ce cas, le champ "ti_Data" de ce marqueur doit être un
pointeur sur ce nom (qui doit rester valide le temps d'OpenWindow(), il ne faut donc
pas utiliser le nom qu'on trouve dans les PubScreenNodes, mais une copie).
Si cet écran public n'existe pas ou est en mode privé, l'écran public par défaut sera
utilisé si et seulement si l'attribut "WA_PubScreenFallBack" (attribut booléen, qui peut
être ajusté grâce au marqueur du même nom), est VRAI. Dans le cas contraire,
l'ouverture de la fenêtre échoue. D'ailleurs, on peut demander l'écran public par
défaut en mettant à 0 la valeur du marqueur "WA_PubScreenName".
La seconde méthode consiste à demander à Intuition un pointeur sur l'écran public et à fournir
ce pointeur lors de l'ouverture de la fenêtre. On obtient un pointeur sur l'écran désiré,
ainsi qu'une promesse que l'écran ne sera pas fermé inopinément, grâce à la fonction
"LockPubScreen()". Celle-ci prend en A0 un pointeur sur le nom de l'écran désiré,
ou 0 si c'est l'écran par défaut. En retour, elle renvoie en D0 un pointeur sur la structure
"Screen" de l'écran demandé, ou 0 s'il n'existe pas.
Cette fonction est utilisée implicitement par la première méthode. Ce pointeur est ensuite
utilisé pour indiquer à Intuition l'écran sur lequel la fenêtre doit être ouverte, par
le biais du marqueurs "WA_PubScreen". On peut aussi mettre ce pointeur dans le champ "nw_Screen"
de la structure NewWindow éventuelle, mais il ne faut surtout pas oublier de mettre le champ
"nw_Type" à PUBLICSCREEN et non CUSTOMSCREEN.
Une fois que la fenêtre est ouverte, on doit utiliser la fonction "UnlockPubScreen()",
la présence d'un visiteur étant équivalente à un verrouillage par "LockPubScreen()".
La fonction "UnlockPubScreen()" prend en A0 un pointeur sur le nom de l'écran concerné
en A0 et un pointeur sur sa structure Screen en A1. Le traitement de ces arguments est
un peu spécial : si le pointeur sur le nom est nul, alors le pointeur sur la structure Screen
est utilisé (c'est la meilleure méthode) : dans le cas contraire, l'argument Screen est
ignoré.
C'est souvent la seconde méthode qui est utilisée car elle permet, entre "LockPubScreen()"
et "OpenWindow()", d'examiner les champs de la structure Screen et de sa structure DrawInfo
associée, de façon à pouvoir adapter l'aspect de la fenêtre, des gadgets et des images à
la résolution, largeur, hauteur, couleurs de l'écran public, avant l'ouverture proprement dite de la fenêtre.
Question de style
En dehors des programmes faisait partie d'une grosse application, je pense par exemple Devpac 3
qui ouvre la fenêtre d'assemblage sur l'écran de l'éditeur, il est bien sûr préférable de
laisser l'utilisateur choisir sur quel écran une fenêtre doit s'ouvrir. Ceci se fait, par exemple
grâce aux types d'outils (exploitables par l'icon.library, voir cet article),
aux arguments CLI (disponibles par la fonction "ReadArgs()"), un programme de préférences gérant
un fichier de configuration, voire, pour les plus perfectionnés, une requête d'écrans publics
(fonctions [Un]LockPubScreenList(), voir cet article).
Une autre possibilité non négligeable est offerte par la fonction "NextPubScreen()"
d'Intuition. Elle permet, étant donné un pointeur sur la structure Screen en A0
et un tampon mémoire en A1 de recopier le nom de l'écran public suivant dans ce tampon mémoire.
En retour, D0 pointe sur le tampon, ou est nul si aucun écran public n'est disponible
(cas hautement improbable). Le tampon mémoire doit avoir au moins MAXPUBNAME+1,
c'est-à-dire 140 caractères.
Ceci permet, par exemple, d'ajouter un gadget qui permet à une fenêtre de "sauter" d'écran en
écran. Attention cependant, cette fonction peut renvoyer des noms d'écrans qui sont en mode privé :
il faut donc toujours tester le résultat de "LockPubScreen()". De plus, l'ordre des
écrans publics n'a aucune importance, du moins pour l'instant. Cette remarque nous complique
un peu la vie pour la suite.
Souvent on voudrait pouvoir ouvrir une fenêtre sur l'écran le plus en avant, ce qui est par
exemple utile lursqu'on veut appeler une calculatrice sur l'écran d'une application dont
on ne connaît pas le nom. Pour ce problème, les fenêtres CON: autorisent la valeur
"*" pour l'option "SCREEN", et ToolManager utilise l'écran de la fenêtre active
s'il est public (méthode non parfaite), pour ses docks. C'est la méthode utilisée par le programme
"GetPubName" fourni avec ce même ToolManager que je vais décrire maintenant.
Le fait d'inclure cet algoritme dans vos applications permet non seulement de vous
affranchir de ce programme mais aussi d'utiliser cette possibilité à partir du Workbench
(grâce aux types d'outils).
La fonction réalisant ceci est celle qui est nommée "LockScreen()" dans le listing suivant.
Elle prend en argument un pointeur (en A0) sur le nom de l'écran public désiré (tout
comme "LockScreen()). Si ce nom est différent de "*.LockPubScreen()" est appelé normalement.
Dans le cas contraire, la fonction va essayer de verrouiller l'écran le plus
en avant s'il est public, ou l'écran public par défaut dans le cas contraire (pas
question d'ouvrir des fenêtres sur les écrans non publics, n'est-ce pas ?).
Pour trouver cet écran, on examine le champ "ib_FrontScreen" de la structure
"IntuitionBase" (ne pas oublier d'encadrer par "LockIBase()/UnLockIBase()), et on
traverse la liste des écrans publics (en mode "LockPubScreenList()"
bien sûr) à la recherche de cet écran. S'il est trouvé, on le verrouille grâce à
"LockPubScreen()", dans le cas contraire, on verrouille l'écran par défaut,
qu'on amène en avant (simple coquetterie). Un écran verrouillé par notre "LockScreen()"
est libéré de façon tout à fait normale grâce à "UnlockPubScreen()".
Exemple
J'ai inclus la routine "PubScreen()" dans l'exemple suivant, qui se contente d'ouvrir une
fenêtre sur l'écran frontal et d'attendre la fermeture. Pour voir clairement l'effet de
la routine, assignez ce programme à une touche sous ToolManager et amenez un écran public
en avant. Comme il me restait un peu de place, j'y ai aussi inclus
une routine qui remplit la fenêtre avec un motif (grâce au marqueur "WA_BackFill()"),
son défaut étant de ne pas utiliser les couleurs SHINEPEN/BACKGROUNDPEN de la structUre
DrawInfo, mais toujours les couleurs 2 et 0 : vous remédierez facilement.
Listing (ouverture d'une fenêtre sur l'écran frontal)
Le mois prochain, nous attaquons une série sur l'écriture de bibliothèques partagées,
périphériques logiques et gestionnaires, tâche instructive mais ô combien délicate...
|
