Fenêtre

Pour le module OK, une fenêtre est une zone rectangulaire possédant une couleur de fond, éventuellement, une fenêtre parent et des fonctions gestionnaires d'événements.

Un gestionnaire d'événement est une fonction qui est appelée par le système graphique (X11, Windows, ...) lorsqu'un événement se produit, comme par exemple, l'appui sur une touche ou l'entrée du curseur de la souris dans la fenêtre.

Une fenêtre qui n'a pas de parent est décorée par le gestionnaire de fenêtre qui lui ajoute un cadre et des boutons. Une fenêtre qui possède un parent n'est pas décorée et ne s'affiche que dans le cadre de son parent. Il est possible de créer des fenêtres sans parent et sans décoration ; elles sont utilisées par exemple pour afficher les menus. Il existe une fenêtre particulière qui est la fenêtre racine (le bureau) que l'on peut manipuler quasiment sans distinction.

Création

La fonction de création des fenêtres est :

(ok:create-window parent
                  fond
                  x y
                  width height)

Les arguments sont les suivants :

• Parent est la fenêtre parent ou #f si la fenêtre n'a pas de parent.
• Fond est la couleur de fond de la fenêtre. Cette couleur peut être une constante :

  ok:transparent	ok:green
  ok:white	ok:blue
  ok:black	ok:yellow
  ok:red	ok:gray
  ok:light-gray	ok:dark-gray

  La couleur peut aussi être créée avec la fonction :

  (ok:make-color r g b)
  

  où r, g et b sont respectivement les composantes rouge, verte et bleue de la couleur, sous la forme d'un entier de 0 à 65535.

  La fonction :

  (ok:color nom)
  

  retourne la couleur dont le nom est donné, sous la forme d'une chaîne de caractères. Les noms sont les noms standard du système X11.

• x et y représentent les coordonnées en pixels du coin en haut à gauche de la fenêtre par rapport à la fenêtre parent, s'il y en a une, ou par rapport à l'écran.

  L'origine des coordonnées se situe dans le coin en haut à gauche est l'axe des y descend vers le bas.

• width et height représentent la largeur et la hauteur de la fenêtre, en pixels.

Racine

La fenêtre ok:root est la fenêtre racine, c'est à dire le bureau. Il est possible de dessiner directement dans le bureau, sans limitation.

Cette fenêtre est crée et initialisée au démarrage de OK.

Destruction

La programmation en Scheme utilise de manière transparente un mécanisme de récupération de la mémoire. Si une fenêtre est créée sans parent, et quelle n'est pas stockée dans une variable ou une structure de données, elle sera détruite tôt ou tard.

C'est ce qui arrivera à la fenêtre créée ci-dessous :

Osm> (ok:create-window #t 
                       ok:black
                       1 1
                       100 50)
  => ok:window

Les fenêtre filles sont protégées tant que leur parent l'est. Pour éviter la destruction automatique des fenêtres sans parent, il est nécessaire de les placer dans une variable globale ou toute structure de données accessible au mécanisme ramasse miettes (garbage collector).

Il est possible de détruire explicitement une fenêtre en utilisant la fonction :

(ok:destroy-window fenêtre)

Osm> (define f (ok:create-window #t 
                                 ok:black
                                 1 1
                                 100 50))
  => #unspecified

Osm> f
  => ok:window

Osm> (ok:desroy-window f)
  => #unspecified

Osm> f
  => ok:destroyed-window

Dans ce cas, l'objet Scheme associé à la fenêtre change de nature pour devenir explicitement une fenêtre détruite.

Affichage

Par défaut, les fenêtre créées sont cachées. Pour les afficher, on utilise la fonction suivante :

(ok:show  fenêtre mode)

Les arguments sont les suivants :

• fenêtre est la fenêtre pour laquelle on veut changer l'affichage.

