Nous allons maintenant détailler quelque fonctions qui permettent de gérer l'affichage des fenêtres avec GLUT (il existe d'autres fonctions de gestion des fenêtres, détaillées ici).
void glutSetWindow ( int win );
Etablit que la fenêtre courante est celle dont le numéro est win.
(La fonction glutCreateWindow retourne un entier positif identifiant le numéro de la fenêtre.
C'est cet entier qui est utilisé par la fonction glutSetWindow.)
int glutGetWindow ( void );
Retourne le numéro de la fenêtre courante. (Si elle a été détruite, le numéro retourné est 0.)
void glutDestroyWindow ( int win );
Détruit la fenêtre dont le numéro est win. (Si win identifie la fenêtre
courante, alors la fenêtre courante devient invalide et glutGetWindow retourne la valeur 0).
void glutPositionWindow ( int x, int y );
Change la position de la fenêtre courante, x et y étant les coordonnées en x et y
de la position en pixels de la fenêtre par rapport au coin en haut à gauche de l'écran (pour une fenêtre initialement créée
avec glutCreateWindow).
void glutReshapeWindow ( int width, int height );
Change les dimensions de la fenêtre courante, width étant la nouvelle largeur
et height la nouvelle hauteur en pixels de la fenêtre (ces paramétres doivent être positifs).
void glutFullScreen ( void );
Demande l'affichage de la fenêtre courante en plein écran, c'est-à-dire la suppression des bordures
et des barres de titre, et l'affichage de la fenêtre la plus grande possible (ses dimensions ne correspondent
pas nécessairement aux dimensions de l'écran).
Un appel aux fonctions glutReshapeWindow et glutPositionWindow désactive le mode plein écran.
void glutShowWindow ( void );
Affiche la fenêtre courante (qui peut ne pas être visible si elle est caché par une autre fenêtre).
void glutHideWindow ( void );
Cache la fenêtre courante.
void glutIconifyWindow ( void );
Réduit la fenêtre courante.
Voici un exemple d'utilisation de ces fonctions sur un affichage de deux fenêtres. Les modifications se font avec les touches du clavier (f/F, plein écran, d/D, destruction de la fenêtre, c/C, cache la fenêtre et m/M, montre la fenêtre cachée).
#include <windows.h>
#include <gl/gl.h>
#include <gl/glut.h>
#define WIDTH1 640 // Taille de la fenêtre 1
#define HEIGHT1 480
#define WIDTH2 400 // Taille de la fenêtre 2
#define HEIGHT2 300
int nFullScreen1=0;
int nFullScreen2=0;
int nF1, nF2, nFcour; // numéros des fenêtres
int nCache=0;
void vClavier1(unsigned char key, int x, int y); // Fonctions de gestion des touches du clavier
void vClavier2(unsigned char key, int x, int y);
void vDisplay1(); // Fonctions d'affichage
void vDisplay2();
void vReshape1(); // Fonctions de redimensionnement
void vReshape2();
int main( int argc, char *argv[ ])
{
printf("*********************************************\n");
printf("* Affichage de fenetres avec GLUT *\n");
printf("* Options proposees : *\n");
printf("* f ou F : Plein ecran *\n");
printf("* d ou D : Detruit la fenetre *\n");
printf("* c ou C : Cache la fenetre *\n");
printf("* m ou M : Montre la fenetre cachee *\n");
printf("*********************************************\n");
glutInit(&argc,argv); // initialisation de GLUT
glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);
// Affichage de la première fenêtre
glutInitWindowSize(WIDTH1,HEIGHT1);
glutInitWindowPosition(50,50);
nF1=glutCreateWindow("Fenêtre 1");
glutDisplayFunc(vDisplay1);
glutReshapeFunc(vReshape1);
glutKeyboardFunc(vClavier1);
// Affichage de la deuxième fenêtre
glutInitWindowSize(WIDTH2,HEIGHT2);
glutInitWindowPosition(150,150);
nF2=glutCreateWindow("Fenêtre 2");
glutDisplayFunc(vDisplay2);
glutReshapeFunc(vReshape2);
glutKeyboardFunc(vClavier2);
glutMainLoop();
return 0;
}
void vClavier1(unsigned char key, int x, int y)
{
switch (key) {
case 'f' :
case 'F' :
if (nFullScreen1==0)
{
glutFullScreen();
nFullScreen1=1;
break;
}
if (nFullScreen1==1)
{
glutReshapeWindow(WIDTH1,HEIGHT1);
glutPositionWindow (50,50);
nFullScreen1=0;
break;
}
case 'd' :
case 'D' :
nFcour=glutGetWindow();
glutDestroyWindow(nFcour);
break;
case 'c' :
case 'C' :
if (nCache==0){
glutHideWindow();
nCache=1;
}
break;
case 'm' :
case 'M' :
if (nCache==1){
glutSetWindow(nF2);
glutShowWindow();
nCache=0;
}
break;
default :
break;
}
}
void vClavier2(unsigned char key, int x, int y)
{
switch (key) {
case 'f' :
case 'F' :
if (nFullScreen2==0)
{
glutFullScreen();
nFullScreen2=1;
break;
}
if (nFullScreen2==1)
{
glutReshapeWindow(WIDTH2,HEIGHT2);
glutPositionWindow (150,150);
nFullScreen2=0;
break;
}
case 'd' :
case 'D' :
nFcour=glutGetWindow();
glutDestroyWindow(nFcour);
break;
case 'c' :
case 'C' :
if (nCache==0){
glutHideWindow();
nCache=1;
}
break;
case 'm' :
case 'M' :
if (nCache==1){
glutSetWindow(nF1);
glutShowWindow();
nCache=0;
}
break;
default :
break;
}
}
void vDisplay1()
{
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 vDisplay2()
{
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);
glColor3d(0.8,0.8,0.8); // rectangle de couleur grise
glVertex2d(-50,-50);
glVertex2d(50,-50);
glVertex2d(50,50);
glVertex2d(-50,50);
glEnd();
glFlush();
}
void vReshape1(int w, int h)
{
float L;
float H;
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w<=h)
{
if (w==0) H=HEIGHT1;
else H=(GLfloat) (WIDTH1*h/w);
L=WIDTH1;
}
else
{
H=HEIGHT1;
if (h==0) L=WIDTH1;
else L=(GLfloat) (HEIGHT1*w/h);
}
gluOrtho2D(-L/2,L/2,-H/2,H/2);
}
void vReshape2(int w, int h)
{
float L;
float H;
glViewport(0,0,w,h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if (w<=h)
{
if (w==0) H=HEIGHT2;
else H=(GLfloat) (WIDTH2*h/w);
L=WIDTH2;
}
else
{
H=HEIGHT2;
if (h==0) L=WIDTH2;
else L=(GLfloat) (HEIGHT2*w/h);
}
gluOrtho2D(-L/2,L/2,-H/2,H/2);
}