Logiciel - QuickPascal - Le clavier et l'écran

Le clavier et l'écran

Pratiquement tous les programmes reçoivent ou envoient des informations d'une manière ou d'une autre, peut-être en les acceptant du clavier ou d'un fichier, peut-être en les affichant à l'écran ou sur une imprimante. Le QuickPascal prend en charge toutes les fonctionnalités d'entrée et de sortie de Pascal standard et comprend une unité spécialement conçue pour améliorer l'apparence et la facilité d'utilisation de vos programmes.

Cette page contient deux parties. Le premier couvre les bases de l'entrée et de la sortie Pascal et comment formater la sortie. La deuxième partie présente l'unité Crt et comment l'utiliser pour affiner le contrôle du clavier et de l'écran.

Entrée et sortie de base

Le Pascal fournit les procédures Read et Readln pour l'entrée et les procédures Write et WriteLn pour la sortie. Ces procédures peuvent gérer à la fois des éléments de données uniques et des listes d'éléments séparés par des virgules. Tous les quatre utilisent une syntaxe similaire :

Read([FileName,]InputVariable) [, InputVariable...]

Write([FileName, ]OutputVariable [:Width[:Decimals]][,OutputVariable[:Width[:Decimals]]])

où FileName fait éventuellement référence à un fichier disque ou à un périphérique (tel qu'une imprimante ou un modem), et Width et Decimals font référence à des informations de formatage. Sans FileName, la procédure Read accepte les données du périphérique d'entrée standard (généralement le clavier) et Write envoie les données au périphérique de sortie standard (généralement l'écran). Si la lecture ou l'écriture rencontre une erreur, le programme se termine avec un message d'erreur d'exécution. Vous pouvez inclure la directive de compilateur {$I-} dans votre programme si vous souhaitez que votre programme continue malgré les erreurs d'exécution en lecture ou en écriture.

Si vous choisissez d'utiliser la directive de compilation {$I-}, vous devez appeler la fonction IOResult immédiatement après chaque opération d'entrée ou de sortie. La valeur renvoyée par IOResult indique si une erreur s'est produite. Le QuickPascal ignore toute tentative d'entrée ou de sortie après une erreur, sauf si vous appelez IOResult.

Les sections suivantes traitent de l'utilisation de base des instructions Read et Write. La section suivante aborde les détails de formatage (de la largeur et des décimales).

Procédures Read et ReadLn

Les procédures Read et ReadLn placent les données dans une ou plusieurs «variables d'entrée». Le plus souvent, les procédures Read et Readln reçoivent leur entrée du clavier ou d'un fichier de données.

Les variables d'entrée doivent appartenir à l'un des types de données prédéfinis (sauf booléen) ou à un type de sous-gamme que vous avez défini, et elles doivent être d'un type qui peut accepter le type de données que vous essayez de lire. Par exemple, une variable d'entrée de type Char ne peut pas accepter une valeur réelle.

La procédure ReadLn tente de lire des données dans la liste des variables d'entrée. Si le nombre d'éléments de données saisis sur une seule ligne dépasse le nombre de variables, les éléments de données supplémentaires sont ignorés. Cependant, si ReadLn reçoit moins d'éléments de données que le nombre de variables d'entrée, il s'attend à ce que les données supplémentaires apparaissent sur les lignes suivantes. Par exemple, l'instruction ReadLn dans l'extrait suivant attend trois valeurs :



WriteLn('Pour l''investissement que sont : la valeur actualisée,');

WriteLn('rendement annuel et nombre d''années investies ?');

ReadLn(present_value, rate_of_return, years_invested);

Supposons que vous exécutez le programme et en réponse au prompt :

Pour l'investissement que sont : la valeur actualisée, rendement annuel et nombre d'années investies ?

vous tapez :

3000.00 1.05

et appuyez sur Enter. Le programme attendra alors que vous saisissiez la valeur finale. N'oubliez pas d'utiliser des espaces, des tabulations ou des retours chariot pour séparer les valeurs. L'utilisation de virgules provoque une erreur d'exécution. Si vous êtes préoccupé par la possibilité de telles erreurs, vous pouvez soit écrire le programme avec une instruction ReadLn pour chaque élément saisi, soit lire les données sous forme de chaîne de caractères de texte et créer une procédure pour séparer la chaîne de caractères en nombres.

La procédure Read, en revanche, ne lit que suffisamment de données pour remplir ses variables d'entrée. Mais les procédures Read ou ReadLn suivantes peuvent récupérer les données restantes.

Supposons que vous ayez réécrit l'exemple ci-dessus comme :



WriteLn('Pour l''investissement, qu''est-ce que : la valeur actuelle ?');

Read(present_value);

WriteLn('le rendement annuel?');

Read(rate_of_return);

WriteLn('et le nombre d''années investies ?');

Read(years_invested);

et a exécuté le programme avec cette réponse :

Pour l'investissement, qu'est-ce que : la valeur actuelle ? 3000.00 12.8 37

Le programme accepterait alors 3000.00 comme valeur_présente et imprimerait immédiatement les deux prompts restantes sans s'arrêter :

le rendement annuel? et le nombre d'années investies ?

et fixe rate_of_return et years_invested égaux à 12,8 et 37, respectivement. À moins que votre programme n'effectue un certain type de vérification des erreurs, l'utilisation d'une telle série d'instructions Read peut potentiellement introduire des erreurs.

Comme ReadLn, Read accepte tous les types de données standard Pascal mais les saisit différemment. Les données de caractères ne sont pas délimitées ; Read affecte tout type d'entrée aux variables de type caractère, y compris les retours chariot, les espaces,... Les chaînes de caractères saisies avec Read peuvent inclure n'importe quelle combinaison de texte ASCII à l'exception d'un retour chariot, signifiant la fin de la chaîne de caractères. Pour les données numériques. La lecture ignore les blancs de début, commence par le premier chiffre ou signe (+ ou -) et continue jusqu'à ce qu'elle atteigne le prochain caractère d'espace blanc ou retour chariot.

Procédures Write et WriteLn

Les procédures Write et Writeln vous permettent d'envoyer des variables, des constantes et des chaînes de caractères à l'écran, à des fichiers sur disque ou à d'autres périphériques de sortie. Les variables ou constantes que vous utilisez dans Write et WriteLn peuvent être l'un des types de données standard Pascal ou une sous-gamme de l'un de ces types.

Les procédures Write et Writeln ne diffèrent que par le fait que WriteLn termine la ligne après avoir envoyé ses données au périphérique de sortie. La sortie suivante apparaît sur la ligne suivante.

Vous utilisez souvent l'instruction Write pour afficher des prompts à l'écran. La procédure WriteLn affiche des lignes complètes de texte et est utile pour laisser des lignes vides à l'écran à des fins esthétiques.

La procédure Write est souvent utilisé avec Read pour une simple saisie de prompt de réponse :



Write('Veuillez saisir deux nombres entiers séparés par un espace :');

Read(Int1,Int2);

Pour les lignes complètes de texte et pour les lignes vides, vous pouvez utiliser WriteLn :



WriteLn('Le modèle même d''un général d''une division moderne');

WriteLn('==================================================');

WriteLn;

WriteLn('Par Shorty Bonaparte');

Notez que les chaînes de caractères de texte apparaissent sur le bord gauche de l'écran.

Par eux-mêmes. Les procédures Write et Writeln ne fournissent pas beaucoup de formatage numérique ; ils affichent des nombres dans un format par défaut selon le type de variable. Par exemple, la sortie de :



real_num:=3.1415;

long_int:=1234567;

WriteLn('Un nombre réel s''affiche comme ', real_num, '.');

WriteLn('Et un entier long s''affiche comme ', long_int,'.');

ressemble à :

Un nombre réel s'affiche comme 3.14150000000154E+0000. Et un entier long s'affiche comme 1234567.

La section suivante explique comment modifier ces formats par défaut.

Sortie formatée avec Write et WriteLn

Le format de sortie numérique par défaut pour les nombres réels est la notation scientifique. Pour les nombres entiers, le format de sortie par défaut est une séquence de chiffres. Et, Pascal affiche normalement les chaînes de caractères justifiées à gauche. Mais Write et Writeln vous permettent de modifier les formats par défaut.

Rappelez-vous que les instructions Write et Writeln suivent la syntaxe :

Write([FileName, ] OutputVariable [: Width[:Decimals]][,OutputVariable[:Width[:Decimals]]])

Les deux champs optionnels Width et Decimals contrôlent la mise en forme. Le champ Width définit le nombre maximum d'espaces disponibles pour l'affichage de la variable appelée OutputVariable et indique la justification à droite ou à gauche par son signe (positif pour la justification à droite, négatif pour la gauche).

Le Pascal formate le texte et les données entières de la même manière. Ces instructions affichent l'entier my_int et la chaîne de caractères my_str dans un espace de six colonnes de large et justifié à droite :



WriteLn(my_int:6);

WriteLn(my_str:6);

Si my_int ou my_str dépasse une largeur de six colonnes, le QuickPascal affiche l'entier entier ou la chaîne de caractères avec le format par défaut.

Les variables de type Real peuvent également spécifier Decimals, indiquant le nombre de chiffres devant apparaître à droite du point décimal. Vous ne pouvez pas spécifier de décimales pour des entiers ou des chaînes de caractères.

Les procédures Write et Writeln ne tronquent pas les chaînes de caractères ni aucun type de données numériques. Si OutputVariable est plus large que Width, Width est remplacé et l'intégralité de OutputVar est affichée. Pour les types à virgule flottante. Les procédures Write et Writeln affichent toujours le nombre de décimales spécifié par Decimals, même si cela implique de dépasser la spécification Width.

La ligne suivante justifie à droite un nombre réel realnum et l'affiche avec quatre décimales :



WriteLn(realnum:12:4);

Si realnum contient 12 chiffres ou moins, le dernier chiffre se trouve dans la colonne 12.

Cet exemple :



int_var:=12345;

str_var:='Cette phrase est une chaîne de caractères.';

real_var:=9870.65434;

 
WriteLn('1234567890123456789012345678901234567890 Règle');

WriteLn(' 10 20 30 40');

WriteLn(int_var:8);

WriteLn(int_var:85);

WriteLn(str_var:35);

WriteLn(str_var:-3);

WriteLn(real_var:-2:6);

WriteLn(real_var:14:2);

produit la sortie suivante :

1234567890123456789012345678901234567890 Règle 10 20 30 40 12345 12345 Cette phrase est une chaîne de caractères. Cette phrase est une chaîne de caractères. 9870.654340 9870.65

Les besoins de formatage varient d'un programme à l'autre. Toutefois, si vous formatez fréquemment vos données dans un style particulier, il peut être utile d'écrire une procédure suivant automatiquement ce format.

Redirection DOS : fichiers d'entrée et de sortie

Un processus appelé "redirection DOS" vous permet de spécifier à la fois les fichiers d'entrée et de sortie pour les programmes QuickPascal. Un fichier d'entrée contient les réponses à toutes les questions posées par le programme (à condition qu'elles soient saisies avec des instructions Read ou Readln). Un fichier de sortie reçoit toutes les informations écrites par les instructions Write et Writeln allant généralement à l'écran.

Redirection standard

Les programmes redirigés s'exécutent de manière tout à fait normale ; ils acceptent simplement leur entrée à partir d'un fichier au lieu du clavier et envoient leur sortie dans un fichier au lieu de l'écran. Vous pouvez exécuter des programmes redirigés uniquement à partir de la ligne de commande DOS. Pour utiliser la redirection depuis l'environnement QuickPascal, vous devez d'abord choisir la commande DOS Shell dans le menu File. La syntaxe générale de redirection est :

ProgramName [< InputFile] [>OutputFile]]

Vous pouvez inclure InputFile uniquement, OutputFile uniquement ou les deux. Les deux doivent être des fichiers texte. Si vous exécutez uniquement InputFile :

ProgramName < InputFile

vous voyez toujours les requêtes du programme et d'autres sorties à l'écran. Cependant, à moins que vous écriviez spécifiquement votre programme pour faire écho à l'entrée de l'utilisateur, vous ne voyez pas les données d'entrée à l'écran car elles proviennent directement du fichier d'entrée.

Si vous exécutez ProgramName et incluez uniquement OutputFile :

ProgramName >OutputFile

vous devez connaître l'ordre dans lequel le programme requiert sa saisie ; toutes les sorties, y compris les prompts d'entrée, vont à OutputFile. Le DOS crée un nouveau fichier de sortie chaque fois que vous exécutez le programme et spécifiez OutputFile. Si un fichier nommé Output-File existe déjà, l'ancien est effacé et un nouveau est créé. Mais, si vous ajoutez un symbole > supplémentaire :

ProgramName >>OutputFile

Le DOS ajoute la nouvelle sortie à la fin du fichier existant nommé OutputFile.

Par exemple, supposons que vous écriviez un programme de base de données appelé ADDRESS.EXE lisant les noms des employés et renvoie leurs adresses postales. À l'aide de QuickPascal ou d'un autre éditeur enregistrant des fichiers texte, vous pouvez créer une liste de noms d'employés et l'enregistrer sous NOM.TXT. Ensuite, si vous entrez :

ADDRESS <NAME.TXT

vous pouvez afficher la liste des adresses des employés à l'écran. Entrer :

ADDRESS <NAME.TXT >ADD.TXT

crée un nouveau fichier appelé ADD.TXT contenant les adresses des employés. Et, si vous écrivez un autre fichier d'entrée appelé MORENAME.TXT, puis la commande :

ADDRESS <MORENAME.TXT >>ADD.TXT

ajoute les adresses supplémentaires à la fin du fichier ADD.TXT existant.

L'unité Crt et la redirection DOS

L'unité Crt remplace la redirection DOS. Les programmes avec Crt dans leurs instructions USES ignorent les fichiers d'entrée et de sortie.

Si vous souhaitez exécuter des programmes utilisant l'unité Crt avec des fichiers d'entrée et de sortie, vous devez inclure les lignes suivantes dans votre programme avant la première instruction d'entrée ou de sortie :



Assign(Input,'');

Reset(Input);

Assign(Output,'');

Rewrite(Output);

L'unité Crt modifie les noms des sources d'entrée et de sortie standard ; les quatre lignes ci-dessus les réaffectent à leurs paramètres d'origine.

L'unité Crt

Si vous avez lu la page «Les unités», vous connaissez le concept d'unités. L'unité Crt est une unité standard fournissant des types de données et des procédures pour la saisie au clavier, le contrôle du curseur, le contrôle de l'écran et les fenêtres. Cette section décrit certaines des variables et toutes les procédures fournies dans l'unité Crt. Vous pouvez obtenir plus d'informations sur chacune de ces variables et procédures via le système d'aide en ligne.

Si vous envisagez d'utiliser les unités Crt et MSGraph, vous devez faire attention à certaines restrictions aux programmes appelant à la fois les unités Crt et MSGraph.

Utilisation de l'unité Crt

De nombreux exemples de programmes complets présentés dans ce manuel utilisent l'unité Crt. Pour accéder à ses fonctions, procédures, variables et constantes dans vos propres programmes, ajoutez l'instruction USES Crt; immédiatement après votre déclaration de programme.

Lorsque vous démarrez un programme graphique, vous devez indiquer à QuickPascal comment vous souhaitez qu'il affiche le texte. Vous transmettez une constante particulière à la procédure TextMode en fonction du mode texte souhaité. Les constantes apparaissent dans le tableau suivant :

Identificateur de constante	Évaluer	Affichage
BW40	0	Écran de texte noir et blanc 40 par 25
BW80	2	Écran de texte noir et blanc 80 par 25
Mono	7	Écran de texte monochrome 80 par 25
CO40	1	Écran de texte de 40 par 25 couleurs
CO80	3	Écran de texte de 80 par 25 couleurs
Font8x8	256	43 lignes en EGA/VGA

L'unité Crt établit également les constantes de couleur indiquées dans le tableau précédent. Lorsque vous affichez du texte dans différentes couleurs ou créez des fenêtres avec des arrière-plans de couleurs différentes, faites référence à la couleur par sa valeur :

Couleur	Valeur	Couleur	Valeur
Black	0	LightBlue	9
Blue	1	LightGreen	10
Green	2	LightCyan	11
Cyan	3	LightRed	12
Red	4	LightMagenta	13
Magenta	5	Yellow	14
Brown	6	White	15
LightGray	7	Blink	128
DarkGray	8

En plus des constantes, l'unité Crt exporte les variables répertoriées dans le tableau suivant. Ils permettent à vos programmes d'accéder aux paramètres d'état et d'information utilisés par QuickPascal, tels que le mode vidéo précédent ou les attributs de texte actuels.

Variable	Type de données	Objectif
CheckBreak	Boolean	Indique l'état de la vérification `Ctrl`+`Break`.
CheckEof	Boolean	Active/désactive la vérification du caractère de fin de fichier lors de la saisie au clavier.
CheckSnow	Boolean	Active/désactive la «vérification de la neige» pour l'écran.
DirectVideo	Boolean	Active/désactive la sortie vidéo directe.
LastMode	Word	Enregistre le mode vidéo précédent.
TextAttr	Byte	Contient l'attribut d'affichage de texte actuel.
WindMin	Word	Enregistre les coordonnées précédentes du coin supérieur gauche de la fenêtre active.
WindMax	Word	Enregistre les coordonnées précédentes du coin inférieur droit de la fenêtre active.

La variable DirectVideo joue un rôle important dans l'accélération de la sortie d'écran. Définir DirectVideo sur True envoie la sortie des instructions Write et Writeln directement dans la mémoire de votre écran. Malheureusement, cette technique ne fonctionne pas sur certaines configurations informatiques. Définir DirectVideo sur False, d'autre part, utilise le système d'entrée-sortie de base (BIOS) de votre machine. Le BIOS s'affiche toujours correctement mais fonctionne à une vitesse plus lente ; expérimentez pour voir quel paramètre fonctionne le mieux pour votre ordinateur.

Les variables WindMin et WindMax entreposent les coordonnées de la fenêtre active. Utilisez les fonctions Hi et Lo prédéfinies pour lire les octets de poids fort et de poids faible contenus dans les variables WindMin ou WindMax, comme illustré ci-dessous :



UpperLeftX:=Lo(WindMin)+1;

UpperLeftY:=Hi(WindMin)+1;

LowerRightX:=Lo(WindMax)+1;

LowerRightY:=Hi(WindMax)+1;

Le tableau suivant répertorie toutes les procédures et fonctions Crt ; en le parcourant, vous aurez une idée de l'unité Crt. La colonne "Objectif" décrit ce que fait chaque procédure. L'aide en ligne donne une explication plus complète et les exemples de programmes montrent d'autres utilisations de ces procédures :

Procédure	Objectif	Exemple
AssignCrt	Associe une variable de fichier texte à l'écran.	AssignCrt(DataFile);
ClrEol	Effacer jusqu'à la fin de la ligne	ClrEol;
ClrScr	Efface la fenêtre et place le curseur dans le coin supérieur gauche	ClrScr;
Delay	Retarde le programme d'un nombre spécifié de millisecondes.	Delay(1000){1 seconde };
DelLine	Supprime la ligne à l'emplacement actuel du curseur.	DelLine;
GotoXY	Déplace le curseur aux coordonnées de la fenêtre spécifiée.	GotoXY(40,25);
HighVideo	Affiche les caractères en haute intensité.	HighVideo;
InsLine	Insère une ligne vide à l'emplacement actuel du curseur.	InsLine;
KeyPressed	Renvoie True s'il y a un caractère dans le tampon du clavier.	WHILE KeyPressed DO ...
LowVideo	Affiche les caractères en faible intensité.	LowVideo;
NormVideo	Restaure les attributs de l'écran à ceux en vigueur au démarrage du programme.	NormVideo;
NoSound	Éteint le haut-parleur	NoSound;
ReadKey	Lit le caractère suivant de la mémoire tampon du clavier sans l'afficher à l'écran.	akey:=ReadKey;
Sound	Allume le haut-parleur.	Sound(frequency);
TextBackground	Sélectionne la couleur d'arrière-plan pour l'affichage de texte ultérieur.	TextBackground(Black);
TextColor	Sélectionne la couleur de premier plan pour l'affichage de texte ultérieur	TextColor(Red);
TextMode	Sélectionne le mode d'affichage	TextMode(BW80);
WhereX	Renvoie la coordonnée X de l'emplacement du curseur	posx:=WhereX;
WhereY	Renvoie la coordonnée Y de l'emplacement du curseur	posy:=WhereY;
Window	Définit une nouvelle fenêtre d'affichage	Window(2,2,40,10;

Saisie de caractères

Vous pouvez lire les caractères du clavier de différentes manières. Dans le cas des procédures Read et Readln, au fur et à mesure que chaque lettre est saisie, elle est placée dans les variables d'entrée et affichée à l'écran. La fonction ReadKey de Crt lit également les entrées du clavier, mais ne peut lire qu'un seul caractère à la fois ; il n'affiche pas le caractère à l'écran.

Bien que vous souhaitiez peut-être effectuer votre collecte de données principale avec Read et Readln, la fonction ReadKey vous permet d'ajouter des touches finales à vos programmes. Par exemple, la ligne suivante interrompt l'exécution du programme jusqu'à ce que l'utilisateur appuie sur Enter :



Repeat until ReadKey=Chr(13);

La fonction ReadKey lit également les touches de fonction, les touches de contrôle du curseur, les touches de contrôle et les touches alternatives. Ces touches spéciales envoient une séquence de caractères. Le premier est un caractère nul (c'est-à-dire ASCII 0). Le deuxième caractère est un code de clé étendu.

L'extrait suivant illustre un processeur de caractères typique pour un programme piloté par clavier. Il vérifie le code de caractère spécial #0 et les touches alphanumériques standard. Si la première touche est spéciale, une deuxième instruction CASE identifie la touche enfoncée. Une fois que le processeur de caractères a déterminé la touche enfoncée, il invoque la procédure applicable.



Var

 done:Boolean;

 ch,ch2:Char;

 

BEGIN

 done:=False;

 REPEAT

  ch:=ReadKey;

  Case ch of

   #0:Begin

    ch2:=ReadKey;

    Case ch2 of

     59: { Demande la touche F1 }

       DoF1; { procédure F1 }

	    { : }

    End; { CASE ch2 }

   End; { #0 }

   '0'..'9',

   'A'..'Z',

   'a'..'z':

     DoAlphaDigit(ch); { Procédure pour les touches normal }

   Else

    done:=True;

  End;

 Until Done;

END.

Le programme CRT1.PAS de QuickPascal Advisor montre comment détecter des touches spéciales à l'aide de ReadKey. Vous pouvez compiler et exécuter le programme, effectuant les opérations suivantes :

Déplace le caractère 'o' sur l'écran lorsque vous appuyez sur les touches fléchées ↑, ↓, ← et →.
Simule un effet de balle qui rebondit si vous appuyez sur la touche de fonction F2.
Masque le curseur.
Quitte lorsque vous appuyez sur la touche de fonction F1.

Si vous n'aimez pas les effets sonores, réglez la musique constante sur FALSE. Dans le programme CRT1.PAS, l'instruction IF :



If c1=#0

devient TRUE lorsque vous appuyez sur une touche spéciale. Dans ce cas, ReadKey renvoie deux caractères, dont le premier est toujours ASCII #0. Le chemin emprunté par les boucles WHILE dépend de la touche sur laquelle vous appuyez.

La procédure cursor_off appelle le BIOS pour désactiver le curseur. Les procédures Sound et Delay du Crt sont également utilisées dans ce programme. L'aide en ligne contient plus d'informations sur ces deux procédures.

Contrôle du curseur et de l'écran

L'unité Crt fournit plusieurs procédures pour le contrôle de l'écran et du curseur. Leurs noms reflètent leurs actions : DelLine, HighVideo, GotoXY,...

Cette section vous renvoie à deux exemples de programmes dans QP Advisor. Le programme CRT2.PAS utilise des procédures Crt pour insérer et supprimer des lignes, modifier la tension de la vidéo et produire des effets sonores. Le programme nécessite très peu de lignes de code pour accomplir ces tâches.

Le programme CRT3.PAS utilise la fonction GotoXY pour contrôler le curseur. Le tableau suivant montre les instructions GotoXY utilisées pour déplacer le curseur par rapport à sa position actuelle, en supposant que le curseur n'est pas au bord d'une fenêtre.

Exemple	Description
GotoXY(WhereX-1, WhereY)	Se déplace d'un caractère vers la gauche
GotoXY(WhereX+1, WhereY)	Déplace un caractère vers la droite
GotoXY(WhereX, WhereY-1)	Remonte d'une ligne
GotoXY(WhereX, WhereY+1)	Descend d'une ligne
GotoXY(1, WhereY)	Passe au début de la ligne courante
GotoXY(80, WhereY)	Se déplace à la fin de la ligne courante

Le programme CRT3.PAS vous invite à taper un caractère, puis "fait rebondir" ce caractère sur l'écran. Le caractère change de direction et émet un bip lorsqu'il atteint le bord de l'écran. La vitesse du caractère augmente chaque fois que le caractère change de direction. Lorsqu'il atteint une vitesse maximale, le caractère ralentit pour revenir à sa vitesse d'origine.

Utilisation de fenêtres

L'unité Crt permet de contrôler facilement les fenêtres de texte. La procédure Window permet de définir une nouvelle zone active de l'écran.

La procédure Window accepte les coordonnées des lignes et des colonnes pour les coins supérieur gauche et inférieur droit de la nouvelle fenêtre. Ces coordonnées doivent être des entiers de type Byte. Les lignes vont de 1 à 25 (ou 1 à 43 ou 1 à 50, selon le mode texte) et les colonnes vont de 1 à 80.

La procédure Window est analogue au choix de la taille d'une feuille de papier sur laquelle dessiner ; les coordonnées que vous transmettez à la procédure indiquent à QuickPascal la taille du morceau de papier. Par exemple, l'instruction suivante définit la totalité de la zone d'écran :



Window(1,1,25,80);

De nombreuses applications utilisent les lignes supérieure et inférieure de l'écran pour afficher un menu ou un texte d'aide. Pour exclure ces lignes de la zone d'écran active, utilisez :



Window(1,2,24,80);

Si vous écrivez une application dessinant un cadre autour de l'écran, vous pouvez utiliser l'instruction suivante pour réduire la zone d'écran active :



Window(2,2,24,79);

Lorsque vous créez une nouvelle fenêtre, le coin supérieur gauche de la zone d'affichage est (1,1). Ainsi, GotoXY(1,1) déplace le curseur vers le coin supérieur gauche de la fenêtre active, quels que soient la taille et l'emplacement de la fenêtre. GotoXY revient à poser votre crayon lumineux à un endroit précis sur la feuille de papier. Les fonctions WhereX et WhereY vous ramènent à votre emplacement actuel.

Choisissez les couleurs de premier plan et d'arrière-plan de la fenêtre active avec les procédures TextColor et TextBackground. Pour continuer la comparaison précédente, TextColor vous permet de sélectionner la couleur de votre crayon lumineux et TextBackground sélectionne la couleur du morceau de papier. Notez qu'après avoir changé la couleur d'arrière-plan, vous devez effacer l'écran pour voir la nouvelle couleur. L'effacement de l'écran réinitialise le curseur sur (1,1).

Le programme CRT4.PAS montre comment ces procédures fonctionnent (bien que vous ayez besoin d'un moniteur couleur pour voir les couleurs). Il illustre les informations suivantes :

Des fenêtres bougeant tout en gardant leur taille fixe.
Fenêtres se déplaçant et changeant simultanément de taille.
Contrôle de l'écran et du curseur du texte dans une fenêtre

CRT4.PAS vous donne une idée de ce que vous pouvez faire avec les fenêtres. Avec quelques lignes de code similaires, vous pouvez améliorer l'impact visuel de votre écran et ajouter de la clarté et de l'emphase à vos programmes.

Dernière mise à jour : Dimanche, le 28 août 2022

Section courante

A propos

Section administrative du site