Désirs et contraintes
C) Influence de l’implémentation de Cabr
Quelle est l’influence de l’implémentation et des choix de conception du logiciel sur la spécification du prototype ?
Cabri-géomètre étant un produit commercial, il n’est pas possible de décrire trop précisément ses principes de conception et leur réalisation sans risquer de découvrir ses secrets d’implémentation. C’est pourquoi nous nous restreignons à quelques idées générales et aux points qui ont un rapport direct avec nos besoins de développement.
1°) Comment Cabri est-il structuré ?
Cabri est une IHM, donc le programme principal est basée sur une boucle qui attend les événements, gère ceux qui la concernent, et répercute leurs effets sur les données (§I-2-A-4°-b). Cabri est codé en C, avec passage de procédures par les champs des structures de données. Cette organisation permet d’associer des comportements aux données et ainsi de les rapprocher du concept d’objet (§I-2-A-3°-a). Plusieurs procédures sont ainsi associées à chaque objet, dont : création, affichage, distance (entre l'objet et la position du curseur) et destruction. Les créations et les destructions sont génériques : elles sont identiques pour tous les objets puisqu’une seule et même structure de données permet de décrire tous les objets.
Lorsqu'un objet est créé, plusieurs niveaux de mémorisation permettent de gérer les animations. La classe de l'objet dépend de la contrainte qui le relie aux autres objets : par exemple une droite perpendiculaire à un autre objet. La méthode de construction de cet objet (parmi les constructions possibles d'objets dans cette classe) dépend du type des objets dont il dépend effectivement. Par exemple, dans le cas d'une droite perpendiculaire à un objet, la méthode dépend du fait que cet autre objet est un segment ou un côté d’un triangle. Ce concept de méthode précisant une classe permet de supporter le polymorphisme des outils de Cabri : les classes de construction ont pour rôle d’identifier la méthode de construction adaptée au choix des paramètres effectué par l’utilisateur.
Au niveau de la classe de construction, on mémorise :
• toutes les méthodes possibles pour l’outil courant,
• la procédure de sélection des objets sur lesquels l’outil courant peut être appliqué,
• la gestion des retours d’information fournis à l’utilisateur pour l’aider dans son choix des objets à sélectionner.
La création d’un objet consiste en :
• la mémorisation de la classe de construction dont il est issu,
• l’identification de la méthode de construction et la mémorisation de son identificateur parmi les méthodes mémorisées dans la classe,
• la mémorisation de la liste des constituants de l’objet, c’est-à-dire des objets par rapport auxquels cet objet est effectivement contraint.
La méthode de construction permet de calculer les valeurs des paramètres algébriques de l’objet. Ces paramètres algébriques sont : dans le cas d’un point, ses coordonnées, dans le cas d’une droite, les coefficients de son équation, etc. Ils sont obtenus par résolution des contraintes décrites par la méthode mémorisée et utilisation des paramètres algébriques des constituants de l’objet. Par exemple, les coefficients de l’équation d’une droite sont déterminés en fonction des coordonnées des deux points qui la définissent, en résolvant le système d’équations associé :
Si et si alors
les deux points sont A (xA, yA) et B (xB, yB), la droite a pour équation ax + by - c = 0,
le système obtenu est le classique système de deux équations à deux inconnues :
{
a xA + b yA = c a xB + b yB = cLe calcul effectué pour résoudre ce système met à jour les valeurs caractéristiques de la représentation graphique de l’objet. Ainsi, c’est au niveau de la méthode de construction que sont mémorisées les informations utiles pour paramétrer la procédure de sélection des objets, la procédure qui reconnaît que deux objets sont identiques (au sens que les contraintes qui les définissent sont basées sur les mêmes objets), mais aussi les procédures utilisées pour les animations.
Dans l’exemple ci-dessus, les coefficients de la droite sont obtenus (dans le cas général, on peut se ramener à c=1) en fonction des coordonnées du point A, fixe, et du point B, animé, par : a = yA - yB ————— xB yA - xA yB b = xB - xA ————— xB yA - xA yB
Remarque : dans l’exemple ci-dessus, nous n’avons pas considéré les cas particuliers qui posent problème, car le but de cette explication est seulement de donner une idée des principes d’implémentation du logiciel.
La création d’un objet est immédiatement suivie d’un premier affichage de l’objet dans l’état courant de la figure telle qu’elle est au moment de la création, avec
• application de la méthode de construction aux objets dont il dépend, avec leurs positions et leurs formes courantes, pour obtenir les valeurs algébriques de l’objet,
• mémorisation de ces valeurs, caractéristiques de l’objet, avec son type,
• utilisation de ces valeurs pour l’affichage, qui ne dépend plus que du type de l’objet.
Ensuite, à chaque tour de la boucle principale d’attente d’événements, la distance entre la position du curseur et l’objet, est calculée en fonction des valeurs algébriques. Ce calcul ne dépend aussi que du type de l’objet. Lorsque cette distance est inférieure à un seuil, l’objet en question est considéré comme « survolé » par le curseur, et le logiciel génère le retour d’information associé à cet objet pour l’outil courant.
calcule identifie déplace m é t h o d e - à une droite calcule identifie déplace m é t h o d e - à un segment m é t h o d e - à un côté d'un triangle m é t h o d e - à un côté d'un polygone calcule identifie déplace calcule identifie déplace suggère-le-dessin guide-la-sélection Classe droite perpendiculaire T y p e droite dessine distance
Ainsi, l'affichage de l'objet et le calcul de sa distance à tout point de la feuille sont définis par des procédures que ne dépendent que de ses valeurs caractéristiques et du type de l’objet concerné. De même, la manière dont un objet en contraint un autre ne dépend que de ses valeurs et de son type, à travers une méthode de construction. Ainsi, les procédures de dessin et de calcul de distance sont associées aux types des objets.
Cabri-géomètre est très bien adapté aux objets qu’il permet de manipuler : graphiques et même géométriques. Ses structures de données sont conçues spécialement pour gérer la manipulation directe des données et permettre la géométrie dynamique.
2°) Conséquences sur l’insertion de l’édition textuelle dans l’existant
Ajouter une vue textuelle revient à ajouter d’autres modes d’affichage et d’édition à des données déjà existantes, de façon à pouvoir exercer les différents modes d’affichage et de saisie indifféremment depuis la vue programme ou depuis la vue résultat. De plus, l’éditeur textuel doit permettre de modifier la présentation du programme.
L’objectif est de garder les principes de développement, mais de les appliquer à la manipulation d’autres formes de données que les données du domaine, même si les techniques de manipulation qui sont efficaces pour ces nouvelles formes de donnée sont radicalement différentes des précédentes (existantes).
a. Quelles sont les manipulations attendues ?
En tant qu’éditeur textuel, le prototype doit permettre d’accéder aux données et au programme, et guider l’utilisateur dans sa saisie du programme. En tant qu’environnement de programmation, il doit de plus lier la saisie du programme à son exécution, et permettre de revoir la construction pas à pas.
Accès aux données
D’une manière générale, lorsqu’un utilisateur manipule des données, deux motivations peuvent intervenir dans ses actions : agir sur la présentation et agir sur les données elles- mêmes. La vue textuelle doit gérer ces deux aspects pour elle-même et « à distance » pour la vue résultat.
Accès aux objets géométriques
L’édition graphique d’un point est effectuée par sélection directe d’un point de la fenêtre guidée par le retour d’information fourni par le curseur. Un point déjà construit peut être saisi et déplacé quand il possède au moins un degré de liberté. Il possède deux degrés de liberté s’il est un point libre et un degré de liberté s’il est un point sur un autre objet. On peut alors dire qu’il peut être animé. Dans les autres cas, le point est lié et contraint par les autres objets. La mise à jour de ses valeurs algébriques est gérée par la méthode de construction.
Le dessin d’un point constitue son identificateur géométrique, le logiciel reconnaît que le curseur le désigne lorsque la distance entre la position du curseur et celle du dessin est inférieure à un certain seuil. Lorsque deux points sont situés au même endroit (points confondus dans l’état de la figure représentée par le dessin), l’ambiguïté est résolue par le retour d’information fournie sous le curseur : le logiciel affiche la chaîne : « quel objet ? » et déroule le menu constitué des diffrérentes possibilités si l’utilisateur appuie sur la souris. La sélection et le choix se font au moment du relachement de la souris.
Dans l’éditeur textuel, un point et son identificateur textuel sont dissociés et l’identificateur apparaît en différents endroits du programme : une fois dans la liste des objets construits, et autant de fois qu’il est utilisé pour d’autres constructions, dans la liste des constructions mémorisées par le logiciel. On parle d’ubiquité de l’identificateur et de l’objet dans la vue programme, et entre la vue géométrique et la vue programme. L’identificateur textuel est « multiple ». L’éditeur textuel doit reconnaître que le curseur désigne l’objet lorsqu’il survole n’importe quelle occurrence de son identificateur, c’est-à-dire que la position du curseur est contenue dans une zone « silhouette » d’une des occurrences de l’objet.
Pour que la vue textuelle soit dynamique, un point doit pouvoir être construit depuis l’éditeur textuel. L’utilisateur doit pouvoir entrer, par saisie au clavier, les paramètres algébriques « libres » des objets animables. Depuis la vue textuelle, le schéma de fonctionnement des outils de construction peut d’abord être identique à celui de la vue géométrique : l’objet est créé par l’action de l’outil sur des objets sélectionnés dans le programme (avec le même guide fourni par le curseur), le texte du programme de construction s’affiche. Mais ensuite, avec l’affichage des objets construits, plusieurs variantes sont envisageables.
• Soit le logiciel présente directement la bulle de présentation des informations graphiques (cf. §II-1-A-3°-a) et la bloque en attendant la saisie au clavier des paramètres algébriques non calculables. Ce blocage provoque une rupture d’engagement direct, un peu comme dans Géoplan, mais moins forte si la bulle est reliée à l’objet qu’elle décrit, et si elle ne cache pas l’occurrence de définition de l’objet et cache le moins possible de texte du programme.
• Soit il initialise les paramètres algébriques en fonction de la position du curseur, comme si la fenêtre textuelle était la fenêtre géométrique. Mais cela conduit à un décalage entre le rendu géométrique et le mouvement du curseur.
• Soit il initialise les paramètres algébriques avec des valeurs aléatoires (en laissant les objets accessibles dans la fenêtre), ce qui ramène le problème de l’initialisation à celui de la modification, et qui donc peut constituer un choix temporaire de développement.
La position de l’objet géométrique doit être modifiable au clavier en entrant des valeurs nouvelles pour ses coordonnées : depuis les bulles de présentation, depuis la troisième colonne du programme quand l’utilisateur l’a affichée, ou depuis la vue géométrique. Le fait que les valeurs soient ou non modifiables doit être signalé à l’utilisateur, par exemple en utilisant la convention des menus : les valeurs modifiables en noir, les valeurs fixées en gris.
Ainsi, le prototype doit permettre d’éditer les paramètres algébriques (et de la même manière les attributs graphiques). Nous choisissons la troisième solution proposée (valeurs aléatoires) avec les possibilités de modifications depuis les bulles d’aide. Cependant, nous n’avons eu le temps d’implémenter cette fonctionnalité.
Présentation du programme et notations secondaires
L’utilisateur doit aussi pouvoir modifier la position d’une occurrence de l’identificateur, par exemple en insérant un passage à la ligne ou en modifiant l’ordre de la construction.
Lors des appels de macros en particulier, la liste des objets construits peut être trop longue pour tenir sur une ligne. L’éditeur textuel doit donc permettre d’insérer des retours à la ligne. Mais lorsqu’il plie et déplie une macro, il doit retrouver son programme dans l’état de présentation dans lequel il l’avait mis.
Il ne s'agit pas de notations secondaires, puisque celles-ci ont pour objet d'insister sur la syntaxe et la sémantique du texte du programme, et doivent donc être générées par le prototype. Il s'agit plutôt d'ajustements ponctuels de présentation.
Dans le formalisme textuel choisi, le retour à la ligne n’a de valeur sémantique qu’en fin de description de construction. Dans la partie gauche du texte, la fin de la primitive est alignée sur la liste des déclarations des objets qu’elle construit, contenue dans la partie droite du texte. Dans la partie droite du texte, la fin de la liste des objets coustruits est marquée par le début de la partie gauche de la ligne suivante, qui décrit la construction suivante.
L’artéfact qui contient l’information sémantique est donc l’alignement et non le simple retour-charriot.
Accès à la structure du programme
L’outil de redéfinition des contraintes agit sur l’ordre des constructions (§II-1°-A). Mais cette évolution n’est pas maîtrisable par l’utilisateur. Or, le remplissage des objets fermés (polygones, cercles) est actuellement consécutif à cet ordre dans Cabri. Cet ordre est déterminent pour les recouvrements des objets. Il n’y a pas actuellement de gestion séparée des remplissages et des contraintes de constructions.
L’éditeur textuel doit donner accès aux modifications possibles de cet ordre, c’est-à-dire aux modifications qui respectent les dépendances entre les objets issus des contraintes et l’ordre des remplissages.
Si, ultérieurement, Cabri permet de gérer séparément les contraintes topologiques et les contraintes de remplissage, le paradigme de programmation sous-jacent à l’utilisation de Cabri pourra devenir plus déclaratif. En effet, la déclaration d’un objet, c’est-à-dire l’élément du programme de la deuxième colonne qui déclare un objet, pourra alors remonter dans l’historique de la construction en entrainant avec elle la partie droite correspondante, jusqu’à la dernière primitive qui a servi à définir un objet dont dépend la primitive déplacée. De même, elle ne pourra descendre que jusqu’à la première commande basée sur un des objets qu’elle construit. Les déplacements possibles seront beaucoup plus libre que dans l’état actuel du logiciel où l’ordre des remplissages doit aussi être respecté.
Dans les éditeurs textuels habituels, il est conventionnel que les éléments de texte sélectionnés soient affichés en inversion vidéo. De plus, lorsque l’utilisateur laisse la souris appuyée, il peut déplacer le bloc de texte sélectionné et le lâcher quand la position proposée par le logiciel lui convient.
Ensuite, deux possibilités sont envisageables :
• Soit le retour d’information proposé par le logiciel bloque le déplacement sur la dernière position possible, (celle qui précède l’utilisation de l’objet construit comme objet initial de la commande),
• Soit après un court délai, le déplacement de la ligne se met à entraîner le déplacement des lignes filles.
En pratique, l’utilisateur pourra règler lui-même le délai infini pour le premier cas, sinon court, moyen ou long.
Guider l’utilisateur
Le prototype doit associer étroitement un éditeur textuel aux manipulations de l’interface. Élément essentiel de l’environnement de programmation ainsi constitué, non seulement l’éditeur textuel doit être un éditeur syntaxique (§I-3-A-3°-b), mais aussi il doit être muni d’effets visuels pour aider l’utilisateur à assimiler le paradigme de programmation sollicité. Ces artefacts sont attendus pour les constructions de nouveaux objets, les destructions d’objet, les redéfinitions de contraintes et les définitions de macros.
Construction
L’éditeur textuel doit adapter les retours d’information fournis dans la vue géométrique pour guider l’utilisateur dans son choix des objets sur lesquels il peut appliquer chaque outil.
Pour cela, le texte du programme peut être construit au fur et à mesure des sélections, en proposant de considérer l’objet survolé de la manière indiquée sous le curseur. L’utilisateur valide la proposition en sélectionnant l’objet survolé, et l’éditeur passe au paramètre suivant de l’action associée à l’outil.
En cas de renoncement à la construction entamée, l’éditeur textuel doit effacer toute la ligne de commande.
Pour informer de façon permanente l’utilisateur de l’état « en cours », et donc immédiatement réversible ou abandonnable, la ligne de programme correspondante peut être affichée dans une autre couleur.
Des constructions doivent pouvoir être insérées. Il faut donc que l’utilisateur puisse se replacer entre deux éléments de la liste des constructions. Les constructions précédentes doivent être accessibles, mais pas les suivantes. L’utilisateur doit être informé de cet état des constructions, sans pour autant perdre la suite du programme. Pour cela, l’éditeur textuel peut utiliser des couleurs.
Destruction
Contrairement à un éditeur textuel classique (pas syntaxique), l’effacement d’éléments de texte peut avoir des conséquences éloignées de la zone de texte manipulée. L’éditeur textuel doit mettre en évidence les objets qui seront détruits en propageant par exemple l’affichage en couleur de toutes les occurrences de leurs identificateurs à travers la relation de dépendance.
L’illustration ci-dessous reprend l’exemple de la destruction du point C de la figure du §I- 1-B-1°. D1 C D2 A B E M G
Le premier tableau représente le programme de cette construction.
Figure > Point > Point
> Segment ("A", "B")
> Droite perpendiculaire (Par "A", Perpendiculaire à S1) > Cercle ("A" comme centre, passant par "B")
> Point(s) sur deux objets ("D1", C1)
> Cercle (P1 comme centre, passant par "A") > Médiatrice (Médiatrice de S1)
> Point sur un objet (Sur "C") > Point(s) sur deux objets ("D2", "C") > Point(s) sur deux objets ("D2", "C")
> Symétrie centrale (Symétrique de "M", par rapport à ce centre P2) > Milieu (Milieu de P3, et de P2)
> Arc (Par "M", "A" intermédiaire, et "E" final) > Point
> Arc (Par "E", P4 intermédiaire, et "G" final) Fin de la figure -> point "A" -> point "B" -> segment S1 -> droite "D1" -> cercle C1 -> point P1 -> cercle "C" -> droite "D2" -> point "E" -> point "M" -> point P2 -> point P3 -> point "G" -> arc A2 -> point P4 -> arc A3
Le deuxième tableau met en évidence les constructions affectées par la destruction du point C. Figure > Point > Point > Segment ("A", "B")
> Droite perpendiculaire (Par "A", Perpendiculaire à S1) > Cercle ("A" comme centre, passant par "B")
> Point(s) sur deux objets ("D1", C1)
> Cercle (P1 comme centre, passant par "A") > Médiatrice (Médiatrice de S1)
> Point sur un objet (Sur "C")
> Point(s) sur deux objets ("D2", "C")
> Point(s) sur deux objets ("D2", "C")
> Symétrie centrale (Symétrique de "M", par rapport à ce centre P2)
> Milieu (Milieu de P3, et de P2)
> Arc (Par "M", "A" intermédiaire, et "E" final)
> Point
> Arc (Par "E", P4 intermédiaire, et "G" final)
Fin de la figure -> point "A" -> point "B" -> segment S1 -> droite "D1" -> cercle C1 -> point P1 -> cercle "C" -> droite "D2" -> point "E" -> point "M" -> point P2 -> point P3 -> point "G" -> arc A2 -> point P4 -> arc A3
Le troisième tableau contient le programme après destruction.
Figure > Point > Point
> Segment ("A", "B")
> Droite perpendiculaire (Par "A", Perpendiculaire à S1) > Cercle ("A" comme centre, passant par "B")
> Point(s) sur deux objets ("D1", C1) > Médiatrice (Médiatrice de S1) > Point Fin de la figure -> point "A" -> point "B" -> segment S1 -> droite "D1" -> cercle C1 -> point P1 -> droite "D2" > point P4 Définition de macros
Des effets visuels doivent visualiser par simulation le processus suivi par le logiciel pour extraire les commandes de la macro. Le prototype doit permettre à l’utilisateur de remonter dans la dépendance des objets construits depuis les objets terminaux et en s’arrêtant sur les objets initiaux. Les constructions ainsi parcourues doivent rester affichées en couleur avant d’être recopiées une à une dans le corps de la macro.
L’illustration ci-dessous reprend l’exemple du §I-1-B-1°-b.
C
I
G E
Le tableau ci-dessous représente le programme de la construction de cette figure, déjà illustré par le graphe du § I-1-B-1°-c.
Figure > Point
> Cercle ("I" comme centre)
> Point
> Point sur un objet (Sur "C")
> Segment ("E", "I") > Segment ("I", "G") > Droite (Par "I", et "E")
> Cercle ("E" comme centre, passant par "G") > Cercle ("G" comme centre, passant par "I") > Point(s) sur deux objets (C2, C3)
> Cercle (P1 comme centre, passant par "E") > Point(s) sur deux objets (D1, C2)
> Cercle (P2 comme centre, passant par "E") > Segment ("E", "G")
> Cercle ("G" comme centre, passant par "E") > Point(s) sur deux objets (C2, C6)
> Cercle (P3 comme centre, passant par "E") > Point(s) sur deux objets (C2, C6)
> Droite (Par P4, et P3)
> Point(s) sur deux objets (D2, C3)
> Cercle (P5 comme centre, passant par "E") > Médiatrice (Médiatrice de S3)
> Point(s) sur deux objets (D1, D3)
> Cercle (P6 comme centre, passant par "E")
Fin de la figure -> point "I" -> cercle "C" -> point "G" -> point "E"