CodeS-SourceS est hébergé par Frontier.fr

Ce site au démarrage

begin process at 2012 02 12 08:10:10

Accueil Codes Tutoriels Forum Livres Emploi Services Connexion

Trouver un code source :

dans

[ Dernières recherches ]

Accueil >

Graphique

> GENERATION DE FENETRE TYPE WINDOWS EN OPENGL

GENERATION DE FENETRE TYPE WINDOWS EN OPENGL

Information sur la source

Note :
Aucune note

Catégorie :Graphique Niveau :Débutant Date de création :26/09/2002 Date de mise à jour :26/09/2002 19:06:18 Vu / téléchargé :5 700 / 334

Auteur : sebos2013

Ecrire un message privé

Commentaire sur cette source (3)

Ajouter un commentaire et/ou une note

Description

Ce prog affiche une fenetre type windows avec differents boutons, qui eux memes peuvent ouvrir une autre fenetre.
Ca ne sert pas a grand choise, c'est seulement pour le fun et pour impressionner les pots.

Source

#include <gl\glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#define nb_fenetre 6
int xmouse,ymouse,souris_gauche=0,souris_droite=0,souris_milieu=0,tailley=599,taillex=799;
//Gestion des clique de la souris
void Souris_clique(int button,int state,int x,int y)
{
xmouse=x;
ymouse=tailley-y;
if((button==GLUT_LEFT_BUTTON)&&(state==GLUT_DOWN))
souris_gauche=1;
if((button==GLUT_LEFT_BUTTON)&&(state==GLUT_UP))
souris_gauche=0;
if((button==GLUT_RIGHT_BUTTON)&&(state==GLUT_DOWN))
souris_droite=1;
if((button==GLUT_RIGHT_BUTTON)&&(state==GLUT_UP))
souris_droite=0;
if((button==GLUT_MIDDLE_BUTTON)&&(state==GLUT_DOWN))
souris_milieu=1;
if((button==GLUT_MIDDLE_BUTTON)&&(state==GLUT_UP))
souris_milieu=0;
}
//Gestion des coordonnees de la souris
void Souris_position(int x,int y)
{
xmouse=x;
ymouse=tailley-y;
}
void Clavier_standart(unsigned char key,int x,int y)
{
if(key==27) exit(0);
}
typedef struct
{
int xbas;
int ybas;
int largeur;
int hauteur;
char *texte;
int etat;
int dep;
int place;
int flag_quitter;
int flag_reduction;
}FENETRE;
int depl1x,depl1y,depl2x,depl2y;
int x2,y2;
int flag_bouton1=0,flag_bouton2=0,flag_bouton3=0,flag_bouton4=0,flag_bouton5=0;
int fac1=1,fac2=1,fac3=1,fac4=1,fac5=1;
void Tri_fenetres(FENETRE *,int);
void Menu(FENETRE &,int,FENETRE *,int);
void Bouton_quitter(int,int,FENETRE &,int);
void Bouton_reduction(int,int,FENETRE &,int,int);
void Gere_boutons_reduits(FENETRE *,int);
void Deplace_fenetre(FENETRE &);
void bouton(char *,int,int,int,float,FENETRE &,FENETRE *,int &,int);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Affichage des fenetres //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Fenetre(FENETRE *fen,int nb)
{
int i,j,modif;
Tri_fenetres(fen,nb);
for(i=0;i<nb;i++)
{
for(j=0;j<nb;j++)
{
if(fen[j].place==nb-i)
{
if(fen[j].etat!=0)
{
if((fen[j].flag_quitter==0)&&(fen[j].flag_reduction==0))
{
Deplace_fenetre(fen[j]);
}
Gere_boutons_reduits(fen,nb);
if(fen[j].place==1) modif=1;
else modif=0;
Menu(fen[j],modif,fen,nb);
if(fen[j].flag_quitter==1) modif=1;
else modif=0;
Bouton_quitter(fen[j].xbas+fen[j].largeur-25,fen[j].ybas+fen[j].hauteur+2,fen[j],modif);
if(fen[j].flag_reduction==1) modif=1;
else modif=0;
Bouton_reduction(fen[j].xbas+fen[j].largeur-45,fen[j].ybas+fen[j].hauteur+2,fen[j],modif,nb);
}
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Bouton quitter de la fenetre //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Bouton_quitter(int x,int y,FENETRE &fen,int modif)
{
//Initialisation du flag pour le clique sur le bouton
if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==1)&&(fen.place==1))
{
fen.flag_quitter=1;
}
//Fermeture de la fenetre du bouton_quitter
if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==0)&&(fen.flag_quitter==1))
{
fen.etat=0;
fen.flag_quitter=0;
}
//Annulation si la souris est relachee a cote du bouton
if(((xmouse<x)||(xmouse>x+15)||(ymouse<y)||(ymouse>y+15))&&(fen.flag_quitter==1))
{
fen.flag_quitter=0;
}
glBegin(GL_QUADS);
glColor3f(0.5,modif,modif);
glVertex2d(x,y);
glColor3f(fabs(modif-0.8),modif,modif);
glVertex2d(x+15,y);
glColor3f(0.5,modif,modif);
glVertex2d(x+15,y+15);
glColor3f(1-modif,1-modif,1-modif);
glVertex2d(x,y+15);
glEnd();
glBegin(GL_LINE_LOOP);
glColor3f(fabs(modif-0.6),fabs(modif-0.1),fabs(modif-0.3));
glVertex2d(x,y);
glVertex2d(x+15,y);
glVertex2d(x+15,y+15);
glVertex2d(x,y+15);
glEnd();
glBegin(GL_LINES);
glColor3f(1-modif,1-modif,1-modif);
glVertex2d(x,y);
glVertex2d(x+15,y+15);
glVertex2d(x,y+15);
glVertex2d(x+15,y);
glEnd();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Gere la reduction des fenetres //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Bouton_reduction(int x,int y,FENETRE &fen,int modif,int nb)
{
//Initialisation de la reduction pour le clique sur le bouton
if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==1)&&(fen.place==1))
{
fen.flag_reduction=1;
}
//Reduction ou agrandissement de la fenetre
if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==0)&&(fen.flag_reduction==1))
{
fen.etat=3-fen.etat;
fen.flag_reduction=0;
}
//Annulation si la souris est relachee a cote du bouton
if(((xmouse<x)||(xmouse>x+15)||(ymouse<y)||(ymouse>y+15))&&(fen.flag_reduction==1))
{
fen.flag_reduction=0;
}
glBegin(GL_QUADS);
glColor3f(0.5,modif,fabs(modif-0.8));
glVertex2d(x,y);
glColor3f(modif,modif,fabs(modif-0.8));
glVertex2d(x+15,y);
glColor3f(0.5,modif,fabs(modif-0.8));
glVertex2d(x+15,y+15);
glColor3f(1-modif,1-modif,1-modif);
glVertex2d(x,y+15);
glEnd();
glBegin(GL_LINE_LOOP);
glColor3f(fabs(modif-0.6),fabs(modif-0.1),fabs(modif-0.3));
glVertex2d(x,y);
glVertex2d(x+15,y);
glVertex2d(x+15,y+15);
glVertex2d(x,y+15);
glEnd();
glBegin(GL_LINES);
glColor3f(1-modif,1-modif,1-modif);
glVertex2d(x+2,y+4);
glVertex2d(x+13,y+4);
glEnd();
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Affiche du texte en OpenGL //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Ecrire(int x,int y,char *texte)
{
unsigned int i;
glRasterPos2d(x,y);
for (i = 0; i < strlen (texte); i++)
glutBitmapCharacter (GLUT_BITMAP_HELVETICA_10, texte[i]);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Reoganisation de la place des fenetres //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Tri_fenetres(FENETRE *fen,int nb)
{
int i,j,num_proche=nb,num_eloigne=-1;
//num_proche est le numero de la fenetre a placer au 1er plan apres un clique
for(i=0;i<nb;i++)
{
if(fen[i].etat==1)
{
if((xmouse>=fen[i].xbas)&&(xmouse<=fen[i].xbas+fen[i].largeur)&&(ymouse>=fen[i].ybas)&&(ymouse<=fen[i].ybas+fen[i].hauteur+20)&&(souris_gauche==1))
{
if(num_proche==nb) num_proche=i;
if(fen[num_proche].place>fen[i].place) num_proche=i;
}
}
if(fen[i].etat==2)
{
if((xmouse>=fen[i].xbas)&&(xmouse<=fen[i].xbas+fen[i].largeur)&&(ymouse>=fen[i].ybas+fen[i].hauteur)&&(ymouse<=fen[i].ybas+fen[i].hauteur+20)&&(souris_gauche==1))
{
if(num_proche==nb) num_proche=i;
if(fen[num_proche].place>fen[i].place) num_proche=i;
}
}
}
//mise a jour des places en fonction de la fenetre mise en 1er plan
if(num_proche!=nb)
{
for(i=0;i<nb;i++)
if(fen[i].place<fen[num_proche].place) fen[i].place+=1;
fen[num_proche].place=1;
}
//num_eloigne est le numero de la fenetre la plus eloigne
for(i=0;i<nb;i++)
{
if(num_eloigne==-1) num_eloigne=i;
if(fen[num_eloigne].place<fen[i].place) num_eloigne=i;
}
//mise a jour des places en fonction des fenetres supprimees
if(num_eloigne!=-1)
{
for(i=0;i<nb;i++)
{
if(fen[i].etat==0)
{
for(j=0;j<nb;j++)
if(fen[j].place>fen[i].place) fen[j].place-=1;
fen[i].place=nb;
}
}
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Cadre de la fenetre //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Menu(FENETRE &fen,int modif,FENETRE *fen_global,int nb)
{
int epaisseur=3;
if(fen.etat!=2)
{
glBegin(GL_POLYGON);
glColor3f(0,0,0.8);
glVertex2d(fen.xbas,fen.ybas);
glVertex2d(fen.xbas+fen.largeur,fen.ybas);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0,0,0.8);
glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0,0,0.8);
glVertex2d(fen.xbas,fen.ybas);
glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0,0,0.8);
glVertex2d(fen.xbas+fen.largeur,fen.ybas);
glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0.8,0.7,0.6);
glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
glColor3f(0.5,0.4,0.3);
glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
glEnd();
if(fen.texte=="Fenetre principale.")
{
bouton("Fenetre1",fen.xbas+5,fen.ybas+fen.hauteur-40,120,fac1,fen,fen_global,flag_bouton1,nb);
bouton("Fenetre2",fen.xbas+5,fen.ybas+fen.hauteur-40-50,120,fac2,fen,fen_global,flag_bouton2,nb);
bouton("Fenetre3",fen.xbas+5,fen.ybas+fen.hauteur-40-100,120,fac3,fen,fen_global,flag_bouton3,nb);
bouton("Fenetre4",fen.xbas+5,fen.ybas+fen.hauteur-40-150,120,fac4,fen,fen_global,flag_bouton4,nb);
bouton("Fenetre5",fen.xbas+5,fen.ybas+fen.hauteur-40-200,120,fac5,fen,fen_global,flag_bouton5,nb);
}
}
glBegin(GL_POLYGON);
glColor3f(modif,modif,fabs(modif-0.8));
glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
glVertex2d(fen.xbas,fen.ybas+fen.hauteur+10);
glVertex2d(fen.xbas+10,fen.ybas+fen.hauteur+20);
glColor3f(fabs(modif-0.2),fabs(modif-0.7),fabs(modif-0.9));
glVertex2d(fen.xbas+fen.largeur-10,fen.ybas+fen.hauteur+20);
glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur+10);
glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
glEnd();
glColor3f(1,0,0);
Ecrire(fen.xbas+10,fen.ybas+fen.hauteur+5,fen.texte);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Deplacement de la fenetre et activation //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Deplace_fenetre(FENETRE &fen)
{
if((xmouse>=fen.xbas)&&(xmouse<=fen.xbas+fen.largeur)&&(ymouse>=fen.ybas+fen.hauteur)&&(ymouse<=fen.ybas+fen.hauteur+20)&&(souris_gauche==1)&&(fen.dep==0)&&(fen.place==1))
{
depl1x=xmouse;
depl1y=ymouse;
fen.dep=1;
}
if((souris_gauche==1)&&(fen.dep==1)&&(fen.place==1))
{
depl2x=xmouse;
depl2y=ymouse;
fen.xbas+=(depl2x-depl1x);
fen.ybas+=(depl2y-depl1y);
if(fen.xbas<0) fen.xbas=0;
if(fen.xbas>taillex-fen.largeur) fen.xbas=taillex-fen.largeur;
if(fen.ybas+fen.hauteur<0) fen.ybas=-fen.hauteur;
if(fen.ybas>tailley-fen.hauteur-20) fen.ybas=tailley-fen.hauteur-20;
depl1x=depl2x;
depl1y=depl2y;
}
if(souris_gauche==0)
{
depl1x=depl1y=depl2x=depl2y=fen.dep=0;
}
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Tri des fenetres reduites //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Gere_boutons_reduits(FENETRE *fen,int nb)
{
int i,nb_reduit=0;
for(i=0;i<nb;i++)
{
if(fen[i].etat==2)
{
nb_reduit+=1;
fen[i].ybas=tailley-fen[i].hauteur-20*nb_reduit;
fen[i].xbas=0;
}
}
}
//Bouton
void bouton(char *text,int x,int y,int lg,float fac,FENETRE &fen,FENETRE *fen_global,int &flag_bouton,int nb)
{
int i;
if((xmouse>=x)&&(xmouse<=x+200)&&(ymouse>=y)&&(ymouse<=y+25)&&(souris_gauche==1)&&(fen.place==1))
{
flag_bouton=1;
fac=0.5;
}
if((xmouse>=x)&&(xmouse<=x+200)&&(ymouse>=y)&&(ymouse<=y+25)&&(souris_gauche==0)&&(flag_bouton==1))
{
flag_bouton=0;
for(i=1;i<nb;i++)
if(text==fen_global[i].texte) fen_global[i].etat=2;
}
//Annulation si la souris est relachee a cote du bouton
if(((xmouse<x)||(xmouse>x+200)||(ymouse<y)||(ymouse>y+25))&&(flag_bouton==1))
{
flag_bouton=0;
fac=1;
}
int lettres;
lettres=strlen(text);
glColor3f(fac*0.4,fac*0.4,fac*0.4);
glBegin(GL_POLYGON);
glVertex2f(x,y);
glColor3f(fac*0.3,fac*0.7,fac*0.9);
glVertex2f(lg+x,y);
glColor3f(fac*0.3,fac*0.8,fac*0.8);
glVertex2f(lg+x,y+25);
glColor3f(fac*0.8,fac*0.2,fac*0.8);
glVertex2f(x,y+25);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0,fac*0.6,0);
glVertex2f(lg+x,y+25);
glVertex2f(lg+2+x,y+30);
glColor3f(0,fac*0.3,0);
glVertex2f(x+2,y+30);
glVertex2f(x,y+25);
glEnd();
glBegin(GL_POLYGON);
glColor3f(0,fac*0.6,0);
glVertex2f(x+lg,y+25);
glVertex2f(lg+2+x,y+30);
glColor3f(0,fac*0.8,0);
glVertex2f(lg+2+x,y+2);
glVertex2f(lg+x,y);
glEnd();
glColor3f(fac*0.1,fac*0.3,fac);
Ecrire(x+lg/2-4.5*lettres/2,y+10,text);
}
void Draw(void);
// xbas | ybas| largeur | hauteur | titre | etat(0:supprime 1:active 2:reduite) | deplacement_en_cours(0 ou 1) |
// plan(1 jusqua nb_fenetre) | flag_quitter(0 ou 1) | reduction(0 ou 1)
//La hauteur de la fenetre sera de hauteur+20 pour le titre.
FENETRE liste[nb_fenetre]={
{400,180,400,400,"Fenetre principale.",1,0,1,0,0},
{100,200,300,300,"Fenetre1",0,0,2,0,0},
{100,200,300,300,"Fenetre2",0,0,3,0,0},
{100,200,300,300,"Fenetre3",0,0,4,0,0},
{100,200,300,300,"Fenetre4",0,0,5,0,0},
{100,200,300,300,"Fenetre5",0,0,6,0,0}
};
//Fonction de rafraichissement d'une fenêtre OpenGL
void Reshape(int width, int height)
{
tailley=height;
taillex=width;
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0,width,0,height,1,-1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
}
int main()
{
glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(800,600);
glutCreateWindow("seb");
glutReshapeFunc(Reshape);
glutDisplayFunc(Draw);
glutKeyboardFunc(Clavier_standart);
glutMotionFunc(Souris_position);
glutMouseFunc(Souris_clique);
glutMainLoop();
return 0;
}
void Draw()
{
glutSetWindowTitle("Fenetre principale.");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Mise en place des fenetres
Fenetre(liste,nb_fenetre);
//Forcage de l'affichage
glutPostRedisplay();
glutSwapBuffers();
}

