Suivez-nous sur X
|
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z,
ALL
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
0,
A,
B,
C,
D,
E,
F,
G,
H,
I,
J,
K,
L,
M,
N,
O,
P,
Q,
R,
S,
T,
U,
V,
W,
X,
Y,
Z
|
|
A propos d'Obligement
|
|
David Brunet
|
|
|
|
En pratique : CanDo - programmez un éditeur de texte (CanEdit)
(Article écrit par Guy Beteille et extrait d'Amiga News - février 1992)
|
|
Ce mois-ci, pour varier les plaisirs, je vous propose d'écrire une application particulièrement originale :
un éditeur de texte ! Enfin, je tempère mon propos : il s'agit d'un éditeur de texte très modeste et sans
aucune originalité. Bien sûr, me direz-vous, des éditeurs il y en a à la pelle... Certes, mais un éditeur écrit
par vos soins, il n'y en aura qu'un. Nous allons programmer le noyau du programme et par la suite vous verrez
qu'il vous sera très facile d'ajouter ou de modifier des fonctions.
Que va faire CanEdit
Éditer des fichiers ASCII ou FTXT, avec possibilité de sauver dans un de ces deux formats, imprimer,
copier/couper/coller des mots ou des lignes, chercher/remplacer et enfin permettre d'utiliser un glossaire.
Ce glossaire sera un fichier texte (par défaut de nom "CanEditGlossaire"), présenté sous forme d'une
deuxième fenêtre, un double-clic sur un mot du glossaire insérera ce mot dans votre texte. Cette fonction peut-être
utile pour avoir toujours sous la main l'ensemble des instructions CanDo par exemple.
Vous pourrez imaginer toute une série de fichiers "glossaire" en fonction de vos besoins.
De quoi va être composé l'éditeur ?
D'un "deck" et d'un "sous-deck" (fenêtre sur le Workbench). Le deck (l'application) comprendra deux cartes,
l'une pour recevoir l'éditeur, l'autre nous servira de fenêtre de requête. Quant au sous-deck
il n'aura qu'une seule carte.
Sur la carte "Éditeur" des menus et un objet "document" de type "mémo". La carte "Requester" aura deux boutons
et deux champs de saisie.
Le sous-deck (à réaliser comme un deck habituel) aura un objet "document" de type "list"
et qui sera appelé par le deck à son ouverture.
Le listing de CanEdit en fin d'article est, je crois, assez commenté pour que vous
puissiez le comprendre sans trop de difficultés. J'ai laissé le nom des différents objets et des menus
ainsi qu'une partie des définitions. Bien entendu ce ne sont que les scripts qui sont la partie
programmation. Objets et menus s'éditent avec leurs éditeurs respectifs.
L'éditeur
C'est un document de type "mémo" qui sert à éditer le texte dans une fenêtre. Ici c'est le document de nom d'objet
"document1" et de nom de document "document". CanDo possède sa propre gestion de l'édition, par exemple le défilement
du texte, l'insertion, la gestion des touches "Del" et "Backspace". La programmation concerne donc tout ce qui est
"traitement" du texte. Compter les caractères, couper un mot, une ligne, déplacer le curseur, chercher ou remplacer
du texte, etc. Rien de bien compliqué car il existe toute une série d'instructions pour faire cela.
Je rappelle qu'un document n'est pas forcément visible à l'écran (donc pas forcément associé à un objet document).
Une limite de cet éditeur est la longueur de la ligne, limitée à 255 caractères. Cela peut provoquer des erreurs
lors de l'ouverture d'un fichier ou lors de l'insertion d'un texte.
Créer des menus
Avec CanDo on crée des menus de la même manière que l'on crée des boutons ou autres objets. Un éditeur de menu
est là pour cela. Il vous faut entrer le nom d'un menu, puis définir chaque "item" de ce menu sachant que chaque
"item" peut lui-même avoir des "sub-items". Vous pouvez y associer des raccourcis clavier (ShortCutKey).
Un seul type d'événement peut subvenir avec un menu : c'est lorsqu'il est sélectionné. Donc il n'y a qu'un
script à écrire. Si vous regardez le menu "édition" vous remarquerez que les scripts sont particulièrement courts.
Vous pouvez ainsi ajouter d'autres menus qui effectueront d'autres tâches. Par exemple un menu "déplacement" pour amener
le curseur en bout de ligne, en haut ou en bas du document... avec l'instruction "MoveCursorTo" associée au mot
clé "Start01", "EndOf" et "Line" ou "Document".
Gestion des erreurs
Dans la petite application du mois dernier j'avais délibérément évité de gérer les erreurs.
Cette fois-ci j'ai inclus cette gestion des erreurs dans le listing de CanEdit...
Du moins autant que possible car personne n'est à l'abri d'un bogue
sournois.
CanDo permet de gérer les erreurs de trois manières :
- Par la commande "DoOnError Routine". Cette commande intercepte les erreurs au niveau d'un
script et provoque l'exécution d'une routine prévue à cet effet.
- Par le test conditionnel "If Error... EndIf" qui intercepte l'erreur juste après la commande qui
est susceptible de la provoquer (Cf. LoadDocument). Cela permet de ne pas interrompre le script
et d'inclure tout un bloc d'instructions qui est exécuté si l'erreur survient ou pas.
- Par la création d'un objet "XTra" (bouton en bas à droite du tableau principal) qui exécutera un
script, censé intercepter toutes les erreurs, à quelques niveaux qu'elles se produisent. Ceci
n'est possible qu'avec la version 1.5.
Cartes ou sous-deck ?
La programmation de cet éditeur met en relief la nécessité d'ouvrir des fenêtres de requête.
Dans le cas présent nous avons besoin d'une requête qui nous demande le mot à chercher/remplacer.
Jusqu'à présent il fallait ouvrir une carte pour chaque requête. Ce n'est pas une très bonne solution
car changer de carte peut prendre du temps et être une gêne. J'ai tout de même utilisé cette technique
pour CanEdit afin que vous la compariez avec l'utilisation des sous-decks... de plus ceux qui n'ont pas
la version 1.5 ne peuvent pas utiliser des sous-decks.
Il est évident que l'emploi des sous-decks est particulièrement intéressant pour créer des requêtes
ou ouvrir une deuxième fenêtre.
Les arguments
Vous remarquez dans le listing des variables de nom "ARG1", "ARG2" et "ARG3". Ce sont des variables
système qui prennent la valeur des arguments que vous passez lors de l'appel d'une routine ou d'un
changement de carte. "ARG1" correspond au premier argument et ainsi de suite. Il peut y avoir jusqu'à dix
arguments.
Retour à ClicList
Le mois dernier j'avais laissé en suspens une question concernant
l'affichage de certaines commandes du DOS lorsque CanDo exécute des scripts AmigaDOS.
Reportez-vous au listing de ClicList routine "LanceProgramme"...
Dans ce script c'est la ligne DOS "Execute || Programme" qui permettait l'exécution d'un script AmigaDOS.
Remplacez-la par "Do "ExecuteScript"" et ajouter la routine suivante :
Cette routine est en fait un moyen de tricher. Elle prend un fichier AmigaDOS et y ajoute les commandes
"Wait" et "EndCli", resauve ce fichier en RAM:. "Endcli" est ajoutée pour être sur d'avoir la fermeture
du Shell. Ensuite, "C:NewShell" ouvre une fenêtre Shell et y exécute le fichier RAM:ClicListExecute. Il
faut bien sûr que l'ensemble de ces commandes soit dans le tiroir C:.
Le listing
|
