Discussion :

[miloutch]

salut à tous !

voilà je me demandais comment sous linux, on pouvais implementer la gestion des touches directionnelles sous console ?
j'ai vu partout que des getch non implémenté sous linux en dehors des ncurses.
or je ne veux pas utiliser ncurses parce que ca m'oblige à réécrire mon shell parce que la position du curseur pars en vrille
du coup si vous avez des olutions dans le genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
while((a=getch())==224)
    {
        b=getch();
        if(b==80)
            if(position<3)
                position+=1;
        if(b==72)
            if(position>0)
                position-=1;
    }

qui marchent sous linux, ca m'irait bien
en attendant je continue à chercher
merci !

[Obsidian]

Bonjour,

Tu peux jeter un œil à cette discussion.

Bon courage.

[miloutch]

Merci beaucoup, je regarde ca

[Elijha]

Salut,

Je me suis moi même re-développé une petite librairie pour avoir les fonctions kbhit() et getch(). Je m'était inspiré de ces informations : kbhit() for linux.

kbhit: Dans le principe il faut passer ton terminal (console) en mode raw, vérifier la présence d'un caractère, si oui, le mettre dans un buffer, et repasser le terminal en normal.
getch: Retourne le plus ancien caractère positionné dans ton buffer.

Cela évite d'inclure ncurses pour juste utiliser les fonctions de gestion clavier.

Si ça peut t'aider.

[miloutch]

merci beaucoup !
je regarde ca !

[miloutch]

Bon alors j'ai regardé et en fait ce n'est pas du tout ce que je voulais faire
mais merci quand même ca pourrais servir cette petite fonction !
non ce que je veux moi, c'est pourvoir taper une commande tranquillement (et qu'elle s'affiche à l'écran en même temps que je la tape) et quand je tape sur la fleche du haut, Là, il ne m'affiche pas un caractère bizarre, mais recupère la valeur et fasse l'action correspondante. Comme sur un shell basique qui utilise la biblio readline quoi !
Je me suis plongé dans cette dernière, mais c'est pas la peine il y a trop de données et de fonctions.

[ABandApart]

Bon alors j'ai regardé et en fait ce n'est pas du tout ce que je voulais faire
mais merci quand même ca pourrais servir cette petite fonction !
non ce que je veux moi, c'est pourvoir taper une commande tranquillement (et qu'elle s'affiche à l'écran en même temps que je la tape) et quand je tape sur la fleche du haut, Là, il ne m'affiche pas un caractère bizarre, mais recupère la valeur et fasse l'action correspondante. Comme sur un shell basique qui utilise la biblio readline quoi !
Je me suis plongé dans cette dernière, mais c'est pas la peine il y a trop de données et de fonctions.

Bah il ne te reste que la solution tercamps/ncurses.
Ou alors utiliser une bibliothèque graphique.
Je ne vois pas d'autres solutions.

[miloutch]

mais on peut utiliser la même chose que readline, c'est à dire termcap, termios et ioctl , mais le code est un peu complexe pour tout piger
en tout cas c'est ce qui est utilisé. je vous montre un bout de code :

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
 
static void
save_tty_chars (tiop)
     TIOTYPE *tiop;
{
  _rl_last_tty_chars = _rl_tty_chars;
 
  if (tiop->flags & SGTTY_SET)
    {
      _rl_tty_chars.t_erase = tiop->sgttyb.sg_erase;
      _rl_tty_chars.t_kill = tiop->sgttyb.sg_kill;
    }
 
  if (tiop->flags & TCHARS_SET)
    {
      _rl_intr_char = _rl_tty_chars.t_intr = tiop->tchars.t_intrc;
      _rl_quit_char = _rl_tty_chars.t_quit = tiop->tchars.t_quitc;
 
      _rl_tty_chars.t_start = tiop->tchars.t_startc;
      _rl_tty_chars.t_stop = tiop->tchars.t_stopc;
      _rl_tty_chars.t_eof = tiop->tchars.t_eofc;
      _rl_tty_chars.t_eol = '\n';
      _rl_tty_chars.t_eol2 = tiop->tchars.t_brkc;
    }
 
  if (tiop->flags & LTCHARS_SET)
    {
      _rl_susp_char = _rl_tty_chars.t_susp = tiop->ltchars.t_suspc;
 
      _rl_tty_chars.t_dsusp = tiop->ltchars.t_dsuspc;
      _rl_tty_chars.t_reprint = tiop->ltchars.t_rprntc;
      _rl_tty_chars.t_flush = tiop->ltchars.t_flushc;
      _rl_tty_chars.t_werase = tiop->ltchars.t_werasc;
      _rl_tty_chars.t_lnext = tiop->ltchars.t_lnextc;
    }
 
  _rl_tty_chars.t_status = -1;
}
 