#include <gl\glut.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>

#define nb_fenetre 6

int xmouse,ymouse,souris_gauche=0,souris_droite=0,souris_milieu=0,tailley=599,taillex=799;

//Gestion des clique de la souris
void Souris_clique(int button,int state,int x,int y)
{
	xmouse=x;
	ymouse=tailley-y;

	if((button==GLUT_LEFT_BUTTON)&&(state==GLUT_DOWN))
		souris_gauche=1;
	if((button==GLUT_LEFT_BUTTON)&&(state==GLUT_UP))
		souris_gauche=0;
	if((button==GLUT_RIGHT_BUTTON)&&(state==GLUT_DOWN))
		souris_droite=1;
	if((button==GLUT_RIGHT_BUTTON)&&(state==GLUT_UP))
		souris_droite=0;
	if((button==GLUT_MIDDLE_BUTTON)&&(state==GLUT_DOWN))
		souris_milieu=1;
	if((button==GLUT_MIDDLE_BUTTON)&&(state==GLUT_UP))
		souris_milieu=0;
}

//Gestion des coordonnees de la souris
void Souris_position(int x,int y)
{
	xmouse=x;
	ymouse=tailley-y;
}

void Clavier_standart(unsigned char key,int x,int y)
{
	if(key==27) exit(0);
}

