Greetings !!

Je pensais avoir trouvé une solution pour pouvoir saisir un caractère sans devoir:

+ appuyer sur entrée (c'est un peu idiot de devoir appuyer sur entrée pour saisir un caractère)
+ au niveau des processus, attendre que le caractère ait été saisi avant de passer à l'instruction suivante
+ ne pas faire l'écho (afficher) le caractère en question (notamment en mode console quand il s'agit de "touches spéciales" comme les touches de direction, de fonction, etc...)

Voici la fonction bloquante:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#ifdef LINUX
int getch() 
{
  struct termios oldt, newt;
	struct sigaction Detournement;
 
	Detournement.sa_handler=SIG_IGN;
	// On ne peut pas interrompre le getch...
	sigaction(SIGINT,&Detournement,NULL);
 
    int ch;
    tcgetattr(STDIN_FILENO, &oldt);
    newt = oldt;
		newt.c_lflag &= ~(ICANON | ECHO ); // works !!
    //newt.c_lflag &= ~(ICANON | ECHO | NOFLSH); // 22 aug 2014
    tcsetattr(STDIN_FILENO, TCSANOW, &newt);
    ch = getchar();
    tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
 
		Detournement.sa_handler=SIG_DFL;
		Detournement.sa_flags=0;
		sigaction(SIGINT,&Detournement,NULL);
 
    return ch;
}
#endif

Voici la fonction non-bloquante:

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#ifdef LINUX
int nbgetch(void)
{
	char							Buffer;
	struct termios		oldt;
	struct termios		newt;
 
	tcgetattr(STDIN_FILENO, &oldt);
  newt = oldt;
 
	newt.c_lflag &= ~(ICANON | ECHO ); 			// affiche le caractère alors que je dis de ne pas faire l'écho... 
 
	// mode non bloquant...
 
	newt.c_cc[VMIN] = 0;
	newt.c_cc[VTIME] = 0;
	tcsetattr(STDIN_FILENO, TCSANOW, &newt);
 
	Buffer=getchar();	// retourne EOF (-1) si il y a rien dans le buffer
 
	// on restitue "l'ancienne configuration"
	tcsetattr(STDIN_FILENO, TCSANOW, &oldt); 
	return Buffer;
}
#endif
Ces deux fonctions me permettent de faire un gestionnaire de saisie clavier. Le principe est de boucler indéfiniment (dans un thread) et dés qu'il y a quelque chose dans le buffer, essayer de déterminer ce
qu'il faut faire en fonction des codes (ANSI) présents dans le buffer. Le traitement sera différent pour la touche de direction "HAUT" (SEQUENCE: 27 91 65) que la touche "DROITE" (SEQUENCE: 27 91 66)
ça je suis bon, mais ce que je ne comprends pas c'est pourquoi "^[[A" est affiché à l'écran alors que j'ai mis à 0 le bit pour "faire écho" du caractère

Code : Sélectionner tout - Visualiser dans une fenêtre à part
newt.c_lflag &= ~ECHO
Est-ce que quelqu'un pourrait m'expliquer à quoi cela est-ce dû ? Et quelles modifications apporter pour permettre à cette fonction non bloquante de continuer à l'être et en plus à ne pas afficher les caractères saisis au clavier ?

Merci d'avance...