static int
get_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  set_winsize (tty);
 
  tiop->flags = tiop->lflag = 0;
 
  errno = 0;
  if (ioctl (tty, TIOCGETP, &(tiop->sgttyb)) < 0)
    return -1;
  tiop->flags |= SGTTY_SET;
 
#if defined (TIOCLGET)
  if (ioctl (tty, TIOCLGET, &(tiop->lflag)) == 0)
    tiop->flags |= LFLAG_SET;
#endif
 
#if defined (TIOCGETC)
  if (ioctl (tty, TIOCGETC, &(tiop->tchars)) == 0)
    tiop->flags |= TCHARS_SET;
#endif
 
#if defined (TIOCGLTC)
  if (ioctl (tty, TIOCGLTC, &(tiop->ltchars)) == 0)
    tiop->flags |= LTCHARS_SET;
#endif
 
  return 0;
}
 
static int
set_tty_settings (tty, tiop)
     int tty;
     TIOTYPE *tiop;
{
  if (tiop->flags & SGTTY_SET)
    {
      ioctl (tty, TIOCSETN, &(tiop->sgttyb));
      tiop->flags &= ~SGTTY_SET;
    }
  _rl_echoing_p = 1;
 
#if defined (TIOCLSET)
  if (tiop->flags & LFLAG_SET)
    {
      ioctl (tty, TIOCLSET, &(tiop->lflag));
      tiop->flags &= ~LFLAG_SET;
    }
#endif
 
#if defined (TIOCSETC)
  if (tiop->flags & TCHARS_SET)
    {
      ioctl (tty, TIOCSETC, &(tiop->tchars));
      tiop->flags &= ~TCHARS_SET;
    }
#endif
 
#if defined (TIOCSLTC)
  if (tiop->flags & LTCHARS_SET)
    {
      ioctl (tty, TIOCSLTC, &(tiop->ltchars));
      tiop->flags &= ~LTCHARS_SET;
    }
#endif
 
  return 0;
}
 
static void
prepare_terminal_settings (meta_flag, oldtio, tiop)
     int meta_flag;
     TIOTYPE oldtio, *tiop;
{
  _rl_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
  _rl_echoctl = (oldtio.sgttyb.sg_flags & ECHOCTL);
 
  /* Copy the original settings to the structure we're going to use for
     our settings. */
  tiop->sgttyb = oldtio.sgttyb;
  tiop->lflag = oldtio.lflag;
#if defined (TIOCGETC)
  tiop->tchars = oldtio.tchars;
#endif
#if defined (TIOCGLTC)
  tiop->ltchars = oldtio.ltchars;
#endif
  tiop->flags = oldtio.flags;
 
  /* First, the basic settings to put us into character-at-a-time, no-echo
     input mode. */
  tiop->sgttyb.sg_flags &= ~(ECHO | CRMOD);
  tiop->sgttyb.sg_flags |= CBREAK;
 
  /* If this terminal doesn't care how the 8th bit is used, then we can
     use it for the meta-key.  If only one of even or odd parity is
     specified, then the terminal is using parity, and we cannot. */
#if !defined (ANYP)
#  define ANYP (EVENP | ODDP)
#endif
  if (((oldtio.sgttyb.sg_flags & ANYP) == ANYP) ||
      ((oldtio.sgttyb.sg_flags & ANYP) == 0))
    {
      tiop->sgttyb.sg_flags |= ANYP;
 
      /* Hack on local mode flags if we can. */
#if defined (TIOCLGET)
#  if defined (LPASS8)
      tiop->lflag |= LPASS8;
#  endif /* LPASS8 */
#endif /* TIOCLGET */
    }
 
#if defined (TIOCGETC)
#  if defined (USE_XON_XOFF)
  /* Get rid of terminal output start and stop characters. */
  tiop->tchars.t_stopc = -1; /* C-s */
  tiop->tchars.t_startc = -1; /* C-q */
 
  /* If there is an XON character, bind it to restart the output. */
  if (oldtio.tchars.t_startc != -1)
    rl_bind_key (oldtio.tchars.t_startc, rl_restart_output);
#  endif /* USE_XON_XOFF */
 
  /* If there is an EOF char, bind _rl_eof_char to it. */
  if (oldtio.tchars.t_eofc != -1)
    _rl_eof_char = oldtio.tchars.t_eofc;
 
#  if defined (NO_KILL_INTR)
  /* Get rid of terminal-generated SIGQUIT and SIGINT. */
  tiop->tchars.t_quitc = -1; /* C-\ */
  tiop->tchars.t_intrc = -1; /* C-c */
#  endif /* NO_KILL_INTR */
#endif /* TIOCGETC */
 
#if defined (TIOCGLTC)
  /* Make the interrupt keys go away.  Just enough to make people happy. */
  tiop->ltchars.t_dsuspc = -1;	/* C-y */
  tiop->ltchars.t_lnextc = -1;	/* C-v */
#endif /* TIOCGLTC */
}
 
