Gestion du clavier et de la souris

La gestion du clavier et de la souris s'effectue entre autres avec les fonctions glutKeyboardFunc et glutSpecialFunc pour le clavier, et avec glutMouseFunc, glutMotionFunc et glutPassiveMotionFunc pour la souris. Toutes ces fonctions établissent les fonctions de rappel pour le clavier ou la souris pour la fenêtre courante.

Exemple global de gestion du clavier et de la souris ici

On distingue deux sortes de touches pour le clavier. Les touches normales (associées à des caractères ASCII) et les touches spéciales (associées aux caractères non-ASCII).

La fonction glutKeyboardFunc gère les touches normales du clavier :

void glutKeyboardFunc ( void (*func) ( unsigned char key, int x, int y ) );

func identifie la fonction de rappel du clavier.

unsigned char key, int x, int y sont les paramètres de cette fonction : key est le code ASCII du caractère tapé, et x et y les coordonnées de la souris (en pixels) par rapport au coin en haut à gauche de la fenêtre lors de la frappe d'une touche.

Il suffit d'appeler glutKeyboardFunc(NULL); pour désactiver la fonction de rappel pour les touches normales du clavier.

Voici un exemple de gestion du clavier :


void vClavier(unsigned char key, int x, int y)
{
	printf(" Touche: %c\n Souris a: %d %d \n",key,x,y); 
}

Pour gérer les différentes touches, on peut par exemple appeler un switch :


void vClavier(unsigned char key, int x, int y)
{
	switch (key){
	
	//Mode plein écran
		case 'f' :
		case 'F' :
			if (nFullScreen==0)
			{
				glutFullScreen();
				nFullScreen=1;
				break;
			}
			if (nFullScreen==1)
			{
				glutReshapeWindow(WIDTH,HEIGHT);
				glutPositionWindow (50,50);
				nFullScreen=0;
				break;
			}
	
	//Supprimer le traitement des touches normales du clavier
		case 's' :
		case 'S' :
			glutKeyboardFunc(NULL);
			break;

	//Quitter
		case 'q' :
		case 'Q' :
		case 27  : // Touche ESC
			exit (0);
			break;

		default :
			printf(" Touche: %c\n Souris a: %d %d \n",key,x,y); 
			break;

	}
}

L'appel à la fonction glutKeyboardFunc se fait dans le main, après avoir créé la fenêtre, et avant le glutMainLoop();. On obtient donc, pour notre exemple :


#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>

#define WIDTH 640
#define HEIGHT 480 

int nFullScreen=0;

void vDisplay();
void vReshape();
void vClavier(unsigned char key, int x, int y);

int main( int argc, char *argv[ ]) 
{ 
	glutInit(&argc,argv); // initialisation de GLUT
	glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);
	glutInitWindowSize(WIDTH,HEIGHT);
	glutInitWindowPosition(50,50);
	glutCreateWindow("Clavier");
	glutDisplayFunc(vDisplay);
	glutReshapeFunc(vReshape);

	glutKeyboardFunc(vClavier);

	glutMainLoop();
	return 0; 
} 

void vDisplay() 
{ 
	glClearColor(0,0,0,0);
	glClear(GL_COLOR_BUFFER_BIT);

	glBegin(GL_QUADS);
	glColor3d(0.5,1,0.5); // rectangle de couleur verte
	glVertex2d(-50,-50);
	glVertex2d(50,-50);
	glVertex2d(50,50);
	glVertex2d(-50,50);
	glEnd();

   
	glFlush(); 
} 


void vReshape(int w, int h) 
{ 
	float L; 
	float H; 

	glViewport(0,0,w,h); 
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity(); 
	if (w<=h) 
	{ 
	  if (w==0) H=HEIGHT; 
	  else H=(GLfloat) (WIDTH*h/w); 
	  L=WIDTH; 
	} 
	else 
	{ 
	  H=HEIGHT; 
	  if (h==0) L=WIDTH; 
	  else L=(GLfloat) (HEIGHT*w/h); 
	} 
	gluOrtho2D(-L/2,L/2,-H/2,H/2); 
}






La fonction glutSpecialFunc gère les touches spéciales du clavier :

void glutSpecialFunc ( void (*func) ( int key, int x, int y ));

func identifie la fonction de rappel du clavier pour les caractères non-ASCII (ce sont par exemple les touches de fonction (F1 à F12) ou de direction).

int key, int x, int y sont les paramètres de cette fonction : key est une constante correspondant à une touche spéciale (GLUT_KEY_*), et x et y les coordonnées de la souris (en pixels) par rapport au coin en haut à gauche de la fenêtre lors de la frappe d'une touche.

Il suffit d'appeler glutSpecialFunc(NULL); pour désactiver la fonction de rappel pour les touches spéciales du clavier.

Les valeurs correspondant aux touches spéciales sont :

Touche Valeur
F1 GLUT_KEY_F1
F2 GLUT_KEY_F2
F3 GLUT_KEY_F3
F4 GLUT_KEY_F4
F5 GLUT_KEY_F5
F6 GLUT_KEY_F6
F7 GLUT_KEY_F7
F8 GLUT_KEY_F8
F9 GLUT_KEY_F9
F10 GLUT_KEY_F10
F11 GLUT_KEY_F11
F12 GLUT_KEY_F12
GLUT_KEY_LEFT
GLUT_KEY_UP
GLUT_KEY_RIGHT
GLUT_KEY_DOWN
Page précédente (Pg up) GLUT_KEY_PAGE_UP
Page suivante (Pg down) GLUT_KEY_PAGE_DOWN
Origine (Home) GLUT_KEY_HOME
Fin (end) GLUT_KEY_END
Insertion (ins) GLUT_KEY_INSERT