typedef struct
{
	int xbas;
	int ybas;
	int largeur;
	int hauteur;
	char *texte;
	int etat;
	int dep;
	int place;
	int flag_quitter;
	int flag_reduction;
}FENETRE;

int depl1x,depl1y,depl2x,depl2y;
int x2,y2;
int flag_bouton1=0,flag_bouton2=0,flag_bouton3=0,flag_bouton4=0,flag_bouton5=0;
int fac1=1,fac2=1,fac3=1,fac4=1,fac5=1;

void Tri_fenetres(FENETRE *,int);
void Menu(FENETRE &,int,FENETRE *,int);
void Bouton_quitter(int,int,FENETRE &,int);
void Bouton_reduction(int,int,FENETRE &,int,int);
void Gere_boutons_reduits(FENETRE *,int);
void Deplace_fenetre(FENETRE &);
void bouton(char *,int,int,int,float,FENETRE &,FENETRE *,int &,int);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//												Affichage des fenetres										   //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Fenetre(FENETRE *fen,int nb)
{
	int i,j,modif;

	Tri_fenetres(fen,nb);

	for(i=0;i<nb;i++)
	{
		for(j=0;j<nb;j++)
		{
			if(fen[j].place==nb-i)
			{
				if(fen[j].etat!=0)
				{
					if((fen[j].flag_quitter==0)&&(fen[j].flag_reduction==0))
					{
						Deplace_fenetre(fen[j]);
					}

					Gere_boutons_reduits(fen,nb);

					if(fen[j].place==1) modif=1;
					else modif=0;
					Menu(fen[j],modif,fen,nb);

					if(fen[j].flag_quitter==1) modif=1;
					else modif=0;
					Bouton_quitter(fen[j].xbas+fen[j].largeur-25,fen[j].ybas+fen[j].hauteur+2,fen[j],modif);

					if(fen[j].flag_reduction==1) modif=1;
					else modif=0;
					Bouton_reduction(fen[j].xbas+fen[j].largeur-45,fen[j].ybas+fen[j].hauteur+2,fen[j],modif,nb);
				}
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                           Bouton quitter de la fenetre                                      //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Bouton_quitter(int x,int y,FENETRE &fen,int modif)
{
//Initialisation du flag pour le clique sur le bouton
	if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==1)&&(fen.place==1))
	{
		fen.flag_quitter=1;
	}

//Fermeture de la fenetre du bouton_quitter 
	if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==0)&&(fen.flag_quitter==1))
	{
		fen.etat=0;
		fen.flag_quitter=0;
	}

//Annulation si la souris est relachee a cote du bouton
	if(((xmouse<x)||(xmouse>x+15)||(ymouse<y)||(ymouse>y+15))&&(fen.flag_quitter==1))
	{
		fen.flag_quitter=0;
	}

		glBegin(GL_QUADS);
		glColor3f(0.5,modif,modif);
		glVertex2d(x,y);
		glColor3f(fabs(modif-0.8),modif,modif);
		glVertex2d(x+15,y);
		glColor3f(0.5,modif,modif);
		glVertex2d(x+15,y+15);
		glColor3f(1-modif,1-modif,1-modif);
		glVertex2d(x,y+15);
		glEnd();
		glBegin(GL_LINE_LOOP);
		glColor3f(fabs(modif-0.6),fabs(modif-0.1),fabs(modif-0.3));
		glVertex2d(x,y);
		glVertex2d(x+15,y);
		glVertex2d(x+15,y+15);
		glVertex2d(x,y+15);
		glEnd();
		glBegin(GL_LINES);
		glColor3f(1-modif,1-modif,1-modif);
		glVertex2d(x,y);
		glVertex2d(x+15,y+15);
		glVertex2d(x,y+15);
		glVertex2d(x+15,y);
		glEnd();	
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                        Gere la reduction des fenetres                                                       //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Bouton_reduction(int x,int y,FENETRE &fen,int modif,int nb)
{
//Initialisation de la reduction pour le clique sur le bouton
	if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==1)&&(fen.place==1))
	{
		fen.flag_reduction=1;
	}