#else  /* !defined (NEW_TTY_DRIVER) */
 
#if !defined (VMIN)
#  define VMIN VEOF
#endif
 
#if !defined (VTIME)
#  define VTIME VEOL
#endif
 
#if defined (TERMIOS_TTY_DRIVER)
#  define TIOTYPE struct termios
#  define DRAIN_OUTPUT(fd)	tcdrain (fd)
#  define GETATTR(tty, tiop)	(tcgetattr (tty, tiop))
#  ifdef M_UNIX
#    define SETATTR(tty, tiop)	(tcsetattr (tty, TCSANOW, tiop))
#  else
#    define SETATTR(tty, tiop)	(tcsetattr (tty, TCSADRAIN, tiop))
#  endif /* !M_UNIX */
#else
#  define TIOTYPE struct termio
#  define DRAIN_OUTPUT(fd)
#  define GETATTR(tty, tiop)	(ioctl (tty, TCGETA, tiop))
#  define SETATTR(tty, tiop)	(ioctl (tty, TCSETAW, tiop))
#endif /* !TERMIOS_TTY_DRIVER */

voyez ?
ils utilisent bien termios, termcap et ioctl !

[miloutch]

Ca y est j'ai trouvé !

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
#include <termios.h>
 
/* Use this variable to remember original terminal attributes. */
 
struct termios saved_attributes;
 
void 
reset_input_mode (void)
{
  tcsetattr (STDIN_FILENO, TCSANOW, &saved_attributes);
}
 
void 
set_input_mode (void)
{
  struct termios tattr;
  //char *name;
 
  /* Make sure stdin is a terminal. */
  if (!isatty (STDIN_FILENO))
    {
      fprintf (stderr, "Not a terminal.\n");
      exit (EXIT_FAILURE);
    }
 
  /* Save the terminal attributes so we can restore them later. */
  tcgetattr (STDIN_FILENO, &saved_attributes);
  atexit (reset_input_mode);
 
  /* Set the funny terminal modes. */
  tcgetattr (STDIN_FILENO, &tattr);
  tattr.c_lflag &= ~(ICANON|ECHO); /* Clear ICANON and ECHO. */
  tattr.c_cc[VMIN] = 1;
  tattr.c_cc[VTIME] = 0;
  tcsetattr (STDIN_FILENO, TCSAFLUSH, &tattr);
}
 
int main (void)
{
	char c;
	set_input_mode ();
	int j=0;
	while (1)
    {
		int i=0;
		j=read (STDIN_FILENO, &c, 1);
		if (c == '\004')
		{         /* C-d */
			printf("Salut ! :)\n");
			break;
		}
		else if(c == '[')
		{
			j=read (STDIN_FILENO, &c, 1);
			switch(c)
			{
					case 'A':
						printf("appuyé sur la touche du haut\n");
					break;
					case 'B':
						printf("appuyé sur la touche du bas\n");
					break;
			}
		}
    }
	return EXIT_SUCCESS;
}

[Obsidian]

Tu as trouvé ça où ? Tu l'as écrit tout seul ou tu l'as repris quelque part ? As-tu jeté un œil à la discussion que je t'avais laissée en lien ? Parce que là, il manque au moins le traitement du code ESC.

[miloutch]

Non je l'ai pas écris tout seul
oui j'ai regardé ta discussion, mais j'ai du regarder en profondeur, j'ai vu que tu mettais que les fleches n'étaient pas codées, or c'est ce que je veux manipuler.
d'ou le bout de code que j'ai mis
suffirai de faire if(c == '\033') pour gerer le ESC.

[Obsidian]

Non. J'y ai dit que les flèches n'avaient pas de code A.S.C.I.I. propre.

Pour coder des fonctions de terminal « intelligentes », il faut donc faire des séquences de caractères, et inventer une sorte de langage. Le code A.S.C.I.I. « ESC » servant, en principe, à sortir du flux de caractères ordinaire pour donner un ordre au terminal.

