Adapté a HTML par Normand Henault
XWindow |---MainWindow | +---SideWindow | | |---GraphPage | | +---PopupWindow | | +---PopupMenu | | | +---SimpleWindow | +---Subwindow |---Button | |---FancyButton | |---MenuButton |---DrawWindow | +---GraphWindow | |---InputWindow | |---ItemWindow | | |---BoolItemWindow | | |---CharItemWindow | | |---IntItemWindow | | |---reallItemWindow | | |---textItemWindow | +---ListWindow | +---SelectionListWindow | |---MessageWindow |---ParameterList |---ParameterMenu |---ParameterWindow | |---BoolParameter | |---CharParameter | |---IntParameter | |---realParameter | +---textParameter | |---PromptWindow |---RadioPanel +---ScrollWindow +---MenuScrollWindow +-DirectoryMenu
Windowtools est un "toolkit" comme Motif dont l'objectif est de faciliter le plus possible la création d'interface du style Mac/Windows. Pour ce faire, Windowtools utilise la programmation par objet. Le comportement par défaut des objets implantés est celui auquel les usagers modernes sont habitués: nous avons sacrifié la flexibilité à la simplicité. Dans la majorité des cas, les objets fournis peuvent être utilisés tels quels et il est donc possible de mettre en oeuvre une interface GUI Graphic User Interface professionnelle avec peu d'efforts. Effectivement, pour faire apparaître une fenêtre affichant ``Hello World'' à l'écran, il suffit d'une dizaine de lignes avec Windowtools au lieu de plusieurs pages avec X (c.f HelloWorld).
Windowtools est l'oeuvre de B. Kirkerud qui a travaillé dessus depuis plusieurs années. En 1995, ce logiciel a été installé au DIRO et il a servi pour les TP de ift1020. Entre temps, il a subit une première révision par J. Vaucher. Durant l'été 1995, Charles De Léan (sous la direction du prof. Vaucher) a soumis Windowtools à une phase de vérification intensive, d'extension et de réécriture.
Le document quit suit vise les programmeurs qui se servent de Windowtools pour créer des interfaces graphiques. Son but est de présenter rapidement les differéntes classes (ainsi que leurs fonctions) qui peuvent leur être utiles. Un développeur éventuel pourrait avoir besoin de plus d'information, voir à lire le code source. Pour d'autres informations, vous pouvez explorer le site ftp ftp.ifi.uio.no
Windowtools contient une grande varieté de classes. La majorité d'entre elles sont des classes de fenêtres dont nous discuterons plus loin. Sinon, il y a quelques classes à part. La plus importante d'entre elles est XDisplay. C'est la classe d'un objet qui gère les messages (venant du clavier ou de la souris par exemple) et les ressource (fontes et curseurs par exemple). Il ne doit y avoir qu'un seule instance de cet objet dans le programme. Cette instance sera mentionné dans ce document sous le nom de ``display''. Pour s'assurer de l'unicité d'un tel objet, nous introduisons deux fenêtres spéciales qui seront les fenêtres principales dans le programme.Ces fenêtres créent le display, et donc, il faut en faire une et une seule (c.f mainwindow et SimpleWindow au tout début du programme.
Les ressources, gérées par le display, sont définies par plusieurs classes. Les fontes sont définies par XFont (c.f fontes), les curseurs le sont par la classe Cursor (c.f souris), les bitmaps et pixmaps (très utiles pour simuler de la couleur) par Bitmap et PixMap (c.f ), et les requêtes d'alarmes ainsi que les messages internes, par alarm_request et own_event (c.f Evenements).
Chaque fenêtre possède un objet très utile pour ses fonctions graphiques. C'est le contexte graphique (graphic context), défini par la classe XGraphicalContext. C'est un objet contenant des paramètres servant aux fonctions graphiques. Ces paramètres peuvent être modifiés par plusieurs fonctions (c.f ).
Passons maintenant aux fenêtres. On peut dire qu'il existe trois types de fenêtres :
Les classes utiles pour fabriquer les fenêtres de Windowtools ne sont pas toutes décrites ici. Certaines classes ont été volontairement omises car elles ne risquent pas d'être utiles à un programmeur. Ces classes omises sont
Voici la hiérarchie des fenêtres dont nous discuterons.
XWindow |---MainWindow | +---SideWindow | | |---GraphPage | | +---PopupWindow | | +---PopupMenu | | | +---SimpleWindow | +---Subwindow |---Button | |---FancyButton | |---MenuButton |---DrawWindow | +---GraphWindow | |---InputWindow | |---ItemWindow | | |---BoolItemWindow | | |---CharItemWindow | | |---IntItemWindow | | |---reallItemWindow | | |---textItemWindow | +---ListWindow | +---SelectionListWindow | |---MessageWindow |---ParameterList |---ParameterMenu |---ParameterWindow | |---BoolParameter | |---CharParameter | |---IntParameter | |---realParameter | +---textParameter | |---PromptWindow |---RadioPanel +---ScrollWindow +---MenuScrollWindow +-DirectoryMenu
Cette classe contient toutes les fonctions communes aux fenêtres et sert de super-classe pour toute fenêtre graphique. Elle ne permet pas la création directe d'une fenêtre. Seules ses sous-classes peuvent y mener.
Géometrie
Dans cette section, on retrouve toutes les fonctions ayant rapport à
la
disposition des
fenêtres (position et taille).
Accès
Ces fonctions donnent les différentes caractéristiques
géométriques de la fenêtre en pixels.
Toute position est relative au point supérieur gauche de sa
fenêtre
parente.
Largeur et longeur de la partie dessinable de la fenêtre.
Positions relatives à la fenêtre parente des coins et centre
de la
partie dessinable de
la fenêtre.
Epaisseur de la bordure à l'extérieur de la partie
dessinable.
Epaisseur de la bordure à l'intérieur de la partie
dessinable.
Position absolue de la partie dessinable par rapport à la
fenêtre
Changement
Ces fonctions modifient (ou initialisent) la taille,position et bordure de la
fenêtre à
partir de paramètres qui leurs sont donnés.
Changent la taille de la fenêtre
Place la fenêtre à la position donnée. La position est relative à la fenêtre parente.
Voir BorderWidth et DepthBorder ( AccesGeo)
Fixent la taille de la fenêtre en fonction de la fonte utilisée.
Positionnement relatif
Ces fonctions permettent de placer les fenêtres par rapport à la
fenêtre parente
(ou le fond de l'écran au besoin), ou par rapport à une autre
fenêtre. Dans le
deuxième cas, il faut que cette fenêtre soit une fenêtre
soeur
(sous-fenêtre de la fenêtre parente). Sinon, les résultats
ne
seront pas bons.
Windowtools essaiera de conserver la disposition donnée lors des changements de taille de fenêtre.
Ces fonctions utilisent et/ou modifient les sous-fenêtres.
Séparation entre les sous-fenêtres lors du placement automatique de celles-ci.
Met tous les boutons de la fenêtre à la même largeur(soit celle de la plus large).
Changent la taille de la fenêtre pour englober exactement les sous-fenêtres. Il ne se passe rien s'il n'y a pas de sous-fenêtre.
Création de fenêtres
Dans cette partie, on vous explique deux façons de créer des
fenêtres
et comment
les détruire.
Version manuelle
Il est toujours possible de créer des fenêtres à l'aide de la fonction new. Une fois un objet instancié, vous pouvez le manipuler comme une fenêtre. N'oubliez pas, dans plusieurs cas, les fenêtres ne s'affichent pas tout seuls et peuvent avoir des tailles ou des positions indésirables (c.f affecran, changementgeo et positionrel).
Version automatique
Ces fonctions servent à répondre à la demande de création de sous-fenêtres.Par défaut, elles créent la fenêtre, la place et l'affichent à l'écran. Ces fenêtres seront séparées d'une distance prédéfinie accessible par subwindowspacing (c.f geosousfenetre). Attention ! Si jamais vous détruisez une fenêtre créé par ces fonctions, ne les réutilisez plus pour cette fenêtre.
Destruction
La création des choses prévoit souvent leur destruction. C'est particulièrement vrai en programmation. Pour détruire une fenêtre, il suffit d'appeler la méthode Destroy, dont la déclaration est : procedure Destroy.
L'appel de cette méthode devrait être la dernière chose que vous faites avec l'objet.
Vous n'êtes pas obligés de détruire une fenêtre une fois qu'elle est inutile. La fin de l'execution du programme s'en chargera. Mais, comme pour l'allocation de mémoire, vous pouvez ainsi libérer un espace qui peut devenir précieux.
Titre
Ces fonctions servent donner un titre à la fenêtre. Les titres
peuvent
être mis
dans une sou-fenêtre ou dans la fenêtre mère.
HeadWindow
Ces fonctions manipulent une sous-fenêtre spéciale qui sert
à
contenir un titre.
Créent au besoin une fenêtre titre et mettent le texte dans la fenêtre titre.
Donnent la taille de la fenêtre titre.
Change la fonte de la fenêtre titre.
Label
Ces fonctions donnent une façon alternative pour donner un titre. Le
``label''
est un titre que la fenêtre mère doit afficher elle-même.
Permet de donner un titre qui sera affiché à côté de la fenêtre.
procedure ShowCurrentLabel
Fonction qui sera appelée lorsque la fenêtre sera
affichée.
Son implantation
par défaut demande à la fenêtre mère(s'il y en
a),
d'afficher le label à
gauche de la fenêtre.Il pourrait être utile de la
réecrire si
vous voulez
changer la position du label. Cependant, si vous changez la position du
label,
il est possible que vous ayez des problèmes avec le positionnement
automatique
qui suppose que le label est toujours a gauche.
Dessin
Les prochaines fonctions servent a dessiner dans le fond de la fenêtre.
En
aucune
façon, elles font dessiner par-dessus une autre fenêtre. Il existe plus
loin
des
fonctions plus avancés qui permettent de modifier le contexte
graphique,
donc le
comportement général des ces fonctions, à la section .
Fonctions Générales
Ces fonctions utilisent le contexte graphique sans modification. Toutes
position
ici est donnée en pixels.
Point de départ et d'arrivée.
Les coordonnées du point.
Les points des différents sommets et le nombre de sommets.
Les coordonnées du rectangle dans lequel serait inscrit l'éllipse si l'arc devait en être une. Les coordonnées sont le coin supérieur gauche et le point inférieur droit. Les angles sont en degrés et vont dans le sens géometrique. L'angle 0 est en position "est" si le "nord" est le haut de l'écran.
Centre et rayon du cercle.
Comme DrawArc, sauf que les angles sont 0 et 360.
Point supérieur gauche et taille du rectangle.
Fonctions Inverse
Ces fonctions modifient momentanément le contexte graphique pour inverser les zones où ils doivent dessiner. On peut faire l'équivalent en appelant la fonction invert, suivis d'appels aux fonctions générales .
Note : Les fonctions DrawInvertRectangle et InvertRectangle sont identiques.
Comme pour les fonctions inverse, ces fonction modifient temporairement le contexte graphique pour remplir les zones dessinées. La couleur utilisée peut etre modifiée par SetFill (c.f ).
texte
Ces fonctions servent a afficher du texte. Elle utilisent la fonte courante
pour
la forme des lettres (c.f fontes).
Indique si on veut une couleur de fond derrière le texte
qu'on affiche.
On donne les coordonnées du point supérieur gauche du
rectangle
contenant le texte.
On donne le point sur lequel le texte doit être centré.
Demande que le texte soit centré dans la fenêtre.
Autres
Ces fonctions opèrent sur des rectangles dans le fond de la
fenêtre.
Copie le rectangle donné par les 4 premiers paramètres à une autre position dont le coin supérieur gauche est donné par les 2 derniers.
Dessine un rectangle blanc plein.
Efface le contenu du rectangle.
Affichage
Ces fonctions manipulent la présentation et le comportement graphique
de la
fenêtre en général sans modifier le comportement du
dessinage
dans le fond
de la fenêtre (i.e.on ne touche pas au contexte graphique encore).
La fenêtre dans l'écran
On a ici le comportement graphique de la fenêtre par rapport aux
autres.
Met la fenêtre au-dessus de toutes ses soeurs.
Montre ou cache la fenêtre (ainsi que le label s'il y en a un).
Demande au systeme de sauver les parties de fenêtres qui seront
cachés par
cette fenêtre. Ne fonctionne pas sur toutes les stations.
Demande au système de sauver le contenu graphique de la
fenêtre si
elle
vient à être cachée par un autre fenêtre ou si
on lui
fait "hide". Ne
fonctionne pas sur toutes les stations.
Le fond de la fenêtre
Fonctions qui modifient le fond de la fenêtre au complet.
Inverse ce qui est affiche dans la fenêtre.
Remplit la fenêtre avec la couleur de remplissage
Efface ce qui est affiché dans la fenêtre.
Indique qu'on veut une présentation spéciale pour cette
fenêtre. Elle
prendra une certaine profondeur et une couleur grise. Cette commande
fait en sorte que toutes les sous-fenêtres crées ensuite
seront
aussi
"fancy".
Indique si une fenêtre est "fancy"
Change la couleur de fond de la fenêtre.
La bordure interne
Les quatre fonctions suivantes dessinent une bordure interne
dont l'épaisseur est donnée par depthborder (c.f
AccesGeo).
Bordure tout autour
Bordure blanche tout autour.
Demi-bordure au gauche et en haut.
Demi-bordure au droite et en bas.
Fontes
Voici les différentes fonctions pouvant manipuler les fontes de la
fenêtre. Les
différentes fontes possibles varient d'un serveur à l'autre. Il
est
conseille
ici que vous vous procurez une documentation supplémentaire pour avoir
acces
aux
différentes qui vous sont accessible.
Change la fonte de la fenêtre. Il faut donner le nom complet.
Change la fonte de la fenêtre. Il suffit de donner les 4
caractéristiques
demandées
.
Comme SetTypeFace, sauf que bold et slanted sont à
"true".
Donne le nom complet de la fonte courante.
Indique si on a bel et bien un fonte pour cette fenêtre.
Donne la taille en pixels que prendrait le texte t avec la fonte courante.
integer procedure width_of_text(t); text t;
Donnent les differentes caractéristiques de la fonte courante.
Permettent de changer certain titre dans la fenêtre et les sous-fenêtres à venir. Les titres "cancel" "clear" "yes" "no" peuvent être ainsi remplacés par leur équivalent norvégiens. Le booléen Norsktekst indique si les textes doivent être donnés en norvégiens. ref(XWindow) procedure SettNorskTekst;
Messages
Voici les fonctions de message principales. Toutes ces fonctions sont des
fonctions
virtuelles. Dans la classe XWindow, elles ne font absolument rien. Elles sont
redéfinies dans les sous-classes des sous-fenêtres (subwindow).
Vous
devriez vous
sentir libre de redéfinir autant de ces fonctions que vous voulez dans
votre
sous-classe éventuelle de mainwindow,sidewindow ou simplewindow. Dans
simplewindow,
seule la fonction handle_configure a été redéfinie. Si
vous
souhaitez redéfinir de
ces fonctions dans une sous-classe d'une sous-fenêtre
(c'est à dire une ``sous-sous-classe'' de subwindow), il est fort
probable
que vous
éliminerez ainsi un comportement de la super-classe.
Certaines de ces fonctions ne seront appelées que sous certaines conditions (c.f Evenements et Filtres)
Les messages sont envoyés par les fenêtres ou par le display.
Messages venant de fenêtres
Ces prochains messages ne proviennent pas du display mais d'autres
fenêtres
(de sous-fenêtres surtout).
Annonce une réponse d'une sous-fenêtre (de classe Button ou
menuwindow, c.f.
Button et menuwindow). La
redéfinition de perform peut entraîner des
problèmes avec la fonction Buttonchoice (c.f Evenements).
La meilleure fonction à implanter pour détecter les boutons
cliqués (c.f Button).
Si ce message n'est pas récupéré par la fenêtre
parente, elle continuera a se propager
dans la hiérarchie des fenêtres.
Annonce qu'on a choisi un radioButton dans un des radiopanel de la
fenêtre
(c.f radiopanel).
Annonce la sélection d'une ligne dans un listwindow, scrollwindow ou
MenuButton
(c.f listwindow et scrollwindow).
Annonce qu'on a changé le contenu d'une sous-fenêtre (c.f
InputWindow). La
fenêtre modifiée peut être une sous-fenêtre
à
n'importe quel niveau de profondeur.
Le message continue à se propager aux fenêtres parents
jusqu'à ce qu'elle soit
interceptée.
Annonce qu'une sous-fenêtre a changé de taille
(c.fpromptwindow).
Fonction appelée à chaque fois qu'une fonction
redéfinissant
la taille est appelée
(c.f changementgeo). Ce message est envoyé de la
fenêtre
à elle-même.
Messages du display
Voici une courte description des causes des appels des messages envoyés par le display.
Le fond de la fenêtre a été effacé. Il faut le redessiner.
Annonce l'enfoncement ou le relâchement d'une touche ayant un code ASCII.
Même chose que les deux fonctions précédantes, sauf
que
c'est pour des touches
spéciales (tels que crtl,shift,alt).
Indique quel bouton de souris vient d'être enfonce, relâché,
cliqué ou cliqué une
deuxième fois. Si l'utilisateur fait un double-click, les deux
messages
handle_Button_click et handle_second_click seront
envoyés.
Annonce la nouvelle position de la souris
Annonce l'entrée ou la sortie de la souris de la fenêtre.
Annonce que la fenêtre a été détruite. N'a
jamais
été redéfinie dans la
librairie.
Annonce que la fenêtre a changé de taille.
Appelés à la suite des appels de WakeUp et
SetAlarm
(c.f Evenements).
Evenements
Ces différentes méthodes agissent directement avec le display.
Ils
permettent de
générer un événement, d'en attendre, ou d'en
traiter
un.
Par défaut, cette fonction ne fait rien. Cette fonction est
redéfinie dans
scrollwindow et Button (c.f Button et
scrollwindow) ou elle attend après
une réponse.
Demande au display s'appeler handle_alarm dans un nombre de
secondes
donné par Time. Les valeurs nulles ou négatives
entraînent un
appel instantané.
Traite un événement éventuel en attente. Cet
événement peut être un événement
d'alarme, ou ayant rapport à l'interface usager. Dans les deux
cas,
un message
venant de X. Si aucun message de ce type est en attente, on traite
alors
les
événements postés par les fenêtres grâce
à la fonction wakeup.
S'assure que tous les événements envoyés par X
sont
traités.
Filtres de messages
Les fonctions suivantes permettent ou interdisent au display d'envoyer des fonctions de message aux fenêtres.
Filtres simples
Ces fonctions modifient l'accès aux fonctions
parenthèsés qui
les suivent dans
la fenêtre concernée (et pas dans ses sous-fenêtres).
Filtres complexes
Les fonctions suivantes sont plus complexes. Elles peuvent modifier la
permission
d'envois de plusieurs fonctions messages et peuvent aussi se transmettre aux
sous-fenêtres.
La fonction par défaut est de transmettre le même message
à
ses sous-fenêtres.
Elles sont redéfinies dans les classes InputWindow,scrollwindow et
listwindow
(c.f InputWindow,scrollwindow et InputWindow)
Par défaut, ces fonctions ne font rien. Les fenêtres
scrollwindow et
listwindow
redéfinissent ces fonctions (c.f listwindow et
scrollwindow).
Permet ou interdit la sélection de tous les boutons de la
fenêtre
(c.f Button).
Contexte graphique
Le contexte graphique est un paquet de paramètres qui sont
passés de
façon
intrinsèque à chaque fonction graphique. Les différentes
couleurs possibles
varient d'une station à l'autre. Cependant, en tout temps, il est
possible
d'utiliser des tons de gris. Il suffit de demander la couleur ``grayXXX''
où XXX est un nombre de 0 à 100, représentant le
degré
de noirceur.
Change la taille des lignes. Une taille de zéro donne
une ligne mince et très rapide à dessiner.
Changent le foreground et le background du contexte graphique en
même
temps.
Le background n'a aucun rapport avec la couleur de fond de la
fenêtre.
Changent le stipple grâce à un nom ou un bitmap.
Arrête l'utilisation du stipple.
Permettent de sauvegarder le contexte graphique. Ainsi, vous pouvez
modifier
le contexte graphique courant à votre guise pour vos
opérations
graphiques.
A la fin, il est important d'appeler restoregc pour faire revenir
le
contexte
graphique à son état initial.
Inverse le fond de l'écran.
Dessine avec la couleur de remplissage.
Dessine en noir ou blanc.
Change la couleur de remplissage.
Change la couleur de dessinage.
Autres fonctions
On a ici les dernières sections trop petites pour être des sections à part.
Fenêtre principale
Lors de la création d'une fenêtre indépendante de la
fenêtre principale (
SideWindow, c.f sidewindow), il faut tout de même y avoir une
référence.
Donne une référence sur la fenêtre principale.
Debugging
Ces différentes fonctions servent à fabriquer des traces dans
le
programme.
Demandent d'imprimer à la sortie standard tous les
événements que le display reçoit.
Fonction virtuelle donnant la classe exacte de la fenêtre. Devrait
être ajouté
à toute nouvelle classe de fenêtre. Sera appelée si on
demande une trace des
événements.
Demande d'imprimer à la sortie standard la taille et position de la
fenêtre.
Souris
Accès à la position et à la forme du pointeur de la
souris.
Place le pointeur de souris relativement à la partie dessinable de
la
fenêtre.
Place le pointeur à droite de la fenêtre.
Indique si la souris est à l'interieur de la fenêtre.
Change le curseur. On a deux curseurs disponibles :"xterm", un curseur pour
l'edition de texte, et "arrow",une flèche,en temps normal.
Ecran
Les fonctions suivantes donnent des informations sur l'écran
où apparaissent les fenêtres.
Taille de l'écran en pixels
Taille de l'écran en millimètres.
Indique si on a plus de 87 pixels par pouces (environ 2.54 cm).
Indique le nombre de bits nécessaires pour coder une couleur.
Buffer de texte
Accès au buffer de texte du systeme. Ceci donne la possibilite
d'échange de texte entre différents programmes ou
fenêtres.
Dans cette partie, chaque section décrit une ou plusieurs sous-classes de XWindow. Les premières lignes donnent les entêtes des classes, permettant ainsi de trouver les variables d'initialisation et la super-classe des classes.
Les fenêtres de classe MainWindow et SimpleWindow créent automatiquement un display avant leur création (c.f simplewindow). Ainsi, une telle fenêtre doit être la première fenêtre que vous créez. De plus, vous ne devez pas avoir plus d'une de ces fenêtres parce que plusieurs display seraient ainsi crées et les messages risqueraient de ne pas être transmis correctement.
SimpleWindow
MainWindow Class SimpleWindow
Ce type de fenêtre peut être une fenêtre principale au même titre que mainwindow. Noubliez pas, on doit avoir une et une seule fenêtre principale (voir mainwindow)
Cette fenêtre permet la création rapide de sous-fenêtres et de leur donner des places automatiquement (c.f creationauto). Attention. Si vous y créez une fenêtre scrollwindow, le simplewindow s'efforcera de maximiser la taille de cette dernière à chaque changement de taille.
Création simultanee de deux fenêtres
Ces fonctions créent des promptwindow demandant l'information
voulue
Version norvégienne des 5 dernières fonctions.
Ces fonctions n'affectent que le scrollwindow créé par
MakeScrollWindow.
Si la fenêtre scrollwindow n'existe pas avant l'appel d'une de ces
fonctions,
elle sera créee (voir scrollwindow)
Ce type de fenêtre permet de créer des fenêtres indépendantes de la fenêtre mère sans causer de problèmes. On peut en créer autant qu'on veut. La variable TopMainWindow peut être correctement initialisée par un appel à topwindow (c.f fenprincipale).
Cette fenêtre contient une fenêtre de classe GraphWindow. Pour
comprendre
l'utilité des fonctions, voir la description de cette classe (
GraphWindow).
Ce type de fenêtre se crée sans demander à l'utilisateur où on veut la placer.
Cette fenêtre permet la sélection d'un item (ligne de texte) à partir d'une fenêtre indépendante des autres.
NoticeWindow est la fenêtre à laquelle on renvoie les messages LineChoice et LineChoiceIn lors de la sélection et par rapport à laquelle il est possible de se positionner. Etant donné que cette fenêtre n'est pas une sous-fenêtre (SubWindow), LineChoiceIn donne ``none'' comme pointeur de fenêtre.
Cette fenêtre est utilisée par MenuButton (c.f. MenuButton)
Positionne la fenêtre relativement à NoticeWindow.
procedure FindPosition(XNotice,YNotice);integer XNotice,YNotice;
Ajoute une ligne de sélection.
Décide quelle sera la ligne de sélection par
défaut.Cette
méthode doit
impérativement être appelée une fois que toutes les
lignes
sont entrées.
Toute fenêtre faite à partir de cette classe est une
sous-fenêtre. C'est à
dire qu'elle considère sa fenêtre mère comme un
écran en ce qui concerne son positionnement.
Donne la taille du label. Les labels ne servent que dans les
sous-fenêtres.
La seule véritable différence entre ces deux classes est la
présentation.
On peut recupérer la sélection d'un bouton par les
fonctions
Perform,PerformIn et ClickInButton.
FancyButton
Le FancyButton est le type de bouton utilisé dans les fenêtres
``fancy''. Vous pouvez en conclure qu'on ne peut faire SetFancy
sur un bouton.
Donne le texte complet qui sera affiché dans le bouton.
Donne le titre du bouton.
Assigne une touche permettant la sélection rapide du bouton.
Permission et interdiction la sélection du bouton.Ces fonctions
changent
sa présentation.
Un bouton "active" ne renvoie pas de message à sa fenêtre
mère. Ca peut être
intéressant pour avoir un bouton après lequel on attend
(utilisation de wait).
Rend le bouton actif en faisant un disallow sur les autres
boutons
frères,
ou le contraire.
Agit comme si on avait cliqué sur le bouton.
Commence une boucle d'attente jusqu'à ce qu'on sélectionne
le
bouton. Cette
boucle est très importante car elle traite les
événements
venant du programme
(c.à.d une boucle appelant handle_event). On peut avoir plus
d'une
boucle imbriqué
à la fois.
Force l'arrêt de la boucle d'attente du bouton. Si c'est la
dernière boucle dans
tout le programme, ce dernier s'arrêtera aussitôt.
Button Class MenuButton
Ce bouton permet l'utilisation d'un PopupMenu (c.f popupmenu) et
de se souvenir de sa dernière sélection. En tout temps, il
affichera
la
dernière sélection (ou celle par défaut).
Pour chaque item de menu, il est possible d'attribuer des clefs. La clef de l'item choisi peut être récupéré par Perform et PerformIn. Sinon, l'item choisi est toujours donné par LineChoice et LineChoiceIn.
Initialisation du menu.
Le paramètre choix contient les différentes entrées du menu. Chaque entrée est soit un item, soit une étiquette suivie d'un item. Dans le deuxième cas, les deux éléments sont séparés par le caractère ':'. L'étiquette servira de clef si elle existe. Sinon, l'entrée servira de clef. Les entrées sont séparées par un séparateur qui est défini comme la première lettre du texte.
Le paramètre defaut est une clef dans choix qui représente le choix par défaut du menu. Si defaut ne correspond à aucune clef, la première entrée sera la sélection par défaut.
Voici un exemple: SetMenu(``+t1:premier+deuxieme+t3:troisieme'',''t3'');
Sélection courante.
Cette fenêtre permet la sélection du contenu d'une
variable
texte.
Ajoute une ligne à choisir.
Change la sélection courante.
Ajoute des boutons permettant la navigation à travers les
choix.
Navigation à travers les différents choix. La
sélection
se fait en boucle.
Ainsi, le dernier élément précède le
premier.
Les boutons mentionnés
permettent d'appeler ces fonctions avec la souris.
La sélection courante. Par défaut, c'est la
première
ligne entrée.
Cette classe n'est pas un classe à instancier. Elle est
abstraite.
Dès que du texte modifié par l'utilisateur, un
message
Centre le texte
Permission d'entrée d'information venant du clavier ou de la
souris.
Efface le contenu de la fenêtre.
ListWindow offre deux fonctionnalités exclusives:
Edition de texte (traitement de texte simple). Sélection de ligne (comme dans un menu).
Si aucune d'entre elles n'est choisie, la fenêtre servira ne fera alors qu'afficher du texte.
Permissions
Ces fonctions décident quelle est la fonctionnalié
utilisée.
Permission de sélection de texte.
SelectionListWindow est une variante de ListWindow qui se comporte différemment. Si vous êtes intréressés qu'à la selection de texte comme dans un menu, cette fenêtre risque d'être la solution. Cette fenêtre sert en fait à la fabriquation des menus déroulants. Un avertissement : le double-click y est détecté. Comme il n'y a pas eu d'établissement d'un protocole de ``feedback'' dans le cas où une fenêtre reçoit un double-click, la fenêtre renvoie handle_second_click dans la fenêtre parente. Ca peut causer des problèmes si cette fenêtre parente réagit a un double-click.
Ajout de texte
Par ces méthodes, vous pouvez entrer du texte dans la fenêtre.
Edition de texte avec un tampon de texte interne à la
fenêtre.
Ajoute une ligne à la fin.
Insère une ligne à la ligne lnr.
Indique si la fenêtre est vide.
Accès au texte
Ces fonctions nous permettent d'obtenir le contenu du texte de la
fenêtre.
Donne une ligne de texte. La deuxième fonction commence a compter
à partir
de la première ligne visible.
Donne le nombre de lignes entrées.
Première ligne sélectionnée (ou ligne
selectionnée
si on est en mode
de sélection).
Numéro de la première ligne sélectionnée (ou
ligne
selectionnée
si on est en mode de sélection).
Modification de la présentation du texte Ces méthodes forcent la fenêtre à afficher certaines parties tu texte de façon différente.
Inverse la sélection courante ou une ligne particulière.
Taille de la fenêtre
On a une fonction supplémentaire pour modifier la taille de la
fenêtre.
Change la taille de la fenêtre pour qu'elle puisse contenir le nombre de rangées (lignes) et de colonnes(nombre de caracteres par ligne) spécifiées.
Scrolling (déplacement)
Déplacement de plusieurs lignes
Déplacement au début et à la fin
Fraction doit être entre 0 et 1. C'est la fraction du texte
à
laquelle on
veut se rendre.
MenuWindow
SubWindow Class MenuWindow
Ce type de fenêtre permet la création d'un menu à partir
de
boutons. Tout bouton
sélectionné dans cette fenêtre sera rapporté
à la
fenêtre parente comme s'il lui
appartenait (c.f Button). Bref, Cette classe
permet
une extension du nombre de
boutons de sa fenêtre parente.
Décision de l'arrangement des boutons qui seront ajoutés
ensuite.
Création d'un bouton. La sélection future d'un tel bouton
sera
transmise à la
fenêtre mère comme si le bouton lui appartenait
directement. La
sélection d'un
bouton est récupérable par Perform et
ClickInButton.
Cette fenêtre permet la sélection et l'édition de
texte.
Lorsqu'une ligne
est sélectionnee, la fenêtre renvoie deux messages à
la
fenêtre mère :
linechoice et linechoicein.
Crée un bouton qui permettera d'attendre après une
réponse.
Fait attendre la fenêtre après une réponse. Ne
fonctionne
que si un bouton a
été créé par MakeWaitButton (c.f Button).
Crée un bouton qui permettera d'ignorer la fenêtre.
Fonction supplémentaire pour changer la fonte de la fenêtre
titre.
Les trois prochaines méthodes servent à manipuler le menu
venant
avec le
scrollwindow (c.f menuwindow).
Les prochaines méthodes (mise à part les deux
premières)
sont très très
proches de celles de listwindow (c.f listwindow pour des
descriptions).
Fait un "refresh" pour les lignes de texte. A appeler après avoir
fait
des
appels à InitPutLine.
Donne le nombre de lignes entrées dans la fenêtre.
(très proche de info_top de listwindow).
MenuScrollWindow
DirectoryMenu
Ces deux classes permettent la sélection d'une ligne de texte
qu'elles rapportent par LineChoice et LineChoieIn.
On peut aussi obtenir la réponse par WaitMenu.
DirectoryMenu n'a pas besoin d'être initialisé en aucune
façon. Il suffit de donner un répertoire par DirName
et la fenêtre se remplira d'elle-même. Un nom de
répertoire
incorrect (none par exemple), causera la lecture du répertoire
courant. Elle donnera un nom de fichier complet (i.e répertoire
inclu) comme réponse. Un exemple d'utilisation de cette classe
se trouve en directorycode.
Initialise le menu. Les rôles de choix et de defaut sont
bien
expliqués dans la description de SetMenu de la classe
MenuButton
(c.f. ).
Attend après une réponse avant de continuer
l'exécution du
programme. C'est
une fonction très similaire au Wait de la classe Button (c.f
Button).
Exécute SetMenu, puis WaitMenu.
Itemwindow est une classe abstraite d'une famille de fenêtres
pouvant
receuillir des types de données.Chaque sous-classe ont leur
put et
get. Il suffit d'ajouter leur prefixe distinctif à la
fin de
ces
commandes. Ainsi un intItemWindow possède les
méthodes
SubWindow Class ParameterList
C'est une fenêtre qui peut contenir une collection de
fenêtres
(voir ItemWindow). Elle va gérer leur création
et leur
positionnement.
Les différentes fonctions créent différents
types de
fenêtre d'items. Elles
vont toujours placer la dernière fenêtre en dessous des
autres.
Les paramètres donnés ont la meme signification.
Cette classe abstraite permet l'arrivée d'une autre famille
de fenêtre paramètre (voir ItemWindow).
Les sous-classes intparameterwindow,realparameterwindow et
textparameterwindow prennent une variable d'initialisation
supplémentaire :
c'est un entier qui détermine le nombre maximum de
caractères
que ces
fenêtres peuvent contenir.
La véritable différence ici, c'est que ces
fenêtres ont
un bouton "ok"
permettant ainsi une forme de confirmation. Tant que le bouton ok
n'a pas été cliqué, la valeur affichée
n'est
pas considèrée.
Chaque sous-classe permet l'accès et la modification de sa
valeur
grâce à current_value et set_current_value. La
valeur
de retour
de current_value et le paramètre de set_current_value seront
de type
correspondant à la sous-classe. Ainsi, un IntParameterWindow
aurait
les
fonctions
ParameterMenu
SubWindow Class ParameterMenu
Comme pour listwindow (voir listwindow), parametermenu permet
de
manipuler
une collection de fenêtres contenant des paramètres
(voirparameterwindow).
Les paramètres donnes ont la même signification.
Cette fenêtre sert à poser une question
nécessitant
qu'une seule valeur
comme réponse. Elle offre la possibilité de s'agrandir
toute
seule si
la fenêtre de réponse est pleine.
Création de boutons de contrôle. Il faut au moins avoir le
OkButton.
Il est possible de demander à la fenêtre de ne pas
afficher
à l'écran la
valeur donnée par l'utilisateur.
Les méthodes commençant par ``be_om'' sont les versions
norvégiennes de
celles commençant par ``ask_for''. Voici la signification de leur
paramètres:
SubWindow Class RadioPanel
Le radiopanel est encore une autre forme de sélection.
Il comporte plusieurs boutons. Un seul peut être
sélectionné à la
fois. Tous les boutons doivent avoir un texte différent.
La sélection d'un bouton par l'usager fait envoyer à la
fenêtre mère un message
Décison si les boutons seront placés verticalement ou
horizontalement.
texte du bouton choisi
Ajoute un bouton.
Ces fonctions créent des fenêtres de messages.
Attention.
Lorsque ces
fenêtres ont fini leur travail, elles sont détruites.
Tout
pointeur
dessus serait ainsi érroné, une fois disparues de
l'écran.
Les deux dernières fonctions sont identiques. Elles
créent une fenêtre message qui se détruit au bout
d'un
laps
de temps. Si le temps demandé est negatif (ou nul),
la fenêtre sera instantanément détruite.
SubWindow Class DrawWindow
Ce type de fenêtre permet de dessiner à léchelle. Il
suffit de
donner les échelles
avec SetScales et d'utiliser les méthodes de dessin propres
à
cette classe.
Détermine les valeurs minimales et maximales des
coordonnées
dessinées par les
fonctions de dessin suivants, puis les coordonnées du point
d'origine,
suivi
du coin opposé à l'origine (en pixels), dans lequel on
dessinera.
Fonctions permettant de dessiner à l'echelle.
Convertir des coordonnées virtuelles en réelles (pixels),
ou le
contraire.
Ce type de fenêtre permet deux modes de dessin definis par les
deux
méthodes
suivantes.
Définit le point d'origine en bas à gauche et s'assure que
toute
la fenêtre
servira à dessiner.
Code
Ce code sert surtout à montrer à quel point il faut peu de code
pour afficher ``Hello World'' à l'écran avec
Windowtools.
inspect new simplewindow(``Test'') do !Creation d'une fenetre principale;
begin
ref(Button) quit;
quit :- MakeButton(``Quit''); !Creation du bouton de sortie;
DrawCentertext(``Hello World''); !Affichage du texte;
quit.wait; !Debut de la boucle d'attente d'evenements;
end;
end.
Edition de texte
Ce code-ci est un éditeur de texte. Le programme
demande un nom de fichier à l'usager et l'éditera
si le fichier existe.
Ces fonctions servent à nous déplacer dans le texte
entré dans
la fenêtre.
Déplacement pour avoir la ligne au centre de la fenêtre.
Déplacement pour avoir la ligne en haut de la fenêtre
ref(MenuWindow) procedure SetVertical;
Le intItemWindow possède une fonction supplémentaire
permettant de
mettre des bornes aux réponses possibles:
boolItemWindow
Pour le boolItemWindow, makeempty affiche false,
alors
que pour les
autres fenêtres, on vide.
Si la fenêtre est vide lorsqu'on lui demande son entrée,
la réponse sera ``false'',''caractère
nul'',''0'',''0.0'' ou
``notext'', en
fonction du type de la sous-classe.
et
Sélectionne le bouton avec le texte t.
Ajoute et sélectionne un bouton
Création d'une fenêtre message.
Convertir une distance virtuelle en réelle (pixel).
Transforme la fenêtre en graphe avec repère
cartésien et
trace des lignes de
coordonnées. On ne dessinera pas dans la zone reservée
à
ces lignes.
Dans cette partie, on donne du code en exemple. Il est important de
noter qu'il existe plusieurs fichiers de code que vous pouvez aussi
regarder librement. Il devrait en exister une liste tout près
de la provenance de ce fichier.
begin
external class Windowtools; !appel de la librairie;
begin
external class Windowtools;
simplewindow class MyWindow;
begin
ref(Button) quit,save; !boutons de sortie et de sauvegarde du
fichier;
ref(scrollwindow) edit; !fenetre d'edition;
text filename; !nom du fichier d'entree et/ou sortie;
boolean procedure readfile(fname);text fname;
!procedure qui lit un fichier et le met dans edit et qui
indique a la fin si le fichier demande existe;
begin
ref(InFile) f;
boolean opened;
f:-NEW InFile(filename);
opened := f.Open(Blanks(500));
IF opened then
begin
f.InImage;
while not f.Endfile DO !On met le fichier ligne par
ligne dans edit;
begin
edit.initputline(f.Image.strip);
f.InImage;
end;
edit.refreshlines; !On rafraîchit la fenêtre;
f.Close;
end;
readfile:=opened;
end;
procedure savefile(fname); text fname;
!Sauve le contenu de edit dans le fichier;
begin
integer i,nlines=20;
text t;
ref(OutFile) output;
output:-new OutFile(fname);
output.Open(Blanks(500));
for i:=1 step 1 until edit.GetNumberOfLines do
begin
t:-edit.getline(i);
output.Outtext(t);
output.OutImage;
end;
output.Close;
MakeMessageWindow.TimedMessage(``File Saved'',3);
end;
procedure createnewfile;
begin
filename :- ask_for_text(``Filename''); !Nouveau fichier;
if filename=/=notext then !ouverture du fichier;
begin
if ReadFile(filename) then
MakeMessageWindow.TimedMessage(``File Exists'',3);
edit.allowinput;
save.allow;
end;
end;
procedure opennewfile;
begin
ref (DirectoryMenu) menu;
menu :- new directorymenu(this XWindow,notext);
menu.setsize(400,300);
menu.placecentered;
menu.show;
filename :- menu.Waitmenu;
if filename =\= notext and then ReadFile(filename) then
begin !ouverture du fichier;
edit.allowinput;
save.allow;
end;
menu.destroy; !destruction du menu inutile;
end;
procedure ClickInButton(b);ref(Button) b;
!Recupere l'enfoncement du bouton enfonce et agit en consequence;
if b==save then savefile(filename)
else
if b==newfile then createnewfile
else
if b==openfile then opennewfile;
quit :- makeButton(``Quit''); !creation des sous-fenetres;
save :- makeButton(``Save'').Disallow; !interdiction de sauver
avant d'avoir un nom de
fichier;
newfile:-makeButton(``New File''); !boutons d'ouverture de
fichier;
openfile:-makeButton(``OpenFile'');
edit :- makescrollwindow;
filename :- ask_for_text(``Filename''); !demande du nom de fichier;
if not ReadFile(filename) then !ouverture du fichier;
MakeMessageWindow.TimedMessage(``Nouveau Fichier'',3);
edit.allowinput; !permission pour editer le contenu de edit;
save.allow; !permission de sauver;
quit.Wait; !boucle d'attende d'evenement;
end;
new Mywindow(``Edit File''); !creation de la fenetre principale;
end.