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
|
|
|
|
Programmation : GFA Basic - La fonction INKEY$
(Article écrit par Dominique Lorre et extrait d'Amiga News Tech - mai 1990)
|
|
Quand on débute avec un langage de programmation tel que le GFA Basic, la gestion lu clavier pose
souvent des problèmes. Parmi ceux-ci, on peut citer la façon de lire les touches de fonction et aussi
comment lire une touche sans qu'elle soit affichée (frappe sans écho). Je vous propose ce mois-ci
une série de programmes qui utilisent la fonction INKEY$, qui permet de résoudre ces problèmes.
INKEY$ ?
La fonction INKEY$ est une fonction d'un grand intérêt qui se situe entre les fonctions de très
haut niveau comme INPUT et celles de très bas niveau (niveau quasiment matériel, lecture des
scan-codes). Au niveau des touches, la fonction INKEY$ reconnaît les touches du clavier selon la
configuration clavier (keymap) utilisée. Il n'y aura donc pas besoin d'effectuer une quelconque conversion. INKEY$
offre aussi l'avantage de lire une touche à la fois sans avoir besoin d'une validation par
"Entrée".
Une autre particularité de INKEY$ est que cette fonction n'est pas bloquante comme
INPUT. Si aucune touche n'est pressée, INKEY$ renvoie une chaîne vide. Les touches ne sont pas affichées
non plus, ce qui peut permettre d'effectuer un traitement avant affichage tel que le passage en
majuscules et également de n'afficher que les caractères valides (par exemple si on demande un chiffre,
notre routine pourra n'afficher aucune lettre pouvant être tapée par l'utilisateur).
Et le dernier avantage de INKEY$ est la reconnaissance des touches curseur, des touches de fonction
et de la touche "Help".
Programme 1
Pour vous familiariser en douceur avec cette fonction, examinez le premier programme. Dans la boucle DO...LOOP,
la variable a$ prend à chaque fois la valeur de INKEY$ puis est affichée. On aurait pu écrire PRINT INKEY$
mais alors on n'aurait pas pu tester la fin du programme. Le code CHR$(27) est celui de la touche "Esc".
Si vous essayez toutes les touches du clavier avec ce programme, vous constaterez que les touches curseur
fonctionnent réellement, que la touche "Effacement" revient bien d'un caractère vers la gauche mais sans
effacer le caractère et que la touche "Entrée" ne fait que revenir au début de la ligne. Tout cela est normal
car les codes qui vous sont retournés sont bruts.
Un caractère "Effacement" ne peut pas être lu avec INPUT mais INKEY$ le reconnaît. C'est l'instruction PRINT a$;
qui fait ainsi revenir le curseur d'un caractère vers la gauche alors que quand INPUT reçoit un "Effacement"
du clavier, elle envoie à l'écran un "Effacement", un "Espace" (pour effacer le caractère) et un deuxième
"Effacement" (pour revenir à la bonne position). C'est ainsi que les touches peuvent être filtrées, quand
la touche "Entrée" est reconnue par INPUT, un "Ctrl-J" (line-feed ou saut de ligne) est envoyé à la suite
pour que le curseur descende d'une ligne. Vous pouvez aussi remarquer que l'appui de "Ctrl-L" efface l'écran.
Programme 2
À propos du curseur, celui-ci brille par son absence. Un deuxième problème est que l'on est obligé d'activer
la fenêtre avant de commencer à taper au clavier. Ces deux problèmes sont réglés par le programme numéro 2
qui ouvre une fenêtre avec le drapeau ACTIVATE($1000) positionné. La procédure curon est la même que celle
de cet article (je vous avais dit qu'on en reverrait des codes ANSI...).
Programme 3
Maintenant, il serait temps de passer aux touches de fonction. Le programme numéro 3 vous permet de comprendre
comment INKEY$ s'y prend pour les récupérer. C'est ici que l'on peut découvrir une ruse de Sioux qui a fait
date dans les annales de la programmation (d'accord, j'exagère un peu...). Lorsqu'une touche de fonction ou
du curseur est pressée, la fonction INKEY$ renvoie dans a$ une chaîne de caractères d'une longueur comprise
entre 2 et 4. Si vous ne me croyez pas ce programme est là pour le prouver.
En ce qui concerne la manière de quitter le programme, j'ai changé le test pour reconnaître la pression des
deux boutons de la souris simultanément. La longueur de a$ est affichée en inverse vidéo à chaque fois
(c'est joli, l'inverse vidéo). Le test IF II>0 permet d'éviter que des 0 ne remplissent pas l'écran en
permanence car a$ change de valeur plusieurs fois par seconde et est le plus souvent vide.
Programme 4
Comme nous sommes maintenant persuadés que nos touches de fonctions sont codées sur plusieurs caractères, le
programme numéro 4 nous permet de savoir à quoi elles ressemblent. Toutes les touches sont ici affichées dans
leur valeur hexadécimale.
Ceux qui sont observateurs remarqueront que les touches de fonctions, les touches
de curseur et la touche "Help" commencent toutes par le caractère CSI (Control Sequence Introducer,
9B en hexadécimal) qui devrait commencer à être connu de la plupart d'entre vous. Quant à ceux qui
en plus d'être observateurs, ont une table de conversion ASCII en hexadécimal et réciproquement, ils
auront pu remarquer que la plupart des codes affichés auraient pu être imprimés, à l'exception toutefois
du CSI. Ces judicieuses remarques sont d'ailleurs confirmées par la documentation officielle de
Commodore.
Programme 5
Le programme numéro 5 se contente donc de tester uniquement le caractère CSI pour afficher ensuite
la séquence CSI correspondant aux touches de fonction. Le test sur longueur permet d'ignorer les
chaînes vides (qui, hélas, sont toujours à l'affût).
Programme 6
Et pour finir en beauté, nous allons identifier chacune des touches de fonction en affichant son nom à
l'écran (programme numéro 6). Les touches curseur sont identifiées au moyen d'un SELECT...CASE. Les
touches de fonction sont calculées, ce qui nous permet d'économiser un peu de place. Vous avez sans doute
remarqué que l'instruction SELECT...CASE vous permet d'écrire une petite sous-routine pour chaque touche de
fonction, et donc de les utiliser dans vos futurs programmes.
|