Il y en a plein, mais les plus répandus, notamment sur PC, sont les fameux codes standards ANSI, dits « CSI », car leur majorité commence par la séquence C.S.I. Cette séquence est « Esc [ ».

Donc :

• ESC [ A fait monter le curseur ;
• ESC [ B fait descendre le curseur ;
• ESC [ C le fait avancer ;
• ESC [ D le fait reculer ;
• ESC [ 34 m permet d'écrire en bleu ;
• ESC [ 1 m active la surbrillance ;
• etc.

Tu peux également mettre un quantitatif numérique entre le « [ » et le code proprement dit sur certaines fonctions la répéter. Par exemple, « ESC [ 10 B » fera descendre le curseur de dix lignes.

Ce n'est pas bien difficile, mais il faut être sûr de savoir ce que l'on fait.

[miloutch]

C'est énorme, t'est le génie de la lampe !
Mon message n'était pas du tout à propos de ca.
Mais je l'ai résolu et là je cherchais comment faire bouger le curseur, et sans rien demander, tu me donne la solution !!!
tu m'a l'air sacrément calé en C vu le nombre de message auquels tu as répondu
Merci pour tout vraiment !

[Obsidian]

Mais je l'ai résolu et là je cherchais comment faire bouger le curseur, et sans rien demander, tu me donne la solution !!! tu m'a l'air sacrément calé en C vu le nombre de message auquels tu as répondu

Mouais, la quantité n'implique pas forcément la qualité. En général, c'est même inversement proportionnel ! Je me suis déjà fait remettre à ma place ici même et à juste titre… Mais content de t'avoir été utile en tout cas.

À bientôt.

[Jean-Marc.Bourguet]

Il y a différents problèmes à résoudre ici.

- pouvoir controller le gestionnaire de terminal pour qu'il ne fasse pas d'édition (très basique, je sais) lui-même et renvoie les caractères directement.

Ça se faisait jadis avec les ioctl, POSIX est passé par là et a standardisé des fonctions pour se faire (tcXXX).

- savoir ce qu'il faut envoyer et ce qu'on reçoit du terminal. Obsidan a parlé des codes "ANSI" (à ma connaissance, l'ANSI n'a rien en plus à faire que l'AFNOR pour ça, la base technique provient des terminaux de DEC et la normalisation a été faite par un comité joint ISO-ECMA -- ce qui fait que le moyen le plus simple d'en avoir la définition c'est chercher après ECMA-48 *). Sous Unix il y a deux bases de données rassemblant l'information pour pas mal de terminaux (beaucoup de définition n'ont qu'un intérêt historique, mais certaines sont toujours utiles car les terminaux sont loins d'implémenter complètement ECMA-48 -- certaines choses sont d'ailleurs sans objet dans ce cadre -- et on parfois des extensions ou des bugs; avoir une description adéquate permet d'utiliser ces extensions et de contourner les bugs): termcap et terminfo. La dernière semblant être prédominante maintenant. En plus d'une base de donnée, il y a aussi une API de bas niveau.

- les API abstrayant cela. readline et les variantes de curses sont des exemples.

---------------

Maintenant, si tu as un problème avec l'utilisation de curses, je vois trois causes:
- tu n'utilises pas la bonne description du terminal, donc ça part en vrille (les bugs et les variantes font que ça peut presque marcher jusqu'à ce qu'on voit un problème) -> chercher la bonne description
- la description du terminal a une feature qui t'embêtes (je pense à la sauvegarde et la restauration du contenu, c'est énervant avec les programmes comme more ou ce qu'on voulait voir disparait). Le problème est que certains terminaux ont besoin de ça pour fonctionner, mais ce n'est pas le cas des émulateurs de terminaux -> chercher une description du terminal qui n'utilise pas ça ou en écrire une soi-même (les db sont prévues pour être incrémentales, tu ne dois décrire que ce qui différe de la base qui t'intéresse)
- tu utilises mal curses et oublie d'appeler la fonction prévue pour restaurer le terminal


* l'ECMA est avec l'ISO et l'IEEE une des sources majeures de normes dans notre domaine. Il y a souvent des comités conjoints et des republications sous le nom ISO de choses sortant de l'ECMA. Un avantage, c'est que les versions ECMA sont gratuites (voir son site http://www.ecma-international.org/). Un inconvénient, c'est que pour participer à la normisation par l'ECMA, c'est beaucoup plus cher.