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 : C - entrées/sorties sur une fenêtre RAW
(Article écrit par Barrou Diallo et extrait d'Amiga News - octobre 1993)
|
|
Nous revoilà ensemble pour un nouvel épisode de C.
Solution du précédent article
Tout d'abord, j'espère que le petit exercice de la
dernière fois
ne vous a pas trop impressionné et pour ceux qui auraient eu du mal à trouver
la solution, la voici : la Macro 1 permettait d'extraire les j bits à droite de la position
k dans l'entier x.
Eh oui, ce n'était pas bien difficile. Cette macro est d'ailleurs équivalente à (x DIV 2^k)
MOD 2^j. Avec la fonction DIV qui symbolise la division entière et MOD le reste d'une
division entière.
La seconde macro permettait tout simplement d'échanger le contenu de deux variables sans passer par
une variable intermédiaire ! Le tout grâce aux opérateurs logiques dont on ne peut plus se passer,
une fois qu'on y a goûté !
Programme du jour
Suite à la demande de lecteurs, nous allons nous intéresser aujourd'hui à des entrées-sorties sur
une fenêtre dite RAW, adressable comme un vulgaire flux de données allant et venant d'un fichier.
Cette technique est, il faut le rappeler, propre à l'Amiga, malgré que les codes d'échappements
utilisés soit des codes ANSI.
En effet, il est possible d'ouvrir une fenêtre ayant les mêmes caractéristiques qu'une fenêtre CLI/Shell.
Ceci est dû au fait que ces fenêtres sont des périphériques DOS comme les autres. On peut lire,
écrire et changer leur mode d'accès comme dans un fichier classique.
Commençons tout de suite avec le début d'un programme qui nous servira d'exemple tout au long des explications :
#include <dos.h> /* Pour Open/Close... */
#include <stdio.h> /* Pour printf()...*/
#include <stdlib.h> /* Pour exit()... */
#include <string.h> /* Pour strlen() */
#ifndef NOPROTO
#ifndef PROTO
#define PROTO(arg) arg
#endif
#else
#ifndef PROTO
#define PROTO(arg) ()
#endif
#endif
|
Tout bon programme C doit commencer par des inclusions permettant de définir les prototypes des fonctions
qu'il utilise. Les tests préprocesseurs concernant la constante PROTO permettent de bien définir le
prototype d'une fonction suivant le compilateur. Certains ne veulent pas d'arguments, d'autres les exigent.
Pour les premiers, on définira NOPROTO.
void OpenConsole PROTO((void));
void CloseConsole PROTO((void));
|
Voici les deux prototypes des fonctions principales qui, respectivement, ouvriront et fermeront une
fenêtre console. Nous essayons de travailler surtout sous forme de macros préprocesseur pour le reste
des actions qui sont souvent très courtes.
struct FileHandle *flux;
long dosbase;
char tampon[1024];
|
Nous déclarons trois variables globales (globales pour simplifier l'explication, mais à éviter à tout
prix dans les programmes). La variable "flux" sera l'équivalent du descripteur de fichier dans
lequel nous voulons lire et écrire. Cette structure est habituellement stockée dans le fichier
d'inclusion dos/dosextens.h et contient le lien logique entre un process DOS et EXEC.
La variable "dosbase" nous servira de descripteur pour l'ouverture de la bibliothèque standard dos.library.
Quant au "tampon", il servira de zone où seront stockées les données.
/* Fonction qui permet d'ouvrir une console */
void OpenConsole()
{
if (!(dosbase=OpenLibrary("dos.library",OL)))
exit(1);
if (!(flux=(struct FileHandle *)Open(FENETRE, MODE_NEWFILE)))
{
printf("Impossible d'ouvrir la fenêtre d'entrées-sorties");
exit(2);
}
}
|
La première opération consistera à ouvrir la dos.library, et s'il y a un échec (ce qui est rare),
on quittera le programme avec le code retour 1, que l'on pourra tester avec "fault" et "failat"
sous le Shell). Puis, il faudra ouvrir ce fameux flux avec la fonction Open. Remarquons qu'il
nous manque la définition de FENETRE qu'il faudra ajouter au début du programme :
#define FENETRE "con:50/40/400/220/AmigaNews/NOSIZE/CLOSE0"
|
La fenêtre s'ouvrira aux coordonnées écrans 50,45 et aura une largeur de 400 pour une hauteur
de 220. Son titre sera "AmigaNews" et ses attributs CLOSE et NOSIZE.
D'autres attributs sont bien sûr possibles comme SMART, SIMPLE, NODRAG, WAIT ou NOBORDER.
void CloseConsole()
{
Close(flux);
CloseLibrary(closbase);
}
|
Ceci est la définition de la fonction qui clôturera la session console et fermera la
bibliothèque DOS. Mais passons aux fonctions les plus importantes qui sont celles qui permettent effectivement
les entrées-sorties :
#define WRITE(txt) {int len=strlen(txt); if(len) Write(flux,txt,len);}
#define READ(txt) {int len=Read(flux,txt,1024-1); *(txt+len)=0;}
|
Il suffit de taper WRITE("mon texte") pour voir apparaître ce texte dans la fenêtre, ou
READ(buffer) pour trouver le texte tapé au clavier dans la zone tampon. Ces macros sont
essentiels et seront la base de celles qui suivent. Nous allons maintenant modifier les
attributs d'affichage et donner la possibilité d'écrire en gras, italique, etc.
#define GRAS ON WRITE("x9b""1m");
#define GRAS_OFF WRITE("x9b""22m");
#define ITALIQUE_ON WRITE("x9b""3m");
#define ITALIQUE_OFF WRITE("x9b""23m");
#define SOULIGNE_ON WRITE("x9b""4m");
#define SOULIGNE_OFF WRITE("x9b""24m");
#define INVERSE_OFF WRITE("x9b""7m");
#define INVERSE_OFF WRITE("x9b""27m");
|
Toujours sous forme de macros, nous pouvons déplacer le curseur, le désactiver,
effacer l'écran ou même le faire clignoter :
#define GOTOXY(x,y) sprintf(tampon,"x9b%d;%d;H0",x,y); WRITE(tampon);
#define CURSEUR ON_WRITE("x9b""p");
#define CURSEUR_OFF WRITE("x9b""0");
#define CLS WRITE("x0c");
#define BEEP WRITE("x07");
|
Passons aux choses sérieuses : le test de toutes ces macros avec un programme principal
qui reprend la plupart d'entre elles et les exécute en ayant pris soin d'avoir ouvert
une fenêtre.
Le programme se terminera automatiquement, mais sans fermer la console.
C'est laissé au gré de l'utilisateur grâce au gadget du coin supérieur gauche !
void main(void)
{
char buffer[1024];
OpenConsole();
ITALIQUE_ON; WRITE("On est en italique...");
ITALIQUE_OFF;
GRAS_ON;
WRITE("On est en gras..." );
GRAS OFF;
INVERSE_ON;
WRITE("On est en inverse vidéo...");
INVERSE_OFF;
WRITE("taper sur Entrée pour continuer:");
READ(buffer);
CLS; BEEP;
GOTOXY(2,10);
WRITE("On a tout effacé en musique (ou flash)...");
CloseConsole();
}
|
Bien, voilà nos entrées-sorties effectuées, il est possible à partir de ces exemples de tester
des touches spéciales comme les touches de fonctions. Amusez-vous bien et A+.
|