Atttention! Certaines touches qui pourraient sembler spéciales génèrent des caractères ASCII! Voici quelques uns de ces caractères :

Touche Valeur (en décimal)
Retour Arrière (Backspace) 8
Tabulation (Tab) 9
Entrée (Enter) 13
Echappement (Escape) 27
Supprime (Delete) 127

Pour avoir la valeur décimale ASCII d'un caractère associé à une touche, il suffit d'utiliser la fonction de rappel suivante et de l'appeler avec glutKeyboardFunc :


void vClavier(unsigned char key, int x, int y)
{
	printf(" Touche: %c = %d \n",key,key); 
}

Voici un exemple de gestion des touches spéciales du clavier (qui permet de modifier la position d'un carré. Le code complet est disponible ici) :


void vSpecial(int key, int x, int y)
{
	switch (key)
	{
		case GLUT_KEY_UP :
			fVertic+=fPasV;
			break;
		
		case GLUT_KEY_DOWN :
			fVertic-=fPasV;
			break;

		case GLUT_KEY_LEFT :
			fHoriz-=fPasH;
			break;

		case GLUT_KEY_RIGHT :
			fHoriz+=fPasH;
			break;

		default :
			printf(" Autre Touche Speciale\n ");
			break;	
	}
}



La fonction de rappel pour la souris est établie par la fonction glutMouseFunc :

void glutMouseFunc ( void (*func) ( int button, int state, int x, int y ) );

func identifie la fonction de rappel pour la souris.

int button, int state, int x, int y sont les paramètres de cette fonction :

button vaut GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON, ou GLUT_RIGHT_BUTTON.

state indique si la fonction de rappel a été appelée suite à l'appui ou au relâchement d'un bouton de la souris. Il vaut GLUT_UP ou GLUT_DOWN.

x et y sont les coordonnées de la souris (en pixels) par rapport au coin en haut à gauche de la fenêtre lors de la modification de l'état d'un bouton.

Chaque appui ou relâchement d'un des boutons de la souris provoque un appel à la fonction de rappel de la souris. Si on veut avoir l'état de la souris en permanence, on peut par exemple utiliser
glutMotionFunc ou glutPassiveMotionFunc

Si un menu est attaché à un bouton de la souris, aucun rappel de la fonction de la souris n'est effectué pour ce bouton.

Il suffit d'appeler glutMouseFunc(NULL); pour désactiver la fonction de rappel pour la souris.

Voici un exemple :


void vMouse(int button, int state, int x, int y)
{
	printf("Souris a: %d %d \n",x,y); 
	switch (button)
	{
		case GLUT_LEFT_BUTTON :
			printf("Bouton Gauche\n");
			if (state==GLUT_DOWN) printf("Appui\n");
			if (state==GLUT_UP) printf("Relachement\n");
			break;
		
		case GLUT_MIDDLE_BUTTON :
			printf("Bouton du Milieu\n");
			if (state==GLUT_DOWN) printf("Appui\n");
			if (state==GLUT_UP) printf("Relachement\n");
			break;

		case GLUT_RIGHT_BUTTON :
			printf("Bouton Droit\n");
			if (state==GLUT_DOWN) printf("Appui\n");
			if (state==GLUT_UP) printf("Relachement\n");
			break;

		default :
			printf("Erreur??\n");
			break;
	}
}



L'appel à la fonction glutMouseFunc se fait dans le main, après avoir créé la fenêtre, et avant le glutMainLoop();.


	...

	glutReshapeFunc(vReshape);
	
	...

	glutMouseFunc(vMouse); // Gestion de la souris

	...

	glutMainLoop();



La fonction glutMotionFunc gère les déplacements de la souris lorsqu'un ou plusieurs boutons sont appuyés (il y a un retour seulement si la souris bouge) :

void glutMotionFunc ( void (*func) (int x, int y ));

func identifie la nouvelle fonction de rappel pour un déplacement de la souris, dont les paramètres x et y sont les coordonnées de la souris (en pixels) par rapport au coin en haut à gauche de la fenêtre.

Il suffit d'appeler glutMotionFunc(NULL); pour désactiver la fonction de rappel pour le déplacement de la souris avec au moins un bouton appuyé.



Voici un exemple :


void vMotion(int x, int y)
{
	printf("Souris a: %d %d \n",x,y);
}



L'appel à la fonction glutMotionFunc se fait dans le main, après avoir créé la fenêtre, et avant le glutMainLoop();.


	...

	glutReshapeFunc(vReshape);
	
	...

	glutMotionFunc(vMouse);

	...

	glutMainLoop();



La fonction glutPassiveMotionFunc gère les déplacements de la souris lorsqu'aucun bouton n'est appuyé (il y a un retour seulement si la souris bouge) :

void glutPassiveMotionFunc ( void (*func) (int x, int y ));

func identifie la nouvelle fonction de rappel pour un déplacement de la souris, dont les paramètres x et y sont les coordonnées de la souris (en pixels) par rapport au coin en haut à gauche de la fenêtre.

Il suffit d'appeler glutPassiveMotionFunc(NULL); pour désactiver la fonction de rappel pour le déplacement de la souris avec aucun bouton appuyé.



Voici un exemple :


void vPassive(int x, int y)
{
	printf("Souris a: %d %d \n",x,y);
}



L'appel à la fonction glutPassiveMotionFunc se fait dans le main, après avoir créé la fenêtre, et avant le glutMainLoop();.


	...

	glutReshapeFunc(vReshape);

	...
	
	glutPassiveMotionFunc(vPassive);

	...

	glutMainLoop();