//Reduction ou agrandissement de la fenetre 
	if((xmouse>=x)&&(xmouse<=x+15)&&(ymouse>=y)&&(ymouse<=y+15)&&(souris_gauche==0)&&(fen.flag_reduction==1))
	{
		fen.etat=3-fen.etat;
		fen.flag_reduction=0;
	}

//Annulation si la souris est relachee a cote du bouton
	if(((xmouse<x)||(xmouse>x+15)||(ymouse<y)||(ymouse>y+15))&&(fen.flag_reduction==1))
	{
		fen.flag_reduction=0;
	}

		glBegin(GL_QUADS);
		glColor3f(0.5,modif,fabs(modif-0.8));
		glVertex2d(x,y);
		glColor3f(modif,modif,fabs(modif-0.8));
		glVertex2d(x+15,y);
		glColor3f(0.5,modif,fabs(modif-0.8));
		glVertex2d(x+15,y+15);
		glColor3f(1-modif,1-modif,1-modif);
		glVertex2d(x,y+15);
		glEnd();
		glBegin(GL_LINE_LOOP);
		glColor3f(fabs(modif-0.6),fabs(modif-0.1),fabs(modif-0.3));
		glVertex2d(x,y);
		glVertex2d(x+15,y);
		glVertex2d(x+15,y+15);
		glVertex2d(x,y+15);
		glEnd();
		glBegin(GL_LINES);
		glColor3f(1-modif,1-modif,1-modif);
		glVertex2d(x+2,y+4);
		glVertex2d(x+13,y+4);
		glEnd();
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//                                          Affiche du texte en OpenGL                                         //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Ecrire(int x,int y,char *texte)
{
	unsigned int i;
	glRasterPos2d(x,y);

	for (i = 0; i < strlen (texte); i++)
		glutBitmapCharacter (GLUT_BITMAP_HELVETICA_10, texte[i]);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//								 Reoganisation de la place des fenetres										   //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Tri_fenetres(FENETRE *fen,int nb)
{
	int i,j,num_proche=nb,num_eloigne=-1;

//num_proche est le numero de la fenetre a placer au 1er plan apres un clique
	for(i=0;i<nb;i++)
	{
		if(fen[i].etat==1)
		{
			if((xmouse>=fen[i].xbas)&&(xmouse<=fen[i].xbas+fen[i].largeur)&&(ymouse>=fen[i].ybas)&&(ymouse<=fen[i].ybas+fen[i].hauteur+20)&&(souris_gauche==1))
			{
				if(num_proche==nb) num_proche=i;
				if(fen[num_proche].place>fen[i].place) num_proche=i;
			}
		}

		if(fen[i].etat==2)
		{
			if((xmouse>=fen[i].xbas)&&(xmouse<=fen[i].xbas+fen[i].largeur)&&(ymouse>=fen[i].ybas+fen[i].hauteur)&&(ymouse<=fen[i].ybas+fen[i].hauteur+20)&&(souris_gauche==1))
			{
				if(num_proche==nb) num_proche=i;
				if(fen[num_proche].place>fen[i].place) num_proche=i;
			}
		}
	}

//mise a jour des places en fonction de la fenetre mise en 1er plan
	if(num_proche!=nb)
	{
		for(i=0;i<nb;i++)
		if(fen[i].place<fen[num_proche].place) fen[i].place+=1;
		fen[num_proche].place=1;
	}

//num_eloigne est le numero de la fenetre la plus eloigne
	for(i=0;i<nb;i++)
	{
		if(num_eloigne==-1) num_eloigne=i;
		if(fen[num_eloigne].place<fen[i].place) num_eloigne=i;
	}

//mise a jour des places en fonction des fenetres supprimees
	if(num_eloigne!=-1)
	{
		for(i=0;i<nb;i++)
		{
			if(fen[i].etat==0)
			{
				for(j=0;j<nb;j++)
					if(fen[j].place>fen[i].place) fen[j].place-=1;
				fen[i].place=nb;
			}
		}
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//													Cadre de la fenetre										   //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Menu(FENETRE &fen,int modif,FENETRE *fen_global,int nb)
{
	int epaisseur=3;

	if(fen.etat!=2)
	{
		glBegin(GL_POLYGON);
		glColor3f(0,0,0.8);
		glVertex2d(fen.xbas,fen.ybas);
		glVertex2d(fen.xbas+fen.largeur,fen.ybas);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
		glEnd();

		glBegin(GL_POLYGON);
		glColor3f(0,0,0.8);
		glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
		glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glEnd();

		glBegin(GL_POLYGON);
		glColor3f(0,0,0.8);
		glVertex2d(fen.xbas,fen.ybas);
		glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
		glEnd();

		glBegin(GL_POLYGON);
		glColor3f(0,0,0.8);
		glVertex2d(fen.xbas+fen.largeur,fen.ybas);
		glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
		glEnd();

		glBegin(GL_POLYGON);
		glColor3f(0.8,0.7,0.6);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+epaisseur);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+epaisseur);
		glColor3f(0.5,0.4,0.3);
		glVertex2d(fen.xbas+fen.largeur-epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glVertex2d(fen.xbas+epaisseur,fen.ybas+fen.hauteur-epaisseur);
		glEnd();
		if(fen.texte=="Fenetre principale.")
		{
			bouton("Fenetre1",fen.xbas+5,fen.ybas+fen.hauteur-40,120,fac1,fen,fen_global,flag_bouton1,nb);
			bouton("Fenetre2",fen.xbas+5,fen.ybas+fen.hauteur-40-50,120,fac2,fen,fen_global,flag_bouton2,nb);
			bouton("Fenetre3",fen.xbas+5,fen.ybas+fen.hauteur-40-100,120,fac3,fen,fen_global,flag_bouton3,nb);
			bouton("Fenetre4",fen.xbas+5,fen.ybas+fen.hauteur-40-150,120,fac4,fen,fen_global,flag_bouton4,nb);
			bouton("Fenetre5",fen.xbas+5,fen.ybas+fen.hauteur-40-200,120,fac5,fen,fen_global,flag_bouton5,nb);
		}
	}

	glBegin(GL_POLYGON);
	glColor3f(modif,modif,fabs(modif-0.8));
	glVertex2d(fen.xbas,fen.ybas+fen.hauteur);
	glVertex2d(fen.xbas,fen.ybas+fen.hauteur+10);
	glVertex2d(fen.xbas+10,fen.ybas+fen.hauteur+20);
	glColor3f(fabs(modif-0.2),fabs(modif-0.7),fabs(modif-0.9));
	glVertex2d(fen.xbas+fen.largeur-10,fen.ybas+fen.hauteur+20);
	glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur+10);
	glVertex2d(fen.xbas+fen.largeur,fen.ybas+fen.hauteur);
	glEnd();

	glColor3f(1,0,0);
	Ecrire(fen.xbas+10,fen.ybas+fen.hauteur+5,fen.texte);
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//										Deplacement de la fenetre et activation								   //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Deplace_fenetre(FENETRE &fen)
{
	if((xmouse>=fen.xbas)&&(xmouse<=fen.xbas+fen.largeur)&&(ymouse>=fen.ybas+fen.hauteur)&&(ymouse<=fen.ybas+fen.hauteur+20)&&(souris_gauche==1)&&(fen.dep==0)&&(fen.place==1))
	{
		depl1x=xmouse;
		depl1y=ymouse;
		fen.dep=1;
	}

	if((souris_gauche==1)&&(fen.dep==1)&&(fen.place==1))
	{
		depl2x=xmouse;
		depl2y=ymouse;
		fen.xbas+=(depl2x-depl1x);
		fen.ybas+=(depl2y-depl1y);

		if(fen.xbas<0) fen.xbas=0;
		if(fen.xbas>taillex-fen.largeur) fen.xbas=taillex-fen.largeur;

		if(fen.ybas+fen.hauteur<0) fen.ybas=-fen.hauteur;
		if(fen.ybas>tailley-fen.hauteur-20) fen.ybas=tailley-fen.hauteur-20;

		depl1x=depl2x;
		depl1y=depl2y;
	}

	if(souris_gauche==0)
	{
		depl1x=depl1y=depl2x=depl2y=fen.dep=0;
	}
}

/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//											Tri des fenetres reduites										   //
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
void Gere_boutons_reduits(FENETRE *fen,int nb)
{
	int i,nb_reduit=0;

	for(i=0;i<nb;i++)
	{
		if(fen[i].etat==2)
		{
			nb_reduit+=1;
			fen[i].ybas=tailley-fen[i].hauteur-20*nb_reduit;
			fen[i].xbas=0;
		}
	}
}

//Bouton
void bouton(char *text,int x,int y,int lg,float fac,FENETRE &fen,FENETRE *fen_global,int &flag_bouton,int nb)
{
	int i;

	if((xmouse>=x)&&(xmouse<=x+200)&&(ymouse>=y)&&(ymouse<=y+25)&&(souris_gauche==1)&&(fen.place==1))
	{
		flag_bouton=1;
		fac=0.5;
	}

	if((xmouse>=x)&&(xmouse<=x+200)&&(ymouse>=y)&&(ymouse<=y+25)&&(souris_gauche==0)&&(flag_bouton==1))
	{
		flag_bouton=0;

		for(i=1;i<nb;i++)
			if(text==fen_global[i].texte) fen_global[i].etat=2;
	}

//Annulation si la souris est relachee a cote du bouton
	if(((xmouse<x)||(xmouse>x+200)||(ymouse<y)||(ymouse>y+25))&&(flag_bouton==1))
	{
		flag_bouton=0;
		fac=1;
	}

	int lettres;
	lettres=strlen(text);
	glColor3f(fac*0.4,fac*0.4,fac*0.4);
	glBegin(GL_POLYGON);
	glVertex2f(x,y);
	glColor3f(fac*0.3,fac*0.7,fac*0.9);
	glVertex2f(lg+x,y);
	glColor3f(fac*0.3,fac*0.8,fac*0.8);
	glVertex2f(lg+x,y+25);
	glColor3f(fac*0.8,fac*0.2,fac*0.8);
	glVertex2f(x,y+25);
	glEnd();


	glBegin(GL_POLYGON);
	glColor3f(0,fac*0.6,0);
	glVertex2f(lg+x,y+25);
	glVertex2f(lg+2+x,y+30);
	glColor3f(0,fac*0.3,0);
	glVertex2f(x+2,y+30);
	glVertex2f(x,y+25);
	glEnd();

	glBegin(GL_POLYGON);
	glColor3f(0,fac*0.6,0);
	glVertex2f(x+lg,y+25);
	glVertex2f(lg+2+x,y+30);
	glColor3f(0,fac*0.8,0);
	glVertex2f(lg+2+x,y+2);
	glVertex2f(lg+x,y);
	glEnd();

	glColor3f(fac*0.1,fac*0.3,fac);
	Ecrire(x+lg/2-4.5*lettres/2,y+10,text);
}

void Draw(void);

// xbas | ybas| largeur | hauteur | titre | etat(0:supprime 1:active 2:reduite) | deplacement_en_cours(0 ou 1) | 
// plan(1 jusqua nb_fenetre) | flag_quitter(0 ou 1) | reduction(0 ou 1)

//La hauteur de la fenetre sera de hauteur+20 pour le titre.
FENETRE liste[nb_fenetre]={
	{400,180,400,400,"Fenetre principale.",1,0,1,0,0},
	{100,200,300,300,"Fenetre1",0,0,2,0,0},
	{100,200,300,300,"Fenetre2",0,0,3,0,0},
	{100,200,300,300,"Fenetre3",0,0,4,0,0},
	{100,200,300,300,"Fenetre4",0,0,5,0,0},
	{100,200,300,300,"Fenetre5",0,0,6,0,0}
};

//Fonction de rafraichissement d'une fenêtre OpenGL
void Reshape(int width, int height)
{
	tailley=height;
	taillex=width;
	glViewport(0,0,width,height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(0,width,0,height,1,-1);
	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();
}

int main()
{
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
	glutInitWindowSize(800,600);
	glutCreateWindow("seb");
	glutReshapeFunc(Reshape);
	glutDisplayFunc(Draw);
	glutKeyboardFunc(Clavier_standart);
	glutMotionFunc(Souris_position);
	glutMouseFunc(Souris_clique);
	glutMainLoop();
	return 0;
}

void Draw()
{
	glutSetWindowTitle("Fenetre principale.");
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

//Mise en place des fenetres
	Fenetre(liste,nb_fenetre);

//Forcage de l'affichage
	glutPostRedisplay();
	glutSwapBuffers();
}

Conclusion

Il faut que la librairie opengl soit installée.

Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

fenetre.cpp 15 678 octets

Télécharger le zip

Sources du même auteur

DÉBUT DE RAYTRACER

DOOM LIKE EN OPENGL

EDITEUR D'IMAGES .BMP ET .SEB AVEC QUELQUES OPERATIONS BASIQ...

LISTER L'ENSEMBLE DES FICHIERS MP3 ID3V1 DU DISQUE

Toutes les sources de sebos2013

Sources de la même categorie

APPLICATION DE DESSIN DE QUELQUES FIGURES par laguchori

HDR EXPOSURE FUSION par mecrosoft

IRC CLIENT MULTISERVEUR EN MFC (TXIRC) par TeniX

ENTETE DU FICHIER BMP (BIPMAP) par k.Lutchi

XCOUPE : COUPE 2D par pop70

Toutes les sources de la catégorie Graphique

Commentaires et avis

Commentaire de Krox68 le 17/02/2003 19:03:29

bof pas mal

Commentaire de sebos2013 le 15/08/2003 21:05:46

C'etait juste pour m'amuser.

Commentaire de barraq le 14/10/2004 01:09:55

Salut !

Moi g une erreur :

--------------------Configuration: Fenetre - Win32 Debug--------------------
Linking...
LIBCD.lib(wincrt0.obj) : error LNK2001: unresolved external symbol _WinMain@16
Debug/Fenetre.exe : fatal error LNK1120: 1 unresolved externals
Error executing link.exe.

Je débutre :) sa doit etre tout con mais c coi ? :)

Merci

Ajouter un commentaire

Nos sponsors

Derniers Blogs

SESSION SILVERLIGHT 5 3D : SLIDES ET DEMOS par Groc

[TECHDAYS 2012] SESSION WEBMATRIX 2 : LE COUTEAU SUISSE GRATUIT POUR VOS DéVELOPPEMENTS WEB - SLIDES par gpommier

[SHAREPOINT] LES SESSIONS TECHDAYS 2012. par Patrick Guimonet

TECHDAYS PARIS 2012 : SESSION PLEINIèRE JOUR 3 par ROMELARD Fabrice

MISHRA READER : UN LECTEUR RSS TRèS ZUNE STYLE EN OPEN SOURCE ! par Vko

Forum

RE : INVERSER UNE CHAîNE DE CARACTèRES LANGAGE C+ par Renfield

RE : EXCEPTIONS par rt15

RE : [QT]JEUX SIMILAIRE à ZELDA EN MULTIJOUEUR par Neckara

RE : çA COMPILE SUR DEV ET çA MARCHE PAS SUR CODEBLOCKS par rt15

RE : C DUP UTILISATION par rt15

Côté IT

Offres d'emploi

Formations Video

Appels d'offres

Passerelle Pericles sur site Joomla 17
Budget : 499€
Infogerance Serveur Debian Linux
Budget : 2 400€
Developpeur applications iphone - ipad - android
Budget : 800€

Logiciels

Tribler (2012)
TRIBLER (2012)

Tribler est un client pair à pair (P2P/Peer-to-Peer) open source avec la capacité de regarder des...

Cliquez pour télécharger Tribler
OneSwarm (2012)
ONESWARM (2012)

Le peer-to-peer qui protège votre vie privée, c'est OneSwarm. Ce logiciel de peer-to-peer crypté...

Cliquez pour télécharger OneSwarm
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V8.4)
PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO (V8.4)

PONAMEDIA TV DEVIENS HELLLOOO FLASH LA TV SUR VOTRE ORDINATEUR. Toute une plateforme Multi...

Cliquez pour télécharger PONAMEDIA PREMIUM - HELLLOOO FLASH DEMO
Academy System (17.2.1.0)
ACADEMY SYSTEM (17.2.1.0)

Logiciel de gestion des établissements. - élèves/étudiants (inscription, dossier, absence...) -...

Cliquez pour télécharger Academy System
Easy-Planning (1.0.0.1)
EASY-PLANNING (1.0.0.1)

Basé sur les mêmes principes que MyPlanning, Easy-Planning permet de créer des plannings sous la ...

Cliquez pour télécharger Easy-Planning