MANUEL D'UTILISATION. PrologIA HERITAGE II+
Ci-dessous, vous trouverez de brèves informations concernant II+ Prolog. Ce manuel de référence décrit en détail le langage Prolog II+, son utilisation, ainsi que ses caractéristiques, comme la compilation incrémentale, la modularité, l'ouverture vers d'autres langages et l'environnement de programmation.
A!ociation
Prolog
HERITAGE
PROLOG II+
MANUEL D'UTILISATION
WINDOWS
© PrologIA
ii
Manuel d'Utilisation Windows
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Manuel d'Utilisation Windows
iii
Table des matières
Table des matières..........................................................................................iii
Avant-Propos ................................................................................................. vii
1. Guide d'installation sous l'environnement Windows..................
U 1 - 1
1.0. Préambule.................................................................................U 1 - 1
1.1. Matériel et logiciel requis..........................................................U 1 - 1
1.1.1. Pour lancer Prolog ...................................................... U 1 - 1
1.1.2. Pour ajouter des extensions ....................................................
(méthode standard, en 32 bits)..................................... U 1 - 1
1.1.3. Pour ajouter des extensions en code 16 bits................
U 1 - 2
1.1.4. Pour créer des applications et les diffuser ...................
U 1 - 2
1.2. Contenu du kit d'installation......................................................U 1 - 2
1.2.1. Fichiers indispensables pour utiliser Prolog................
1.2.2. Fichiers annexes pour l'utilisation de Prolog...............
U 1 - 2
U 1 - 3
1.2.3. Fichiers pour les extensions standards (32 bits)..........
1.2.4. Extensions en code16 bits (réservé Windows 3).........
U 1 - 4
U 1 - 5
1.2.4.1. Principe des extensions 16 bits...................... U 1 - 5
1.2.4.2. Fichiers pour les extensions 16 bits ...............
U 1 - 6
1.2.4.3. Exemples fournis ........................................... U 1 - 6
1.2.5. Fichiers d'exemples..................................................... U 1 - 7
1.2.6. Conventions pour les suffixes des fichiers..................
U 1 - 7
1.3. Procédure d'installation.............................................................U 1 - 8
1.4. Modification de l'environnement d'exécution............................U 1 - 8
2. Utilisation de Prolog II+ Windows ................................................U 2 - 1
2.1. Lancement et arrêt de Prolog.....................................................U 2 - 1
2.1.1. Activation, fichiers par défaut ...................................... U 2 - 2
2.1.2. Arrêt de Prolog............................................................ U 2 - 2
2.2. Espaces et tailles par défaut.......................................................U 2 - 2
2.3. Syntaxe de la ligne de commande .............................................U 2 - 3
2.4. Création et exécution d'un programme....................................U 2 - 10
2.5. Interruption d'un programme ..................................................U 2 - 11
2.6. Construction et lancement de Prolog avec graphisme..............
U 2 - 11
© PrologIA
iv
Manuel d'Utilisation Windows
2.7. Compilation et édition de liens ............................................... U 2 - 12
3. Spécificités de Prolog II+ Windows............................................... U 3 - 1
3.1. Valeurs extrêmes des constantes arithmétiques........................ U 3 - 1
3.2. Les caractères dans la syntaxe Prolog II+................................ U 3 - 1
3.3. Personnalisation d'une Application........................................... U 3 - 2
3.4. Modification du module principal ............................................ U 3 - 4
3.5. Extensions en mode 16 bits (Réservé Windows 3) ..................
U 3 - 4
3.6. Utilisation de PrologII+ sous forme de DLL........................... U 3 - 6
4. Communication avec une application, en utilisant ................................
le protocole DDE .............................................................................. U 4 - 1
4.1. Aperçu du protocole DDE ....................................................... U 4 - 1
4.1.2. Les possibilités du protocole DDE Prolog ..................
U 4 - 3
4.2. Utilisation simple de Prolog II+ comme serveur DDE.............
U 4 - 4
4.2.1. Initialisation du serveur Prolog II+..............................U 4 - 4
4.2.2. Transmission d'une requête à Prolog II+.....................U 4 - 5
4.2.3. Exécution d'un but Prolog avec récupération .........................
des solutions................................................................U 4 - 6
4.2.4. Schéma du Serveur Prolog II+....................................U 4 - 7
4.2.5. Exemples.....................................................................U 4 - 7
4.3. Programmer en Prolog II+ un applicatif Client ou Serveur......
U 4 - 8
4.3.1. Programmer un applicatif Client DDE.........................U 4 - 9
4.3.2. Programmer un applicatif Serveur DDE....................
U 4 - 11
5. Primitives Graphiques .................................................................... U 5 - 1
5.1. Description du système graphique ........................................... U 5 - 2
5.1.1. Evénements..................................................................U 5 - 2
5.1.2. Objets graphiques........................................................U 5 - 2
5.1.3. Configuration du graphique Prolog II+ au démarrage. U 5 - 5
5.1.4. Conventions utilisées dans ce chapitre.........................U 5 - 6
5.2. Primitives de gestion des fenêtres............................................. U 5 - 7
5.2.1. Création, destruction d'une fenêtre...............................U 5 - 7
5.2.2. Configuration, manipulation d'une fenêtre.................
U 5 - 10
5.2.3. Rafraîchissement des zones graphiques.....................U 5 - 12
5.3. Primitives élémentaires de gestion des objets attachés .........................
à une fenêtre........................................................................... U 5 - 13
5.3.1. Création, destruction d'objets.....................................U 5 - 13
5.3.2. Configuration d'objets ...............................................U 5 - 17
5.3.3. Gestion des événements.............................................U 5 - 20
5.4. Primitives spécifiques pour la gestion de menu...................... U 5 - 21
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Manuel d'Utilisation Windows
5.4.1. Sauvegarde et changement de la barre de menu.........
U 5 - 21
5.4.2. Description d'un menu .............................................. U 5 - 22
5.5. Mode de dessin et d'écriture....................................................U 5 - 25
5.6. Dessin et positionnement........................................................U 5 - 29
5.7. Position de la souris dans une zone graphique........................U 5 - 33
5.8. Primitives spéciales de saisie...................................................U 5 - 34
5.8.1. Simulation de boutons............................................... U 5 - 34
5.8.2. Affichage de message avec validation........................ U 5 - 35
5.8.3. Saisie de texte............................................................ U 5 - 35
5.8.4. Boites de choix.......................................................... U 5 - 37
5.8.5. Choix de fichier......................................................... U 5 - 39
5.8.6. Choix d'un noeud d'un arbre..................................... U 5 - 41
5.9. Règles pour gérer des objets structurés...................................U 5 - 41
5.10. Envoi d'événements à Prolog depuis un objet externe.............
U 5 - 48 v
© PrologIA
vi
Manuel d'Utilisation Windows
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Manuel d'Utilisation Windows
vii
Avant-Propos
La documentation concernant Prolog II+ a été regroupée en deux manuels :
- le manuel de référence, qui décrit de manière précise le langage et son utilisation.
Ce manuel est valable pour toutes les implantations.
- le manuel d'utilisation, qui décrit tout ce qui est dépendant d'un ordinateur ou d'un système d'exploitation spécifique. Il y a donc un manuel d'utilisation par matériel. Celui-ci concerne la version WINDOWS.
Le manuel d'utilisation précise comment se réalisent de manière pratique sur votre ordinateur, certaines fonctions décrites dans le manuel de référence.
Le chapitre premier décrit l'installation de Prolog sur votre machine.
Le deuxième chapitre concerne le lancement de Prolog, la gestion des états sauvés et la structure des noms de fichiers.
Le troisième chapitre de ce manuel décrit ce qui est spécifique à cette version: ce qu'il y a en plus et en moins par rapport à la version de base, ainsi que les valeurs extrêmes des constantes.
Le quatrième chapitre décrit la communication avec une autre application en utilisant le protocole DDE.
Le dernier chapitre décrit la bibliothèque de primitives graphiques, spécifique à chaque implantation.
Dans les exemples de ce manuel, ce qui a été affiché par l'ordinateur apparaît en caractères "machine à écrire" droits, tandis que ce qui doit être tapé par l'utilisateur apparaît en caractères machine à écrire penchés.
© PrologIA
viii
Manuel d'Utilisation Windows
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
1. Guide d'installation sous l'environnement Windows
1.0. Préambule
1.1. Matériel et logiciel requis
1.2. Contenu du kit d'installation
1.3. Procédure d'installation
1.4. Modification de l'environnement d'exécution
Ce chapitre décrit la procédure d'installation du compilateur Prolog II+ en tant qu'Application dans l'environnement Windows. Il est recommandé de le lire en entier avant de commencer l'installation.
1.0. Préambule
Prolog II+ pour Windows est maintenant une véritable application 32 bits qui fonctionne aussi bien sur Windows NT, Windows 3.1 étendu avec le kit Win32s, et
Windows 95.
Pour les utilisateurs Windows 3, Prolog II+ offre toujours la possibilité d'extensions en C 16 bits, extensions désormais isolées dans une DLL, donc ne nécessitant que le SDK 16 bits classique.
1.1. Matériel et logiciel requis
1.1.1. Pour lancer Prolog
Au minimum un ordinateur PC 386 équipé avec 4 Mo de mémoire, et doté de
Windows version 3.1 augmenté du kit Win32s, sachant que le système standard standard actuel serait plutôt Windows 95 ou Windows NT.
1.1.2. Pour ajouter des extensions (méthode standard, en 32 bits)
Tous les moyens d'extension de Prolog sont utilisables ici. L'outil de développement recommandé est le "MicroSoft Visual C++ version 2.xx". Tout autre SDK compatible est utilisable.
© PrologIA
U 1 - 2
Manuel d'Utilisation Windows
1.1.3. Pour ajouter des extensions en code 16 bits
Cette méthode est destinée aux utilisateurs de Windows 3, la DLL d'extension n'étant pas reconnue par Windows NT et Windows 95. Seule la méthode des parasites décrite en annexe est disponible ici, le code d'extension prenant place dans une DLL chargée automatiquement par Prolog. Pour construire cette DLL, une librairie statique qui inclut les fonctions de communication (get_integer...) est fournie. Elle est compilée avec le "CL version 8.00" du "MicroSoft Visual C++ version 1". Tout autre SDK compatible est utilisable.
Cette DLL a accès à l'ensemble de l'API 16 bits de Windows.
1.1.4. Pour créer des applications et les diffuser
Pour créer des applications et les diffuser, il vous faut commander le kit suivant:
Run Time Prolog II+ sous Windows. Pour Windows 3, vous devrez aussi redistribuer le kit Win32s.
A!ociation
Prolog
HERITAGE
1.2. Contenu du kit d'installation
Note concernant Windows 3
Dans le cas de Windows 3, la première chose à faire est d'installer le kit Win32s fourni. Il est doté de sa procédure d'installation autonome et devra être redistribué tel quel à vos propres clients utilisant Windows 3. Le jeu "FreeCall" fourni avec ce kit vous permettra de vérifier son bon fonctionnement.
Le kit d'installation de Prolog II+ sous Windows consiste en un volume comportant les fichiers suivants:
1.2.1. Fichiers indispensables pour utiliser Prolog
err.txt
Fichier contenant les messages d'erreurs en anglais, et consulté par Prolog lors de l'appel de la règle ms_err si l'option -r n'a pas été utilisée pour en choisir un autre. Pour avoir les messages en français, il faut choisir le fichier
fr_err.txt.
fonts.usr
Fichier de définition des fontes utilisées dans l'environnement graphique par
PrologII+. L'utilisateur peut intervenir sur ce fichier avant le démarrage pour définir les fontes :ft(1), :ft(2)... (utilisées par exemple par le prédicat gr_font).
initial.po
Fichier contenant le code sauvé du superviseur.
© PrologIA
A!ociation
Prolog
HERITAGE
Guide d'installation sous l'environnement Windows
U 1 - 3
prolog.exe
Fichier exécutable de la version de développement de Prolog II+.
1.2.2. Fichiers annexes pour l'utilisation de Prolog
customiz.dl_
DLL contenant des ressources de personnalisation de Prolog II+.
Automatiquement reconnue si renommée en customiz.dll.
dde.mo
Module objet Prolog à charger pour l'écriture d'un applicatif client ou serveur utilisant le protocole DDE.
dessin.m2, dessin.mo
Fichiers source et objet du module de dessin d'arbres.
edinburg.mo
Module objet chargé automatiquement lorsque l'on active la syntaxe
Edinburgh. Contient toutes les règles prédéfinies spécifiques à la syntaxe
Edinburgh. Le chargement de ce module dans une session Prolog en syntaxe
Marseille provoque le passage en mode de compatibilité Edinburgh.
fr_err.txt
Fichier contenant les messages d'erreurs en français.
graphic.mo
Module objet Prolog contenant toutes les primitives graphiques. Fichier à charger pour lancer l'environnement graphique de Prolog.
graphstr.mo
Module objet Prolog utilisé automatiquement par l'environnement graphique en fonction de la configuration choisie au démarrage de Prolog.
obdialog.mo
Module objet Prolog à charger pour utiliser la primitive de gestion d'objets graphiques structurés : gr_dialog. Est automatiquement chargé par le chargement du fichier graphic.mo.
prolog2.pre
Fichier texte contenant la ligne de commande Prolog II+. Si ce fichier existe, les options qui y sont spécifiées remplacent les options par défaut. Ce fichier est d'abord recherché dans le répertoire courant, puis dans le répertoire défini par la variable d'environnement PrologDir2. Il est éditable par n'importe quel processeur de texte.
© PrologIA
U 1 - 4
Manuel d'Utilisation Windows tools
Répertoire d'outils comme:
dbgbase.mo
Module objet à recharger pour avoir des messages d'erreur plus complets concernant les règles prédéfinies de la syntaxe Prolog II.
dbgedin.mo
Module objet à recharger pour avoir des messages d'erreur plus complets concernant les règles prédéfinies de la syntaxe Edinburgh. Peut être chargé directement à la place de edinburg.mo.
dbggraph.mo
Module objet à recharger pour avoir des messages d'erreur plus complets, concernant les règles prédéfinies graphiques. Peut être chargé directement à la place de graphic.mo.
int_edit.mo
Module objet Prolog à recharger (prédicat reload) pour pouvoir utiliser l'éditeur intégré, à la place de l'éditeur externe défini par la variable d'environnement PrologEdit.
A!ociation
Prolog
HERITAGE
1.2.3. Fichiers pour les extensions standards (32 bits)
Tous les fichiers cités ci-dessous, servent à la reconstruction de Prolog II+. Les fichiers objets et la librairie sont indispensables et constituent l'exécutable final :
prolog.exe.
princip.c, princip.obj
Fichiers source et objet contenant le lancement du but principal de Prolog.
proentry.c, proentry.obj
Fichiers source et objet contenant la routine d'entrée standard de Prolog II+
(WinMain). Le fichier proentry.obj peut être remplacé par un programme utilisateur utilisant Prolog comme un sous-programme.
proext.h
Fichier source C, contenant des déclarations de macros et de structures, à inclure dans les modules utilisateur écrits en C.
prolink.bat
Fichier de commandes pour refaire l'édition de liens et reconstruire l'exécutable. Il peut être modifié par l'utilisateur.
© PrologIA
A!ociation
Prolog
HERITAGE
Guide d'installation sous l'environnement Windows
U 1 - 5
prolog.def
Fichier de description de module. Est utilisé lors de l'édition de liens.
L'utilisateur doit y rajouter les noms des Callbacks qu'il désire exporter s'il y a lieu (voir SDK Windows).
prolog.lib
Librairie contenant les fonctions de Prolog.
prolog.res
Fichier compilé des ressources de Prolog.
prouser.c, prouser.obj
Fichiers source et objet de l'interface externe C.
use_win.h
Fichier source à inclure obligatoirement dans les modules utilisateur écrits en
C pour assurer leur compatibilité avec l'environnement fenétré de prolog.
1.2.4. Extensions en code16 bits (réservé Windows 3)
1.2.4.1. Principe des extensions 16 bits
Les extensions 16 bits sont localisées dans une DLL réalisable au moyen du SDK standard de Windows 3, sans modification de l'exécutable 32 bits. Cette DLL est chargée automatiquement dès l'invocation d'une règle d'extension située dans la plage réservée, et déchargée lorsque Prolog se termine. Sa localisation obéit aux règles suivantes:
La DLL doit se trouver au même endroit que l'exécutable 32 bits de Prolog, et son nom doit être le même, sauf le dernier caractère qui est remplacé par un '-',
et l'extension qui est ".DLL".
exemple: à c:\prolog\prolog.exe correspond: c:\prolog\prolo-.dll
Attention: il est possible de lancer plusieurs instances d'une application Prolog, la
DLL d'extensions 16 bits sera alors partagée. Ceci peut entraîner des conflits au niveau des données privées que la DLL maintient.
Lors de l'utilisation des primitives de communication avec Prolog, il est utile de savoir que les pointeurs passés sont convertis mais que les données pointées ne sont pas copiées. L'opération est donc relativement performante.
© PrologIA
U 1 - 6
Manuel d'Utilisation Windows
1.2.4.2. Fichiers pour les extensions 16 bits
usermpty.c
Fichier d'extension vierge, à compléter par vos fonctions, qui peuvent
également figurer dans un source séparé ou des librairies statiques. Ce fichier fournit aussi les fonctions standards d'initialisation et de terminaison de la
DLL, permettant d'y placer éventuellement les votres.
callpro.h
Fichier fournissant les prototypes des primitives de communication, à inclure.
callpros.lib, callprol.lib
Librairie statique fournissant le code de liaison à Prolog, disponible en modèle
Small (callpros) et Large (callprol). L'une des deux versions doit être liée à votre code.
callpro.def
Fichier de définition de module standard pour la DLL, utilisé par l'éditeur de liens. Vous devrez éventuellement en modifier les paramètres et y rajouter vos propres exports. Les ordinaux sont sans importance, les fonctions de connexion étant reconnues par leur nom.
userdll.mak
Exemple de makefile pour la DLL, à adapter.
1.2.4.3. Exemples fournis
Les DLLs d'extensions réalisées en exemple doivent donc être copiées auprès de l'exécutable et renommées pour être reconnues. Une seule est donc utilisable à la fois:
tutorial.c, tutorial.mak, tutorial.p2 -> tutorial.dll
Exemple didactique minimal décrivant les règles essentielles à respecter.
userfunc.c,, userfunc.mak, userfunc.p2 -> userfunc.dll
Exemple conséquent fournissant diverses règles qui exploitent la plupart des primitives de communication.
userxtrn.c, userxtrn.mak, userxtrn.p2 -> userxtrn.dll,
Exemple connectant lui-même une seconde DLL 16 bits, et faisant appel à l'API Windows. Il s'agit de la transposition en 16 bits de l'exemple des objets externes, tel que fourni en 32 bits. Les sources de la DLL chargée sont regroupés dans un sous répertoire.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Guide d'installation sous l'environnement Windows
U 1 - 7
1.2.5. Fichiers d'exemples
Les exemples se trouvent dans le sous-répertoire examples du Kit Prolog.
Exemples de programmation en prolog commentés en Annexe:
automat.p2
database.p2
deriv.p2
grammar.p2
menu.p2
money.p2
mutant.p2
path.p2
sur les arbres infinis sur l'évaluation d'une formule sur la dérivation formelle sur les grammaires la composition d'un menu un casse-tête les mutants la construction d'un chemin
Autres exemples :
D'autres exemples concernant l'environnement graphique sont donnés, ainsi que des exemples d'ajout de prédicats externes auto-documentés.
1.2.6. Conventions pour les suffixes des fichiers
Pour les fichiers et leur signification les conventions suivantes sont utilisées:
.c
.obj
.d2
Suffixe des fichiers contenant des sources écrits en C.
Suffixe des fichiers contenant des fichiers objet .
.m2
Suffixe des fichiers ne contenant que des définitions de macros
Prolog II+.
Suffixe des fichiers contenant un module source Prolog II+ écrit en syntaxe Prolog II.
.m2E
.mo
.po
.p2
Suffixe des fichiers contenant un module source Prolog II+ écrit en syntaxe Edinburgh.
Suffixe des fichiers contenant le code d'un module Prolog compilé
(attention, ils ne sont pas compatibles avec un éditeur de liens du système, seul Prolog peut les manipuler).
Fichiers de format identique au précédent, mais contenant un état complet (fichiers sauvés avec la commande exit). Seuls ces fichiers peuvent être utilisés comme état initial pour le démarrage d'une session
Prolog.
Suffixe d'un fichier source contenant des règles Prolog II+ écrites en syntaxe Prolog II. Le fichier est chargé avec la commande insert lorsque la syntaxe courante est la syntaxe Prolog II.
© PrologIA
U 1 - 8
Manuel d'Utilisation Windows
.p2E
Suffixe d'un fichier source contenant des règles Prolog II+ écrites en syntaxe Edinburgh. Le fichier est chargé avec la commande consult lorsque la syntaxe courante est la syntaxe Edinburgh.
.pex
Suffixe d'un fichier source contenant des commandes Prolog. Doit
être utilisé par la commande input.
Suffixe de fichiers contenant du texte quelconque.
.txt
Les fichiers livrés dont les noms se terminent par .p2 contiennent les textes sources des programmes donnés en exemple en Annexe.
A!ociation
Prolog
HERITAGE
1.3. Procédure d'installation
Le volume de distribution de Prolog II+ a été confectionné par compression d'une arborescence. Exécuter la commande de chargement indiquée sur la feuille de description accompagnant le kit de distribution après s'être placé dans le répertoire où l'on désire installer les fichiers.
Il est conseillé de créer un répertoire réservé à Prolog, par exemple c:\prolog, dans lequel seront installés les fichiers du kit. Il faut alors définir la variable d'environnement qui est utilisée par Prolog pour accéder à ces fichiers (voir § 1.4 ).
1.4. Modification de l'environnement d'exécution
Pour une meilleure utilisation de Prolog, les variables suivantes doivent être définies dans votre environnement d'exécution:
PrologDir2
Chemin utilisé par Prolog si les fichiers suivants ne sont pas définis dans le répertoire courant: initial.po, edinburg.mo, err.txt. La variable concaténée au nom du fichier doit donner son chemin complet.
PrologEdit
Nom de votre fichier de commande qui lancera l'éditeur de textes devant être utilisé par Prolog (prédicats edit, editm) lors de l'édition avec un éditeur de la machine hôte.
La commande suivante doit pouvoir être comprise par l'interpréteur de commandes:
%PrologEdit% nom-de-fichier
Il n'y a pas de valeur par défaut pour cette variable.
Note: Sous Windows3, votre fichier de commande devra en plus, à la fin, créer un fichier de nom file.end dans un répertoire défini par la variable d'environnement de nom TEMP, ceci afin d'indiquer la terminaison de l'édition. Si vous désirez par exemple utiliser l'éditeur edlin du DOS, vous devez construire un fichier de commande (myedit.bat) ayant la forme:
© PrologIA
A!ociation
Prolog
HERITAGE
Guide d'installation sous l'environnement Windows
U 1 - 9 rem begin edlin %1 echo >> file.end
rem end
Si vous désirez par contre utiliser l'éditeur intégré plutôt qu'un éditeur externe, vous devez exécuter le prédicat suivant:
> reload("int_edit.mo");
© PrologIA
U 1 - 10
Manuel d'Utilisation Windows
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
2. Utilisation de Prolog II+ Windows
2.1. Lancement et arrêt de Prolog
2.2. Espaces et tailles par défaut
2.3. Syntaxe de la ligne de commande
2.4. Création et exécution d'un programme
2.5. Interruption d'un programme
2.6. Construction et lancement de Prolog avec graphisme
2.7. Compilation et édition de liens
Prolog II+ est le compilateur d'une version avancée du langage Prolog. Le compilateur Prolog II+ Windows vous permet de charger, d'exécuter, d'étendre ou de modifier interactivement un programme Prolog.
Le compilateur est lancé avec un état initial. Lorsque l'on sort de Prolog avec la commande exit, l'état courant du programme est sauvegardé dans un fichier de code binaire, qui pourra être utilisé plus tard comme nouvel état initial. Le fichier
initial.po qui vous est livré est un état initial neuf, c'est-à-dire constitué uniquement d'un superviseur et des règles prédéfinies.
Ce chapitre fournit une description de la façon de lancer le compilateur Prolog II+
Windows, d'y créer un programme et d'en sortir.
Ce chapitre est destiné également à décrire la façon d'utiliser les autres outils du kit
Prolog II+.
2.1. Lancement et arrêt de Prolog
Pour commencer une session, lancez l'exécutable Windows prolog.exe par un moyen quelconque (à travers le Gestionnaire de Programmes, à partir d'un shell...).
Pour terminer une session, lancez l'un des buts Prolog: quit; ou exit;, ou utilisez l'option Quitter du menu principal.
© PrologIA
U 2 - 2
Manuel d'Utilisation Windows
2.1.1. Activation, fichiers par défaut
Si aucun nom de fichier n'est donné dans la commande de lancement, le nom de fichier initial.po est pris par défaut pour le fichier état initial. Exemple sous
MS/DOS:
win prolog
Cette commande lance le compilateur avec l'état initial initial.po recherché d'abord dans le répertoire courant, puis avec le chemin indiqué dans la variable d'environnement PrologDir2. Une erreur survient si un tel fichier n'existe pas. (La commande Prolog exit sauvera l'état du programme dans un fichier appelé prolog.po dans le répertoire courant.)
win prolog myfile.po
Cette commande lance le compilateur avec l'état initial myfile.po. Une erreur survient si un tel fichier n'existe pas.
Au lancement, Prolog crée sa fenêtre Application et la fenêtre Console, puis affiche sa bannière et des informations sur sa configuration puis charge l'état binaire de démarrage.
Le chargement terminé, Prolog se met en attente de commande. Pour cela il affiche un prompt et attend une suite de buts pour l'exécuter. Prolog fonctionnera dans ce mode jusqu'à sa terminaison, produite par l'exécution du but quit ou exit.
2.1.2. Arrêt de Prolog
Lorsque l'on sort de Prolog en exécutant la règle prédéfinie quit ou par un menu, aucun état n'est sauvegardé.
Lorsque l'on sort de Prolog en exécutant la règle prédéfinie exit, l'état courant est sauvegardé sous le nom prolog.po.
Lorsque l'on sort de Prolog en exécutant la règle prédéfinie exit("nom-de-fichier"), alors c'est ce dernier nom qui sera utilisé dans tous les cas pour l'état sauvé produit.
2.2. Espaces et tailles par défaut
L'espace de travail de Prolog est subdivisé en plusieurs espaces. Par défaut, les tailles de ces espaces sont lues dans le fichier binaire initial, à moins d'utiliser l'option de la ligne de commande qui permet de changer le moyen de déterminer ces valeurs initiales qui sont alors:
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 3
espace du code
C'est l'espace où est chargé l'état initial et le code généré par le compilateur. La taille par défaut est de 500 Ko. Il n'y a pas de limite sur la taille des modules, hormis la contrainte que la somme des tailles des modules soit inférieure à l'espace total pour le code.
Lorsque des règles (à fortiori des modules) sont supprimées, l'espace est automatiquement récupéré pour les règles qui ne sont pas en cours d'utilisation.
espace du dictionnaire
Dictionnaire des identificateurs Prolog. Taille par défaut: 200Ko.
espace de la pile de récursion (stack)
Contient les variables locales de la démonstration en cours. Taille par défaut:
100Ko. Il n'y a pas de consommation d'espace dans cette pile dans le cas de récursion terminale (voir chapitre Contrôle de l'effacement des buts du manuel de référence).
espace de la pile de copie (heap)
Le compilateur Prolog II+ utilise une technique de copie de structures, permettant la mise en oeuvre d'un "garbage collector" très performant. La taille par défaut est de 100Ko.
espace de la pile de restauration (trail)
Pile de mémorisation des valeurs à restaurer lors des retours arrière
(backtracking) dans l'exécution en cours. Taille par défaut: 50 Ko. Le
"garbage collector" permet la récupération d'espace dans cette pile en cas de débordement.
espace pour les appels directs en C
C'est un espace de travail pour le codage des arguments lors des appels directs de procédures ou fonctions C par la primitive callC. Taille par défaut: 1 Ko.
Ces tailles par défaut peuvent être modifiées individuellement par des options sur la ligne de commande ou dans le fichier prolog2.pre.
2.3. Syntaxe de la ligne de commande
Dans toutes les descriptions syntaxiques de ce manuel, les éléments facultatifs sont mis entre crochets: [ ], ceux qui peuvent apparaître un nombre quelconque de fois
-éventuellement aucune- sont écrits entre accolades: { }.
© PrologIA
U 2 - 4
Manuel d'Utilisation Windows
Il est possible de mémoriser la commande de lancement de Prolog en l'incluant dans un fichier nommé prolog2.pre qui peut se trouver dans le répertoire courant ou dans le répertoire d'installation de Prolog. En effet, si un tel fichier existe, Prolog traitera toutes les options de ce fichier ne figurant pas déjà sur la ligne de commande (qui a donc priorité). Seule la première ligne est lue, les autres lignes sont ignorées. Le premier mot est aussi ignoré (nom du programme).
La syntaxe de la commande Prolog est: win (sous MS-DOS) prolog [parametres] [etat_initial]
Le nom de fichier etat_initial, donné dans la syntaxe du système hôte, désigne le fichier d'état avec lequel on souhaite démarrer la session Prolog. Si rien n'est spécifié, le nom initial.po est pris par défaut.
Les paramètres peuvent être spécifiés dans un ordre quelconque, ils permettent de modifier les tailles et les options par défaut du compilateur. La liste des paramètres possibles est:
[-H] [-c n] [-C file] [-d n] [-E] [-f fv{fv}] [-h n] [-i file] [j file] {-m file} [-M n] [-o file] [-P parameter] [-q n] [-Q] [-r file] [-R n] [-s n] [-t n]
Signification des paramètres:
-H
(Help) Affiche au démarrage de Prolog, l'aide de la ligne de commande. Pour chaque option affiche également la configuration par défaut.
-c entier
(code) Définit la taille en Ko utilisée pour l'espace des règles, des variables statiques, et des tableaux Prolog.
-C file
(Compilation) Compile le fichier source de nom file, génère un fichier objet.et quitte Prolog. La détermination du nom du fichier objet suit les règles suivantes :
Si l'option -o est utilisée simultanément, c'est le nom désigné dans cette option qui sera utilisé ;
Si le fichier source ne comporte aucun module, c'est le nom empty.mo qui sera utilisé ;
Si le fichier source ne comporte qu'un seul module, c'est ce nom de module, suffixé par .mo qui sera utilisé (si cet unique module est le module vide, c'est le nom user.mo qui sera utilisé ;
Si le fichier source comporte plusieurs modules, c'est le nom du fichier source suffixé par .mo. qui sera utilisé.
-d entier
(dictionnaire) Définit la taille en Ko utilisée pour le dictionnaire.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 5
-E
(Edinburgh) active Prolog en mode de compatibilité Edinburgh (cf Chapitre
10 du manuel de référence). Est équivalent à l'option -m edinburg.mo. Change la syntaxe et charge les nouvelles règles prédéfinies spécifiques au mode
Edinburgh. La syntaxe Edinburgh suppose que la syntaxe des variables n'est pas la syntaxe Prolog, et la syntaxe des réels est la syntaxe standard. Par conséquent l'utilisation de cette option, modifie la valeur des flags s, v, et r qui vaudra respectivement E, E ou U et S. Le traitement de cette option est réalisé en dernier. Par conséquent, si par l'option -f les flags s et r sont spécifiés, ils seront ignorés et le flag v défini à P sera également ignoré.
-f fv{fv}
(flags) Définit les valeurs des options de comportement de Prolog. Les valeurs par défaut des options sont équivalentes au paramètre:
-f a1A0cIe0g1G0i1o1rPsSuWvPw1zU
fv{fv} est une suite de couples de caractères où dans chaque couple, le premier caractère définit l'option concernée, le second définit sa valeur.
Les options disponibles sont:
option
a
A c i
G e g v w z s u r o
valeurs possibles
0,1
0,1,c,C,d,D,h,H,s,S,t,T
I,M
0,1
0,1
0,1,c,C,d,D,s,S
0,1
0,1
P,S
A,C,I,S
E,F,W
E,P,U
0,1,2
U,D a: (atomes préfixés)
La valeur détermine si l'on doit attribuer automatiquement le préfixe vide
("") aux atomes en position d'argument et non explicitement préfixés :
0 Ces atomes ne seront pas préfixés (attribution du préfixe vide).
1 Ces atomes seront préfixés en fonction du contexte.
A: (réallocation)
La valeur détermine si l'on doit interdire ou permettre la réallocation de l'espace concerné:
1 Toutes les réallocations sont interdites
© PrologIA
U 2 - 6
Manuel d'Utilisation Windows
0 Toutes les réallocations sont permises c (resp. C) La réallocation du code est interdite (resp. permise) d (resp. D) La réallocation du dictionnaire est interdite (resp. permise) h (resp. H) La réallocation de la pile de copie (heap) est interdite (resp.
permise) s (resp. S) La réallocation de la pile de récursion (stack) est interdite
(resp. permise) t (resp. T) La réallocation de la pile de restauration (trail) est interdite
(resp. permise) c: (codage des caractères)
La valeur détermine le type de codage interne des caractères:
I codage selon le jeu ISO 8859-1.
M codage selon le jeu de la machine hôte.
e: (escape mode)
Détermine le mode d'impression des caractères accentués n'appartenant pas au jeu de la machine hôte. Ce flag n'a de signification qu'en mode de codage ISO. Les valeurs possibles sont:
0 le caractère est écrit comme une séquence format_escape -\code octal-
(cf R1.29). Cette option a la particularité de réduire l'ensemble des caractères qui peuvent créer une ambiguité pour l'écriture du "\" (cf R1-
7).
1 le caractère est écrit comme une séquence accent_escape (cf R1.29 à
R1.31).
g: (garbage collection information)
Si la valeur est 1 (option par défaut), un message est imprimé chaque fois qu'il y a récupération mémoire, sinon aucune information n'est imprimée.
G: (garbage collection)
La valeur détermine si l'on doit interdire ou permettre la récupération de mémoire dans l'espace concerné:
1
0
Toutes les récupérations sont interdites
Toutes les récupérations sont permises c (resp. C) La récupération dans le code est interdite (resp. permise) d (resp. D) La récupération dans le dictionnaire est interdite (resp.
permise)
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 7 s (resp. S) La récupération dans les piles est interdite (resp. permise) i: (interprète la lecture du caractère spécial '\')
Si la valeur est 1 (option par défaut), le ou les caractères suivant le '\' sont spécialement interprétés (par exemple la séquence \t signifie le caractère de tabulation). Si la valeur est 0, le caractère '\' perd sa valeur de caractère spécial, il n'est plus possible de le composer avec un format_escape ou un
accent_escape pour représenter un autre caractère, quelle que soit la valeur de l'option e.
o: (optimisation)
Optimisation du code généré (pour: les instructions arithmétiques, les instructions de comparaison, les tests de type, block, val, assign.).
Lorsque cette option est activée, les opérations arithmétiques peuvent donner, lorsqu'on décompile une règle (avec rule par exemple), une suite de termes différente de la suite originale. Il en est de même pour le prédicat block, pour lequel la décompilation donnera, dans certains cas, un terme équivalent mais non identique. Le debugger peut ne pas visualiser certaines opérations arithmétiques, ou certains tests de type, ou encore les arguments de certains prédicats prédéfinis optimisés tels que val, assign ou block. La valeur détermine si l'optimisation est active ou pas.
0 (pas d'optimisation) Le programme apparaît sous sa forme originale lorsqu'on décompile ou lorsqu'on utilise le debugger.
1 (optimisation) C'est la valeur par défaut. L'option s'applique pour tout nouveau code produit par insert, module ou assert.
r: (real)
La valeur détermine la syntaxe à utiliser pour les réels.
P (Prolog) Notation Prolog II (permet l'utilisation simultanée avec la notation infixée des listes).
S (Standard) Notation standard (les réels y sont écrits sous forme abrégée et les listes en notation "crochets". Ex: [1, 2, 3]).
s: (string)
Cette option n'est prise en compte qu'en mode Edinburgh. La valeur définit l'interprétation syntaxique de l'unité lexicale string décrite au § 1.4
du manuel de référence.
A (Atom) L'unité représente un identificateur. Il sera préfixé en fonction du contexte courant de lecture.
C (Character) L'unité représente une liste d'identificateurs d'une lettre. Ils seront préfixés en fonction du contexte courant de lecture.
© PrologIA
U 2 - 8
Manuel d'Utilisation Windows
I (Integer) L'unité représente une liste d'entier égaux respectivement au code (Machine ou ISO, en fonction de l'option choisie) de chaque caractère de la chaîne.
S (String) L'unité représente une chaîne de caractère Prolog.
u: (undefined)
La valeur détermine le comportement lors d'une tentative d'effacement d'une règle non définie. Les valeurs possibles sont:
E (Error) Impression du but en cause et arrêt.
F (Fail) Même comportement que l'interpréteur: échec.
W (Warning) Impression d'un message et échec.
v: (variables)
La valeur détermine la syntaxe à utiliser pour les variables et les identificateurs.
E (Edinburgh) Notation type Edinburgh.
P (Prolog II+) Notation type Prolog II+.
U (Underlined variables) Seules les suites alpha-numériques commençant par "_" dénotent des variables. C'est la forme de base (voir le manuel de référence, chapitre 1).
w: (warning)
Paramètre l'avertissement de certaines configurations étonnantes. N'agit pas sur les messages qui résultent de l'option uW, quand un prédicat appelé n'est pas défini.
0 aucun message n'est donné.
1 prévient en cours d'exécution de l'effacement de :
- block_exit/1 ou block_exit/2 avec une variable libre à la place du numéro d'erreur,
- load/2 ou reload/2 avec une demande de substitution d'un préfixe inexistant,
- save/2 ou kill_module/1 pour un module inexistant,
- suppress/1 ou suppress/2 pour une règle inexistante,
- kill_array/1 d'un tableau non défini.
2 donne les mêmes avertissements qu'en mode 1 et en supplément signale :
- pendant la compilation, les variables non muettes qui n'ont qu'une seule occurence dans la règle (susceptibles de résulter d'une faute de frappe).
z: (lectures des tailles de Prolog)
La valeur détermine la manière de définir les tailles de l'espace de Prolog:
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 9
U lecture des tailles des espaces dans le fichier binaire initial.
D tailles par défaut définies au chapitre 3.
-h entier
(heap) Définit la taille en Ko réservée pour la pile de copie.
-i file
(input) Définit le nom du fichier sur lequel est dirigée l'unité courante de lecture dès le démarrage. Par défaut la lecture se fait à la console.
-j file
(journal) Définit le nom du fichier journal créé par la primitive paper de
Prolog (défaut: "prolog.log").
-m file
(module) Charge au démarrage de Prolog après chargement de l'état binaire le module objet de nom file. Si le fichier n'est pas trouvé dans le répertoire courant, il est cherché dans le répertoire défini par la variable d'environnement
PrologDir2. Si plusieurs de ces options (maximum 20) sont utilisées, elles sont traitées dans l'ordre d'apparition.
-M entier
Temps de réponse maximal accepté, en millisecondes, pour un échange DDE, avant de signaler une erreur.
-o file
(output) Définit le nom du fichier sur lequel est dirigée l'unité de sortie courante dès le démarrage. Par défaut l'écriture se fait dans la "console". La bannière de Prolog apparait toujours dans la console.
-P parameter
Permet de passer un paramètre sur la ligne de commande. Ce paramètre est récupérable depuis Prolog dans le tableau prédéfini de chaînes de caractères
tab_user_param. Si une chaîne vide est rendue, c'est qu'il n'y a plus de paramètres à récupérer. Au maximum 20 paramètres peuvent être transmis sur la ligne de commande. Exemple: prolog -P 1 -P foo
> val(tab_user_param[1], V);
{V = "1"}
> val(tab_user_param[2], V);
{V = "foo"}
> val(tab_user_param[3], V);
{V = ""}
-q entier
Définit la taille en Ko réservée pour le codage des arguments des appels directs de procédures C.
© PrologIA
U 2 - 10
Manuel d'Utilisation Windows
-Q
Permet le démarrage de Prolog à l'état iconique (Quiet).
-r file
Définit le nom du fichier d'erreurs utilisé par Prolog (défaut: "err.txt"). Pour avoir les messages d'erreur en français, choisir le fichier fr_err.txt.
-R entier
(Realloc) Définit le pourcentage d'augmentation de taille pour la réallocation automatique (défaut: 25%).
-s entier
(stack) Définit la taille en Ko réservée pour la pile de récursion et des variables locales.
-t entier
(trail) Définit la taille en Ko réservée pour la pile de restauration (variables à restaurer après backtracking).
A!ociation
Prolog
HERITAGE
2.4. Création et exécution d'un programme
Voici un exemple complet de création et d'exécution d'un programme définissant une petite base de données, démarrant avec l'état de base. $ représente le caractère d'invite du système, > celui de Prolog. Par souci de concision, la règle insert a été utilisée directement, sans appeler l'éditeur.
$ win prolog (sous DOS)
PROLOG II+ ...
...
PrologIA
Prolog est lancé avec l'état initial, les seules règles (ou programmes) présentes en mémoire sont les règles prédéfinies.
>insert;
pere(Jean,Marie) ->; pere(Jean,Pierre) ->;
;
Ici, le programme utilisateur est compilé, il est maintenant connu par
Prolog.
{}
>pere(x,y);
Une exécution de ce programme est lancée.
{x=Jean, y=Marie}
{x=Jean, y=Pierre}
>exit;
On sauve un nouvel état binaire de démarrage contenant le programme utilisateur.
Bye......
$
Le fichier prolog.po a maintenant été créé, contenant un nouvel état (règles prédéfinies et votre programme). Pour repartir avec l'état précédent, relancer Prolog en donnant le nom de fichier correspondant:
© PrologIA
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 11
$ win prolog prolog.po
PROLOG II+ ...
...
PrologIA
>pere(Jean,y);
{y=Marie}
{y=Pierre}
>quit;
Bye......
$
Prolog connait maintenant les règles prédéfinies et votre programme.
Vous pouvez lancer une exécution.
On sort sans sauver.
Pour sauvegarder l'état sous un autre nom de fichier, utilisez la commande
exit("nom-de-fichier").
2.5. Interruption d'un programme
A tout instant, un programme Prolog peut être interrompu par la frappe de la commande Ctrl+Pause. Cette interruption est traitée par le système Prolog de gestion des erreurs et correspond à l'erreur 16. Ainsi, elle peut être récupérée par un programme au moyen de la règle prédéfinie block (voir le manuel de référence). Si ce n'est pas le cas, l'erreur remonte jusqu'au niveau de la ligne de commande Prolog, et le message: INTERRUPTION UTILISATEUR est affiché.
2.6. Construction et lancement de Prolog avec graphisme
Pour la première exécution, exécuter la commande de lancement de Prolog avec le module graphique:
C:\> win prolog -m graphic.mo
Après avoir effectué les choix proposés dans le panneau de configuration, il est conseillé de sauver l'état courant afin de ne plus avoir à refaire ces choix:
> save_state("monini.po");
Pour les exécutions suivantes, il suffira alors de lancer la commande:
C:\> win prolog monini.po
2.7. Compilation et édition de liens
Pour une extension de Prolog, il est possible d'utiliser le fichier prouser.c ou bien créer un ou plusieurs autres modules. Il faut ensuite recompiler le(s) module(s) et faire l'édition de liens entre celui(ceux)-ci et la bibliothèque Prolog pour construire le fichier prolog.exe. Ceci est réalisé par le programme prolink.bat.
© PrologIA
U 2 - 12
Manuel d'Utilisation Windows
prolink.bat
Le programme prolink.bat permet de recréer un exécutable de Prolog modifié ou augmenté d'un certain nombre de modules pouvant contenir des descripteurs de données externes. La commande prolink est de la forme : prolink [liste_modules_objets] : [liste_descripteurs]
liste_modules_objets
est une suite de noms (séparés par des blancs) de modules objets compilés auparavant, devant être inclus dans l'exécutable final.
liste_descripteurs
est une suite de noms (séparés par des blancs) de tables de descripteurs (voir le chapitre 7. du manuel de référence) se trouvant dans les modules objets indiqués en premier argument. Si l'on n'a pas créé de table de descripteurs, le deuxième argument peut être supprimé.
Attention: ne pas oublier le caractère blanc de part et d'autre du caractère séparateur
':'.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Utilisation de Prolog II + Windows
U 2 - 13
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
3. Spécificités de Prolog II+ Windows
3.1. Valeurs extrêmes des constantes arithmétiques
3.2. Les caractères dans la syntaxe Prolog II+
3.3. Personnalisation d'une Application
3.4. Modification du Programme principal
3.5. Extensions en mode 16 bits
3.6. Utilisation de PrologII+ sous forme de DLL
3.1. Valeurs extrêmes des constantes arithmétiques
Les booléens sont représentés par les entiers 0 et 1.
Les valeurs des entiers manipulés dans Prolog ne sont pas limitées à priori. Les valeurs des entiers qui peuvent être communiqués avec un langage externe sont comprises entre -2 147 483 648 et 2 147 483 647 (231-1) : ceci correspond au type
long int de C.
Les réels manipulés dans Prolog correspondent au type double de C (IEEE 64 bits).
Les valeurs des doubles sont comprises entre -1.79e308 et +1.79e308 et la plus grande valeur négative et la plus petite valeur positive sont respectivement -2.2e-308 et +2.2e-308. Certaines fonctions de communication acceptent uniquement des réels simple précision. Les valeurs des réels simple précision sont comprises entre
-3.4e38 et +3.4e38 et la plus grande valeur négative et la plus petite valeur positive sont respectivement -1.2e-38 et +1.2e-38. Ces réels correspondent au type float de
C (IEEE 32 bits).
3.2. Les caractères dans la syntaxe Prolog II+
Tout au long du premier chapitre du manuel de référence la syntaxe était plus spécialement décrite pour le jeu ISO, ce chapitre décrit une partie de la syntaxe relative aux caractères, adaptée au système Windows. Elle est valide pour chaque session Prolog qui utilise le jeu de caractères de la machine hôte.
Il faut noter que si MS-DOS utilise le jeu de caractères OEM, Windows utilise le jeu ANSI qui correspond pratiquement au jeu ISO. Il est donc possible que des fichiers écrits sous MS-DOS et contenant des caractères accentués affichent des rectangles noirs aux emplacements correspondants lorsqu'ils apparaissent dans une fenêtre Windows. Il est conseillé de créer les fichiers de texte avec un éditeur sous
Windows.
© PrologIA
U 3 - 2
Manuel d'Utilisation Windows
big_letter = letter = digit = alpha = separator = separatorP= special_char = special_charE = graphic_c = graphic_charE = graphic_char = character = string_char = format_escape =
"A" | … | "Z" ; big_letter | "a" | … | "z"
| "À" … "ß" - "$"
| "à" … "ÿ" - "÷";
"0" | … | "9" ; letter | digit | "_";
"(" | ")" | "[" | "]" | "{" | "}"
| "|" | "," ;
";" | "." | "<" | ">" ;
"%" | "'" | """ | "_" | "!" | "`" |;
";" ; graphic_char | "\", graphic_char ;
"." | "<" | ">" ;
"#" | "$" | "&" | "*" | "+" | "-" | ":"
| "/" | "=" | "?" | "\" | "@" | "^" | "~"
| NBSP … ¿ | $ | ÷ ; letter | digit | separator | graphic_char | special_char ; character - ( """ | "\") | """"
| "\", format_escape ;
"b" | "f" | "n" | "r" | "t" | "\"
| newline
| octal_digit, octal_digit, octal_digit
| ("x" |"X"), hex_digit, hex_digit ;
3.3. Personnalisation d'une Application
Lors de l'initialisation de l'Application, la DLL customiz.dll est chargée si elle existe dans le répertoire qui contient l'exécutable de Prolog. Cette DLL ne contient pas de code exécutable, son rôle est de servir de support pour les ressources utilisateur. En effet, l'exécutable de Prolog contient déjà les ressources de Prolog. Les ressources utilisateur seront donc compilées et liées à ce module en utilisant un fichier makefile fourni.
Les ressources suivantes sont recherchées lors de l'initialisation et si elles existent, remplacent les ressources originales correspondantes:
10
est une ressource de type Icône, elle sera utilisée à la place de l'icône
"Colonne" de Prolog pour représenter la fenêtre principale de l'Application.
Elle peut également être utilisée pour représenter l'Application dans la fenêtre du Gestionnaire d'Applications: il faut pour cela la rechercher dans le module
customiz.dll (au lieu de prolog.exe).
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Spécificités de Prolog II + Windows
U 3 - 3
1, dans une ressource STRINGTABLE
est une ressource de type chaîne de caractères, qui sera utilisée comme titre initial de la fenêtre principale de Prolog, à la place de "Prolog II+". Attention, ne pas oublier que dans une ressource, le caractère '\0' final doit être explicite.
100
est une ressource de type Description de Boîte de Dialogue, qui pourra être
écrite à la main ou en utilisant l'Editeur de Dialogues du SDK. Si elle est trouvée, l'item "A propos de Prolog ..." du menu "Application" disparaît et l'item "A propos ..." est validé, commandant l'ouverture de cette "About Box".
Son contenu peut être quelconque, mais un seul bouton sera reconnu, et devra porter l'identificateur 1 (IDOK).
D'autres ressources utilisateur peuvent être fournies, mais elles ne seront pas gérées automatiquement. Suivre la procédure standard du système. Se rappeler seulement deux points essentiels:
- Votre fonction de dialogue doit aussi être exportée par l'Application, donc il faut la rajouter dans le module prolog.def.
- Votre ressource sera localisée dans le module customiz.dll et non dans
prolog.exe, donc il faut utiliser le handle hUserDLL, disponible dans prouser.c, à la place du handle d'instance, dans toutes les primitives manipulant vos ressources (DialogBox(), ...).
Dans le cas de Windows 3 et pour utiliser des ressources au moyen d'extensions
16 bits, il sera plus judicieux de lier ces ressources directement à la DLL d'extension.
Le module userrsc.rc, fourni dans le kit, est un exemple de script de ressources de personnalisation. Il a été compilé et inclus dans le fichier customiz.dl_ fourni dans le kit Prolog. Cette DLL doit être renommée en customiz.dll pour avoir une démonstration de cet exemple.
La compilation d'une DLL de personnalisation avec le SDK 16 bits fait l'objet d'une procédure particulière décrite en commentaires dans le fichier userrsc.rc.
3.4. Modification du module principal
Le fichier proentry.c contient le source de la routine principale de Prolog en tant qu'application. Cette routine est largement commentée et effectue des appels aux fonctions:
© PrologIA
U 3 - 4
Manuel d'Utilisation Windows
- InitializeProlog (hInstance, hPrevInstance, lpCmdLine, nCmdShow) qui va faire les initialisations nécessaires au lancement de Prolog. Cette fonction retourne 0 si l'initialisation a réussi, un numéro d'erreur sinon. Ses paramètres sont ceux de la fonction WinMain. . Elle remplace la fonction ProStart mentionnée au chapitre 8 du manuel de référence.
- StartPrologMainGoal() qui va lancer le but principal de Prolog, par appel à la fonction promain(), du fichier princip.c, dont le source est également fourni. Cette fonction retourne 0 si l'appel a réussi, un numéro d'erreur sinon.
L'appel à la fonction StartPrologMainGoal n'est pas obligatoire pour utiliser la machine Prolog, il peut être remplacé par l'appel d'une procédure utilisateur qui installe son propre but et ainsi utilise Prolog en tant que runtime.
Cependant, si cette procédure constitue une tache longue (notion intuitive), elle doit être lancée de la manière décrite dans le fichier afin de ne pas paralyser la machine.
- TerminateProlog() qui accomplira les tâches nécessaires à la terminaison de
Prolog. Elle remplace la fonction ProFinal mentionnée au chapitre 8 du manuel de référence.
Dans ce fichier est également fournie la fonction dont se sert Prolog pour distribuer chaque message Windows lorsque sa lecture est faite de manière interne par l'environnement de Prolog.
3.5. Extensions en mode 16 bits (Réservé Windows 3)
Dans l'environnement 16 bits certaines fonctionnalités ne sont pas accessibles. Cet environnement ne permet pas l'appel direct de fonctions C (via le prédicat callC), la création de zones partagées, l'utilisation de descripteurs et l'utilisation des fonctions
new_pattern et get_formats.
L'ajout de procédures externes est limité à la méthode des parasites décrite en
Annexe D.
Dans la méthode des liens par parasites, un module utilisateur sert de relais entre
Prolog et les routines utilisateur écrites en C. Les numéros de parasites 20000 à
29999 sont réservés aux routines C liées à ce mode. Ce module peut être développé comme pour une DLL Windows 3 standard. Le temps de commutation et de transfert de contrôle est très rapide et tout se passe comme si l'extension était directement liée à l'application 32 bits.
Exemple complet : ajout d'une règle en mode 16 bits
Voici un exemple complet, décrivant l'ensemble des opérations à exécuter pour créer une nouvelle règle prédéfinie implantée par une routine externe en code 16 bits.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Spécificités de Prolog II + Windows
U 3 - 5
Supposons que vous programmiez en C et que vous vouliez ajouter la règle prédéfinie roots(a,b,c,x,y) qui calcule les deux racines réelles x et y de l'équation: ax 2 + bx + c = 0 si elles existent et qui provoque un backtracking sinon.
Etape par étape, la marche à suivre est la suivante:
0. Copier les fichiers proext.h, libentry.obj, usermpty.c, callpro.h, callpro.def,
callproS.lib, userdll.mak dans votre répertoire courant. Renommer usermpty.c en roots.c. Adapter userdll.mak en affectant la macro SourceName à roots.
1. Ajouter dans le fichier roots.c le code suivant:
#include <math.h> puis real_roots(perr_nb) int *perr_nb;
{ float a, b, c, d, x1; if ( !get_real(1, &a, perr_nb)
|| !get_real(2, &b, perr_nb)
/*backtrack*/ else if ( (d = b * b - 4 * a * c) < 0.)
*perr_nb = -1; /*backtrack*/ else
|| !get_real(3, &c, perr_nb)) return; if ( a == 0.)
*perr_nb = -1;
{ x1 = (-b + sqrt(d)) / (2 * a); if ( ! put_real(4, x1, perr_nb) ) return; put_real(5, -b/a - x1, perr_nb);
}
}
2. Modifier la fonction user_rule du fichier roots.c en ajoutant l'appel du nouveau programme externe. Par exemple, en donnant le numéro 20001 à la nouvelle règle: user_rule(nb, err, err_nb) int nb, *err, *err_nb;
{
*err = *err_nb = 0;
switch (nb)
{
...
case 20001: real_roots(err_nb); break;
...
}
}
3. Effectuer les compilations et l'édition de liens :
$ nmake -f userdll.mak
4. Renommer le fichier roots.dll en prolo-.dll et le copier au même endroit que l'exécutable prolog.
© PrologIA
U 3 - 6
Manuel d'Utilisation Windows
$ copy roots.dll c:\prolog\prolo-.dll
5. Lancer une session Prolog:
$ win prolog
PROLOG II+, ...
... PrologIA
>
6. Insérer l'appel de la règle externe dans le module "":
> insert;
roots(a,b,c,x,y) -> /?20001;
;
{}
>
7. Essayer la nouvelle règle:
> roots(1.0e,-8.0e,15.0e,x,y);
{x=5.0e0, y=3.0e0}
> roots(+2.0e,+4.0e,+8.0e,x,y);
>
3.6. Utilisation de PrologII+ sous forme de DLL
Prolog II+ est également disponible sous la forme d'une DLL 32 bits (fichier
prolog.dll) dénuée de tout environnement: graphisme, entrées/sorties. Cette DLL peut être utilisée par toute application Windows 32 bits, laquelle pourra aussi fonctionner sous Windows 3 étendu de l'API Win32s. La DLL Prolog exporte les routines décrites ci-après, ainsi que les routines classiques décrites au chapitre traitant des extensions en C à Prolog.
On retiendra seulement que toutes ces routines sont exportées par la DLL selon le protocole cdecl. L'utilisation de la librairie d'import (fichier prodll.lib) et de la définition des prototypes (fichier exportsw.h ) évitera tout problème à ce niveau.
ConnectDescriptors( EXTERNAL_DESCRIPTOR * paD[] )
Cette routine permet de déclarer dans le code de l'application le tableau de descripteurs paD, écrit comme on l'aurait fait pour une extension C directe. Ce tableau de descripteurs doit être persistant durant toute la session Prolog qui l'utilise (par exemple, qualifié de static s'il est en position de variable locale), et la déclaration doit être faite avant le début de la session (avant l'appel de
ProStart() ).
Si l'argument est NULL, les descripteurs seront supprimés dans la prochaine session. Si la routine est invoquée plusieurs fois, c'est le dernier tableau qui est pris en compte. La routine retourne 0 en cas de succès, -1 en cas d'échec
(session déjà lancée).
L'exemple fourni avec la DLL utilise une fonction déclarée ainsi.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Spécificités de Prolog II + Windows
U 3 - 7
ConnectUserRule( UserRuleFunction * pfUR )
Cette routine permet de déclarer une fonction d'aiguillage appartenant à l'utilisateur pfUR() pour les extensions C utilisant la méthode des parasites.
Cette fonction jouera le rôle de la fonction user_rule() du module prouser.c.
Le format de cette fonction (type UserRuleFunction défini dans le fichier des prototypes) est imposé: c'est le même que celui de la fonction user_rule().
Si l'argument est NULL, la fonction d'aiguillage couramment installée est supprimée. Par sécurité, il est requis de supprimer la fonction courante avant d'en installer une nouvelle. La routine retourne 0 en cas de succès, -1 en cas d'échec (remplacement refusé).
La gamme de numéros de parasites qui peuvent être installés ainsi est celle qui correspondait aux extensions ordinaires: 1 à 9999.
Les mécanismes relatifs aux autres gammes de numéros restent inchangés: on peut par exemple appeler une fonction externe écrite en mode 16 bits de la même façon qu'avec la version standard de développement (DLL 16 bits).
ConnectInString( InStringFunction * pfIS )
Cette routine permet de compléter la DLL en y ajoutant les entrées, par la déclaration d'une fonction d'entrée de texte pfIS() à laquelle Prolog soumettra toutes les entrées (prédicats): avant l'installation d'une telle fonction, une chaîne vide est rendue pour chaque demande d'entrée (rendant donc celle-ci impossible). Le remplacement et la suppression de cette fonction fonctionnent comme la précédente.
Le format de cette fonction (type InStringFunction défini dans le fichier des prototypes) est imposé: son premier argument est l'adresse d'un buffer prêt à recevoir le texte (donc alloué), son second argument est la capacité maximale de ce buffer. Le code de retour de la fonction est ignoré: en cas d'erreur, elle doit rendre une chaîne vide dans le buffer.
Intérieurement, la fonction peut effectuer toute opération même bloquante (en traitant les événements) nécessaire pour obtenir le texte à retourner.
ConnectOutString( OutStringFunction * pfOS )
Cette routine permet de compléter la DLL en y ajoutant les sorties, par la déclaration d'une fonction de sortie de texte pfOS() à laquelle Prolog soumettra toutes les sorties (prédicats, messages): avant l'installation d'une telle fonction, aucune sortie ne peut être visible. Le remplacement et la suppression de cette fonction fonctionnent comme la précédente.
Le format de cette fonction (type OutStringFunction défini dans le fichier des prototypes) est imposé: son unique argument est l'adresse d'un buffer contenant le texte à imprimer. Le code de retour de la fonction est ignoré: aucune erreur n'est attendue.
Intérieurement, la fonction peut effectuer toute opération même bloquante (en traitant les événements) nécessaire pour afficher le texte. Toutefois, on remarquera que Prolog peut émettre des lignes vides, et donc un filtrage peut
être nécessaire si par exemple des boîtes de messages sont utilisées.
© PrologIA
U 3 - 8
Manuel d'Utilisation Windows
InterruptProlog( )
Cette routine sans argument permet de déclencher une interruption utilisateur dans la session Prolog en cours d'exécution. Elle peut être invoquée à tout moment. L'exemple fourni avec la DLL en montre l'utilisation pour stopper l'exécution du prédicat Prolog enum.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
4. Communication avec une application, en utilisant le protocole
DDE
4.1. Aperçu du protocole DDE
4.2. Utilisation simple de Prolog II+ comme serveur DDE
4.3. Programmer en Prolog II+ un applicatif Client ou Serveur
L'environnement de Prolog II+ supporte le protocole DDE, d'une manière portable entre Windows 32 et OS/2-PM. Ces nouvelles fonctionnalités offrent deux types de possibilités:
- Lancer des buts Prolog et en récupérer les résultats depuis un applicatif Client externe, et ce, sans écrire aucun code d'interface,
- En chargeant un module Prolog spécifique, disposer d'un jeu complet de primitives permettant l'écriture en Prolog, sans aucune extension C, de tout applicatif Client ou
Serveur DDE.
4.1. Aperçu du protocole DDE
Ceci n'est qu'une présentation très rapide du protocole DDE. L'utilisateur est invité à se reporter à la documentation du système hôte choisi pour approfondissement.
Le DDE est un protocole de communication unidirectionnelle entre deux applicatifs nommés Client et Serveur, à l'initiative du Client, de manière interne à la plateforme.
© PrologIA
U 4 - 2
Manuel d'Utilisation Windows
4.1.1. Les trois niveaux d'identification du protocole DDE
Le protocole DDE est fondé sur une identification à trois niveaux d'échanges, couramment nommés "Service", "Topic" et "Item". Chaque identifiant est une chaîne de texte, en général sensible aux minuscules/majuscules, limitée à environ
255 caractères, et à priori unique dans le contexte fixé par l'identifiant du niveau précédent.
Le Service identifie un Serveur logique. En pratique, c'est le plus souvent le nom générique de l'applicatif Serveur lui-même ("EXCEL", "WORD", "CLOCK", ...).
Mais rien n'empêche un Serveur de déclarer plusieurs Services, s'il est capable de les gérer.
Le Topic indique un thème de conversation. C'est donc la base fondamentale de l'ouverture d'un échange DDE. En pratique, le Topic relève le plus souvent d'un
Serveur précis, et donc il existe entre Topic et Service un lien implicite (par exemple: qui sait éditer la "Feuille de Calcul Excel nommée EXAMPLE.XLS" ?). Mais rien n'empêche un Serveur quelconque qui en a la compétence d'accepter un Topic donné.
Le nom d'Item indique un objet "donnée" précis relatif à une conversation ouverte sur un thème donné. En pratique, il s'agit donc souvent d'un "paragraphe" précis du
"document" ouvert (par exemple: la plage "E7-K9" de la feuille de calcul précitée).
Mais ce peut être toute entité conceptuellement subordonnée au Topic, compatible avec les opérations DDE à effectuer sur elle (par exemple: un signal "Reset" accédé forcément pour une opération "Poke", dans une conversation de Topic "Time" ouverte avec "CLOCK").
Indépendamment de ces identifications, un échange DDE se caractérise par le choix d'un format de donnée. Celui-ci, public ou propriétaire, est négocié implicitement lors de l'ouverture de la conversation: le Client est supposé s'être enquis des formats supportés par le Serveur pour le Topic visé, et avoir choisi le plus riche que luimême supporte.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 3
Client Logique
Le Formalisme DDE
TEXT seulement pour Prolog
(actuellement)
Execute( Ordre)
RequestData
HotLinkData
WarmLinkData
PokeData( Donnée)
Data pour RequestData, sinon STATUT Booléen
"Item 1"
"Item 2"
"Item z"
Serveur Logique
= son Service
"Service"
"Topic 1"
Telle Donnée
Telle Autre
Donnée
"Topic n"
4.1.2. Les possibilités du protocole DDE Prolog
Afin de respecter le modèle de programmation standard de Prolog II+, le protocole
DDE général a été adapté suivant les possibilités suivantes:
- Tous les échanges se traduisent par des appels de primitives ou bien l'appel automatique de buts par le système. Ces buts seront dans toute la suite appelés
"buts-callbacks". Le retour d'une primitive correspond à la fin d'une transaction et fournit le statut associé.
- Les paramètres des communications lui sont présentés sous une forme classique en Prolog II+: les chaînes de texte elles-mêmes pour les chaînes d'identification
(Service,Topic,Item), et un entier opaque pour les identificateurs de conversation.
Une base de données interne assure la conversion et le contrôle de cohérence des paramètres fournis par l'utilisateur.
- Les capacités du DDE Prolog sont limitées à des données de type "Chaîne de
Texte Standard".
- Le cas où ni le Service ni le TOPIC n'est spécifié par le Client potentiel suppose une phase de négociation où le Serveur décrit ce qu'il propose. Ce sous-protocole n'est pas implémentable sous forme de squelette extensible en Prolog. Donc il a
été décidé que seules les "Wild Connections" avec Topic spécifié seraient
acceptées par Prolog.
© PrologIA
U 4 - 4
Manuel d'Utilisation Windows
- Les buts-callbacks intervenant dans des mécanismes systèmes, avec les problèmes classiques que cela suppose, ne peuvent pas être mis au point "sur site" mais devront l'être avant raccordement, dans un contexte de simulation. De même, ils doivent fournir des traitements de durée "raisonnable", cette notion restant intuitive.
- La notification de la transmission d'une donnée se fait sur la base du Topic. La distribution à chaque client concerné par ce Topic est assurée de manière interne.
A!ociation
Prolog
HERITAGE
4.2. Utilisation simple de Prolog II+ comme serveur DDE
Pour utiliser Prolog II+ comme un Serveur DDE, il est nécessaire de disposer d'un applicatif Client capable de formuler des requêtes paramétrables au format
"Texte Pur". A titre de test, il existe plusieurs possibilités:
- disposer déjà d'un tel applicatif, même surdimensionné pour cet usage,
- utiliser un "Sample DDE Client" fourni avec le Software Development Kit pour la plate-forme hôte (exemple: le SDK 32 bits de MicroSoft pour Windows),
- utiliser une autre instance de Prolog II+ programmée en Client DDE.
4.2.1. Initialisation du serveur Prolog II+
Afin de valider le Service DDE, la primitive suivante doit être invoquée:
ddePublishExternalEvent( _bActivate)
Active (_bActivate vaut 1) ou désactive (_bActivate vaut 0) le Service.
La désactivation du Service interdit toute future connexion, mais ne congédie pas les Clients éventuellement déjà connectés. Cependant, ils le seront de manière correcte si Prolog II+ se termine prématurément.
Après validation, Prolog II+ publie un Service (ou nom d'application) intitulé
Prolog2 et sous lequel il reconnaît le Topic ExternalEvent. Une "Wild
Connection" sans Service mais spécifiant ce Topic sera aussi acceptée. Un nombre quelconque de Clients peuvent se connecter (chacun suivant sa méthode), jusqu'à limitation par le système.
Il est à remarquer que lors de la connexion et de toute opération ultérieure, la console de Prolog II+ ne manifeste aucune réaction, sauf pour une opération d'écriture explicite.
Après connexion, le Client peut utiliser librement les requêtes DDE standards avec la sémantique qui va être décrite ci-après.
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 5
4.2.2. Transmission d'une requête à Prolog II+
Il existe deux possibilités:
- Envoi d'une requête de type Poke sur un Item nommé "texte", sans donnée additionnelle (ignorée si présente): un événement de type extern_event( "texte", 0,
0) est placé dans la queue d'événements de Prolog II+, et pourra être lu par le prédicat get_event/3 du module graphique.
- Envoi d'une requête de type Execute (le paramètre Item n'existe pas), avec une donnée but_prolog: le but transmis est placé dans la queue d'exécution de
Prolog II+, et sera lancé par la machine de manière asynchrone. Le succès de la
requête traduit celui de la transmission, et non celui du but transmis. On ne considère pas ici la récupération des solutions.
Les messages d'erreur éventuels de Prolog se manifestent dans l'unité de sortie courante, par défaut la console, et ne sont pas transmis au Client. L'unification des variables du but transmis ne produit aucune trace. Seules les écritures explicites seront visibles.
Limitation: La donnée but_prolog est limitée à 32767 caractères et doit avoir la forme d'un but unique (et non pas une suite ou liste de buts) respectant la syntaxe en cours, sinon, une erreur est générée.
Exemples: réponses de la console de Prolog II+ à quelques requêtes:
- Requête Poke sur l'Item "Lily was here" avec la donnée "You won't see me":
> get_event( 0, x, y);
{ x=extern_event( "Lily was here", 0, 0), y=0 }
>
- Requête Execute avec donnée "please( "anser me")":
-> please/1 : APPEL A UNE REGLE NON DEFINIE
>
- Requête Execute avec donnée "enum( i, 15)":
>
(il ne se passe rien de visible)
- Requête Execute avec donnée "outml( "Hello )":
Hello
> ( mais pas d'affichage de {} )
© PrologIA
U 4 - 6
Manuel d'Utilisation Windows
4.2.3. Exécution d'un but Prolog avec récupération des solutions
La donnée transmise par la requête Execute accepte une seconde syntaxe dont la description suit:
but_prolog, Index, Identifiant où:
but_prolog obéit aux contraintes précédemment exposées,
Index est le numéro basé en 1 de l'argument de but_prolog à récupérer,
Identifiant a la syntaxe d'un identificateur abrégé Prolog (sans préfixe) et désignera la solution.
Lors de l'exécution du but, la valeur assignée à l'argument désigné sera convertie en une chaîne de caractères, et associée à son identifiant. Si le but échoue ou produit une erreur, la valeur assignée à la solution sera respectivement "*Failure" ou
"*Error nnn", nnn étant le code d'erreur Prolog. Le Client peut récupérer la ou les solutions de deux manières:
- Par l'envoi d'une requête Request sur l'Item Identifiant lancée après l'exécution du but: la valeur rendue est celle de la dernière solution courante du but auquel est associé l'identifiant, dans les conditions décrites précédemment.
L'inconvénient est qu'il n'existe aucun moyen de synchronisation automatique permettant de savoir si le but a été exécuté. Si ce n'est pas le cas, la requête
échoue, sauf si l'identifiant utilisé contient déjà la solution d'un autre but lancé précédemment. Le second inconvénient est que l'on récupère seulement la dernière solution.
- Par l'envoi d'une requête HotLink ou Advise sur l'Item Identifiant, lancée avant exécution du but: lors de l'exécution du but auquel est associé l'identifiant, chaque solution (au sens précédent) est transmise au Client en tant que mise à jour de l'Item. L'avantage de cette méthode est que la synchronisation est semiimplicite: elle convient très bien à un Client à structure événementielle. Il est à noter que si le Client veut différencier la dernière solution des autres, le but appelé devra être encapsulé afin de transmettre une solution différentiable. Après avoir eu satisfaction, le Client devra annuler le lien (Requête Unadvise).
Remarques:
- Si le Serveur Prolog II+ est sollicité par plusieurs Clients, les buts transmis sont empilés par ordre chronologique, sans autre lien avec leur auteur que l'identifiant spécifié. Cette caractéristique permet de partager des données entre Clients, avec ou sans leur consentement. Dans le cadre d'une application reposant sur plusieurs applicatifs, il convient de bien choisir les identifiants utilisés.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 7
- Dans le cas où l'un des Clients transmet le but quit, ou tout autre ayant un effet de bord quelconque, Prolog II+ l'exécute sans considération pour les intérêts des autres Clients. Exemple: un outil tentant périodiquement une connexion sur
Prolog II+ pour y lancer une requête Execute( quit) constituerait un vrai vaccin anti-Prolog.
4.2.4. Schéma du Serveur Prolog II+
Ce schéma est à rapprocher de celui plus général donné précédemment:
Client Logique
Le Service DDE "PROLOG"
Serveur Logique:
Service Automatique
"Prolog2"
Conversation Unidirectionnelle (TEXT)
"ExternalEvent"
Execute( "But, Arg, Numéro")
RequestData
"Der. Solution N°"
HotLinkData
"Toute Solution N°"
PokeData()
"N'importe Quoi"
Data pour RequestData, sinon STATUT Booléen
Queue des Buts
Execution
Queue d'Evénements
get_event()
4.2.5. Exemples
- La requête Execute avec la donnée 'eq(production, x), 2, my_var' réussit et associe dans l'interface la valeur de x (ici production) à l'identifiant my_var.
- La requête Execute avec la donnée 'eq(production, x), 1, my_atom' réussit.
- La requête Request pour l'item my_var réussit et rend production
© PrologIA
U 4 - 8
Manuel d'Utilisation Windows
- La requête Request pour l'item my_atom' réussit et rend production (1er argument).
- La requête Execute avec la donnée 'arg2( X, Y, Z), 3, my_arg' réussit, mais le message:
-> <v33> : ARGUMENT DE MAUVAIS TYPE
est affiché dans la console de Prolog II+
- La requête Request pour l'item my_arg réussit et rend *Error 253
- La requête Advise (ou HotLinkData) pour l'item enumerate réussit.
- La requête Execute avec donnée 'enum( i, 5), 1, enumerate ' réussit, et le Client reçoit successivement: 1, 2, 3, 4, 5.
- La requête Request pour l'item enumerate réussit et rend 5.
A!ociation
Prolog
HERITAGE
4.3. Programmer en Prolog II+ un applicatif Client ou Serveur
Il est nécessaire dans les deux cas de charger le module "dde.mo" qui installe les primitives DDE. Sa désinstallation se fait par l'appel à la primitive:
ddeCleanup/0
Termine toutes les conversations et Services en cours et élimine les primitives de Prolog relatives au DDE. Cette primitive n'est pas le bon moyen pour un applicatif Client ou Serveur de terminer son activité DDE. Elle ne devrait être utilisée qu'ensuite.
Selon les performances du système et des applicatifs, des problèmes de time-out peuvent survenir, produisant une erreur Prolog. Le délai général de time-out, bien que confortable (3 secondes) peut être ajusté par l'option -M tttt de la ligne de commande, où tttt est la durée en millisecondes. Cette valeur sera à déterminer par essais. Elle est talonnée par les valeurs 200 et 15000 ms.
Les paragraphes qui suivent étudient séparément les deux modes, mais rien n'interdit
à un applicatif d'être simultanément Client et Serveur pour des conversations différentes. Il convient alors en l'écrivant d'accorder le plus grand soin à la gestion des numéros de conversations et éventuellement aux identificateurs DDE utilisés.
Pour cela, la primitive suivante sera un auxilliaire précieux:
ddeRememberDatabase( _xData)
Enumère les Services et les conversations en cours et les unifie avec l'argument _xData. Son format est le suivant:
dde_I_serve(_tService) pour les Services (seulement pour le Serveur donc),
dde_I_am_Client(_hConversation, _tTopic) ou
dde_I_am_Server(_hConversation, _tTopic,) (selon le cas) pour les conversations.
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 9
4.3.1. Programmer un applicatif Client DDE
Les transactions DDE sont à l'initiative du Client, mais certaines prennent aussi la forme de notifications asynchrones de la part du Serveur. Le Client est supposé en tenir compte pour adapter sa conduite. De même, le Client est supposé connaître le mode d'emploi du Serveur qu'il prétend utiliser. Eventuellement, il y aura également lieu pour le Client de démarrer l'applicatif Serveur désiré.
Primitives de connexion et de déconnexion
ddeDeclareAsClient( _xService, _tTopic, _hConversation)
Tente d'ouvrir une conversation sur le Topic spécifié par la chaîne de caractères _tTopic avec le Serveur logique spécifié par la chaîne de caractères
_xService, ou n'importe quel serveur si _xService vaut nil. Si la conversation est ouverte, l'argument _hConversation est unifié avec une valeur (entier opaque) unique identifiant cette conversation pour toute opération future. Si aucun serveur n'est trouvé, une erreur est signalée. Si plusieurs serveurs sont candidats, seule la première réponse sera retenue.
ddeEndConversation( _hConversation)
Termine la conversation désignée par _hConversation en congédiant le
Serveur. Si _hConversation est une variable libre, termine par énumération
(backtracking) toutes les conversations en cours en unifiant _hConversation avec la conversation concernée. Si la conversation désignée n'existe pas, l'unification échoue. L'usage de cette primitive est naturel pour le Client.
Primitive de transmission de requêtes
ddeTransmitRequest( _hConversation, _xRequest)
Effectue de manière synchrone la requête _xRequest auprès du Serveur lié à la conversation _hConversation. Le statut de terminaison de cette primitive
(succès ou erreur) est lié à celui de la requête. Les requêtes reconnues sont les suivantes:
- ddeRequestData(_tItem, _xValue): effectue une requête Request standard pour la donnée nommée par la chaîne _tItem, et tente d'unifier le résultat, une chaîne de texte Prolog, avec la valeur de _xValue.
- ddeWarmLinkData(_tItem, ddeOpen) ou
ddeWarmLinkData(_tItem, ddeClose): effectue une requête Advise standard pour la donnée nommée par la chaîne _tItem, demandant un abonnement de type notification de modification de cette donnée (lien tiède), ou résilie ce même abonnement.
- ddeHotLinkData(_tItem, ddeOpen) ou
ddeHotLinkData(_tItem, ddeClose): effectue une requête Advise standard pour la donnée nommée par la chaîne _tItem, demandant un abonnement de type mise à jour systématique de cette donnée (lien chaud), ou résilie ce même abonnement.
© PrologIA
U 4 - 10
Manuel d'Utilisation Windows
- ddePokeData(_tItem, _xData): effectue une requête Poke standard pour l'Item nommé par la chaîne _tItem, adressant ainsi au Serveur la donnée
_xData, qui est soit une chaîne de texte, soit nil (simple signal sans donnée jointe).
- ddeExecute(_xArgument): effectue une requête Execute standard au Serveur, lui passant une commande textuelle contenue dans la chaîne _xArgument.
Buts-callbacks
Les buts-callbacks (noms prédéfinis) sont dans le module global (ils ont le préfixe
""). Ils sont écrits par l'utilisateur et appelés par le système. Ils sont donc soumis à des contraintes relevant de la programmation système. On retiendra principalement les règles suivantes:
- Les buts-callbacks peuvent effectuer des retours arrière, mais la requète transmise sera validée (si toutefois la requête attend une validation) s'il existe au moins une solution.
- Les buts-callbacks ne doivent pas effectuer de traitements de taille déraisonnable
(notion purement intuitive), ni à fortiori d'intèraction avec l'utilisateur incluant des phases modales. Il y a risque de time-out, voire même de réaction défensive du système.
- Ceci implique que les buts-callbacks ne peuvent pas être mis au point sur site. Il est nécessaire d'effectuer leur mise au point avec un simulateur.
:ddeCbServerClosing( _hConversation)
Signale la terminaison prématurée de la conversation _hConversation par le
Serveur, quelle qu'en soit la raison. Il s'agit d'une notification à postériori, et le statut de terminaison de son traitement est sans effet sur le résultat transmis au serveur. La valeur de _hConversation doit être considérée comme désormais invalide et recyclable (donc ddeEndConversation( _hConversation) échouera si tenté).
:ddeCbServerUpdate( _hConversation, _tItem, _xArgument)
A la suite d'une requête Advise, notifie un changement dans la valeur de l'Item auquel le Client s'est abonné pour la conversation _hConversation. Cet Item est désigné par la chaîne de caractères _tItem. La nouvelle valeur est soit transmise dans _xArgument (lien chaud) soit disponible pour une future requête de type ddeRequestData (lien tiède). Dans ce dernier cas, _xArgument vaut nil. Le statut de terminaison de ce but n'a aucun sens ni aucun effet sur le résultat transmis au serveur.
Exemple
Le scénario suivant décrit, en Prolog, un dialogue avec un Serveur de type horloge.
> load( "dde.mo") ;
{}
> insert; % Code minimum nécessaire pour suivre le dialogue
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 11
ddeCbServerUpdate( _hC, "Now", "24:00:00") -> ddeTransmitRequest( _hC, ddeExecute("Close") )
! ; ddeCbServerUpdate( _, "Now", _tTime) -> outm( "\tIt is ") outml( _tTime) ; ddeCbServerClosing( _) -> outml( "\t\tEnd !") ;
;
{}
> ddeDeclareAsClient( nil, "Time", _hC);
{ _hC=1 }
> ddeTransmitRequest( 1, ddeRequestData("Now", _t));
{ _t="15:20:33" }
> ddeTransmitRequest( 1, ddePokeData("Now", "23:59:30"));
{}
> ddeTransmitRequest( 1, ddeHotLinkData("Now", ddeOpen));
{}
It is 23:59:55
It is 23:59:56
It is 23:59:57
It is 23:59:58
It is 23:59:59
End !
> ddeEndConversation( 1); % Failure, number 1 is out-of date
>
4.3.2. Programmer un applicatif Serveur DDE
Ce mode est plus contraignant, car un Serveur doit savoir être à la complète disposition de Clients quelconques, et aussi éviter tout conflit d'intérêts avec d'autres
Serveurs. Donc il importe en premier lieu de définir formellement puis de doter de noms pertinents toutes les commandes qu'il pourra recevoir. Son mode d'emploi devra être très complet.
Primitive de déclaration
ddeDeclareAsServer( <_nMode, _tService>)
Déclare (si _nMode vaut ddeOpen ) ou supprime (si _nMode vaut ddeClose) le Service DDE nommé par la chaîne de caractères _tService. Si _tService est une variable libre et _nMode vaut ddeClose, termine chaque Service déclaré
(backtracking) en l'unifiant avec _tService. La suppression d'un Service renvoie brutalement tous les Clients qui s'y sont connectés. Ceci devrait être
évité, en terminant au préalable toutes les conversations concernées.
Primitives de connexion et de déconnexion
ddeAcceptClient( _tService, _tTopic, _hConversation)
Accepte la requête du Client en cours de connexion, cette primitive devant être invoquée durant l'effacement du but-callback ddeCbClientWantsServer/2. Les arguments _tService et _tTopic sont des chaînes de caractères transmises par ce but-callback. Si aucun problème système ne survient, l'argument
_hConversation sera unifié avec une valeur entière unique identifiant cette conversation pour toute opération future.
© PrologIA
U 4 - 12
Manuel d'Utilisation Windows ddeEndConversation( _hConversation)
Termine la conversation _hConversation en congédiant le Client. Si
_hConversation est une variable libre, termine par énumération toutes les conversations en cours en unifiant _hConversation avec la conversation concernée. L'usage de cette primitive est naturel pour le Client. Bien que possible, l'usage de cette primitive est à priori très déplacé pour le Serveur. Il ne devrait être utile qu'en cas de problème.
Primitive de transmission des données aux Clients:
ddeTransmitData( _tTopic, _tItem, _xNewValue)
- Doit être invoquée à la demande d'un Client, donc durant l'effacement du but-callback ddeCbClientRequest/2 pour une requête ddeRequestData, pour transmettre _xNewValue, la nouvelle valeur de l'Item _tItem.
- Peut être invoquée à l'initiative du Serveur pour transmettre soit la nouvelle valeur _xNewValue de l'Item _tItem (lien chaud) soit une notification aux
Clients ayant demandé un abonnement à l'Item modifié (lien tiède), auquel cas l'argument _xNewValue est ignoré. Le choix de notifier sur la base du Topic
_tTopic et non à chaque Client concerné est imposé par des contraintes d'implémentation. La base de données interne assure la bonne distribution des notifications.
Buts-callbacks
Mêmes remarques que pour le mode Client.
:ddeCbClientWantsServer( _xService, _tTopic)
Notifie une demande de connexion d'un Client pour le Topic désigné par la chaîne de caractères _tTopic et au Serveur logique désigné par la chaîne de caractères _xService, sauf si _xService vaut nil, ce qui signifie "sans préférence". Pour que la conversation soit établie, le Serveur doit effacer ce but et durant cette opération effacer la primitive ddeAcceptClient/3, sans quoi
(erreur ou échec) le Client est débouté. A priori, le Client n'est pas tenu d'insister, et donc un refus du Serveur peut être considéré comme définitif.
:ddeCbClientRequest( _hConversation, _xRequest)
Notifie la requête _xRequest du Client, dans les conditions liées à la conversation _hConversation, et attend la réponse de manière synchrone. Le statut de terminaison de ce but conditionne celui de la requête. Une erreur
Prolog aura ici le même effet qu'un échec. Les requêtes reconnues sont les suivantes:
- ddeRequestData(_xArgument): notifie une requête Request standard pour la donnée nommée par la chaîne _xArgument, et attend du Serveur l'exécution de la primitive ddeTransmitData/3 passant sa nouvelle valeur durant l'effacement du but,
- ddeWarmLinkData(_tItem, ddeOpen) ou
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Communication avec une application, en utilisant le protocole DDE
U 4 - 13
ddeWarmLinkData(_tItem, ddeClose): notifie une requête Advise standard pour la donnée nommée par la chaîne _tItem, demandant un abonnement de type notification à cette donnée (lien tiède), ou la résiliation de ce même abonnement, information que le Serveur est supposé enregistrer pour adapter son comportement futur,
- ddeHotLinkData(_tItem, ddeOpen) ou
ddeHotLinkData(_tItem, ddeClose): notifie une requête Advise standard pour la donnée nommée par la chaîne _tItem, demandant un abonnement de type mise à jour systématique à cette donnée (lien chaud), ou la résiliation de ce même abonnement, information que le Serveur est supposé enregistrer pour adapter son comportement futur,
- ddePokeData(_tItem, _xValue): notifie une requête Poke standard pour l'Item nommé par la chaîne _tItem, adressant ainsi la donnée _xValue (chaîne de texte Prolog) au Serveur, ou bien encore un simple signal sans donnée jointe, _xValue valant alors nil,
- ddeExecute(_xArgument): notifie une requête Execute standard au Serveur, lui passant une commande textuelle préconvenue contenue dans la chaîne
_xArgument, que le Serveur est supposé comprendre et exécuter de manière synchrone, et dont le statut doit conditionner le succès de ce but,
- ddeClose: notifie la déconnexion du Client. La base de donnée interne est mise à jour automatiquement, et le Serveur est supposé faire de même pour ses données propres éventuelles. Il s'agit d'une notification à postériori, et le statut de terminaison du but est sans effet.
Exemple
Imaginons un Serveur représentant le garde-manger d'un restaurant. Il doit gérer le stock de différents plats, consommés de manière aléatoire. Il doit pour chacun pouvoir donner la quantité disponible et retrancher la quantité consommée. Il doit alerter le patron en cas de rupture de stock et ensuite pouvoir lister sur commande les plats à renouveler. Enfin, il doit pouvoir enregistrer une livraison.
On définit le nom du Service: Fridge.
On définit les noms des Topics: Boss, réservé au maître unique des lieux,
Waiter, pour les serveurs de la salle.
Les Items seront les noms des plats, associés à une quantité disponible dans une base de données interne. Un Item nommé "Rupture" et accessible au seul patron lui permet de connaître la liste des plats dont le stock est inférieur à 5. Le patron peut l'interroger par Request et/ou s'y abonner. Il recevra alors la liste à jour à chaque consommation d'un serveur de la salle. Seul le patron est autorisé à alimenter le
Frigo par une requête Execute passant une liste chiffrée. Il a aussi accès à toutes les opérations permises aux serveurs de la salle.
© PrologIA
U 4 - 14
Manuel d'Utilisation Windows
Le code de cet exemple est donné dans le fichier ddefrigo.p2 du kit. On remarque qu'il est nettement plus volumineux que le précédent. Pour l'utiliser de manière amusante, il est préférable de disposer de plusieurs (environ 3) applicatifs Clients pouvant utiliser (facilement) des Identifiants DDE arbitraires. pour le cas où des instances de Prolog sont utilisées comme clients, un fichier nommé ddecligo.p2, disponible dans le kit fournit des commandes simplifiées adaptées à cet exemple.
Dans tous les cas, lancer la règle to_begin pour démarrer ces programmes. Ils listent alors leur mode d'emploi.
Les manipulations suivantes sont suggérées:
- En premier, remplir le garde-manger, initialement vide: le patron lance par exemple une requête Execute de la chaîne: "4 Lapin, 15 Poulet, 7 Gateau Basque, end" ,
- Essayer de connecter un second patron, surtout si le premier est déjà abonné à
Rupture,
- Essayer de réclamer un plat indisponible: Requête Poke de "nom du plat, -1" par exemple,
- Vérifier que le patron est prévenu lorsque les stocks diminuent,
- ...
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
5. Primitives Graphiques
5.1. Description du système graphique
5.2. Primitives de gestion des fenêtres
5.3. Primitives élémentaires de gestion des objets attachés à une fenêtre
5.4. Primitives spécifiques pour la gestion de menu
5.5. Mode de dessin et d'écriture
5.6. Dessin et positionnement
5.7. Position de la souris dans une zone graphique
5.8. Primitives spéciales de saisie
5.9. Règles pour gérer des objets structurés
5.10. Envoi d'événements à Prolog depuis un objet externe
Le système Prolog II+ comporte un dispositif asynchrone de gestion des
événements permettant le fonctionnement de l'environnement (fenêtrage, menus, ...) sans que l'utilisateur ait à réorganiser son programme sous la forme d'une boucle de gestion des événements. La plupart des événements tels que le redimensionnement d'une fenêtre, le défilement des fenêtres de texte ..., sont gérés automatiquement.
L'utilisateur peut associer des procédures Prolog à certains événements comme la sélection d'un menu, ou le rafraîchissement d'une fenêtre graphique… Les
événements de type clic souris ou action clavier peuvent être testés par programme, ce qui permet de faire réagir le programme en conséquence.
L'ensemble des primitives graphiques de Prolog II+ offrent également la possibilité de créer des fenêtres, supports d'objets graphiques n'étant pas eux-mêmes des fenêtres. Les primitives de création et manipulation d'objets agissent uniquement sur des objets Prolog. Tous ces objets doivent être créés par les prédicats Prolog, et non par un outil externe (de type générateur d'écran, par exemple). Par contre, les primitives de gestion des événements peuvent aussi manipuler des événements survenus sur des objets externes à Prolog.
Les descriptions des différents environnements ont été regroupées dans un seul document pour mettre en évidence les différences qui existent encore entre ces environnements.
Le signe ! dans la marge indique une primitive ou une caractéristique spécifique au
Macintosh.
Le signe s signale les nouvelles primitives disponibles sous Window3, sous OS/2-
PM et sous Motif 1 . Elles ne sont pas encore implémentées sur Macintosh.
1
La partie graphique PrologII+ sous l'environnement Motif a été développée en collaboration avec Digital Equipment Corporation.
U 5 - 2
Manuel d'Utilisation Windows
Vous ne devez pas utiliser les règles marquées, donc spécifiques à une machine ou un environnement graphique, si vous désirez porter vos programmes sur d'autres configurations.
A!ociation
Prolog
HERITAGE
5.1. Description du système graphique
Ce chapitre décrit une bibliothèque de primitives pour la réalisation d'interfaces graphiques. Il suppose du lecteur une certaine pratique des environnements multifenêtres et de leur boîte à outils. Plus précisément, il suppose du lecteur la connaissance des caractéristiques de l'environnement graphique de la machine hôte.
En effet, l'aspect général du graphique ou le comportement des fenêtres et des objets graphiques, ainsi que le maniement de la souris sont standard à l'environnement hôte; pour toute information sur ce fonctionnement, se référer au manuel correspondant.
Tous les effets graphiques obtenus ici doivent être considérés, du point de vue de
Prolog, comme des effets de bord. En particulier, un objet dessiné n'est jamais effacé au backtracking. De même, la position du point d'écriture est une variable globale.
5.1.1. Evénements
Les événements sont les conséquences d'interruptions matérielles générées par le clavier ou la souris, traités à différents niveaux (système d'exploitation, système graphique…) et donc propagés jusqu'à différents niveaux (…utilisateur final). Nous nous intéressons à ceux qui arrivent jusqu'à Prolog.
Un certain nombre d'objets graphiques Prolog sont sensibles aux événements et les transmettent au programmeur Prolog, qui peut décider trois traitements différents:
- les traiter immédiatement en attachant un programme Prolog sur l'objet;
- les envoyer automatiquement dans la queue d'événements de Prolog pour les traiter ultérieurement;
- les ignorer.
5.1.2. Objets graphiques
Tout d'abord parlons des objets principaux que sont les fenêtres. Toutes les fenêtres peuvent ou non avoir un cadre, une barre de titre, des menus. Elles peuvent
êtres redimensionnées, iconifiées, invisibles. Les fenêtres de texte peuvent avoir des barres de défilement horizontal ou vertical, et peuvent sauvegarder leur contenu.
Il existe quatre types de fenêtre, avec des caractéristiques et des fonctions différentes:
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 3
Les fenêtres EDIT:
ce sont des fenêtres de texte, destinées à l'édition de texte. Tout le contenu de la fenêtre est modifiable directement, au moyen du clavier, de la souris, des menus; par programme, via les primitives d'entrées sorties de Prolog, le point d'écriture se trouve à la fin du texte; le point de lecture est initialement au début de la fenêtre, ensuite après la dernière position lue. Noter que si une lecture est demandée, Prolog copie dans un tampon toute une ligne.
Ces fenêtres ont une capacité limitée, certaines manipulations ayant pour effet l'augmentation de la taille du texte au delà de la limite seront ignorées.
Les fenêtres FRAMEPANEL:
ce sont des fenêtres "vides" dont le seul rôle est d'accueillir des objets. Elles ne possèdent pas de partie dessinable, éditable…
Les fenêtres GRAPHICS:
ce sont des fenêtres destinées au dessin, sensibles aux actions clavier et souris, qui peuvent éventuellement recevoir des objets. Elles peuvent contenir du texte par les moyens classiques d'écriture. Par défaut, l'image bitmap n'est pas sauvegardée, ce qui veut dire que le rafraîchissement n'est pas assuré. Elles peuvent être dotées d'un bitmap qui permettrait leur retraçage automatique.
Il existe toujours, par compatibilité, le type MODAL qui est un sous ensemble du type GRAPHICS et qui désigne les fenêtres GRAPHICS qui ont l'attribut
MODAL, attribut qui donne le focus à la fenêtre, restreint les événements utilisateur à cette seule fenêtre, et donc rend la saisie obligatoire dans cette fenêtre.
Par convention, les primitives qui n'ont d'effet que dans un objet GRAPHICS sont préfixées par gr_.
Les fenêtres TTY:
ce sont des fenêtres de texte qui fonctionnent en écriture et en lecture, toujours
à la fin de la fenêtre. Elles ont un rôle de trace ou listing et fonctionnent à la manière des terminaux. C'est à dire, tout ce qui est affiché n'est pas modifiable, la saisie est en mode ligne et donc, tant que la ligne de saisie n'est pas terminée, elle est modifiable.
Ces fenêtres ont une capacité limitée, une troncature automatique se fait lorsque c'est nécessaire par le haut de la fenêtre.
Voyons maintenant les autres objets; ils sont conçus pour être placés sur une fenêtre qui est alors appelée : parent. Ils se déplacent avec leur parent et ne peuvent exister après sa destruction. Leur taille et leur position sont définies par des coordonnées relatives au coin intérieur supérieur gauche du parent.
Qu'advient-il si le parent change de dimension?
Pour déterminer le comportement d'un objet lors du redimensionnement de son parent, on définira l'attachement de l'objet à un bord de sa fenêtre parent :
© PrologIA
U 5 - 4
Manuel d'Utilisation Windows
Un objet est attaché à un bord de son parent signifie que l'écart (défini au moment de la création) entre ce bord et l'objet est constant quelles que soient les évolutions des dimensions du parent.
Il faut noter que :
- un objet est toujours attaché dans les deux directions (au minimum à un bord pour chaque direction). Par défaut, il s'agit du bord haut et du bord gauche.
- les objets dont la dimension n'est pas fixée par le système, peuvent être attachés aux deux bords pour la même direction. Dans ce cas, l'objet sera redimensionné en même temps que son parent.
Les objets qui doivent avoir un parent sont les suivant :
Check button:
bouton de choix à deux états, quand il est activé, il change d'état et génère un
événement.
Push button:
bouton qui génère un événement quand il est activé.
Radio button:
bouton de choix exclusif; c'est un bouton à deux états qui fait partie d'un groupe de boutons dont un seul peut être sélectionné à la fois. En particulier, dès qu'un bouton du groupe est activé, il génère un événement, il prend la sélection et celui qui l'avait la perd. Par défaut, à la création, c'est le premier bouton du groupe qui est sélectionné.
Drawing area:
zone graphique destinée au dessin, sensible aux actions clavier et souris. Elle peut contenir du texte par les moyens classiques d'écriture. Par défaut, l'image bitmap n'est pas sauvegardée, mais la zone peut être dotée d'un bitmap pour son retraçage automatique. Les primitives préfixées par gr_ agissent dans cette zone si elle a été précédemment définie comme la zone graphique courante (voir gr_window).
Editfield:
zone de texte éditable monoligne ou multiligne, génère un événement lors de la frappe d'un caractère ou de la perte ou du gain de focus.
Label :
zone de texte non éditable, non sensible aux événements, sert uniquement à l'affichage d'un texte dont le retraçage est géré automatiquement. Si le texte est vide, cela permet d'obtenir un rectangle.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 5
Listbox:
liste d'items, inscrits dans un rectangle, avec barre de défilement verticale.
Chaque item peut prendre deux valeurs : sélectionné ou non. A chaque sollicitation d'un item de la listbox, un événement est généré.
Popup menu:
Pulldown menu:
Un menu regroupe une suite d'items disposés verticalement. Un item peut
être soit terminal, soit lui-même un menu, on parlera dans ce cas de menu hiérarchique. La sélection d'un item terminal du menu génère un événement et fait disparaître le menu. On distingue deux formes de menus qui se différencient par la façon de les activer et par les caractéristiques des fenêtres auxquelles ils peuvent être attachés.
Il est possible d'attacher un 'popup menu' particulier à n'importe quelle unité fenêtre. L'activation du 'popup menu' (également appelé menu flottant) d'une fenêtre se fait, alors que le curseur de la souris est dans la fenêtre, soit en appuyant sur le bouton menu de la souris si la souris comporte plusieurs boutons, soit en appuyant simultanément une touche d'option et le bouton de la souris si la souris possède un seul bouton. Le menu apparaît sous le curseur de la souris.
Il est possible d'attacher un ou plusieurs 'pulldown menu' (également appelé
menu déroulant) à n'importe quelle unité fenêtre possédant une barre de titre
(ne convient pas aux fenêtres de forme cadre). Le titre du menu s'insère alors dans la barre de menu de la fenêtre et l'activation du menu se fait en réalisant un clic sur son titre. La liste d'items est alors déroulée au dessous. Noter que le titre du menu n'est pas un item du menu.
Scrollbar:
barre de défilement dont l'ascenseur (curseur qui se déplace dans la barre) exprime par sa position une valeur comprise dans l'intervalle associé à la barre. Peut servir de "doseur". A chaque activation de la 'scrollbar', elle génère un événement.
5.1.3. Configuration du graphique Prolog II+ au démarrage
Au lancement Prolog compte une barre de menus, trois fenêtres prédéfinies dont une seule est visible, il s'agit de :
- la fenêtre "console" de type TTY qui est par défaut, l'unité courante de lecture et d'écriture. L'unité de lecture et l'unité d'écriture peuvent être changées respectivement par les primitives input et output.
Les deux autres fenêtres sont :
- la fenêtre "graphic" de type GRAPHICS, qui est l'unité graphique courante par défaut. L'unité graphique est l'unité sur laquelle agissent les primitives préfixées par gr_. L'unité graphique peut être changée par la primitive
gr_window.
- la fenêtre "trace" de type TTY utilisée en mode debug ou trace.
© PrologIA
U 5 - 6
Manuel d'Utilisation Windows
La barre de menus comporte des menus prédéfinis:
- le menu File qui permet de créer des fenêtres d'édition et sortir de Prolog.
- le menu Windows qui permet de rendre visibles ou invisibles les fenêtres existantes.
- le menu Control qui permet de générer une interruption utilisateur, passer en mode debug, exécuter rapidement certains prédicats prédéfinis Prolog.
- le menu Tools qui permet d'activer certains outils.
- certains menus du système hôte.
Nous avons regroupé ici des primitives très générales du graphisme.
init_screen
initialise le mode graphique. Ce prédicat est automatiquement lancé au chargement du module graphic.mo.
end_screen
désinstalle le graphique, c'est à dire, ferme les fenêtres, supprime les menus, supprime l'accès aux prédicats graphiques.
get_screen(x,y) get_screen(x,y,N)
Unifie x et y respectivement avec la largeur et la hauteur de l'écran en pixels.
Dans la forme à trois arguments, N est unifié avec 1 si l'écran ne possède que deux couleurs (noir et blanc), un nombre supérieur à 1 sinon.
graphic_system(s)
Unifie s avec une chaîne de caractères qui est fonction du système graphique hôte : "M" pour Motif, "W" pour Windows3 ou "P" pour
Presentation Manager.
Le fichier int_edit.mo permet, si on le désire, l'utilisation de l'éditeur intégré par les prédicats edit et editm à la place de l'éditeur défini par la variable d'environnement
PrologEdit. Il faut pour cela effacer les buts suivants:
> reload("int_edit.mo");
> exit("initial.po");
(pour éviter de refaire la même commande à chaque lancement de Prolog).
5.1.4. Conventions utilisées dans ce chapitre
Dans les règles exposées dans ce chapitre, x et y représentent les coordonnées horizontales (x) et verticales (y). L'axe positif des x est dirigé vers la droite. L'axe positif des y est dirigé vers le bas. Se rappeler que l'origine par défaut (i.e. x=0, y=0) coïncide avec le coin intérieur supérieur gauche de l'élément de référence.
Celui-ci est la fenêtre graphique courante pour un tracé, la fenêtre parente pour un objet qui n'est pas une fenêtre, et l'écran pour une fenêtre.
Les coordonnées x ou y peuvent être exprimées indifféremment par des nombres entiers ou réels.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 7
De même les variables commençant par r représenteront des arbres définissant un rectangle. Cet arbre doit être de la forme:
<x1,y1>.<x2,y2> ou bien <x1,y1,x2,y2> où x1,y1 sont les coordonnées du coin supérieur gauche, et x2,y2 celles du coin inférieur droit.
On appellera booléen, un entier qui prend les valeurs 0 ou 1 et qui sert de valeur de vérité pour une propriété (visibilité d'un objet,…).
L'utilisateur peut nommer un objet à l'aide d'une chaîne, cette identification pourra servir pour toutes les primitives de création ou gestion de l'objet. Il peut également laisser Prolog attribuer à l'objet une identification par défaut (ce sera un entier) au moment de sa création (en laissant une variable libre), cette identification pourra être utilisée ultérieurement pour toutes les primitives de gestion de l'objet. Ou encore, pour les objets qui ne sont pas des fenêtres, il peut les nommer à l'aide d'un identificateur qui sera valable pour toutes les primitives agissant sur ces objets.
5.2. Primitives de gestion des fenêtres
5.2.1. Création, destruction d'une fenêtre
s s s s
new_window(s,t) new_window(s,t,s') new_window(s,t,v,r) new_window(s,t,v,s',r) new_window(s,t,v,x1,y1,x2,y2) new_window(s,t,v,s',x1,y1,x2,y2)
Créent une nouvelle fenêtre, et une nouvelle unité d'entrée/sortie de nom s et de type t, où s est l'identification de la fenêtre qui doit être différente de celles des unités existant déjà. s peut être une chaîne. Si s est une variable libre au moment de l'appel, elle sera unifiée avec une identification de fenêtre fournie par Prolog.
La chaîne de caractères s' est affichée dans le bandeau de la fenêtre, comme titre de la fenêtre; si s' n'est pas spécifiée c'est s qui est inscrite.
v est un booléen (1 ou 0) indiquant si la fenêtre doit être visible ou pas. Par défaut, la fenêtre est créée visible.
x1,y1 sont les coordonnées du coin intérieur supérieur gauche de la nouvelle fenêtre par rapport à l'écran.
x2,y2 sont les coordonnées du coin intérieur inférieur droit de la nouvelle fenêtre, l'origine étant située au coin supérieur gauche de l'écran.
t est de la forme type, ou bien type.liste_attributs, où type détermine le type de la fenêtre, et donc les opérations qui peuvent lui être appliquées.
Les valeurs possibles pour type sont:
"EDIT" ou :edit pour la création d'une fenêtre EDIT.
"FRAMEPANEL" ou :framepanel
© PrologIA
U 5 - 8
!
!
s
Manuel d'Utilisation Windows
pour la création d'une fenêtre FRAMEPANEL.
"GRAPHICS" ou :graphics pour la création d'une fenêtre GRAPHICS.
"MODAL" ou :modal pour la création d'une fenêtre GRAPHICS avec l'attribut MODAL.
"TTY" ou :tty pour la création d'une fenêtre TTY.
Les valeurs possibles pour un attribut de liste_attributs sont:
<"DISTANCE", n> ou < :distance, n>
n est un entier et désigne une portion de la partie dessinable de la fenêtre réservée pour une zone de création de boutons. Cette zone se situe en haut de la fenêtre, sur toute la largeur et sur une hauteur égale à
n % de la hauteur totale. Cet attribut est valable pour tout type de fenêtre, mais n'a pas d'utilité pour les fenêtres FRAMEPANEL.
<"FONT", n > ou < :font, n >
Définit le numéro n de la police de caractères utilisée pour le texte d'une fenêtre type texte. La fonte associée à n est dépendante du système hôte.
<"FONTSIZE", n > ou < :fontsize, n >
Définit la taille de la police de caractères utilisée dans une fenêtre de texte.
<"MODAL", b> ou < :modal, b>
b est un booléen indiquant si la fenêtre est bloquante ou pas. La valeur par défaut est b = 0. Cet attribut est valable pour tout type de fenêtre.
Cette fenêtre si elle est bloquante, reste au dessus de toutes les autres fenêtres, et tous les événements extérieurs à la fenêtre sont désactivés
(excepté l'interruption utilisateur). Les événements extérieurs à la fenêtre sont réactivés lorsque la fenêtre est tuée. Les fenêtres modales peuvent
être empilées.
<"NO_RESIZE", b> ou < :no_resize, b>
b est un booléen indiquant si le redimensionnement de la fenêtre au moyen de la souris (ou d'une combinaison de touches prédéfinie pour certaines machines) est interdit ou pas. Par défaut b vaut 0. Quelle que soit la valeur de b, une fenêtre peut toujours être redimensionnée par programme.
<"SHAPE", n> ou < :shape, n>
n est un entier déterminant la forme de la fenêtre. Les formes standard sont 0: fenêtre avec titre, barre de menus et barres de défilement; 1: fenêtre cadre. Par défaut les fenêtres graphiques modales ont l'attribut 1, et les autres types de fenêtres ont l'attribut 0. Cet attribut est valable pour tout type de fenêtre. On notera que les fenêtres GRAPHICS et
FRAMEPANEL n'ont pas de barres de défilement.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 9
!
<"SAVE", r > ou < :save, r >
Cet attribut ne peut être appliqué qu'à une fenêtre graphique ou modale.
Il définit le rectangle r de la fenêtre auquel est associé un bitmap de rafraîchissement (dans le cas de machines couleur une grande zone peut demander une place mémoire importante).
<"SAVE", b > ou < :save, b >
b est un booléen indiquant si un bitmap de rafraîchissement est associé
à la fenêtre. La valeur par défaut est b = 0.
Si b =1, un bitmap de rafraîchissement de la taille de la fenêtre est créé.
Exemple de création d'une fenêtre graphique avec sauvegarde automatique :
> new_window("query","GRAPHICS".<"SAVE",1>.nil);
Les deux buts suivants sont équivalents:
> new_window("fen","MODAL");
> new_window("fen","GRAPHICS".<"MODAL",1>.nil);
create_window(s,t,s',r1) create_window(s,t,v,s',r1) create_window(s,t,v,s',r1,r2)
Similaire à new_window, mais permet de définir un système de coordonnées avec échelle.
r1
est de la forme <x1,y1,x2,y2> où x1,y1,x2,y2 sont des réels indiquant les coordonnées de la partie 'dessinable' de la fenêtre dans un écran
[0,1] * [0,1].
r2
est de la forme <x1,y1,x2,y2> où x1,y1,x2,y2 sont des entiers définissant un système de coordonnées locales propre à l'utilisateur. Ce paramètre n'est à préciser que pour des fenêtres GRAPHICS et
FRAMEPANEL. Si le paramètre r2 n'est pas spécifié, les coordonnées graphiques dans la fenêtre seront données en pixels.
Par exemple si une fenêtre est créée par l'appel suivant:
> create_window("mywindow", "GRAPHICS", 1, "mywindow",
<0.1E0,0.1E0,0.6E0,0.7E0>, <0,0,100,100>);
quelle que soit la taille de l'écran, un rectangle dessiné par
gr_rect(1,0,0,100,100) la remplira, gr_moveto(50,50) positionnera au centre etc...
Autre exemple:
> create_window("ww","GRAPHICS",1,"mywindow",
<1e-1,1e-1,5e-1,5e-1);
© PrologIA
U 5 - 10
Manuel d'Utilisation Windows kill_window(s)
Détruit la fenêtre de nom s. Le nom s ne peut pas être celui d'une fenêtre prédéfinie, ce doit être une fenêtre créée par new_window ou create_window.
Si la fenêtre détruite était l'entrée ou la sortie courante, l'unité d'entrée ou de sortie précédemment active redevient l'unité courante d'entrée ou de sortie. Si la fenêtre détruite était la fenêtre graphique courante, c'est la fenêtre prédéfinie
"graphic" qui redevient l'unité graphique courante. Voir aussi le prédicat
kill_object.
5.2.2. Configuration, manipulation d'une fenêtre
clear_window(s)
Efface le contenu de la fenêtre de nom s. Ne modifie pas ses objets éventuels et ne supprime pas les événements liés à la fenêtre qui pouvaient être dans la queue Prolog. Est valable pour tout type de fenêtre (Sans effet sur une fenêtre
FRAMEPANEL).
s
file_window(s1) file_window(s1,s2)
Créent, si elle n'existe pas déjà, une fenêtre EDIT de nom s2 initialisée avec le texte contenu dans le fichier de nom s1. file_window(s1) équivaut à
file_window(s1,s1).
front_window(s)
Unifie s avec le nom de la fenêtre Prolog se trouvant au premier plan et ayant le focus.
get_window(s,v) get_window(s,v,x1,y1,x2,y2) get_window(s,t,v,x1,y1,x2,y2)
Renseigne sur le type, les attributs, la visibilité et les coordonnées de la fenêtre
s. La forme à deux arguments renseigne uniquement la visibilité. Unifie successivement par backtracking les paramètres s,t,v,x1,y1,x2,y2 avec les valeurs correspondant à chacune des fenêtres. Voir la primitive
new_window(s,t,v,x1,y1,x2,y2) pour la signification des paramètres. Le type et les attributs sont rendus sous la forme identificateur. La valeur de l'attribut
:distance est donnée en pixel et non plus en pourcentage de la partie dessinable.
gr_window(s)
La fenêtre ou la zone graphique s devient l'unité graphique courante.
gr_window_is(s)
Unifie s avec le nom de l'unité graphique courante.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 11
!
option fermeture
Lorsque l'on clique dans la case de fermeture d'une fenêtre, l'unité correspondante est fermée et son nom est retiré du menu contenant les noms des fenêtres, excepté pour les fenêtres prédéfinies. Il est possible de rendre une fenêtre invisible sans la fermer en appuyant sur la touche option en même temps que la case de fermeture est cliquée.
!
print_window(s)
!
print_window(s,f,t)
Imprime le contenu de la fenêtre de texte s avec la fonte f de taille t. Mêmes conventions que gr_text(f,t,l) (Voir 5.5. Mode de dessin et d'écriture). La forme avec un seul argument imprime la fenêtre avec la fonte courante de la fenêtre.
!
gr_print(s)
!
gr_print(s,_rx,_ry,x0,y0)
!
gr_print(s,r1,r2)
Imprime le contenu de la fenêtre graphique s. On peut spécifier, grâce à la troisième forme, la zone à imprimer, qui est le contenu du rectangle r1, le résultat sur papier se situant dans le rectangle r2. Les réductions et translations éventuelles sont automatiques. La forme avec un seul argument imprime la fenêtre sans modification de format. La forme à 5 arguments permet de spécifier la réduction selon les axes des X, des Y sous la forme de deux nombres _rx et _ry compris entre 0e0 et 1e0. On peut donner, en x0 et
y0 la position de l'origine de l'impression sur le papier.
> gr_print("graphic",0.5e0,0.5e0,0,0); imprimera la fenêtre "graphic", réduite au quart (chaque dimension étant réduite de moitié).
reset_window(s)
Repositionne le pointeur de lecture au début de la fenêtre EDIT de nom s.
Echoue si s n'est pas une fenêtre EDIT créée par new_window ou
create_window. Le point d'écriture reste toujours à la fin du texte.
save_window(s1) save_window(s1, s2)
Sauve le contenu de la fenêtre de texte de nom s1 dans le fichier de nom s2.
save_window(s1) équivaut à save_window(s1,s1).
set_window(s,b)
Permet de modifier les attributs ou la visibilité d'une fenêtre. s est l'identification de la fenêtre. b peut être soit un booléen: il indique alors si la fenêtre sera visible (0 : invisible, 1 : visible), soit un attribut (voir
new_window).
Les attributs possibles sont pour les fenêtres graphiques et modales:
<"SAVE", v > où v est un booléen
© PrologIA
U 5 - 12
Manuel d'Utilisation Windows
!
!
!
Ce prédicat avec cet attribut peut aussi être employé pour une 'drawing area'. s est alors son identification.
Si v =1, un bitmap de rafraîchissement de la taille de l'objet est créé.
<"SAVE", r > où r est un rectangle.
Pour une fenêtre de texte:
<"FONT", n >
<"FONTSIZE", n >
Exemple:
> set_window("console",<"FONTSIZE",12>);
set_window(s,b,x1,y1,x2,y2) s
Permet de modifier la visibilité, les dimensions et l'emplacement des fenêtres existantes.
est l'identification (chaîne de caractères ou entier) de la fenêtre, notamment "console", "graphic", "trace" pour les fenêtres prédéfinies.
b
est un booléen, indique si la fenêtre sera visible (0: invisible, 1: visible).
x1,y1 sont les nouvelles coordonnées, par rapport à l'écran, du coin intérieur supérieur gauche de la fenêtre.
x2,y2 sont les nouvelles coordonnées du coin intérieur inférieur droit de la fenêtre, l'origine étant située au coin supérieur gauche de l'écran.
Exemple:
> set_window("graphic",1,50,50,300,300);
5.2.3. Rafraîchissement des zones graphiques
Les fenêtres GRAPHICS ou les 'drawing area' peuvent être rafraîchies automatiquement en leur associant un bitmap auxiliaire (voir les primitives
new_window ou set_window ou new_drawing_area).
Dans le cas contraire, il existe une coroutine attachée aux zones graphiques, et qui est toujours déclenchée lorsque ces zones nécessitent un rafraîchissement. Cette coroutine est: exec(:gr_update(u)) où u représente le nom de l'unité à rafraîchir. La règle :gr_update n'est pas définie dans l'environnement standard, et n'est pas lancée si l'utilisateur ne la définit pas.
L'utilisateur peut donc, en écrivant une règle :gr_update/1, définir par programme ce que doit être le rafraîchissement d'une zone graphique sans utiliser de bitmap auxiliaire.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 13
5.3. Primitives élémentaires de gestion des objets attachés à une fenêtre
Nous les avons qualifiées de primitives élémentaires car elles servent à réaliser des opérations élémentaires telles que la création, la configuration et l'interrogation d'un objet. Ensuite elles manipulent des éléments très simples, à savoir: un objet ou un attribut d'objet ou un événement survenu sur un objet.
L'ensemble des ces primitives ne permet pas de manipuler et configurer complètement les menus, il y a en plus de celles-ci, des primitives spécifiques aux menus, décrites au paragraphe 5.4.
5.3.1. Création, destruction d'objets
L'identification d'un objet peut être soit une chaîne, soit un identificateur Prolog II+, soit, quand elle est générée automatiquement par Prolog, un entier. Pour ce dernier cas, il suffit d'appeler le prédicat de création de l'objet avec une variable libre à la place de l'identification, la variable sera alors unifiée avec un entier attribué à l'objet, qui permettra de l'identifier par la suite.
Certains objets attendent un titre ou un texte, il est déterminé par une chaîne de caractères Prolog qui peut être vide.
Une constante entière est utilisée pour spécifier la visibilité de l'objet à sa création :
0 signifie non visible, 1 signifie visible.
Il est possible de modifier l'attachement par défaut des objets, à l'aide des attributs
:top_attach, :left_attach, :bottom_attach, :right_attach (qui définissent respectivement l'attachement de l'objet au bord haut, gauche, bas, droit) à ajouter dans la liste des options de création. Si l'un des (ou les deux) attributs :top_attach et
:bottom_attach est mentionné, cela redéfinit l'attachement vertical et(ou) si l'un des
(ou les deux) attributs :left_attach et :right_attach est mentionné, cela redéfinit l'attachement horizontal.
Un programme Prolog peut être lié aux événements (s'il en existe) de l'objet créé, qui dès qu'ils se produisent provoquent la suspension du programme Prolog en cours pour lancer le prédicat associé à l'objet, avec en premier argument, l'identification de l'objet et éventuellement en deuxième argument une information supplémentaire (caractère tapé…). Lorsque le prédicat se termine, la démonstration suspendue reprend son cours normalement. Cela permet de gérer "en direct" la saisie dans les écrans graphiques.
Il est également possible de différer le traitement des données saisies ou des
événements. Pour cela il suffit de spécifier sys:get_event à la place du prédicat, ce qui aura pour effet de mettre simplement cet événement dans la queue d'événements de Prolog (elle peut être scrutée par get_event ou vidée par clear_events).
Ou encore, il est possible de ne rien faire. Pour cela il suffit de spécifier nil à la place du prédicat, ce qui aura pour effet d'ignorer les événements de l'objet.
© PrologIA
U 5 - 14
Manuel d'Utilisation Windows
s s s s s s s
kill_object(o)
Détruit l'objet o. Est valable pour tout type d'objet.
new_check_button(o,p,v,s,b,<x1,y1,x2,y2>)
Crée un 'check button' identifié par o, dont le texte est s. Le bouton et le texte seront inscrits dans un rectangle de coordonnées x1, y1, x2, y2 dans la fenêtre parente p. Il sera visible selon la valeur de v.
x2 et y2 doivent être libres ils seront alors unifiés avec les coordonnées effectives du coin inférieur droit de l'objet après création.
b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas,
à chaque activation du bouton le but b(o) est lancé.
new_drawing_area(o,p,v,<x1,y1,x2,y2>,r2,l) new_drawing_area(o,p,v,<x1,y1,x2,y2>,l)
Crée une 'zone graphique' identifiée par o. Elle est inscrite dans un rectangle de coordonnées x1, y1, x2, y2 dans la fenêtre parente p. Elle sera visible selon la valeur de v. r2 a la même signification que dans le prédicat create_window
(système de coordonnées locales). l est une liste d'options, éventuellement vide
(nil), formée à partir des identificateurs :
:no_border si l'on ne veut pas de bordure autour de la zone.
:save
pour avoir un bitmap de sauvegarde.
:top_attach, :left_attach, :right_attach, :bottom_attach
new_push_button(o,p,v,s,b,<x1,y1,x2,y2>) new_push_button(o,p,v,s,b,<x1,y1,x2,y2>,l)
Crée un 'push button' identifié par o, dont le texte est s, dont les coordonnées sont x1, y1, x2, y2 dans la fenêtre parente p. Il sera visible selon la valeur de v.
Si x2 et y2 sont libres ils seront alors unifiés avec les coordonnées effectives du coin inférieur droit de l'objet après création. b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas, à chaque activation du bouton, le but b(o) est lancé. l est une liste d'options, éventuellement vide (nil), formée à partir des identificateurs :
:buttonD
permet de le définir comme 'bouton par défaut', c'est à dire que tout carriage return qui ne sera pas capté par un autre objet activera ce bouton. Ces boutons sont conçus pour qu'il n'y en ait qu'un seul par fenêtre. Si ce n'est pas le cas, le comportement n'est pas garanti et est dépendant du système hôte.
:top_attach, :left_attach, :right_attach, :bottom_attach
new_radio_button(o,g,p,v,s,b,<x1,y1,x2,y2>)
Crée un 'radio button' identifié par o, dont le texte est s. g est un identificateur
Prolog qui représente le groupe auquel appartient le bouton. Le bouton et le texte seront inscrits dans un rectangle de coordonnées x1, y1, x2, y2 dans la fenêtre parente p. Il sera visible selon la valeur de v.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 15 s s s
x2 et y2 doivent être libres ils seront alors unifiés avec les coordonnées effectives du coin inférieur droit de l'objet après création.
b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas,
à chaque activation du bouton le but b(o) est lancé.
new_edit_field(o,p,v,b,<x1, y1, x2, y2>,l)
Crée un 'editfield' identifié par o, dont les coordonnées sont x1, y1, x2, y2 dans la fenêtre parente p. Il sera visible selon la valeur de v.
b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas,
à chaque caractère tapé dans l'editfield, le but b(o,c) est lancé où c est le caractère tapé, et à chaque événement de gain ou perte de focus le but b(o) est lancé.
l est une liste d'options, éventuellement vide (nil), formée à partir des identificateurs :
:multiple
:hscroll
:vscroll
<chars_nb,n>
si le champ peut comporter plusieurs lignes.
pour avoir une barre de défilement horizontale.
pour avoir une barre de défilement verticale.
si le champ est limité à n caractères (n entier).
:top_attach, :left_attach, :right_attach, :bottom_attach
Par défaut l'editfield est monoligne, sans barre de défilement, et le nombre de caractères est limité à 1024.
new_label(o,p,v,s,<x1,y1,x2,y2>,l)
Crée un 'label' identifié par o, dont le texte est s, inscrit dans un rectangle de coordonnées x1, y1, x2, y2 dans la fenêtre parente p. Il sera visible selon la valeur de v.
Si x2 et y2 sont libres ils seront alors unifiés avec les coordonnées effectives du coin inférieur droit de l'objet après création.
l est une liste d'options, éventuellement vide (nil), formée à partir des identificateurs :
:left
:right
si le texte doit être cadré à gauche dans le rectangle.
si le texte doit être cadré à droite dans le rectangle.
:no_border si le texte ne doit pas être encadré.
:top_attach, :left_attach, :right_attach, :bottom_attach
Pour obtenir un texte centré, il faut les deux attibuts :left et :right.
Par défaut le texte est encadré et son alignement est dépendant du système graphique hôte.
new_listbox(o,p,v,b,<x1, y1, x2, y2>,l)
Crée une 'listbox' identifiée par o, dont les coordonnées sont x1, y1, x2, y2 dans la fenêtre parente p. Elle sera visible selon la valeur de v. La définition des items de la listbox devra se faire par la primitive set_attribute.
b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas,
à chaque action de sélection dans la listbox, le but b(o,n,m) est lancé où n est le numéro de l'item affecté et m le modifieur utilisé.
l est une liste d'options, éventuellement vide (nil), formée à partir des identificateurs :
:multiple
si la sélection peut comporter plusieurs items.
© PrologIA
U 5 - 16
Manuel d'Utilisation Windows
s s s
:hscroll
si la barre de défilement horizontale est souhaitée.
:top_attach, :left_attach, :right_attach, :bottom_attach
Par défaut la listbox est en mode sélection simple (au plus 1 item sélectionné) et possède une barre de défilement verticale qui peut être invisible si le nombre d'items de la boite est insuffisant.
new_popup_menu(o,p)
Crée un support de 'popup menu' identifié par o, attaché à la fenêtre p. Aucun item n'est encore créé, il faut pour cela utiliser la primitive set_menu.
Remarque : il n'est pas nécessaire de créer un support de 'popup menu' avant d'utiliser la primitive set_menu. En effet si set_menu est utilisé avec un nom de fenêtre, cela fait référence au 'popup menu' de cette fenêtre. S'il n'existe pas, set_menu le crée, mais son identification n'est pas connue.
En supposant que mygraph est l'identification d'une fenêtre graphique déjà créée, la suite de buts ci-dessous crée un popup menu composé de la liste d'items : "doLine", "doRect", "doOval" avec, attachée à chacun des items, respectivement la procédure : doLine/1, doRect/1, doOval/1.
> new_popup_menu(popgraph,mygraph);
> set_menu(popgraph,nil,doLine.doRect.nil);
> set_menu(mygraph,"new".nil,doOval);
new_pulldown_menu(o,p,s)
Crée un support de 'pulldown menu' identifié par o, de nom s (chaîne de caractères), attaché à la fenêtre p. Ses items seront ensuite créés par la primitive set_menu. N'est pas valable pour les fenêtres de forme cadre.
La suite de buts ci-dessous crée un pulldown menu de titre "custom" composé de la liste d'items : "myColor", "myMode", "myFont", "myPen" avec, attachée
à chacun des items, respectivement la procédure : myColor/1, myMode/1, myFont/1, myPen/1.
> new_pulldown_menu(mymenu,mygraph,"custom");
> set_menu(mymenu,nil,myColor.myMode.myFont.miPen.nil);
> set_menu(mymenu,"miPen".nil,myPen);
new_scrollbar(o,p,v,b,<x1,y1,x2,y2>,l)
Crée une 'scrollbar' identifiée par o, dont les coordonnées sont x1, y1, x2, y2 dans la fenêtre parente p. Elle sera visible selon la valeur de v.
Si x2 et y2 sont libres ils seront alors unifiés avec les coordonnées effectives du coin inférieur droit de l'objet après création.
b peut être nil, sys:get_event ou un identificateur de règle. Dans ce dernier cas,
à chaque activation de la barre de défilement, le but b(o) est lancé.
l est une liste d'options, éventuellement vide (nil), formée à partir des identificateurs :
:vscroll si la barre doit être verticale.
:hscroll si la barre doit être horizontale.
:top_attach, :left_attach, :right_attach, :bottom_attach
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 17
L'orientation par défaut est déterminée par les coordonnées, sachant qu'une barre est plus longue que large.
5.3.2. Configuration d'objets
s
get_attribute(o,a,v)
Permet de se renseigner sur l'état des objets ou leurs propriétés.
o est l'identification de l'objet.
a est l'identification de l'attribut.
v sera unifié avec la valeur de l'attribut interrogé.
Les attributs possibles sont les mêmes que ceux de la primitive set_attribute, excepté les attributs focus et customColor, complétés des attributs suivants qui sont des propriétés de création non modifiables :
:parent : v est unifié avec l'identification du parent de l'objet o.
:type : v est unifié avec un identificateur représentant le type de l'objet o. Les valeurs possibles sont: :graphics, :tty, :edit, :framepanel, :label,
:push_button, :check_button, :radio_button, :scrollbar, :edit_field,
:popup_menu, :pulldown_menu, :listbox, :drawing_area.
:fontheight : v est la hauteur en pixels de la fonte utilisée par l'objet. La hauteur de la fonte est la hauteur du rectangle dans lequel s'inscrivent les caractères (l'interligne est compris).
:group : v est unifié avec l'identificateur de groupe du 'radio button' o.
:items_nb : v est unifié avec le nombre d'items de la 'listbox' o.
s
set_attribute(o,a,v)
Permet de modifier ou de préciser la configuration des objets.
o est l'identification de l'objet.
a est l'identification de l'attribut.
v est la valeur de l'attribut.
Les attributs possibles dépendent du type de l'objets. Les attributs généraux sont les suivants :
:activity : indique si l'objet ou l'item de menu réagit aux événements ou pas. v vaut respectivement 1 ou 0. N'est pas valable pour les labels.
:background : concerne la couleur de fond de l'objet. v est un entier ou un identificateur et suit les mêmes conventions que dans la primitive
gr_color2 (Voir 5.5. Mode de dessin et d'écriture).
:bottom_right : concerne la position du coin extérieur inférieur droit de l'objet.
v est de la forme <p1, p2> où p1 est l'abscisse, p2 est l'ordonnée. A pour effet le redimensionnement de l'objet. N'est pas valable pour les menus.
:cursor : concerne la forme du curseur de la souris quand il est à l'intérieur de la fenêtre o. v est un des identificateurs suivants : :default, :wait, :cross.
Pour set_attribute, si o vaut nil, la définition se rapporte à toutes les fenêtres.
© PrologIA
U 5 - 18
Manuel d'Utilisation Windows
:customColor : définit la couleur utilisateur pour l'objet o. v est de la forme
<_r, _v, _b> où _r, _v, _b sont des entiers ou des réels et représentent la couleur en composantes rouge, vert, bleu comme défini dans la primitive gr_color3 (Voir 5.5. Mode de dessin et d'écriture). Cet attribut n'est pas valable pour la primitive get_attribute.
:focus : donne le focus à l'objet o. v est ignoré. N'est pas un attribut valide pour la primitive get_attribute.
:font : concerne la fonte utilisée par l'objet. v a la même signification que dans la primitive gr_font (Voir 5.5. Mode de dessin et d'écriture). La fonte définit un style et une taille. La taille pourra être obtenue par la primitive
get_attribute avec l'attribut :fontheight.
:foreground : concerne la couleur de traçage (texte ou dessin) de l'objet. v est un entier ou un identificateur et suit les mêmes conventions que dans la primitive gr_color2 (Voir 5.5. Mode de dessin et d'écriture).
:predicate : v est le prédicat Prolog attaché à l'objet. N'est pas valable pour les labels (puisqu'ils ne sont pas sensibles), ni pour les menus et leurs items (voir pour ça la primitive set_menu).
Remarque : il peut être utilisé pour les unités graphiques, il correspond alors au prédicat qui doit être lancé, si l'unité n'a pas de bitmap, sur un
événement "expose" (nécessité de retracer une partie de l'unité). La valeur attribuée par défaut est gr_update.
Remarque : ne pas confondre avec le prédicat qui est lancé sur un
événement clic, il est lui lié à une portion de l'unité (Voir le prédicat
gr_sensitive). Il n'est pas modifiable par set_attribute.
:protected permet de désactiver l'option de fermeture dans le menu par défaut d'une fenêtre.
:rank : concerne la numérotation des objets dans leur parent. v est le rang local de l'objet dans son parent, ce numéro est unique pour un parent donné. Implicitement c'est le numéro d'ordre de création. Cet attribut n'est pas valable pour les fenêtres.
:state : concerne l'état de l'objet: sélectionné ou non sélectionné. v vaut respectivement 1 ou 0. Est valable uniquement pour les check buttons et les radio buttons.
:text : concerne le texte d'un champ d'édition, le titre d'une fenêtre, le libellé d'un objet de type bouton ou d'un label. Dans le cas général, v est une chaîne de caractères. Pour un champ d'édition, v peut être de la forme
<s, 1> ce qui signifie que la chaîne de caractères s doit être ajoutée
(mode append) au contenu du champ d'édition.
:text_selection : concerne la sélection dans un champ d'édition. v est de la forme <p1, p2> où p1 est l'indice du premier caractère sélectionné
(débute à 0), p2 est l'indice suivant le dernier caractère sélectionné,
p2 >= p1.
:top_left : concerne la position du coin supérieur gauche de l'objet. v est de la forme <p1, p2> où p1 est l'abscisse, p2 est l'ordonnée. A pour effet le déplacement de l'objet. N'est pas valable pour les menus.
:user_field : concerne le champ utilisateur qui n'est pas du tout géré par
Prolog. v est un entier. Le programmeur peut s'en servir par exemple, comme variable globale associée à l'objet.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 19
:visibility : concerne la visibilité de l'objet. v vaut 0 si l'objet est invisible, 1 si l'objet est visible. N'est pas valable pour les menus.
:width_height : v est de la forme <p1, p2> où p1 est la largeur de l'objet, p2 sa hauteur. N'est pas valable pour les menus.
Les attributs spécifiques aux 'listbox' sont les suivants :
:items : concerne la liste des items d'une listbox. v est une liste de chaînes
Prolog qui décrit, dans le même ordre, tous les items (par leur texte) de la listbox.
:selected_items : concerne la liste des items sélectionnés d'une listbox. v est la liste des rangs des items sélectionnés. Le premier item a le rang 1. S'il est mentionné un rang qui n'existe pas, il est ignoré. S'il est mentionné plus d'un rang pour une listbox en sélection simple, c'est la dernière sélection qui est prise en compte.
:state(i) : concerne l'état d'un item de listbox : sélectionné ou non sélectionné.
v vaut respectivement 1 ou 0. i est un entier pour le numéro de l'item concerné dans la listbox. Le premier item de listbox est représenté par l'entier 1.
:text(i) : concerne le texte d'un item de listbox. i est un entier pour le numéro de l'item concerné dans la listbox. Le premier item de listbox est représenté par l'entier 1. v peut avoir différentes valeurs selon les situations suivantes:
– Interrogation sur le texte de l'item: v est une chaîne de caractères. Si l'item n'existe pas , v est la chaîne vide.
– Modification du texte de l'item : i est un numéro d'item existant, v est une chaîne de caractères non vide.
– Suppression de l'item : i est un numéro d'item existant, v est la chaîne vide.
– Création de l'item : i est un numéro d'item qui n'existe pas, v est une chaîne de caractères éventuellement vide.
– Insertion de l'item : v est de la forme <p1, 1> où p1 est une chaîne de caractères éventuellement vide pour désigner le texte de l'item créé à la position indiquée par i.
:toplist : v est le numéro du premier item visible dans la listbox.
Les attributs spécifiques aux 'scrollbar' sont les suivants :
:scrollb_page : concerne l'amplitude du déplacement du curseur lorsqu'un saut est demandé (clic entre une flèche et le curseur). v est un entier.
:scrollb_pos : v désigne la position du curseur dans la 'scrollbar'. v est une des valeurs entières de l'intervalle de valeurs de la 'scrollbar'. Le 0 est en haut pour les barres verticales, à gauche pour les barres horizontales.
:scrollb_range : concerne l'intervalle de valeurs de la 'scrollbar'. v est un entier. S'il est positif, les valeurs seront comprises entre 0 et v. S'il est négatif, les valeurs seront comprises entre v et –v.
© PrologIA
U 5 - 20
Manuel d'Utilisation Windows
s s
:scrollb_step : v est un entier, il désigne l'amplitude du déplacement
élémentaire du curseur lorsqu'une flèche de 'scroll' est activée.
L'amplitude minimum est 1, c'est aussi la valeur par défaut. Pour obtenir la nouvelle position il faut enlever ou ajouter v à la position actuelle.
get_local_object(p, n, o)
Unifie o avec l'identification de l'objet de parent p et de rang local n dans p.
get_objects(p, l_o)
Unifie l_o avec la liste des objets dont le parent est p.
5.3.3. Gestion des événements
s
get_event(b,e,o)
Teste si un événement de type défini par e concernant l'objet o est présent dans la queue d'événements de Prolog. Si c'est le cas, le premier événement correspondant (le plus ancien dans le temps) est lu donc supprimé de la queue et l'unification des arguments est tentée. Sinon get_event agit en fonction de b qui doit être connu à l'appel.
Si b vaut 0, get_event n'est pas bloquant et génère un backtracking.
Si b vaut 1, get_event est bloquant et un tel événement est attendu, puis lu et enfin l'unification tentée.
o est soit l'identification d'un objet, soit une variable libre. Dans ce dernier cas tous les objets sont concernés.
e est soit une variable libre, dans ce cas tous les événements sont concernés, soit de la forme:
:char(c) : pour les 'edit_field' et les unités (fenêtres ou zones de dessin)
GRAPHICS, où c est le code du caractère.
:click : pour un bouton ("push", "check", "radio") ou une 'scrollbar'. Aucun résultat n'est transmis, simplement un succès ou un échec.
:click(i,m) : pour les menus ou les listbox, où i est le numéro de l'item désigné et m donne l'état des principales touches de modification. m est la somme des valeurs :
1 si la touche SHIFT est appuyée,
2 si la touche CONTROLE est appuyée,
32 s'il s'agit d'un DO UBLE-CLIC
Remarque: Un double clic souris sur un item va générer la séquence d'événements suivante: :click(i,0) :click(i,32).
:click_down(x,y,m) : pour les fenêtres GRAPHICS et FRAMEPANEL et les
'drawing area', où x,y sont les coordonnées du clic relatives à l'objet, m donne l'état des principales touches de modification.
:click_up(x,y,m) : pour les unités (fenêtres ou zones de dessin) GRAPHICS, où x,y sont les coordonnées du clic relatives à l'objet, m donne l'état des principales touches de modification.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 21 s s
Remarque : Un double clic souris dans une unité graphique va générer la séquence d'événements suivante: :click_down(x,y,0) :click_up(x,y,0)
:click_down(x,y,32) :click_up(x,y,0).
:focus_in : pour les 'edit_field'. Aucun résultat n'est transmis, simplement un succès ou un échec.
:focus_out : pour les 'edit_field'. Aucun résultat n'est transmis, simplement un succès ou un échec.
:update : pour les unités (fenêtres ou zones de dessin) GRAPHICS qui n'ont pas de bitmap et qui ont toujours le prédicat par défaut sys:get_event lié
à l'unité.
:extern_event(s, i1, i2): pour les objets externes. s, i1 et i2 sont des données envoyées par l'utilisateur en même temps que l'événement, grace à la procédure send_external_event.
peek_event(b,e,o)
Même principe et mêmes valeurs que la primitive get_event(b,e,o), mais ne fait que consulter la queue d'événements, sans la modifier. L'événement e pour l'objet o n'est pas supprimé de la queue.
clear_events(e,o)
Supprime tous les événements définis par e concernant l'objet o, aucune unification n'est faite, ce prédicat n'échoue jamais. e suit les mêmes conventions que pour get_event(b,e,o).
5.4. Primitives spécifiques pour la gestion de menu
La primitive set_menu décrite dans cette section, permet de définir ou redéfinir des menus hiérarchiques.
Tous les menus, popup ou pulldown, sont attachés à une fenêtre. Il existe néanmoins un support particulier, pour accueillir des menus généraux à l'application, appelé la barre de menus de Prolog.
5.4.1. Sauvegarde et changement de la barre de menu
La barre de menu générale de Prolog est identifiée par :prolog. Pour connaître les identifications de ses menus, il faut effacer sys:get_objects(:prolog,l) qui en rendra la liste.
clear_menubar
Efface la barre de menus standard. Cette primitive permet la redéfinition complète de la barre de menus.
clear_menubar(s)
Efface la barre de menus de la fenêtre s.
© PrologIA
U 5 - 22
Manuel d'Utilisation Windows
s
restore_sysmenus(s,f,e)
Ajoute dans la barre de menus de la fenêtre s les menus prédéfinis "File" et
"Edit" en unifiant leur nom avec f et e. (La variable reste libre, si le menu n'existe pas sur la machine hôte).
!
save_menubar
Mémorise la barre de menus courante. Cette règle ne peut être appelée qu'une fois.
restore_menubar
!
s
Restaure la barre de menus sauvée avec save_menubar.
Initialise la barre de menus de Prolog avec les menus généraux.
!
add_stdmenu(s)
Cette primitive permet de réinsérer un ou plusieurs menus standard après un appel à clear_menubar. s doit être l'une des chaînes suivantes:
"apple"
"file"
"edit"
"find"
"control"
"window"
: pour reinsérer le menu pomme
: pour reinsérer le menu Fichier
: pour reinsérer le menu Editer
: pour reinsérer le menu Recherche
: pour reinsérer le menu Contrôle
: pour reinsérer le menu Fenêtres
5.4.2. Description d'un menu
set_menu(u,c,v)
Permet de définir ou redéfinir par v la valeur de l'item indiqué par c, dans le menu désigné par u.
Signification des arguments:
u (unité) Représente le menu concerné: 0 pour un menu de la barre de menu, l'identification d'une fenêtre pour le popup menu qui lui est associé ou encore l'identification d'un menu (popup ou pulldown).
c (chemin) Liste de chaînes indiquant un chemin de sélection dans le menu
u. L'item correspondant dans ce chemin est remplacé par v. Si une telle hiérarchie n'existe pas, elle est créée. Si la liste est nil, c'est tout le menu qui est concerné. Attention: le titre d'un pulldown menu n'est pas un item, ne pas le mentionner dans le chemin.
v (valeur) Arbre de description de la valeur remplaçant l'item à la position indiquée par c, dans le menu u. Cette valeur peut être une feuille, ou une hiérarchie.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 23
Valeur de type feuille
Une feuille est représentée par :
<"Nom item",Identificateur,n>
La chaîne "Nom item" vient remplacer le texte de l'item indiqué par le chemin.
Ou bien, si la chaîne est vide, l'item désigné est supprimé. Un caractère '&' dans la chaîne "Nom Item" n'apparaitra pas dans le texte de l'item et désignera le caractère qui le suit, comme raccouci clavier pour activer l'item.
Identificateur est l'identificateur d'accès d'une règle d'arité 1 attachée à l'item.
n est un booléen indiquant si l'item est coché ou non.
Il est possible d'utiliser pour v, à la place de ce triplet, les formes simplifiées :
nil
pour indiquer un trait de séparation horizontal
Identificateur
pour
<"Identificateur",Identificateur,0>
<"Nom item",Identificateur> pour
<"Nom item",Identificateur,0>
Lorsque le menu est sélectionné, le programme en cours est suspendu, et le but Identificateur(u) est immédiatement activé. Si le but se termine sans erreur, le programme reprend normalement, sinon l'erreur est propagé par le mécanisme block_exit.
Exemple, en supposant que la fenêtre d'édition "menu.p2" soit ouverte:
>
set_menu( 0
, ["Compilation","Compiler la fenêtre"]
,<"Compiler la fenêtre",compilation_fen>) set_menu( "menu.p2"
, ["Compiler"]
,<"Compiler",compilation_fen>);
{}
>
insert; compilation_fen(0) -> front_window(u) reinsert(u); compilation_fen(u) -> string(u) reinsert(u);;
{}
>
Valeur de type hiérarchie
Une hiérarchie est représentée par un tuple à deux arguments de la forme:
<"Nom item", Liste_de_valeurs>
Chaque valeur représente elle-même une feuille ou une hiérarchie. Il est possible d'utiliser à la place de ce doublet une forme simplifiée:
Liste_de_valeurs
Dans ce cas le nom de l'item est celui indiqué à la fin du chemin c. Ceci revient à apposer la hiérarchie sous l'item indiqué.
Exemple:
> set_menu("graphic",[],
[ <"File", [quit]>
, <"Do", [goal1,<"Stop",goal2>]>
, <"Size", [ <"1",size1>
, <"2",size2,1>
, <"3",size3>
]>
] ); insert; size1(u) -> gr_window(u) gr_text(1,10,nil);
© PrologIA
U 5 - 24
Manuel d'Utilisation Windows size2(u) -> gr_window(u) gr_text(1,12,nil);
...
File
Do
Size
1
2
3
File
Do
Size goal1
Stop
Lorsque l'on utilise set_menu pour la barre de menu, c'est à dire avec u égal à
0, le menu créé sur la barre est un 'pulldown menu'. La première chaîne du chemin c ou bien, si c vaut nil, la première chaîne de la valeur v, représente le titre du pulldown menu. L'identification de ce menu est une chaîne: la chaîne de titre à la création du menu. Les modifications ultérieures du titre ne modifient pas l'identification du menu. L'identification du menu peut être utile pour d'autres primitives telles que kill_object, get_attribute…
Exemple:
>set_menu(0,"new".nil,<"colors",black.grey.white.nil>);
L'identification du menu créé par cet appel est "new", son titre est "colors".
>set_menu(0,nil,colors.black.grey.white.nil);
L'identification du menu créé par cet appel est "colors", son titre est "colors".
>set_menu(0,"colors"."black"."white"."else".nil,else);
L'identification du menu créé par cet appel est "colors", son titre est "colors".
Dans les primitives qui suivent, le premier et le deuxième argument suivent les mêmes conventions que pour set_menu :
!
check_item(u,c,v)
Cette primitive positionne ou enlève le cochage de l'item, suivant les valeurs de
v : 0 indique non coché, 1 indique coché avec la marque standard de la machine.
Si v est un entier plus grand que 1, le caractère de la machine hôte ayant le code v est utilisé comme marque.
Exemple:
> check_item(0,"colors"."black".nil,1);
!
command_menu(u,c,v)
v est le code du caractère utilisé en conjonction de la touche de commande
( ), utilisée comme raccourci pour activer l'item spécifié par les deux premiers arguments.
Exemple de création du raccourci T pour activer la trace Prolog:
> char_code("T",n)
command_menu(0,"Contrôle"."trace".nil,n);
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 25 s Le caractère utilisé comme raccourci clavier est un caractère appartenant au texte de l'item du menu, il est désigné au moment de la définition du menu ou de l'item.
enable_menu(u,c,v)
Permet de désactiver (v =0) ou de réactiver (v =1) un menu ou un item.
L'exemple suivant désactive tout le menu d'édition:
> enable_menu(0,"Editer".nil,0);
!
style_menu(u,c,v)
Spécifie le style d'un item de menu. v est un entier dont chaque bit représente un des styles spécifiés avec l'ordre défini dans la primitive gr_text.
Exemple mettant en italique souligné l'item trace du menu Fenêtres (bit 1 + bit 2 positionnés) :
> style_menu(0,"Fenêtres"."trace".nil,6);
5.5. Mode de dessin et d'écriture
L'ensemble des primitives décrites ici, agit sur des propriétés de l'unité graphique courante (qui peut être une fenêtre de type GRAPHICS ou une 'drawing area').
gr_color3(r,v,b)
Définit la couleur du crayon de l'unité graphique courante en composantes r rouge, v vert, b bleu. Si les valeurs sont réelles, elles correspondent à des pourcentages d'intensité pour chaque composante, elles doivent être comprises entre 0e0 et 1e0, et sont portables d'une machine à l'autre. Si les valeurs sont entières, elles doivent être comprises entre 0 et 65535. Cette couleur est mémorisée comme la :customColor de l'unité graphique courante.
s
!
gr_color(d,c)
Définit la couleur du fond (si d= 0) ou du crayon (si d=1) de l'unité graphique courante. L'argument c est un entier représentant une des 8 couleurs possibles parmi les valeurs: 33:noir, 30:blanc, 205:rouge, 341:vert, 409:bleu, 273:cyan,
137:magenta, 69:jaune.
gr_color1(d,c)
Définit la couleur du fond (si d= 0) ou du crayon (si d=1) de l'unité graphique courante. L'argument c représente une couleur selon les mêmes conventions que celles de la primitive gr_color2.
gr_color2(f,c)
0
1
Définit la couleur f du fond et c du crayon de l'unité graphique courante. Les arguments f et c sont des entiers ou des identificateurs représentant une des couleurs possibles parmi les valeurs : couleur
:white
:red blanc rouge
© PrologIA
U 5 - 26
Manuel d'Utilisation Windows
8
9
6
7
4
5
2
3
:green
:blue
:pink
:orange
:brown
:magenta
:purple
:cyan vert bleu rose orange marron magenta violet cyan
10
11
12
13
:yellow jaune
:lightGrey gris clair
:darkGrey gris foncé
:black
14
15 noir
:defaultColor couleur système
:customColor couleur utilisateur définie par gr_color3.
Remarque: la forme entière est moins explicite que la forme identificateur.
Dans les primitives d'interrogation de la configuration (get_attribute(ob1,
:background, x)), Prolog retourne les valeurs sous forme d'identificateur.
!
gr_choosecolor(p,s,i,f)
Affiche le dialogue de sélection de couleur au point p (de la forme <x,y>) de l'écran. s est une chaîne qui sera affichée dans le dialogue. i et f sont des triplets d'entiers compris entre 0 et 65535; un triplet <r, v, b> représentant une couleur en composantes r rouge, v vert, b bleu. i est la couleur initiale du dialogue et doit être connu au moment de l'appel, f sera unifié avec la couleur choisie. Echoue si l'utilisateur clique sur le bouton Annuler.
gr_pen(l,m)
!
gr_pen(l,h,m)
!
3
4
1
2
Définit la taille en pixels du crayon de l'unité graphique courante et son motif .
l = largeur,
h = hauteur,
m = motif , est un entier ou un identificateur.
m m
0 :clear
:solid motif trame du fond trame pleine
:halfPattern trame demi-teinte
:lightPattern trame claire
:darkPattern trame foncée
Remarque: la forme entière est moins explicite que la forme identificateur.
Dans les primitives d'interrogation de la configuration (gr_get_pen(l, h, m)),
Prolog retourne les valeurs sous forme d'identificateur.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 27 s s
gr_get_pen(l,m) gr_get_pen(l,h,m)
Renseigne sur la taille et le motif du crayon de l'unité graphique courante.
l,h,m ont la même signification que dans la primitive gr_pen(l,h,m). Prolog retourne un identificateur pour le motif du crayon.
gr_stringwidth(s,n)
Unifie n avec la longueur en pixels de la chaîne s en fonction de la fonte, de la taille et du style définis pour l'unité graphique courante.
gr_mode(b,m)
Définit le mode d'application du motif sur le fond, pour l'unité courante graphique.
b=0 Concerne le dessin et donc le motif du crayon.
b=1 Concerne le texte et donc le motif correspondant à chaque caractère.
Il existe quatre opérations de base: Copy, Or, Xor et Bic.
L'opération Copy remplace simplement les pixels de destination par les pixels du motif ou de la source, dessinant sur la destination sans se préoccuper de son état initial.
Les opérations Or, Xor, et Bic laissent inchangés les pixels de destination situés sous la partie blanche du motif ou de la source. Elles traitent différemment les pixels situés sous la partie noire:
Or (ajout) les remplace par des pixels noirs.
Xor (inversion) les remplace par leur contraire.
Bic (effacement) les remplace par des pixels blancs.
Suivant le mode, l'opération est réalisée à partir du motif lui-même (src), ou bien à partie de son inverse (notSrc).
Pour les machines couleur, la partie blanche du motif correspond à la partie couleur du fond, la partie noire du motif correspond à la partie couleur du crayon, la détermination de la couleur inverse est dépendante de la machine.
Voici les valeurs de m pour les différents modes.
m m
2
3
0
1
:srcCopy
:srcOr
:srcXor
:srcBic modes d'application srcCopy srcOr srcXor srcBic
:notSrcCopy notSrcCopy
6
7
4
5 :notSrcOr notSrcOr
:notSrcXor notSrcXor
:notSrcBic notSrcBic
Remarque: la forme entière est moins explicite que la forme identificateur.
Dans les primitives d'interrogation de la configuration (gr_get_mode(1, x)),
Prolog retourne les valeurs sous forme d'identificateur.
© PrologIA
U 5 - 28
Manuel d'Utilisation Windows
s s
gr_get_mode(b,m)
Renseigne sur le mode d'application du motif dans l'unité graphique courante.
b, m ont la même signification que dans gr_mode(b,m). Prolog retourne le mode comme un identificateur.
!
gr_text(f,t,s)
Permet de définir la fonte, la taille et le style des sorties dans l'unité graphique courante. f = numéro de la fonte; t = taille de la fonte; s = liste de numéros de style.
N° fonte
0
1
2
3
4
5
6
7
8 systemFont | applFont newYork geneva monaco venice london athens san Franscico |
|
|
|
|
|
|
|
| N° style
4
5
6
2
3
0
1 gras italique souligné relief ombré condensé
étalé
...
La liste vide représente le texte normal. La combinaison par défaut est
gr_text(4,12,nil).
Par exemple gr_text(3,18,1.3.4.nil) correspond à geneva taille 18, italique, relief et ombré.
Il est possible d'appeler cette règle en donnant en argument des identificateurs auxquels on a assigné les constantes appropriées :
> assign(Geneva,3) assign(Italic,1) assign(Relief,3);
{}
> gr_text(Geneva,18,Italic.Relief.nil)
output("graphic") outm("Hello") output("console");
affiche
Hello
dans l'unité graphique.
gr_font(f)
Charge la fonte représentée par f pour l'unité graphique courante. La fonte de base qui est la fonte proposée par le système est désignée par :ftdefault ; les autres fontes proposées sont de la forme:ft(i) ou bien i, où i est un entier compris entre 1 et 50. La correspondance entre l'entier et le nom de la fonte du système hôte est définie dans le fichier fonts.usr. La totalité des fontes disponibles sur la machine peut être examinée aprés un premier lancement de
Prolog, dans le fichier fonts.all (créé au démarrage du graphisme).
Exemple:
> gr_font(:ft(2));
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 29
5.6. Dessin et positionnement
s
Les primitives décrites ci-dessous agissent sur l'unité graphique courante (qui peut
être une fenêtre de type GRAPHICS ou une 'drawing area'). Elles permettent d'y définir un système de coordonnées, et d'y réaliser des dessins.
gr_setorigin(x,y)
Change l'origine des axes de sorte que x,y représentent les coordonnées du coin intérieur haut et gauche de l'unité graphique courante. L'aspect de l'unité n'est pas modifié.
gr_getorigin(x,y)
Renseigne sur les coordonnées du coin intérieur supérieur gauche de l'unité graphique courante installées par gr_setorigin
gr_penloc(x,y)
Donne en coordonnées entières la position du crayon dans l'unité graphique courante.
gr_penlocr(x,y)
Identique à gr_penloc(x,y) mais donne un résultat de type réel.
gr_erase
Efface le contenu de l'unité graphique courante, repositionne le crayon en haut et à gauche et supprime tous les événements liés à la fenêtre et à ses objets.
gr_move(x,y)
Modifie la position du crayon de x pixels dans le sens horizontal et y pixels dans le sens vertical par rapport à la position courante.
gr_moveto(x,y)
Positionne le point d'écriture (crayon) de l'unité graphique courante en x,y.
gr_line(x,y)
Tire un trait depuis la position courante jusqu'à la nouvelle position du crayon, déplacé horizontalement de x pixels et verticalement de y pixels.
gr_lineto(x,y)
Tire un trait depuis la position courante jusqu'au point x,y, en déplaçant le crayon.
gr_rect(n,r) gr_rect(n,x1,y1,x2,y2)
Permettent d'appeler les routines basiques de dessin inscrit dans un rectangle.
r est l'arbre désignant le rectangle. x1,y1 sont les coordonnées du coin supérieur gauche, et x2,y2 celles du coin inférieur droit du rectangle.
© PrologIA
U 5 - 30
Manuel d'Utilisation Windows
Le premier argument n, où n est un entier ou un identificateur, détermine la procédure appelée:
0, :frameRect, :frame
Dessine le périmètre du rectangle.
1, :paintRect, :paint
Remplit le rectangle avec le motif associé au crayon.
2, :eraseRect, :erase
Efface le contenu et le périmètre du rectangle.
3, :invertRect, :invert
Inverse la couleur de chaque point de l'intérieur du rectangle. Si le rectangle a un coloriage autre que noir et blanc, le résultat est dépendant de la machine.
4, :frameOval
Dessine le périmètre de l'ovale inscrit dans le rectangle.
5, :paintOval
Remplit l'ovale avec le motif associé au crayon.
6, :eraseOval
Efface le contenu et le périmètre de l'ovale.
7, :invertOval
Inverse les bits de l'ovale. Si l'ovale a un coloriage autre que noir et blanc, le résultat est dépendant de la machine.
8, :frameRoundRect
Identique à :frameRect mais avec des coins arrondis.
9, :paintRoundRect
Identique à :paintRect, mais avec des coins arrondis.
10, :eraseRoundRect
Identique à :eraseRect mais avec des coins arrondis.
11, :invertRoundRect
Identique à :invertRect mais avec des coins arrondis.
12, :clipRect
Les dessins ultérieurs traceront uniquement ce qui est à l'intérieur du rectangle. Autrement dit, définit un rectangle de visibilité de tous les dessins à venir. Pour en annuler l'effet, le refaire avec les coordonnées de l'écran.
gr_polygon(n,L)
Dessine un polygone dans l'unité graphique courante. L est une liste de doublets <x,y> indiquant les coordonnées des points définissant le polygone.
Le premier argument n, où n est un entier ou un identificateur, détermine la procédure appelée:
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 31
0, :frame
Dessine le périmètre du polygone.
1, :paint
Remplit le polygone avec le motif associé au crayon.
2, :erase
Efface le contenu du polygone (certaines des lignes brisées formant le contour du polygone peuvent subsister).
3, :invert
Inverse la couleur de chaque point de l'intérieur du polygone. Le résultat est dépendant de la machine si le polygone a un coloriage autre que noir et blanc.
gr_arc(n,r,a1,a2) gr_arc(n,x1,y1,x2,y2,a1,a2)
Dessine un arc d'ellipse inscrit dans le rectangle r entre les angles a1 et a2.
Les angles a1 et a2 sont donnés en degrés.
Le premier argument n, où n est un entier ou un identificateur, détermine la procédure appelée:
0, :frame
Dessine l'arc d'ellipse.
1, :paint
Remplit le secteur défini par l'arc d'ellipse avec le motif associé au crayon.
2, :erase
Efface l'arc et le secteur.
3, :invert
Inverse la couleur de chaque point de l'intérieur du secteur d'ellipse. Le résultat est dépendant de la machine si le coloriage est autre que noir et blanc.
> gr_arc(:frame,100,100,200,170,20,110);
a2
x1,y1
a1
x2,y2
© PrologIA
U 5 - 32
Manuel d'Utilisation Windows gr_arc'(n,r,a1,a2) gr_arc'(n,x1,y1,x2,y2,a1,a2)
Dessine un arc d'ellipse inscrit dans le rectangle r entre les angles a1 et a2. a1 et a2 sont donnés en degrés. Les arguments sont les mêmes que pour gr_arc mais l'origine est sur l'axe vertical, a2 est relatif à la position a1, le sens positif est dans le sens des aiguilles d'une montre.
> gr_arc'(:frame,100,100,200,170,20,30); a1 a2 x1,y1
A!ociation
Prolog
HERITAGE x2,y2
!
gr_icon(n,x1,y1,x2,y2)
!
gr_icon(n,r)
Dessine dans l'unité graphique courante, et inscrit dans le rectangle indiqué une icône décrite dans une ressource 'ICON' de numéro n. Cette ressource est recherchée d'abord dans l'exécutable Prolog II+, puis dans le fichier système.
Le système contient toujours les icônes :
0 Panneau stop.
1 Notification.
2 Panneau danger.
Le meilleur résultat est obtenu en donnant comme rectangle un carré de coté
égal à 32.
gr_load(s)
Dessine dans l'unité graphique courante le contenu d'un fichier graphique de nom s. Ce fichier graphique est un fichier externe à PrologII+ réalisé à l'aide d'un quelconque éditeur graphique du système hôte. Il est possible de dessiner à des endroits différents des parties sélectionnées du fichier, en jouant sur les primitives gr_setorigin et gr_rect(:clipRect,..).
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 33
5.7. Position de la souris dans une zone graphique
!
!
!
s s
Un événement 'clic' peut être utilisé pour sélectionner, pour déclencher un traitement de manière asynchrone, ou encore, simplement pour désigner un point d'un objet de type GRAPHICS. Les primitives décrites ci-dessous concernent l'unité graphique courante (qui peut être une fenêtre de type GRAPHICS ou une 'drawing area').
!
gr_click(b,x,y)
Teste si un bouton de la souris a été pressé depuis le dernier appel de
gr_erase ou gr_click. Si c'est le cas, x et y sont unifiés avec les coordonnées, dans l'unité graphique courante, du point où se trouvait la souris lorsque cet
événement, appelé "clic", s'est produit. Sinon agit selon b. b est un booléen qui doit être connu au moment de l'appel, avec la signification :
b=1 Attendre qu'un nouveau clic se produise dans l'unité graphique courante.
b=0 Ne pas attendre et réaliser un backtracking.
gr_click(b,x,y)
Teste si un événement "clic" dans l'unité graphique courante est présent dans la queue des événements. Si c'est le cas, x et y sont unifiés avec les
"coordonnées du clic" dans l'unité graphique courante et l'événement est supprimé de la queue. Sinon agit selon b. b est un booléen qui doit être connu au moment de l'appel, avec la signification :
b=1 Attendre qu'un nouveau clic se produise dans l'unité graphique courante.
b=0 Ne pas attendre et réaliser un backtracking.
Voir aussi la primitive get_event.
gr_click(b,x,y,m)
4
8
1
2
Identique à gr_click(b,x,y) mais donne en plus l'état des principales touches de modification en unifiant m avec la somme des valeurs :
La touche MAJ USC ULE est appuyée.
La touche CONTROLE 1 est appuyée.
Une touche option est appuyée (OPTION sur Mac).
La touche COMMANDE est appuyée.
16 La touche MAJ USC ULES-VERRO UILLEES est enfoncée.
32 Il s'agit d'un DO UBLE_CLIC.
On a donc m=0 si aucune touche modificatrice n'est appuyée pendant le clic.
gr_clickr(b,x,y)
Identique à gr_click(b,x,y) mais x et y sont de type réel.
1
Cette touche est absente sur le clavier du Macintosh +.
© PrologIA
U 5 - 34
Manuel d'Utilisation Windows
s
gr_sensitive(x1,y1,x2,y2,p)
Définit le rectangle de coordonnées x1,y1,x2,y2 dans l'unité graphique courante f, comme zone sensible aux événements clic, à laquelle est attaché le prédicat p. Si p est un identificateur différent de nil et get_event, à chaque clic
à l'intérieur du rectangle le but p(f) sera lancé. Par défaut toutes les zones sont définies avec get_event et donc tous les clics dans l'unité sont envoyés dans la queue d'événements de Prolog. gr_sensitive(x,y,x',y',nil) permet d'ignorer les clics dans la zone définie.
Les différents rectangles définis doivent être disjoints. Dans le cas contraire, pour un clic dans la partie commune, le comportement n'est pas garanti. C'est une des zones qui le capte, mais on ne sait pas laquelle.
gr_getmouse(x,y) gr_getmouse(x,y,b)
Donne la position actuelle de la souris dans l'unité graphique courante en coordonnées entières relatives à l'origine de l'unité. b=0 si le(s) bouton(s) de la souris sont relevés au moment de l'appel, sinon le numéro du bouton pressé en commençant par la gauche pour une souris à plusieurs boutons (le premier bouton a le numéro 1).
gr_getmouser(x,y)
Identique à gr_getmouse(x,y) mais donne un résultat réel.
A!ociation
Prolog
HERITAGE
5.8. Primitives spéciales de saisie
5.8.1. Simulation de boutons
!
L'utilisation des deux primitives qui suivent nécessite le chargement préalable du module de dessin dessin.mo.
Elles permettent de simuler des boutons dans l'unité graphique courante.
gr_draw_buttons(b)
-
-
-
Dessine tous les boutons de la base de données dont l'identificateur d'accès est b. La base de données de boutons est construite par l'utilisateur. Il attribuera un nom de règle à chaque groupement de boutons. Les règles doivent avoir trois arguments: le rectangle dans lequel le bouton s'inscrit.
la chaîne affichée dans le bouton.
un terme à associer au bouton.
Par exemple les boutons suivants définis par l'utilisateur:
wtButton(<5,160>.<50,175>,"Edit",edit)->; wtButton(<5,180>.<50,195>,"Set",nil)->;
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 35 sont dessinés en lançant le but:
> gr_draw_buttons(wtButton);
gr_button_hit(b,<x,y>,t)
b est l'identificateur d'accès à la base de données de boutons. Cette règle s'efface si x,y sont les coordonnées d'un point à l'intérieur d'un des boutons de la base b. t est alors unifié avec le troisième argument de la règle pour le bouton concerné.
La primitive gr_click combinée avec gr_button_hit permet d'écrire facilement une boucle de scrutation des boutons.
5.8.2. Affichage de message avec validation
s
message_box(t,s,m,b,x)
Crée une fenêtre graphique modale pour afficher un message. Après saisie, la fenêtre est détruite et x est unifié avec le numéro du bouton de sortie. La fenêtre comporte:
- un titre donné par la chaîne de caractères s,
- une icone définie par l'identificateur t parmi les valeurs: :warning, :info,
:question, :wait, :error, dont le dessin dépend de l'environnement graphique de la machine
- un message donné par la chaîne de caractères m,
- une ligne de boutons (au plus 3) telle que: si b est un entier, il y aura b boutons dont les textes sont fonction de leur nombre et du type d'icone, et dépendent de l'environnement graphique de la machine.
si b est une liste de chaînes, chaque chaîne définit le texte d'un bouton. Ceci peut être sans effet sur certains environnements.
5.8.3. Saisie de texte
gr_editf(<s1,p1,p2>,r,s,k) gr_editf(<s1,p1,p2>,x1,y1,x2,y2,s,k)
Créent un rectangle d'édition dans l'unité graphique courante, qui doit être une fenêtre. Dans le cas contraire (drawing area), une erreur est générée.
La fin d'édition est provoquée par un retour chariot, un caractère de tabulation, ou un clic dans la fenêtre en dehors du rectangle d'édition et en dehors d'un objet. Si k n'est pas une variable, le rectangle et son texte sont seulement dessinés sans édition.
s1 est la chaîne qui sert à initialiser l'édition.
p1, p2 sont des entiers définissant les indices des caractères de début
(inclus) et de fin (non inclus) de la sélection dans le texte (représentée en vidéo inverse). Le premier indice est 0. Initialiser avec un champ vide correspond aux valeurs:<"",0,0>.
© PrologIA
U 5 - 36
Manuel d'Utilisation Windows
s
r s
définit la position du rectangle englobant. Le texte est cadré à gauche.
x1,y1,x2,y2
sont les coordonnées des coins supérieur gauche et inférieur droit du rectangle dans la fenêtre.
est la variable qui sera unifiée avec la chaîne éditée.
k
si k est une variable, celle-ci est unifiée en sortie avec le mode de terminaison:
0 si retour chariot,
1 si clic souris dans la fenêtre 1 en dehors du rectangle d'édition,
2 si caractère TAB.
Si k est une constante en entrée, sortie immédiate après affichage de la zone.
Une forme plus simple de la règle est également utilisable pour une chaîne initiale vide: gr_editf(<>,x1,y1,x2,y2,s,k)
Remarque : cette fonction peut également être réalisée avec les primitives de création et manipulation des objets editfield ou label.
!
get_key(c)
!
get_key(a,t,m)
get_key sert à prendre un caractère au vol. Il n'y a aucun écho de ce caractère dans aucune fenêtre que ce soit. Cette primitive permet donc de saisir un motde-passe. Le fonctionnement détaillé est donné dans la description de stty .
get_key(c) rend dans c un caractère.
get_key(a, t, m) rend trois entiers :
- dans a le code ascii étendu
- dans t le numéro de touche (virtual key code décrit dans Inside Macintosh vol. V p.192))
- dans m l'état des touches de modifications (voir la primitive gr_click)
!
stty(" USEGETKEY", t)
réglemente l'usage du prédicat get_key.
t = 0
A!ociation
Prolog
HERITAGE mode par défaut, dans lequel get_key échoue toujours. Les caractères tapés sont insérés dans les fenêtres texte le cas échéant. Dans ce mode, l'utilisateur peut éditer des fenêtres texte pendant que Prolog II+ travaille.
t < 0
1
On peut lire sa position avec gr_click(0,x,y).
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 37
get_key prendra un caractère qui ne peut être plus âgé que t ticks (1/60sec) avant l'appel. Echoue si, au moment de l'appel, aucun caractère n'est disponible, ou si le caractère est trop “vieux” .
t > 0
get_key attendra un caractère pendant au plus t ticks. Echouera si aucun caractère n'est disponible au bout de ce laps de temps. get_key n'attend pas que le délai soit écoulé pour réussir, si on lui fournit un caractère dans les temps. Un caractère peut avoir été tapé à l'avance. Ce mode permet de saisir un mot-de-passe en un temps donné.
Exemples :
> stty(" USEGETKEY", -60);
Le prochain appel à get_key échouera si aucun caractère non lu n'a été tapé moins d'une seconde avant cet appel (1 s = 60 ticks).
> stty(" USEGETKEY", 300);
Le prochain appel à get_key échouera si aucun caractère non lu ne peut être obtenu dans les cinq secondes suivant cet appel (1 s = 60 ticks). Le caractère peut avoir été tapé à l'avance. get_key réussira de suite après avoir obtenu le caractère sans attendre que le délai soit écoulé.
!
stty("FL USH")
Enlève tous les caractères de la queue d'événements. Ils ne sont plus disponibles pour get_key. (permet à get_key de saisir une réponse qui n'a pas
été tapée à l'avance.)
!
gtty(s, v)
Récupère la valeur d'un paramètre concernant le terminal : gtty(" USEGETKEY", v) rend 0 ou un nombre signé de ticks. gtty("TERM", x) rend actuellement "TTY" ou "MPW".
5.8.4. Boites de choix
gr_list(r, l, l_i, v_i, l_o, v_o, o) l r
La règle gr_list gère un choix d'élément(s) dans une liste. Cette liste s'affiche dans l'unité graphique courante, qui doit être une fenêtre. Dans le cas contraire
(drawing area), une erreur est générée.
Description des paramètres :
Le rectangle englobant (ascenseurs compris) de la forme
<x1,y1>.<x2,y2> ou <x1,y1,x2,y2>.
La liste d'items. Elle doit être une liste de constantes (éventuellement mixtes : chaîne, entier, réel, identificateur, <>).
l_i
Est la sélection initiale, sous la forme d'une liste éventuellement vide d'entiers qui sont les rangs (à partir de 1) dans l des éléments que l'on veut sélectionner.
© PrologIA
U 5 - 38
Manuel d'Utilisation Windows
s
v_i
C'est le rang de l'élément qui doit apparaître en première position en haut du rectangle.
l_o
Donne en sortie la liste des rangs des items sélectionnés (même convention que pour l_i).
v_o
Donne en sortie le rang du premier item visible dans le rectangle.
o
Décrit l'opération à réaliser parmi 4 possibles :
<0> Dessine seulement (pas de saisie possible).
<1,k> Dessine et prend la main jusqu'à ce qu'un événement de type frappe de caractère ou clic dans la fenêtre à l'extérieur de la liste ne se produise. NI LE CLIC, NI LE CARACTERE NE SONT L US.
Rend pour k :
0 : Retour Chariot tapé
1 : clic en dehors de la liste
<2,x,y,m>
2 : TAB tapé
Dessine la liste et traite le clic x,y,m (donné par exemple par gr_click(?,x,y,m) ). Sort tout de suite après.
<3,x,y,m,k>
Dessine, traite le clic x,y,m (donné par exemple par gr_click(?,x,y,m)) et prend la main jusqu'à ce qu'un événement de type clavier ou un clic dans la fenêtre à l'extérieur du rectangle se produise. Ni le clic ni le caractère ne sont lus.
Rend pour k :
0 : Retour Chariot tapé
1 : clic en dehors de la liste
2 : TAB tapé
On peut lire le clic de fin de sélection par gr_click(0,x,y).
Remarque : cette fonction peut également être réalisée avec les primitives de création et manipulation des objets listbox.
!
gr_popupItem(r,L,n1)
!
gr_popupItem(r,L,n1,n2)
Crée un champ à valeurs proposées.
L est une liste de constantes. r est le rectangle dans lequel est affiché l'item numéro n1 de la liste L. Si n2 est absent, l'item est simplement dessiné. Si n2 est présent, un menu présentant la liste des choix L vient recouvrir l'item, et l'inversion des champs est gérée tant que le bouton de la souris reste appuyé.
Lorsque le bouton est relaché, le champ sélectionné est dessiné dans le rectangle à la place du précédent, et n2 est unifié avec son numéro (n1 si aucun champ n'est sélectionné). Exemple: rendre la fenêtre graphique visible et taper dans la console l'exemple suivant :
> gr_popupItem(<20,20,120,40>, ["aa","bb","cc","dd",3,4], 2)
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 39
gr_click(1,x,y) gr_popupItem(<20,20,120,40>, ["aa","bb","cc","dd",3,4], 2, i);
Lorsque vous cliquez dans la fenêtre en maintenant le bouton appuyé :
3
4 a a bb cc dd
5.8.5. Choix de fichier
input(x) output(x)
C'est une facilité ajoutée aux primitives input et output, avec x variable libre au moment de l'appel. Cette facilité consiste à demander à l'utilisateur, le nom du fichier par une boite de dialogue. Ensuite le changement d'unité d'entrée ou de sortie est réalisé normalement (voir input output), avec ouverture éventuelle du fichier. En sortie, unifie x avec le nom complet du fichier. Il y a échec et aucune action réalisée si, dans le dialogue de sélection de fichier, le bouton
Annuler est cliqué.
s
sfgetfile(s) sfgetfile(s,Filter,NomInitial,Point)
Affiche une zone de dialogue permettant de visualiser, parmi les noms des fichiers se trouvant sur le(s) disque(s), ceux compatibles avec Filter et d'en sélectionner un.
Point est un point de format <x,y> indiquant l'endroit où est affiché le dialogue.
Ce dialogue comporte une liste de choix pour les fichiers proposés, et un champ d'édition initialisé avec la chaîne NomInitial.
s est unifié avec la sélection faite par l'utilisateur, il s'agit du nom complet du fichier (comprend le chemin d'accès et le nom selectionné). Le fichier n'est pas ouvert. La règle échoue si le bouton Annuler est pressé.
!
sfgetfile(Point,Ltypes,Filter,S)
Affiche une zone de dialogue permettant de visualiser, parmi les fichiers se trouvant sur le(s) disque(s), les noms de ceux dont le type est mentionné dans la liste Ltypes et d'en sélectionner un.
© PrologIA
U 5 - 40
Manuel d'Utilisation Windows
Point est un point de format <x,y> indiquant l'endroit où est affiché le dialogue.
Ltypes est une liste de types précisant les fichiers à proposer. Un type est une chaîne de 4 caractères tel que défini dans Inside Macintosh. Exemple:
"TEXT"."APPL".nil sélectionne tous les fichiers de type texte seul ou application.
Filter est une procédure de filtrage pour l'acceptation des fichiers sélectionnés.
Ce doit être nil pour l'instant.
S est unifié avec la sélection faite par l'utilisateur. Il est de la forme : <C,T,N> où C est le créateur (chaîne de 4 caractères), T est le type du fichier (chaîne de
4 caractères), et N est une chaîne indiquant le chemin d'accès et le nom du fichier sélectionné (le fichier n'est pas ouvert).
La règle échoue si le bouton Annuler est pressé.
sfputfile(s)
Affiche une zone de dialogue permettant de choisir un nom de fichier à créer.
Unifie s avec le nom avec chemin de ce fichier. Le fichier n'est pas ouvert. La règle échoue si le bouton Annuler est pressé.
!
sfputfile(Point,Prompt,NomInitial,s)
Affiche une zone de dialogue permettant à l'utilisateur de choisir un nom, un volume, et un répertoire pour un fichier.
Le nom du fichier se saisit au clavier dans une zone d'édition qui est initialisée avec la chaîne (éventuellement vide) NomInitial qui doit être un nom de fichier sans chemin.
Si l'utilisateur tape un nom de fichier déjà existant, une alerte le prévient. Le fichier n'est ni créé ni ouvert.
s est unifié avec le nom avec chemin validé par l'utilisateur.
Point est un point de format <x,y> indiquant l'endroit où est affiché le dialogue.
Prompt est une chaîne (éventuellement vide) contenant un message destiné à l'utilisateur, ajouté en tête du dialogue.
La règle échoue si le bouton Annuler est pressé.
A!ociation
Prolog
HERITAGE
5.8.6. Choix d'un noeud d'un arbre
gr_tree_click(a,l,n)
L'utilisation de cette primitive nécessite le chargement préalable du module de dessin dessin.mo
Dessine dans l'unité graphique courante l'arbre a, et attend que l'utilisateur clique sur un des noeuds de l'arbre. Lorsque ceci est fait, l est unifié avec le chemin conduisant au noeud, et n est unifié avec le noeud. Le chemin est la liste des numéros des fils à parcourir en partant de la racine. Par exemple, le noeud dd de l'arbre aa(bb,cc(ee(dd),ff)) est représenté par le chemin 2.1.1.nil.
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 41
5.9. Règles pour gérer des objets structurés
gendialog(D,l1,l2) gendialog(P,D,l1,l2)
L'utilisation de cette primitive nécessite le chargement préalable du module
obdialog.mo. Cette primitive donne à l'utilisateur un moyen trés rapide de créer des sources d'écrans graphiques, pouvant être ensuite intégrés à des applications.
P, D et l1 ont la même signification que dans la primitive gr_dialog décrite dans cette section.
Génère dans l2 une liste de buts permettant de créer l'écran de dialogue défini par D.
Exemple :
gendialog(<100,100>.3.nil,"Hello".buttonD,nil, b_uts) b_uts;
va unifier b_uts avec la liste des buts à effectuer pour la création de ce dialogue et ensuite effacer ces buts.
gr_dialog(D,l1,l2) gr_dialog(P,D,l1,l2)
-
-
L'utilisation de cette primitive nécessite le chargement préalable du module
obdialog.mo. Ce module contient le gestionnaire de dialogue Prolog II+ permettant de créer et activer les dialogues décrits par l'argument D.
Dans sa deuxième forme, la primitive gr_dialog accepte un argument
supplémentaire P, qui est une liste formée au choix par : un doublet d'entiers <x,y> pour déterminer la position du coin supérieur gauche du dialogue; un entier i pour choisir la fonte du texte du dialogue. i est comme précisé dans la primitive gr_font.
le terme :title(s) où s est une chaîne de caractères désignant le titre de la fenêtre de dialogue.
D est soit un arbre décrivant un dialogue, soit l'identificateur d'une règle unaire avec un tel arbre en argument. l1 est une liste (éventuellement vide) de paires
(nom_de_zone . valeur_initiale) cette liste est utilisée pour définir ou redéfinir le contenu des zones. En sortie, si l2 est une variable, elle est unifiée avec la liste des couples (nom_de_zone .
valeur_finale) du dialogue. Si l2 est une liste de paires (nom_de_zone . X), chaque paire est unifiée avec le couple correspondant.
Un dialogue est décrit avec des objets primitifs (zone de texte, zone d'édition, boutons, ...) et des primitives d'agencement en colonne ou en rangée. Ces primitives réalisent un ajustement dynamique de la taille des zones en fonction de leur contenu. Les zones dont la valeur peut être modifiée sont identifiées par un nom, ce qui permet de redéfinir leur valeur au moment de l'appel.
Exemple:
© PrologIA
U 5 - 42
Manuel d'Utilisation Windows
> load("obdialog.mo");
> gr_dialog("Hello".buttonD("OK"),nil,L);
A!ociation
Prolog
HERITAGE
> gr_dialog(
"Name:"
.editf(10,field1)
.buttonD("OK")
, (field1."John").nil, L);
Les primitives de description d'objet sont les suivantes:
:text(s) , :text(s,f), :text(s,f,c) ou s
Décrit une ligne de texte non éditable représenté par s où s est une chaîne.f désigne le numéro de fonte à la manière du prédicat gr_font, et
c la couleur du texte à la manière de l'attribut :foreground du prédicat
set_attribute.
:text(i)
Décrit une ligne de texte non éditable dont le nom de zone est i où i est un identificateur. Si une valeur est associée à i dans l1 c'est cette valeur qui est la valeur initiale du champ, sinon c'est la chaîne vide. Il n'est jamais associé de valeur finale à cette zone, puisqu'elle n'est pas modifiable.
:cb(i), :cb(i,v), :cb(i,v,s)
Décrit une boîte, dont le nom de zone est i, de type choix oui/non qui sont représentés respectivement par les deux valeurs possibles de v: 1/0.
Si la valeur de v n'est fournie ni en argument, ni dans la liste l1, c'est la valeur 0 qui est donnée par défaut. Lorsque v est redéfini dans l1, c'est toujours cette dernière valeur qui est prise en compte. s est une chaîne qui définit le texte qui accompagne la boite.
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 43
:rb(<g,i>), :rb(<g,i>,v), :rb(<g,i>,v,s)
Décrit un radio-bouton i d'un groupe g (où g est un identificateur, et i une constante quelconque). Ce radio-bouton de valeur 0/1, fait partie du groupe g, avec au plus une valeur possible à 1 dans le groupe. Si la valeur de v n'est fournie ni en argument, ni dans la liste l1, c'est la valeur
0 qui est prise par défaut. Lorsque v est redéfini dans l1, c'est toujours cette dernière valeur qui est prise en compte. s est une chaîne qui définit le texte qui accompagne le radio-bouton. En sortie, nom_de_zone est représenté par g(i), et valeur_finale par 0 ou 1, et ceci pour chacun des radio-boutons du groupe.
:rb1(<g,i>), :rb1(<g,i>,v), :rb1(<g,i>,v,s)
Sensiblement identique à rb mais avec la contrainte que les éléments du groupe ne peuvent être tous à zéro. Seul l'élément ayant la valeur 1 figure dans la liste de sortie. nom_de_zone est alors représenté par g, et
valeur_finale par i. Ce format de sortie est donc différent et plus simple que celui fourni par rb.
:editf(n,i), :editf(n,i,s)
Décrit une zone d'une ligne de texte éditable de nom i, où i est un identificateur. s représente la valeur initiale de la zone d'édition. Cette valeur initiale est la chaîne vide si elle n'est spécifiée ni en argument, ni dans la liste l1. n est un entier représentant le nombre minimum de caractères de la zone. Si s est plus grand, la zone est dynamiquement expansée.
:button(s,i)
Décrit un bouton avec le label s auquel est associé l'action i. Lorsque le bouton est pressé, une action est réalisée:
- Si i est fail, le dialogue est terminé, et gr_dialog échoue.
- Si i est nil, rien n'est fait.
- Sinon, le but i(l) est activé, l étant la liste des paires nom.valeur des zones du dialogue au moment où le bouton est cliqué.
Lorsque le but i a été exécuté, la gestion du dialogue reprend en l'état.
Pour arrêter le dialogue en cours, l'utilisateur peut programmer dans i un block_exit(<fail,L>) qui provoquera un backtracking de gr_dialog, ou un block_exit(<nil,L>) qui conduira à une terminaison normale, l2
étant construite à partir de la liste des couples nom.valeur indiquée par
L.
:button2(s,i)
Cet item a le même comportement que l'item :button, mais cette fois-ci la règle i est appelée avec deux arguments. Le premier est une liste décrivant l'état des items du dialogue. Le deuxième est à l'appel une variable qui doit être instanciée par la règle i/2 avec la liste des items dont la valeur est modifiée. Cette règle est écrite par l'utilisateur, et permet donc d'attacher une sémantique quelconque aux boutons. La règle définit une relation entre le premier argument (argument d'entrée représentant la liste des valeurs actuelles), et le deuxième argument
(argument de sortie représentant la liste des nouvelles valeurs).
© PrologIA
U 5 - 44
Manuel d'Utilisation Windows
:buttonD, :buttonD(s), :buttonD(s,i)
Décrit un bouton de terminaison de dialogue avec le label s auquel est associé l'action i. Usuellement s est la chaîne "OK", et i est nil. Ce bouton est activable par un clic ou par la frappe d'un Retour Chariot.
:glist(Lignes,Colonnes,Identificateur,ListeValeurs)
Définit un item de type liste de valeurs avec barre de défilement. La signification des arguments est :
Lignes
Entier représentant le nombre d'items devant être visibles. La hauteur du rectangle est calculée automatiquement en fonction de ce paramètre.
Colonnes
Entier représentant le nombre de caractères devant être visible pour un item. La largeur du rectangle est calculée automatiquement en fonction de ce paramètre.
Identificateur
Identificateur servant à donner un nom interne au gestionnaire. Il est utilisé pour donner le résultat en sortie.
ListeValeurs
Liste quelconque de constantes (chaînes, identificateurs, nombres) qui représente la liste des valeurs présentées, ou bien un triplet décrivant l'état initial du gestionnaire. Ce triplet doit alors avoir la forme :
<ListeValeurs, ListeDesNoSelectionnés, NoEnHaut>
Le premier argument est une liste quelconque de constantes (chaînes, identificateurs, nombres).
Le deuxième argument est la liste ordonnée des numéros d'ordre des items composant la sélection initiale. Cette liste peut comporter 0 (pas de sélection), 1, ou plusieurs éléments.
Le troisième argument indique le numéro de l'item à présenter en haut du rectangle d'affichage.
En sortie, donc dans l2, le résultat est donné sous la forme habituelle d'un couple :
(identificateur.listeDesItemsSélectionnés)
Tandis que dans la représentation interne, l'état du gestionnaire est désigné par le triplet décrit ci-dessus. C'est sous cette forme que doit
être manipulée la valeur de la glist dans les programmes liés aux boutons. C'est à dire c'est le couple (identificateur . < ListeValeurs,
ListeDesNoSelectionnés, NoEnHaut >) qui doit apparaître dans les listes manipulées par ces programmes.
Les primitives d'agencement sont basées sur la notion de combinaison de rectangles: mettre deux rectangles en colonne définit un nouveau rectangle englobant les deux autres.
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 45
:col(l) ou l
Décrit une colonne alignée à gauche, dont le contenu est décrit par l. Si l est une séquence, la primitive calcule la taille de chaque élément de la séquence, et constitue une colonne d'éléments disposés les uns au dessus des autres, et alignés sur leur côté gauche.
:ccol(l)
Décrit une colonne centrée verticalement, dont le contenu est décrit par la séquence l.
:row(l)
Décrit une rangée horizontale décrite par la (séquence de) primitive(s) l, et dont les éléments sont alignés sur leur bord supérieur: si l est une séquence, la primitive calcule la taille de chaque élément de la séquence, et constitue une rangée d'éléments disposés côte à côte alignés sur leur bord supérieur.
:crow(l)
Décrit une rangée d'objets décrits par l et centrés horizontalement, c'est à dire disposés de manière à ce que leurs points médians soient tous alignés sur une même horizontale.
:vfill(n)
Décrit un espacement vertical de n pixels, où n est un entier.
:hfill(n)
Décrit un espacement horizontal de n pixels, où n est un entier.
La primitive de groupement suivante permet de gérer l'activation ou la désactivation de zones entières pendant la saisie du dialogue.
:group(identificateur.valeur,DescriptionDesItems)
Permet d'associer un identificateur à un ensemble d'items regroupés géographiquement et sémantiquement. valeur indique si le groupe est actif ou non (0 pour inactif, 1 pour actif). Lorsque le groupe est inactif, il est dessiné en grisé et l'état de ses items ne peut être modifié. L'état d'un groupe ne peut être modifié dans la version actuelle que par les actions associées aux boutons. L'état d'un groupe n'est pas donné dans la liste de sortie, il est par contre fourni, dans la liste des états passée aux boutons, sous la forme d'un couple :
(identificateur.valeur)
Exemples:
> gr_dialog( ccol("Voulez-vous recommencer le test?"
.buttonD
.button("Annuler",fail))
, nil
, L);
© PrologIA
U 5 - 46
Manuel d'Utilisation Windows
> gr_dialog( "Choose the color you want"
.crow( rb(rb_1(red),1,"Red").
rb(rb_1(green),0,"Green"))
.crow( cb(cb_1,0,"Extended colors"))
.ccol( buttonD("Show Color")
.button("Cancel",fail)
)
, (cb_1.1).nil
, (cb_1.C).(rb_1(red).R).(rb_1(green).G).nil );
A!ociation
Prolog
HERITAGE
{C=1, R=1, G=0}
> gr_dialog( :crow( "abcdefgh"
.:ccol( :button("Stop",fail)
.:buttonD("OK",nil)
.:button("Cancel",fail)
."HELLO WORLD"
)
."ijklmnopq"
)
, nil,l);
> gr_dialog( glist( 5, 10, list1
, < [rouge,vert,bleu,jaune
,violet,noir,blanc,orange]
, [4,6]
, 2
© PrologIA
A!ociation
Prolog
HERITAGE
>)
.buttonD
, nil
, L);
{L=(list1.jaune.noir.nil).nil}
Primitives graphiques
U 5 - 47
> insert;
enable( l1, l3 ) ->
set_item(l1, zone1, 1, l2)
set_item(l2, zone2, 0, l3); disable( l1, l3 ) ->
set_item(l1, zone1, 0, l2)
set_item(l2, zone2, 1, l3); set_item( nil, i, b, nil ) -> block_exit(816, "set_item, absent: ".i); set_item( (i._).l, i, b, (i.b).l ) -> ! ; set_item(e.l, i, b, e.l' ) -> set_item( l, i, b, l' ) ;;
{}
> gr_dialog( group(zone1.0, "Hello"
.crow(rb1(color(red),0,"Red"))
.crow(rb1(color(green),1,"Green"))
.editf(5,ed1,"aa")
.button2("Disable",disable)
)
.group(zone2.1, button2("Enable",enable))
.buttonD
, nil
, L);
© PrologIA
U 5 - 48
Manuel d'Utilisation Windows
{L=(color.green).(ed1."aa").nil}
5.10. Envoi d'événements à Prolog depuis un objet externe
Nous appellerons "objet externe", tout objet graphique créé d'une autre manière que par l'appel des prédicats graphiques. Cela peut être fait durant l'appel à un prédicat externe ou bien dans le programme principal avant de démarrer Prolog, par exemple en chargeant un objet décrit dans un fichier de ressources généré par un outil externe (par exemple Dialog Editor sous Windows).
La possibilité qui est offerte ici, est de faire communiquer cet objet avec Prolog, en utilisant le principe des événements.
par l'intermédiaire de l'appel à une fonction C:
send_external_event(no,str,bool,int1,int2)
envoie un événement à Prolog.
Les deux modes de gestion de l'événement sont possibles: traiter l'événement immédiatement, ou bien le mettre dans la queue d'événements.
La signification des arguments est la suivante:
bool, qui est de type int, à valeur booléenne, indique le mode de traitement désiré:
- si bool est non nul, on désire traiter l'événement immédiatement, et dans ce cas:
str, qui est de type char *, représente le but Prolog à appeler,
no, int1, int2, sont ignorés.
- si bool vaut 0, on veut poster l'événement dans la queue de Prolog et dans ce cas:
no, qui est de type int, pourra servir à identifier l'objet,
© PrologIA
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Primitives graphiques
U 5 - 49
int1, int2, qui sont de type int, et str ont des valeurs dont les significations sont laissées libres à l'utilisateur.
Cet évenement sera accessible par les prédicats de lecture d'événements:
get_event(b, e, o) et peek_event(b, e, o) où :
o sera unifié avec no,
e sera unifié avec le terme Prolog :extern_event(str, int1, int2)
© PrologIA
U 5 - 50
Manuel d'Utilisation Windows
A!ociation
Prolog
HERITAGE
© PrologIA
A!ociation
Prolog
HERITAGE
/ R 1 - 23
/ R 10 - 3
// R 10 - 3; 7
/\ R 1 - 23
/\ R 4 - 6
/\ R 10 - 2
:- R 10 - 2
< R 1 - 23
< R 10 - 2; 7
<< R 1 - 23
<< R 4 - 6
<< R 10 - 3
= R 10 - 2; 3
=.. R 10 - 2; 8
=:= R 1 - 23
=:= R 10 - 2; 7
=< R 1 - 23
^ R 1 - 23
^ R 2 - 4
~ R 4 - 6
^ R 10 - 3
* R 1 - 23
* R 10 - 3
** R 1 - 23
** R 4 - 6
** R 10 - 3
+ R 1 - 23
+ R 10 - 2; 3
, R 10 - 2; 3
- R 1 - 23
- R 10 - 2; 3
--> R 10 - 2
-> R 10 - 2; 3
Index
© PrologIA
=< R 10 - 2; 7
== R 10 - 2; 11
=\= R 4 - 4
=\= R 10 - 23; 2; 7
> R 1 - 23
> R 10 - 2; 7
>= R 1 - 23
>= R 10 - 2; 7
>> R 1 - 23
>> R 4 - 6
>> R 10 - 3
?- R 10 - 2
@< R 10 - 2; 12
@=< R 10 - 2; 12
@> R 10 - 2; 12
@>= R 10 - 2; 12 abolish R 10 - 5 abs R 4 - 5 activity U 5 - 17 add R 4 - 4 add_implicit R 3 - 12 add_sentence_terminator R 5 - 7 add_stdmenu U 5 - 22 add_tlv R 2 - 14 alias R 10 - 13 alloc R 6 - 23 append R 5 - 2 arg R 4 - 11 arg R 10 - 8 arg2 R 4 - 10 assert R 2 - 11; 12 assert R 3 - 21 assert R 10 - 5
I - 2
Index Prolog II+ Windows
assert U 2 - 7 assert'' R 3 - 22 asserta R 3 - 21 asserta R 10 - 5 assertn R 3 - 22 assertz R 3 - 22 assertz R 10 - 5 assign R 4 - 7 assign U 2 - 7 at R 10 - 14 atan R 4 - 6 atom R 10 - 6 atomic R 10 - 6 atom_chars R 10 - 8 atom_codes R 10 - 9 atom_concat R 10 - 9 atom_length R 10 - 9 attachement U 5 - 3 at_end_of_stream R 10 - 15 background U 5 - 17 backtrack_term R 4 - 8 bagof R 2 - 4 beep R 5 - 9 binary R 5 - 1 block R 2 - 4; 5 block U 2 - 7 block_exit R 2 - 4; 5 block_exit R 6 - 11 block_exit U 2 - 8 bottom_attach U 5 - 13 bottom_right U 5 - 17 bound R 2 - 6 bound R 4 - 2 bounded R 10 - 19 buttonD U 5 - 14 call R 10 - 4 callC R 7 - 26
© PrologIA callpro.def U 1 - 6 callpro.h U 1 - 6 callprol.lib U 1 - 6 callpros.lib U 1 - 6 cassign R 4 - 7 catch R 10 - 4 ceiling R 4 - 5 char U 5 - 20 chars_nb U 5 - 15
CHAR_ARRAY
R 7 - 18; 21 char_code R 4 - 9 char_conversion R 10 - 19 check button U 5 - 4 check_button U 5 - 17 check_item U 5 - 24 chrono R 6 - 4 clause R 10 - 5 clear_events U 5 - 21 clear_input R 5 - 8 clear_menubar U 5 - 21 clear_window U 5 - 10 click U 5 - 20 click_down U 5 - 20 click_up U 5 - 20 close R 10 - 13 close_context_dictionary R 3 - 12 close_input R 5 - 8 close_output R 5 - 13 code R 6 - 25; 26 command_menu U 5 - 24 compound R 10 - 6 conc_list_string R 4 - 11 conc_string R 4 - 10
ConnectDescriptors R 8 - 10
ConnectInString R 8 - 10
ConnectOutString R 8 - 10 console R 5 - 1
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE consult R 10 - 5 copy_term R 4 - 11 copy_term_with_constraints R 4 - 11 cos R 4 - 6 coupure “!” R 2 - 2 cpu_time R 6 - 4 create_window U 5 - 9 cross U 5 - 17 current_context R 3 - 12 current_file R 5 - 2 current_input R 10 - 15 current_op R 10 - 3 current_output R 10 - 17 current_predicate R 3 - 22 current_prolog_flag R 10 - 20 cursor U 5 - 17 customColor U 5 - 18 customiz.dll U 1 - 3 customiz.dll U 3 - 2 customiz.dl_ U 1 - 3 customiz.dl_ U 3 - 3
C_FUNCTION
R 7 - 18; 23
C_FUNCTION_BACKTRACK
R 7 - 18; 23
C_FUNCTION_BACKTRACK_PROTECTE
D
R 7 - 18; 23
C_FUNCTION_PROTECTED
R 7 - 18; 23 date R 6 - 4 date_string R 6 - 4 date_stringF R 6 - 4 dbgbase.mo R 2 - 6 dbgbase.mo U 1 - 4 dbgedin.mo R 2 - 6 dbgedin.mo U 1 - 4 dbggraph.mo R 2 - 6 dbggraph.mo U 1 - 4 dde.mo U 1 - 3 ddeAcceptClient U 4 - 12
© PrologIA
Index Prolog II+ Windows
ddeCbClientRequest U 4 - 13 ddeCbClientWantsServer U 4 - 12 ddeCbServerClosing U 4 - 10 ddeCbServerUpdate U 4 - 10 ddeCleanup U 4 - 8 ddeDeclareAsClient U 4 - 9 ddeDeclareAsServer U 4 - 11 ddeEndConversation U 4 - 9; 12 ddeExecute U 4 - 10 ddeHotLinkData U 4 - 9 ddePokeData U 4 - 10 ddePublishExternalEvent U 4 - 4 ddeRememberDatabase U 4 - 8 ddeRequestData U 4 - 9 ddeTransmitData U 4 - 12 ddeTransmitRequest U 4 - 9 ddeWarmLinkData U 4 - 9 debug R 3 - 25 debug R 6 - 17; 24 debug R 10 - 19 default R 2 - 8 default U 5 - 17 def_array R 4 - 8 delay R 6 - 4 descripteur R 7 - 18
Dessin R 5 - 14 dessin.m2 R 5 - 14 dessin.m2 U 1 - 3 dessin.mo U 1 - 3 dictionary R 3 - 13 dictionary R 3 - 25 dictionary R 6 - 25; 26 dif R 2 - 7
DIRECT_C_FUNCTION
R 7 - 18; 26 discontiguous R 3 - 23 discontiguous R 3 - 28
DISTANCE
U 5 - 8
I - 3
I - 4
Index Prolog II+ Windows
distance U 5 - 8 div R 4 - 4 dot R 4 - 1 double R 4 - 1; 5
DOUBLE_ARRAY
R 7 - 18; 21 double_quotes R 10 - 19
Drawing area U 5 - 4 drawing_area U 5 - 17 draw_equ R 5 - 11 draw_mode R 5 - 12 draw_tree R 5 - 12 dynamic R 3 - 23 echo R 5 - 13 edinburg.mo R 6 - 24 edinburg.mo U 1 - 3; 4; 8 edinburg.mo U 2 - 5 edinburgh R 6 - 24
EDIT
U 5 - 3; 7 edit R 3 - 27 edit R 6 - 3; 4 edit U 5 - 7; 17
Editfield U 5 - 4 editm R 3 - 14; 27 editm R 6 - 3 edit_area R 5 - 2 edit_field U 5 - 17 enable_menu U 5 - 25 end_module R 3 - 15 end_of_file R 10 - 15; 16 end_of_stream R 10 - 14 end_screen U 5 - 6 ensure_loaded R 3 - 23 enum R 4 - 12 eof R 5 - 3 eof_action R 10 - 13; 14 eof_code R 10 - 13 eol R 5 - 3
© PrologIA eq R 2 - 8 eql R 4 - 4 equations R 2 - 12 equations R 3 - 22 err.txt R 6 - 5 err.txt U 1 - 2 err.txt U 2 - 10 err.txt. U 1 - 8
ERROR
R 8 - 2 error R 10 - 13 exit R 3 - 34 exit R 6 - 1 exit U 2 - 2 exp R 4 - 6 extern_event U 5 - 21; 49 fail R 2 - 8 fail_if R 10 - 4 fasserta R 3 - 23 fassertz R 3 - 23 fgetargtype R 7 - 3 fgetdouble R 7 - 5 fgetinteger R 7 - 5 fgetmaxstring R 7 - 5 fgetreal R 7 - 5 fgetstring R 7 - 5 fgetstrterm R 7 - 9 fgetterm R 7 - 17 file_dictionary R 3 - 13 file_name R 10 - 13 file_window U 5 - 10 findall R 2 - 8 find_pattern R 4 - 10 float R 4 - 5 float R 10 - 6 floor R 4 - 5 flush R 5 - 9 flush_output R 10 - 17
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE focus U 5 - 18 focus_in U 5 - 21 focus_out U 5 - 21
FONT
U 5 - 8 font U 5 - 8; 18 fontheight U 5 - 17 fonts.all U 5 - 28 fonts.usr U 1 - 2 fonts.usr U 5 - 28
FONTSIZE
U 5 - 8 fontsize U 5 - 8 force R 10 - 13 foreground U 5 - 18 fprefixlimit R 7 - 15 fprosymbol R 7 - 15 fputdouble R 7 - 7 fputinteger R 7 - 7 fputreal R 7 - 7 fputstring R 7 - 7 fputstrterm R 7 - 9 fputterm R 7 - 17
FRAMEPANEL
U 5 - 3; 7 framepanel U 5 - 7; 17 free R 2 - 8 free R 4 - 2 freeze R 2 - 10 freplace R 3 - 24 fresetpermanentsymbol R 7 - 16 fretract R 3 - 24 fretractall R 3 - 24 front_window U 5 - 10 fr_err.txt U 1 - 3 fsetpermanentsymbol R 7 - 16 fsymbolstring R 7 - 15 functor R 10 - 9 gc R 6 - 25 gendialog U 5 - 41
© PrologIA
Index Prolog II+ Windows
gensymbol R 4 - 12 get R 10 - 15 get0 R 10 - 16 getenv R 6 - 5 get_arg_type R 7 - 3 get_attribute U 5 - 17 get_byte R 10 - 15 get_char R 10 - 15 get_code R 10 - 16 get_double R 7 - 5 get_error_complement R 8 - 11 get_event U 5 - 13 get_event U 5 - 20 get_formats R 8 - 8; 9 get_integer R 7 - 5 get_key U 5 - 36 get_local_object U 5 - 20 get_max_string R 7 - 5 get_objects U 5 - 20 get_option R 6 - 24 get_real R 7 - 5 get_screen U 5 - 6 get_string R 7 - 5 get_strterm R 7 - 9 get_term R 7 - 16 get_tlv R 2 - 15 get_window U 5 - 10 graphic.mo U 1 - 3; 4 graphic.mo U 5 - 6
GRAPHICS
U 5 - 3; 8 graphics U 5 - 8; 17 graphic_area R 5 - 2 graphic_system U 5 - 6 graphstr.mo U 1 - 3 group U 5 - 17 gr_arc U 5 - 31 gr_arc' U 5 - 32
I - 5
I - 6
Index Prolog II+ Windows
gr_button_hit U 5 - 35 gr_choosecolor U 5 - 26 gr_click U 5 - 33 gr_clickr U 5 - 34 gr_color U 5 - 25 gr_color1 U 5 - 25 gr_color2 U 5 - 25 gr_color3 U 5 - 25 gr_dialog U 1 - 3 gr_dialog U 5 - 41 gr_draw_buttons U 5 - 34 gr_editf U 5 - 35 gr_erase U 5 - 29 gr_font U 5 - 28 gr_getmouse U 5 - 34 gr_getmouser U 5 - 34 gr_getorigin U 5 - 29 gr_get_mode U 5 - 28 gr_get_pen U 5 - 27 gr_icon U 5 - 32 gr_line U 5 - 29 gr_lineto U 5 - 29 gr_list U 5 - 37 gr_load U 5 - 32 gr_mode U 5 - 27 gr_move U 5 - 29 gr_moveto U 5 - 29 gr_pen U 5 - 26 gr_penloc U 5 - 29 gr_penlocr U 5 - 29 gr_polygon U 5 - 30 gr_popupItem U 5 - 38 gr_print U 5 - 11 gr_rect U 5 - 29 gr_sensitive U 5 - 34 gr_setorigin U 5 - 29 gr_stringwidth U 5 - 27
© PrologIA gr_text U 5 - 28 gr_tree_click U 5 - 41 gr_window U 5 - 10 gr_window_is U 5 - 10 gtty U 5 - 37 halt R 10 - 20 heap R 6 - 26 hidden R 3 - 25 hidden_debug R 3 - 25 hidden_rule R 3 - 25 hscroll U 5 - 15; 16 ident R 4 - 1 if R 4 - 5 ignore_ops R 10 - 19 in R 2 - 11 in R 5 - 4 include R 3 - 25 index R 3 - 21; 32 indexation R 3 - 21 inf R 4 - 4 infe R 4 - 5 infinite R 2 - 11 infinite_flag R 6 - 12 initial.po R 3 - 4 initial.po U 1 - 3; 8 initial.po U 2 - 2; 4 initialization R 3 - 27
InitializeProlog U 3 - 4 init_fassert R 3 - 26 init_screen U 5 - 6 ini_module R 3 - 15; 17 ini_module R 6 - 1 inl R 5 - 4 input R 5 - 8 input R 6 - 5 input R 10 - 13 input U 5 - 39
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE input_is R 5 - 8 insert R 3 - 27; 28 insert R 6 - 5 insert U 2 - 7 insertz R 3 - 27; 28 integer R 4 - 1 integer_rounding_function R 10 - 19
Interruption R 2 - 6 interruption R 9 - 1
INT_ARRAY
R 7 - 18; 21 int_edit.mo U 1 - 4 int_edit.mo U 5 - 6 in_char R 5 - 3 in_char' R 5 - 4 in_double R 5 - 5 in_ident R 5 - 6 in_integer R 5 - 5 in_real R 5 - 5 in_sentence R 5 - 6 in_string R 5 - 5 in_word R 5 - 6 is R 10 - 2; 7 is_array R 4 - 9 is_uncompiled R 3 - 28 items U 5 - 19 items_nb U 5 - 17 keysort R 4 - 16 kill_array R 4 - 9 kill_array R 7 - 18 kill_array U 2 - 8 kill_goal R 8 - 3 kill_module R 3 - 32 kill_module R 7 - 18 kill_module U 2 - 8 kill_object U 5 - 14 kill_window U 5 - 10
Label U 5 - 4
© PrologIA
Index Prolog II+ Windows
label U 5 - 17 left U 5 - 15 left_attach U 5 - 13 lg_buffer R 10 - 13 line R 5 - 11 line_width R 5 - 13 list R 3 - 14; 28; 29
Listbox U 5 - 5 listbox U 5 - 17 listing R 10 - 6 list_of R 2 - 8 list_string R 4 - 12 list_tuple R 4 - 12 lkload R 6 - 5 lkload R 7 - 27 ln R 4 - 6 load R 3 - 32 load R 6 - 5 load U 2 - 8 log R 10 - 7 max_arity R 10 - 19 member R 4 - 12 memory_file R 5 - 1 memory_file R 5 - 2 message_box U 5 - 35 mod R 1 - 23 mod R 4 - 4 mod R 10 - 2
MODAL
U 5 - 8 modal U 5 - 8 mode R 10 - 13 module R 3 - 15 module U 2 - 7 month R 6 - 4
"
MPW
" U 5 - 37 ms_err R 6 - 5 mul R 4 - 4
I - 7
I - 8
Index Prolog II+ Windows
multifile R 3 - 28 multifile R 3 - 29 multiple U 5 - 15 name R 10 - 9 new_check_button U 5 - 14 new_drawing_area U 5 - 14 new_edit_field U 5 - 15 new_goal R 8 - 3 new_label U 5 - 15 new_listbox U 5 - 15 new_pattern R 8 - 8 new_popup_menu U 5 - 16 new_pulldown_menu U 5 - 16 new_push_button U 5 - 14 new_radio_button U 5 - 14 new_scrollbar U 5 - 16 new_tlv R 2 - 14 new_window U 5 - 7 next_char R 5 - 4 next_char' R 5 - 4 next_solution R 8 - 3 nl R 10 - 17 nonvar R 10 - 6 not R 2 - 9 not R 10 - 14 not_defined R 3 - 29 no_border U 5 - 14; 15 no_debug R 6 - 18 no_echo R 5 - 14
NO_GOAL
R 8 - 2 no_index R 3 - 33 no_infinite R 2 - 11 no_paper R 5 - 11
NO_RESIZE
U 5 - 8 no_resize U 5 - 8 no_spy R 6 - 8; 18; 20 no_trace R 6 - 7; 18
© PrologIA number R 10 - 6 numbervars R 10 - 19 number_chars R 10 - 10 number_codes R 10 - 10 obdialog.mo U 1 - 3
OFFSET_ZERO_BASED
R 7 - 18 omodule R 3 - 16 once R 10 - 4 op R 5 - 15 open R 10 - 13 opérateurs R 1 - 15; 22 opérateurs R 5 - 15 optimisations R 2 - 5; 11 optimisations R 3 - 20 optimisations R 4 - 3; 7; 8 optimisations R 6 - 6 option fermeture U 5 - 11 or R 2 - 9 out R 5 - 9 outl R 5 - 9 outm R 5 - 10 outml R 5 - 10 output R 5 - 13 output R 10 - 13 output U 5 - 39 output_is R 5 - 13 out_equ R 5 - 11 page R 5 - 11 paper R 5 - 11 paper U 2 - 9 parent U 5 - 3 parent U 5 - 17 past R 10 - 14 peek_byte R 10 - 16 peek_char R 10 - 16 peek_code R 10 - 16 peek_event U 5 - 21
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE phrase R 10 - 10 point d'arrêt R 6 - 7
Popup menu U 5 - 5 popup_menu U 5 - 17 position R 10 - 13 predefined R 3 - 29 predicate U 5 - 18 prefix_limit R 3 - 7 prefix_limit R 7 - 15 princip.c R 8 - 8 princip.c U 1 - 4 princip.c U 3 - 4 princip.obj U 1 - 4 print_window U 5 - 11
PROEDIT.PRO
R 6 - 3 proentry.c U 1 - 4 proentry.c U 3 - 4 proentry.obj U 1 - 4 proext.h R 7 - 18 proext.h U 1 - 4
ProFinal R 8 - 3; 5
ProFinal U 3 - 4 prolink R 7 - 19 prolink.bat U 1 - 5 prolink.bat U 2 - 12 prolog U 5 - 21 prolog.def U 1 - 5 prolog.def U 3 - 3 prolog.exe U 1 - 3 prolog.lib U 1 - 5 prolog.log U 2 - 9 prolog.po R 6 - 1 prolog.po U 2 - 2; 11 prolog.res U 1 - 5 prolog2.pre U 1 - 4 prolog2.pre U 2 - 4
PrologDir2 U 1 - 4; 8
© PrologIA
Index Prolog II+ Windows
PrologDir2 U 2 - 2; 9
PrologEdit U 1 - 4; 8
PrologEdit U 5 - 6 prologII R 6 - 24 prologIIE R 6 - 24
ProStart R 8 - 3; 5
ProStart U 3 - 4 protected U 5 - 18 prouser.c R 4 - 10 prouser.c U 1 - 5 prouser.c U 2 - 12 prouser.c U 3 - 3 prouser.obj U 1 - 5
PRO_BIND
R 7 - 19 pro_signal R 9 - 3 pro_symbol R 7 - 15
Pulldown menu U 5 - 5 pulldown_menu U 5 - 17
Push button U 5 - 4 push_button U 5 - 17 put R 10 - 18 put_byte R 10 - 18 put_char R 10 - 18 put_code R 10 - 18 put_double R 7 - 7 put_integer R 7 - 7 put_real R 7 - 7 put_string R 7 - 7 put_strterm R 7 - 9 put_term R 7 - 16 quit R 6 - 1 quit U 2 - 2 quoted R 10 - 19 rad R 4 - 6
Radio button U 5 - 4 radio_button U 5 - 17 rank U 5 - 18
I - 9
I - 10
Index Prolog II+ Windows
read R 5 - 2 read R 10 - 16 read_line R 10 - 16 read_rule R 5 - 7 read_term R 10 - 16 read_unit R 5 - 7 real R 4 - 1 realloc R 6 - 25; 26 reconsult R 10 - 5 redef_array R 4 - 9 reinsert R 3 - 27; 28 reload R 3 - 33 reload U 2 - 8 rem R 1 - 23 rem R 4 - 4 rem R 10 - 2 remove_implicit R 3 - 12 remove_sentence_terminator R 5 - 7 repeat R 2 - 9 reposition R 10 - 13; 14 reset R 10 - 13 reset_chrono R 6 - 4 reset_cpu_time R 6 - 4 reset_permanent_symbol R 6 - 26 reset_permanent_symbol R 7 - 16 reset_window U 5 - 11 restore_C_backtrack_data R 7 - 23 restore_menubar U 5 - 22 restore_sysmenus U 5 - 22 retract R 3 - 31 retract R 10 - 6 retractall R 10 - 6 right U 5 - 15 right_attach U 5 - 13 round R 4 - 5 rule R 3 - 25; 30 rule_nb R 3 - 31
© PrologIA
SAVE
U 5 - 9 save R 3 - 33 save U 2 - 8 save U 5 - 9; 14 save_menubar U 5 - 22 save_state R 3 - 34 save_window U 5 - 11
Scrollbar U 5 - 5 scrollbar U 5 - 17 scrollb_page U 5 - 19 scrollb_pos U 5 - 19 scrollb_range U 5 - 19 scrollb_step U 5 - 20 see R 10 - 17 seeing R 10 - 17 seen R 10 - 17 selected_items U 5 - 19 send_external_event U 5 - 48 send_prolog_interrupt R 9 - 3 setarg R 4 - 12 setof R 2 - 9 set_alias R 1 - 29 set_attribute U 5 - 17 set_context R 3 - 11 set_cursor R 5 - 11 set_draw_mode R 5 - 12 set_import_dir R 6 - 5 set_input R 10 - 17 set_line_cursor R 5 - 11 set_line_width R 5 - 13 set_menu U 5 - 22 set_options R 6 - 24 set_output R 10 - 18 set_permanent_symbol R 6 - 26 set_permanent_symbol R 7 - 15; 21 set_prefix_limit R 3 - 7 set_prolog_flag R 10 - 20
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE set_stream_position R 10 - 13 set_tlv R 2 - 15 set_window U 5 - 11 sfgetfile U 5 - 39; 40 sfputfile U 5 - 40
SHAPE
U 5 - 8 shape U 5 - 8 show_spy R 6 - 8; 17; 18 sign R 4 - 5 sin R 4 - 6 singleton R 3 - 27 singletons R 10 - 17
SINGLE_FLOAT_ARRAY
R 7 - 18; 21
SOLUTION_EXISTS
R 8 - 2 sort R 4 - 16 split R 4 - 13 sprintf R 5 - 11 sprintf R 7 - 27 spy R 6 - 8; 18; 20 sqrt R 4 - 6 sscanf R 5 - 8 sscanf R 7 - 27 stack R 6 - 26 stacks R 6 - 25
StartPrologMainGoal U 3 - 4 state R 6 - 24 state U 5 - 18; 19 statistics R 6 - 24 store_C_backtrack_data R 7 - 23 stream_property R 10 - 13 string R 4 - 1
STRING_ARRAY
R 7 - 18; 21 string_double R 4 - 13 string_ident R 3 - 4 string_ident R 4 - 13 string_integer R 4 - 13 string_real R 4 - 13
© PrologIA
Index Prolog II+ Windows
string_term R 4 - 14 stty U 5 - 36 style_menu U 5 - 25 sub R 4 - 4 substring R 4 - 10 sub_atom R 10 - 11 sup R 4 - 5 supe R 4 - 5 suppress R 3 - 31 suppress R 7 - 18 suppress U 2 - 8
SYMBOL_ARRAY
R 7 - 17; 18; 21 symbol_string R 7 - 15 sys_command R 6 - 5 tab R 10 - 18 tab_user_param U 2 - 9 tan R 4 - 6 tassign R 4 - 7 tell R 10 - 18 telling R 10 - 18
TerminateProlog U 3 - 4 term_cmp R 2 - 8; 9 term_cmp R 4 - 15 term_cmpv R 4 - 15 term_expansion R 10 - 21 term_vars R 4 - 14 text R 5 - 1 text U 5 - 18; 19 text_selection U 5 - 18 throw R 10 - 4 time R 6 - 4 told R 10 - 18 toplist U 5 - 19 top_attach U 5 - 13 top_left U 5 - 18 to_begin R 6 - 2 trace R 6 - 7; 18
I - 11
I - 12
Index Prolog II+ Windows
trail R 6 - 26 true R 10 - 4 trunc R 4 - 5 truncate R 10 - 7
TTY
U 5 - 3; 8
"
TTY
" U 5 - 37 tty U 5 - 8; 17 tty_area R 5 - 2 tuple R 4 - 1 tval R 4 - 3 type R 10 - 13 type U 5 - 17 unify_tlv R 2 - 15 unify_with_occurs_check R 10 - 5 unix_pipe R 5 - 1 unknown R 10 - 19 update U 5 - 21 userdll.mak U 1 - 6 usermpty.c U 1 - 6 userrsc.rc U 3 - 3 user_field U 5 - 18 use_win.h U 1 - 5 val R 4 - 3 val U 2 - 7 var R 10 - 6 variables R 10 - 16 variable_names R 10 - 16 var_time R 4 - 2 version R 6 - 24 visibility U 5 - 19 vscroll U 5 - 15; 16 wait U 5 - 17 warning U 2 - 8 week R 6 - 4 width_height U 5 - 19 write R 5 - 2 write R 10 - 18
© PrologIA writeq R 10 - 18 write_canonical R 10 - 18 write_term R 10 - 18
\ R 10 - 3; 7
\+ R 10 - 3
\+ R l0 - 2
\/ R 1 - 23
\/ R 4 - 6
\/ R 10 - 2
\= R 10 - 2; 3
\== R 10 - 2; 11
A!ociation
Prolog
HERITAGE
A!ociation
Prolog
HERITAGE
Index Prolog II+ Windows
I - 13
© PrologIA
A!ociation
Prolog
HERITAGE
!"#A($%&K''()*($$+
,,,A-*./.0K1"*2L30"A.*0
Lien public mis à jour
Le lien public vers votre chat a été mis à jour.
Caractéristiques clés
- Compilation incrémentale pour une vitesse optimisée.
- Modularité pour l'écriture de gros programmes.
- Ouverture vers d'autres langages (C, etc.).
- Récupération dynamique de mémoire (garbage collector).
- Débogueur de haut niveau intégré.
- Bibliothèque portable d'interface graphique.