• mode détermine les nouveaux paramètres d'affichage parmi :

  Valeur	Description
  ok:show:iconic	Transforme la fenêtre en icône
  ok:show:plain	La fenêtre est affichée en plein écran
  ok:show:normal	La taille restaurée et fenêtre affichée.
  ok:show:hide	Cache la fenêtre
  ok:show:top	La fenêtre est affichée au-dessus des autres
  ok:show:bottom	La fenêtre est affichée au-dessous des autres

Pour afficher une fenêtre nouvellement créée, on utilisera :

Osm> (define f (ok:create-window #t 
                                 ok:black
                                 1 1
                                 100 50))
  => #unspecified

Osm> (ok:show f ok:normal)
  => #unspecified

Focus clavier

Dans un environnement graphique, les entrées du clavier sont envoyées à une seule fenêtre. En général, le titre de la fenêtre qui reçoit les entrées clavier est dessiné avec une couleur différente des autres. On dit que la fenêtre reliée au clavier ``a le focus''.

OK étend la gestion du focus aux fenêtres filles. Pour savoir si une fenêtre a le focus, on utilise la fonction :

(ok:focus? fenêtre)

qui retourne #t si la fenêtre a le focus et #f sinon.

Pour donner le focus à une fenêtre, on utilise :

(ok:focus! fenêtre)

Quant à la fonction sans argument ok:focus, elle retourne la fenêtre OK qui a le focus, ou #f, si aucune fenêtre ne l'a. Il se peut que la fenêtre ayant le focus n'appartiennent pas au module OK ; dans ce cas, #f est retourné.

Parent / enfant

La fonction :

(ok:parent fenêtre)

retourne la fenêtre parent ou #f si la fenêtre n'a pas de parent.

La fonction :

(ok:parent? fenêtre parent)

retourne #t si parent est un ancêtre direct ou indirect de fenêtre, et #f sinon.

La fonction :

(ok:parent! fenêtre parent)

permet de changer le parent d'une fenêtre. Cette fonction est très puissante ; elle est très utilisée dans les gestionnaires de fenêtres pour ajouter des décorations autour des fenêtres principales. Cette technique est connue sous le nom du reparenting.

La fonction :

(ok:children fenêtre)

retourne la liste des fenêtres filles de fenêtre ou la liste vide, le cas échéant.

Gestionnaire d'événement

Le gestionnaire d'événement est une fonction basée sur une boucle qui traite les événements associés aux fenêtres d'une même application.

Le rôle du gestionnaire d'événement est de lire les événements dans la liste des événements de l'application et de les envoyer aux fenêtres concernées.

A chaque fenêtre, on associe des fonctions appelées fonctions de rappel ou callback destiné à traiter un événement particulier.

Ces fonctions sont appelées callback car elles sont invoquées par le gestionnaire de fenêtre du système, contrairement aux fonctions classiques invoquées par l'application elle-même.

Ce type de programmation est né avec les interfaces graphiques et il est appelé programmation par événements ou programmation événementielle.

Dans OK, le gestionnaire d'événement est initialisé avec la fonction ok:init qui retourne #t en cas de succès et #f en cas d'erreur ;

(if (not (ok:init))
  (error "OK ne peut pas s'initialiser"))

Cette fonction doit être invoquée avant tout appel à une autre fonction graphique.

Le traitement des événements est automatiquement activé lorsque le programme est sur le point de se terminer, comme dernière action. Cependant, il est possible d'activer ``manuellement'' le traitement en appelant la fonction ok:exec.

L'appel à cette fonction active le traitement des événements ; les fenêtres créées et rendues visibles apparaissent sitôt la fonction appelée. L'appel à cette fonction ne se termine que si toutes les fenêtres de l'application sont détruites ou si la fonction suivante fonction est invoquée :

(ok:stop)

On active donc l'affichage des fenêtres avec :

Osm> (ok:exec)
    ; l'appel ne se termine pas

Le traitement des événements est aussi interrompu lorsque toutes les fenêtres de l'application sont détruite.