Windowtools

Windowtools

Auteur: C. de Lean (été 1995)

Adapté a HTML par Normand Henault


Classes de WindowTools

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


Autres references


Introduction a WindowTools

Windowtools est un progiciel (Produit logiciel) destiné à faciliter la construction d'interfaces graphiques pour les programmes écrits en Simula. Windowtools utilise X, un protocole d'interaction graphique largement répandu dans le monde UNIX qui normalise l'encodage des actions de l'usager comme le "clickage" d'une souris ou l'appui sur une touche du clavier et qui fournit aussi un certain nombre de primitives graphiques pour le dessin de lignes, de rectangles et de cercles de diverses couleurs. Par contre, ce que X ne fait pas, c'est implanter (imposer ?) le comportement des éléments graphiques. Si on veut avoir des fenêtres d'édition de texte ou des menus déroulants, il faut ajouter une couche de logiciel entre X et l'usager. Dans la parlance de X, cette couche est appelée un "Toolkit" et Motif en est l'exemple le plus connu. Si la programmation graphique a été normalisée et simplifiée par l'emploi de X et de Motif, elle reste relativement complexe à cause du grand nombre de paramètres et d'objets fournis afin de répondre au plus grande nombre d'applications.

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

HeadWindow
Fenêtre pouvant contenir un titre (c.f HeadWindow)

ScrollBar
Fenêtre permettant d'indiquer où on se trouve dans une liste dont on ne voit qu'une partie. Ne peut servir qu'à ScrollWindow

ScrollBox
Des fenêtres pouvant changer la sélection courante dans une fenêtre. Ne peut servir que dans ScrollWindow et MultipleChoiceWindow

RadioButton
Classe de boutons dans une fenêtre de classe RadioPanel. Ne peut servir que dans RadioPanel.

PopupListWindow(popupmenu)
Sous-classe de ListWindow servant à PopupMenu. Elle n'est pas pensée pour servir à construire d'autres types de fenêtres.

Voici la hiérarchie des fenêtres dont nous discuterons.

Hiérarchie des classes de fenêtres

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

XWindow

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.


Sous-fenêtres

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.


Fonctions de Remplissage

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;

  • ref(XWindow) procedure SetEnglishtext;

    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.

    Attente active qu'un des boutons de la fenêtre soit choisi. Cette attente active est arrêtee par la définition par défaut de la fonction perform. Si vous redéfinissez cette fonction et que vous utilisez ButtonChoice dans le fenêtre, il est fortement conseillé d'ajouter les lignes chosen_Button_heading :- heading; Button_choice_made := true; où heading est le paramètre de perform. De façon plus générale, si un événement doit casser l'attente active de Buttonchoice, l'instruction "Button_choice_made := true;" est la solution. chosen_Button_heading sera la réponse de Buttonchoice une fois l'attente terminée. Poste un événement dans une file d'attente interne à Windowtools. La réponse sera un appel à la fonction handle_wakeup une fois que tous les messages de X et des autres demandés à handle_wakeup déjà en attente soient deja traitées. Un appel à une telle fonction, suivie d'une boucle appelant handle_event sans cesse et s'arrêtant lors de l'appel de handle_wakeup peut être intéressante pour gérer des processus de fenêtres en parallèle.

    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.

    Les sous-classes de XWindow

    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.

    MainWindow SimpleWindow

    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)

    SideWindow

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

    GraphPage

    Cette fenêtre contient une fenêtre de classe GraphWindow. Pour comprendre l'utilité des fonctions, voir la description de cette classe ( GraphWindow).

    PopupWindow

    Ce type de fenêtre se crée sans demander à l'utilisateur où on veut la placer.

    PopupMenu

    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.

    Subwindow

    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.

    Button

    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.

    Dit si le bouton est toujours en attente.

    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.

    MenuButton

    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.

    MultipleChoiceWindow

    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.

    (bouton de gauche)

    (bouton du milieu)
    (bouton de droite)

    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.

    La sélection courante. Par défaut, c'est la première ligne entrée.

    InputWindow

    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.

    Détermine si on affiche le texte entére ou une série d'étoiles.

    Efface le contenu de la fenêtre.

    ListWindow

    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.

    Permission d'édition de texte.
    Permission de sélection de texte.

    SelectionListWindow

    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.

    Insere une ligne. "lnr" désigne le numéro de ligne visible à ce moment là.
    Ajoute une ligne à la fin sans rafraîchir la fenêtre. Interéssant lors du premier remplissage de la fenêtre. On peut ensuite faire un seul "refresh".

    Indique si la fenêtre est vide.

    Vide le contenu de la fenêtre

    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.

    Met une ligne en gris, interdisant la sélection de celle-ci.
  • Contraire de grayline
    Indique si la ligne est grise ou non.

    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)
    Ces fonctions servent à nous déplacer dans le texte entré dans la fenêtre. Va vers le bas de n lignes (n peut être négatif pour remonter).

    Déplacement de plusieurs lignes

    Déplacement au début et à la fin

    Déplacement pour avoir la ligne au centre de la fenêtre.


    Déplacement pour avoir la ligne en haut de la fenêtre


    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.

    ScrollWindow

    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

    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

    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.

    ParameterList

    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.

    ParameterWindow

    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

    et

    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.

    PromptWindow

    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:

    RadioPanel

    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.



    Sélectionne le bouton avec le texte t.


    Ajoute et sélectionne un bouton


    MessageWindow

    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.

    Création d'une fenêtre message.

    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.

    DrawWindow

    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.



    Convertir une distance virtuelle en réelle (pixel).

    GraphWindow

    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.

    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.

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

    HelloWorld

    Ce code sert surtout à montrer à quel point il faut peu de code pour afficher ``Hello World'' à l'écran avec Windowtools.

      begin
    external class Windowtools; !appel de la librairie;

    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.

    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.