C / C++ / C++.NET : Generation de fenetre type windows en opengl

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 / Exemple :

#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.

Télécharger le projet

Codes Sources

voir Télécharger
fenetre.cpp

A voir également

&& c++
Fenetat - Meilleures réponses
Opengl c++ windows - Meilleures réponses
C / C++ / C++.NET : Fenêtre du type windows en opengl - CodeS SourceS - Guide
Rend transparent n'importe qu'elle fenêtre dans windows 2000 et xp - Codes sources - Visual Basic / VB.NET (Graphique)
Sélection de fichier par fenetre de windows - Codes sources - Visual Basic / VB.NET (API)
Parkinson : comment les fenêtres de windows peuvent être prises de folies (win32) - Codes sources - C / C++ / C++.NET (API)
Génération de graphique type camenbert (dev-c++) - Codes sources - C / C++ / C++.NET (Graphique)

Ajouter un commentaire

Commentaires

Signaler

barraq

Messages postés: 89
Date d'inscription: mercredi 25 juin 2003
Statut: Membre
Dernière intervention: 14 septembre 2007

14 oct. 2004 à 01:09

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

Signaler

sebos2013

Messages postés: 64
Date d'inscription: vendredi 23 août 2002
Statut: Membre
Dernière intervention: 7 décembre 2006

15 août 2003 à 21:05

C'etait juste pour m'amuser.

Signaler

Krox68

Messages postés: 157
Date d'inscription: jeudi 17 octobre 2002
Statut: Membre
Dernière intervention: 11 septembre 2004

17 févr. 2003 à 19:03

bof pas mal

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Generation de fenetre type windows en opengl

Description

Source / Exemple :

Conclusion :

Codes Sources

A voir également

Commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Du même auteur (sebos2013)

Début de raytracer

Doom like en opengl

Editeur d'images .bmp et .seb avec quelques operations basiques.

Lister l'ensemble des fichiers mp3 id3v1 du disque

Source / Exemple :

Conclusion :

A voir également

Vous n'êtes pas encore membre ? inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Du même auteur (sebos2013)

Début de raytracer

Doom like en opengl

Editeur d'images .bmp et .seb avec quelques operations basiques.

Lister l'ensemble des fichiers mp3 id3v1 du disque

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !