ouvrir nouvelle fenêtre ou nouvelle instance ?

Le
touirik
bonjour,
j'ai crée une fenêtre qui propose a l'utilisateur plusieurs choix a
l'aide de boutons et d'un menu. maintenant quand l'utilisateur choisit
une option, par exemple: (il clique sur le bouton gestion de projet). je
voudrai effacer la fenetre et ne laisser que le menu horizontal d'en
haut, puis afficher de nouvelles chose dans le corps de la fenetre
(boutons, champs de texte, images.)

comment procéder? est ce que je dois créer une nouvelle instance ou une
nouvelle fenêtre ?
voici mon code:

fichier main:

#include <windows.h>
#include "constantes.h"
//********* définitions des ID des boutons
*****************************************************************************************************

//***********************************************************************************************************************************************

HINSTANCE instance; // déclarer instance comme variable globale, pour
l'utiliser dans callback par exemple

LRESULT CALLBACK procedureFenetrePrincipale(HWND, UINT, WPARAM, LPARAM);
// prototypes de la fct callback de la fen principale
BOOL APIENTRY aPropos_procedure(HWND hDlg,UINT uMsg,WPARAM wParam,LPARAM
lParam); // proto de la fct de boite dialogue aide

int WinMain (HINSTANCE cetteInstance, HINSTANCE precedenteInstance,
LPSTR lignesDeCommande, int modeDAffichage)
{

//**************************************************************************************************************************************
// DECLARATION DE 3 VARIABLE NECESSAIRES
HWND fenetrePrincipale; // le handle windows (poigné windows)
MSG message; // message systeme "evenement"
WNDCLASS classeFenetre; // la classe de la fenettre

//**************************************************************************************************************************************


//************************************************************************************************************************************



//************************************************************************************************************************************


instance = cetteInstance;


//*************************************************************************************************************************************
// REMPLISSAGE DE LA CLASSE DE LA FENETRE "10 CHAMPS"
classeFenetre.style = 0; //le style à affecter à la fenêtre
classeFenetre.lpfnWndProc = procedureFenetrePrincipale; //
définition de la fonction callback à utiliser pour cette fenêtre
classeFenetre.cbClsExtra = 0; // combien de bytes en plus seront
alloués à la suite de la structure
classeFenetre.cbWndExtra = 0; // la même chose, mais suite à l'instance
classeFenetre.hInstance = NULL; // définit l'instance à laquelle
appartient la fenêtre
classeFenetre.hIcon = LoadIcon(NULL, IDI_APPLICATION); // définit
l'icône à utiliser pour la fenêtre
classeFenetre.hCursor = LoadCursor(NULL, IDC_ARROW); // définit le
curseur par défaut à utiliser pour cette fenêtre
classeFenetre.hbrBackground = (HBRUSH)(1 + COLOR_BTNFACE); //
définit la couleur à utiliser pour le fond de la fenêtre
classeFenetre.lpszMenuName = "ID_MENU";// définit le menu associé à
cette fenêtre
classeFenetre.lpszClassName = "classeF"; // le nom de la classe en
question

//**************************************************************************************************************************************




//**************************************************************************************************************************************
//SAUVEGARDE DE LA CLASSE APRES SA CREATION ET SON REMPLISSAGE
//RegisterClass(&classeFenetre); sert a sauvegarder la classe
// On prévoit quand même le cas où ça échoue
if(!RegisterClass(&classeFenetre)) return FALSE;

//**************************************************************************************************************************************




//**************************************************************************************************************************************
// CREATION DE LA FENETRE A L AIDE DE LA FONCTION CREATWINDOW
***********************************************************************
fenetrePrincipale = CreateWindow("classeF", // le nom de la classe
"Première fenêtre en winAPI !", //
titre le la fenetre
WS_OVERLAPPEDWINDOW, /*Style qui
permet d'avoir une fenêtre tout ce qu'il y a de plus normale : barre de
titre, menu système (réduire, maximiser, fermer), bordure etc*/
CW_USEDEFAULT, // Permet à l'OS de
déterminer dynamiquement la position de la fenêtre
CW_USEDEFAULT, //Idem
800,
600,
NULL, // Pas de fenêtre parent,
puisque c'est la principale
LoadMenu(instance, "ID_MENU"),
//un menu lui est associé
cetteInstance,
NULL); // Aucun paramètre à lui
envoyer en plus

if (!fenetrePrincipale) return FALSE; // création de la fenêtre a
échoué

//**************************************************************************************************************************************




//**************************************************************************************************************************************
// AFFICHAGE DE LA FENETRE, ET REFRECH()
ShowWindow(fenetrePrincipale, modeDAffichage); // affichage de la
fenêtre
UpdateWindow(fenetrePrincipale); // comme refresh() en pdcurses,
pour la montrer a l'utilisateur

//**************************************************************************************************************************************




//**************************************************************************************************************************************
// BOUCLE
EVENEMENTIELLE
/* Afin d'interfacer l'utilisateur avec la fenêtre, nous avons
besoin d'une boucle événementielle traitant les messages créés par
l'utilisateur et destinés aux fenêtres concernées. */

while (GetMessage(&message, NULL, 0, 0)) /*Récupération des
évènements de toutes les fenêtres de l'instance dans message*/
{
TranslateMessage(&message); // Traduction de l'événement
DispatchMessage(&message); // Envoi du message correspondant à
la fenêtre concernée
}

//**************************************************************************************************************************************



return message.wParam;
}

//********************************************************************************************************************************************
// CALLBACK
/*La fonction callback étant un traitement des messages envoyés à la
fenêtre, elle est chargée de faire
telle ou telle action en fonction de tel ou tel message. */

LRESULT CALLBACK procedureFenetrePrincipale(HWND fenetrePrincipale, UINT
message, WPARAM wParam, LPARAM lParam)
{
static HWND boutons[4] = {NULL}; // déclaration de handles de boutons
switch (message)
{
// WM_CREATE est envoyé à la création de la fenêtre
case WM_CREATE:
// WS_CHILD solidarise le contrôle à la fenêtre parent. Sans
lui, le contrôle flotterait "en l'air", en dehors de la fenêtre.
// WS_VISIBLE affiche le contrôle (donc, pas besoin de ShowWindow).
boutons[0] = CreateWindow("BUTTON", "Gestion des projets",
WS_CHILD | WS_VISIBLE,
160, 150, 383, 30, fenetrePrincipale,
(HMENU)ID_B_PROJET, instance, NULL);

boutons[1] = CreateWindow("BUTTON", "Gestion du personnel",
WS_CHILD | WS_VISIBLE,
160, 190, 383, 30, fenetrePrincipale,
(HMENU)ID_B_PERSONNEL, instance, NULL);

boutons[2] = CreateWindow("BUTTON", "Gestion des affectation
(projet --> employé)", WS_CHILD | WS_VISIBLE,
160, 230, 383, 30, fenetrePrincipale,
(HMENU)ID_B_AFFECTATION, instance, NULL);

boutons[3] = CreateWindow("BUTTON", "Quitter le programme",
WS_CHILD | WS_VISIBLE,
160, 300, 383, 30, fenetrePrincipale,
(HMENU)ID_B_QUITTER, instance, NULL);
return 0;


/* quand un bouton est enfoncé, le message vaut WM_COMMAND, et
le mot bas de wParam détermine l'ID du bouton qui a été cliqué,
et qui a donc envoyé ce message */
case WM_COMMAND:
switch(LOWORD(wParam))
{
/* prototype: int MessageBox(HWND hWnd, LPCTSTR lpText,
LPCTSTR lpCaption, UINT uType);

affiche une petite messagebox portant comme titre la
chaîne spécifiée par lpCaption, comme texte celui spécifié par lpText,
étant rattachée à la fenêtre spécifiée par hWnd et
ayant comme style ceux spécifiés dans uType. */


// section projet
**********************************************************************************************************
case ID_B_PROJET:
MessageBox(fenetrePrincipale, "commencer à gérer les
projets", "gestion de projets", MB_ICONINFORMATION);
break;
case ID_B_PROJET_AJOUT:
MessageBox(fenetrePrincipale, "ajouter un projet", "ajout
de projets", MB_ICONINFORMATION);
break;

case ID_B_PROJET_AFFICHAGE:
MessageBox(fenetrePrincipale, "afficher un projet",
"afficher un projet", MB_ICONINFORMATION);
break;

case ID_B_PROJET_RECHERCHE:
MessageBox(fenetrePrincipale, "rechercher un projet",
"rechercher un projet", MB_ICONINFORMATION);
break;

case ID_B_PROJET_MODIFICATION:
MessageBox(fenetrePrincipale, "modifier un projet",
"modifier un projet", MB_ICONINFORMATION);
break;

case ID_B_PROJET_SUPPRESSION:
MessageBox(fenetrePrincipale, "supprimer un projet",
"supprimer un projet", MB_ICONINFORMATION);
break;

case ID_B_PROJET_RETARD:
MessageBox(fenetrePrincipale, "projets en retard", "projets
en retard", MB_ICONINFORMATION);
break;
//
*************************************************************************************************************************


// section
personnel********************************************************************************************************
case ID_B_PERSONNEL:
MessageBox(fenetrePrincipale, "commencer à gérer le
personnel", "gestion de personnel", MB_ICONINFORMATION);
break;
case ID_B_PERSONNEL_AJOUT:
MessageBox(fenetrePrincipale, "ajouter personnel", "ajouter
personnel", MB_ICONINFORMATION);
break;
case ID_B_PERSONNEL_AFFICHAGE:
MessageBox(fenetrePrincipale, "affichage personnel",
"affichage personnel", MB_ICONINFORMATION);
break;
case ID_B_PERSONNEL_RECHERCHE:
MessageBox(fenetrePrincipale, "recherche le personnel",
"recherche de personnel", MB_ICONINFORMATION);
break;
case ID_B_PERSONNEL_SUPPRESSION:
MessageBox(fenetrePrincipale, "suppression personnel",
"suppression personnel", MB_ICONINFORMATION);
break;
case ID_B_PERSONNEL_MODIFICATION:
MessageBox(fenetrePrincipale, "modification personnel",
"modification de personnel", MB_ICONINFORMATION);
break;

//*************************************************************************************************************************


// section affectation
****************************************************************************************************
case ID_B_AFFECTATION:
MessageBox(fenetrePrincipale, "commencer à gerer les
affectations", "gestion des affectations", MB_ICONINFORMATION);
break;
case ID_B_AFFECTATION_AJOUT:
MessageBox(fenetrePrincipale, "ajout affectations", "ajout
affectations", MB_ICONINFORMATION);
break;
case ID_B_AFFECTATION_AFFICHAGE:
MessageBox(fenetrePrincipale, "affichage affectations",
"affichage affectations", MB_ICONINFORMATION);
break;
case ID_B_AFFECTATION_MODIFICATION:
MessageBox(fenetrePrincipale, "modification affectations",
"modification affectations", MB_ICONINFORMATION);
break;
case ID_B_AFFECTATION_SUPPRESSION:
MessageBox(fenetrePrincipale, "suppression affectations",
"suppression affectations", MB_ICONINFORMATION);
break;
case ID_B_AFFECTATION_RECHERCHE:
MessageBox(fenetrePrincipale, "recherche affectations",
"recherche affectations", MB_ICONINFORMATION);
break;


//**************************************************************************************************************************
case ID_B_QUITTER:
/* SendMessage ne fait qu'exécuter la fonction callback
avec le message spécifié dans msg, les paramètres spécifiés dans wParam
et lParam, et retourne ce que retourne le callback */
SendMessage(fenetrePrincipale, WM_DESTROY, 0, 0);
break;

}
return 0;

case WM_DESTROY: // WM_DESTROY est envoyé lors de la destruction de
la fenêtre.
PostQuitMessage(0);
return 0;

default:
return DefWindowProc(fenetrePrincipale, message, wParam,
lParam); //on retourne la procédure par défaut fournie par DefWindowProc.
}
}
//***********************************************************************************************************************************************

merci d'avance.
Vidéos High-Tech et Jeu Vidéo
Téléchargements
Vos réponses
Gagnez chaque mois un abonnement Premium avec GNT : Inscrivez-vous !
Trier par : date / pertinence
Laurent
Le #23387351
"touirik" irecjf$faj$
bonjour,
j'ai crée une fenêtre qui propose a l'utilisateur plusieurs choix a l'aide
de boutons et d'un menu. maintenant quand l'utilisateur choisit une
option, par exemple: (il clique sur le bouton gestion de projet). je
voudrai effacer la fenetre et ne laisser que le menu horizontal d'en haut,
puis afficher de nouvelles chose dans le corps de la fenetre (boutons,
champs de texte, images....)

comment procéder? est ce que je dois créer une nouvelle instance ou une
nouvelle fenêtre ?



Des nouvelle fenêtres, plutôt des Dialog Boxes modales par exemple (avec l
'éditeur de Dialog, plus simple)
touirik
Le #23391461
Le 23/05/2011 19:36, Laurent a écrit :
"touirik" irecjf$faj$
bonjour,
j'ai crée une fenêtre qui propose a l'utilisateur plusieurs choix a l'aide
de boutons et d'un menu. maintenant quand l'utilisateur choisit une
option, par exemple: (il clique sur le bouton gestion de projet). je
voudrai effacer la fenetre et ne laisser que le menu horizontal d'en haut,
puis afficher de nouvelles chose dans le corps de la fenetre (boutons,
champs de texte, images....)

comment procéder? est ce que je dois créer une nouvelle instance ou une
nouvelle fenêtre ?



Des nouvelle fenêtres, plutôt des Dialog Boxes modales par exemple (avec l
'éditeur de Dialog, plus simple)




Merci bien, les dialogbox c'est plus pratique
Publicité
Poster une réponse
Anonyme