CMDIChildWnd, classe

Fournit les fonctionnalités d'une fenêtre enfant d'interface multidocument (MDI) Windows, ainsi que des membres permettant de gérer la fenêtre.

Syntaxe

class CMDIChildWnd : public CFrameWnd

Membres

Constructeurs publics

Méthodes publiques

Notes

Une fenêtre enfant MDI ressemble beaucoup à une fenêtre frame classique, sauf que la fenêtre enfant MDI apparaît à l’intérieur d’une fenêtre de cadre MDI plutôt que sur le bureau. Une fenêtre enfant MDI n’a pas de barre de menus propre, mais partage plutôt le menu de la fenêtre frame MDI. L’infrastructure modifie automatiquement le menu frame MDI pour représenter la fenêtre enfant MDI actuellement active.

Pour créer une fenêtre enfant MDI utile pour votre application, dérivez une classe de CMDIChildWnd. Ajoutez des variables membres à la classe dérivée pour stocker des données spécifiques à votre application. Implémentez des fonctions membres de gestionnaire de messages et une table des messages dans la classe dérivée pour préciser ce qu'il advient quand des messages sont dirigés vers la fenêtre.

Il existe trois façons de construire une fenêtre enfant MDI :

• Construisez-le directement à l’aide Createde .

• Construisez-le directement à l’aide LoadFramede .

• Construisez-le indirectement par le biais d’un modèle de document.

Avant d’appeler Create ou LoadFrame, vous devez construire l’objet frame-window sur le tas à l’aide de l’opérateur C++ new . Avant d’appeler Create , vous pouvez également inscrire une classe de fenêtre avec la fonction globale AfxRegisterWndClass pour définir les styles d’icône et de classe pour le cadre.

Utilisez la Create fonction membre pour passer les paramètres de création du frame en tant qu’arguments immédiats.

LoadFrame nécessite moins d’arguments que Create, et récupère à la place la plupart de ses valeurs par défaut à partir de ressources, notamment la légende, l’icône, la table accélérateur et le menu du frame. Pour être accessible par LoadFrame, toutes ces ressources doivent avoir le même ID de ressource (par exemple, IDR_MAINFRAME).

Lorsqu’un CMDIChildWnd objet contient des vues et des documents, ils sont créés indirectement par l’infrastructure plutôt que directement par le programmeur. L’objet CDocTemplate orchestre la création du cadre, la création des vues contenantes et la connexion des vues au document approprié. Les paramètres du CDocTemplate constructeur spécifient les CRuntimeClass trois classes impliquées (document, frame et vue). Un CRuntimeClass objet est utilisé par l’infrastructure pour créer dynamiquement des trames lorsqu’ils sont spécifiés par l’utilisateur (par exemple, à l’aide de la commande File New ou de la commande MDI Window New).

Une classe frame-window dérivée de CMDIChildWnd doit être déclarée avec DECLARE_DYNCREATE afin que le mécanisme ci-dessus RUNTIME_CLASS fonctionne correctement.

La CMDIChildWnd classe hérite de la majeure partie de son implémentation par défaut.CFrameWnd Pour obtenir la liste détaillée de ces fonctionnalités, reportez-vous à la description de la classe CFrameWnd . La CMDIChildWnd classe a les fonctionnalités supplémentaires suivantes :

• Conjointement avec la CMultiDocTemplate classe, plusieurs CMDIChildWnd objets du même modèle de document partagent le même menu, enregistrant les ressources système Windows.

• Le menu de fenêtre enfant MDI actuellement actif remplace entièrement le menu de la fenêtre de cadre MDI, et la légende de la fenêtre enfant MDI actuellement active est ajoutée à la légende de la fenêtre frame MDI. Pour obtenir d’autres exemples de fonctions de fenêtre enfant MDI implémentées conjointement avec une fenêtre frame MDI, consultez la description de la CMDIFrameWnd classe.

N’utilisez pas l’opérateur C++ delete pour détruire une fenêtre frame. Utilisez CWnd::DestroyWindow à la place. L’implémentation CFrameWnd de PostNcDestroy supprimera l’objet C++ lorsque la fenêtre est détruite. Lorsque l’utilisateur ferme la fenêtre frame, le gestionnaire par défaut OnClose appelle DestroyWindow.

Pour plus d’informations sur CMDIChildWnd, consultez Frame Windows.

Hiérarchie d'héritage

CObject

CCmdTarget

CWnd

CFrameWnd

CMDIChildWnd

Spécifications

En-tête : afxwin.h

CMDIChildWnd ::CMDIChildWnd

Appelez pour construire un CMDIChildWnd objet.

CMDIChildWnd();

Notes

Appelez Create pour créer la fenêtre visible.

Exemple

Consultez l’exemple de CMDIChildWnd ::Create.

CMDIChildWnd ::Create

Appelez cette fonction membre pour créer une fenêtre enfant Windows MDI et l’attacher à l’objet CMDIChildWnd .

virtual BOOL Create(
    LPCTSTR lpszClassName,
    LPCTSTR lpszWindowName,
    DWORD dwStyle = WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW,
    const RECT& rect = rectDefault,
    CMDIFrameWnd* pParentWnd = NULL,
    CCreateContext* pContext = NULL);

Paramètres

lpszClassName
Pointe vers une chaîne de caractères terminée par null qui nomme la classe Windows (structure WNDCLASS ). Le nom de classe peut être n’importe quel nom inscrit auprès de la fonction globale AfxRegisterWndClass . Doit être NULL pour une norme CMDIChildWnd.

lpszWindowName
Pointe vers une chaîne de caractères terminée par null qui représente le nom de la fenêtre. Utilisé comme texte pour la barre de titre.

dwStyle
Spécifie les attributs de style de fenêtre. Le style WS_CHILD est requis.

rect
Contient la taille et la position de la fenêtre. La rectDefault valeur permet à Windows de spécifier la taille et la position du nouveau CMDIChildWnd.

pParentWnd
Spécifie le parent de la fenêtre. Si la valeur est NULL, la fenêtre principale de l’application est utilisée.

pContext
Spécifie une structure CCreateContext . Ce paramètre peut être NULL.

Valeur de retour

Valeur différente de zéro cas de réussite ; sinon, 0.

Notes

La fenêtre d’image enfant MDI active peut déterminer la légende de la fenêtre de cadre parent. Cette fonctionnalité est désactivée en désactivant le bit de style FWS_ADDTOTITLE de la fenêtre de cadre enfant.

L’infrastructure appelle cette fonction membre en réponse à une commande utilisateur pour créer une fenêtre enfant, et l’infrastructure utilise le paramètre pContext pour connecter correctement la fenêtre enfant à l’application. Lorsque vous appelez Create, pContext peut être NULL.

Exemple 1

Cet exemple de gestionnaire de commandes Create de menu appelle pour créer une fenêtre enfant MDI :

// CMainFrame::OnFileNewCMdiChildWnd() is a menu command handler for the
// CMainFrame class, which in turn is a CMDIFrameWnd-derived class.
// It shows the creation of a standard Windows MDI child window using
// the registered CMDIChildWnd class.
void CMainFrame::OnFileNewMdiChildWnd()
{
   CMDIChildWnd *pMDIChildWnd = new CMDIChildWnd;
   VERIFY(pMDIChildWnd->Create(
       NULL,                                        // standard CMDIChildWnd class
       _T("My MDIChildWnd"),                        // caption of MDI child window
       WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW, // window styles
       rectDefault,                                 // default rectangle size
       this));                                      // parent window; can be NULL

   // the default PostNcDestroy handler will delete this object when destroyed
}

Exemple 2

L’exemple de code appelle la Create méthode de CHelloWnd, une classe dérivée de CMDIChildWnd:

// CMainFrame::OnHello() is a menu command handler for the CMainFrame
// class, which in turn is a CMDIFrameWnd-derived class.
// It shows the creation of a Windows MDI child window using a custom
// window class. The custom window class is registered in
// CHelloWnd::Create(). CHelloWnd is a CMDIChildWnd-derived class.
void CMainFrame::OnHello()
{
   CHelloWnd *pHelloWnd = new CHelloWnd;
   if (!pHelloWnd->Create(_T("Hello"),
                          WS_CHILD | WS_VISIBLE | WS_OVERLAPPEDWINDOW,
                          rectDefault, this))
      return;

   // the default PostNcDestroy handler will delete this object when destroyed
}

Cet exemple montre l’implémentation Create de la CHelloWnd classe :

BOOL CHelloWnd::Create(
    LPCTSTR szTitle,
    LONG style /* = 0 */,
    const RECT &rect /* = rectDefault */,
    CMDIFrameWnd *parent /* = NULL */)
{
   // Setup the shared menu
   SetHandles(::LoadMenu(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDR_HELLO)),
              NULL);

   // Register a custom WndClass and create a window.
   // This must be done because CHelloWnd has a custom icon.
   LPCTSTR lpszHelloClass =
       AfxRegisterWndClass(CS_HREDRAW | CS_VREDRAW,
                           LoadCursor(NULL, IDC_ARROW),
                           (HBRUSH)(COLOR_WINDOW + 1),
                           LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_HELLO)));

   return CMDIChildWnd::Create(lpszHelloClass, szTitle, style, rect, parent);
}

CMDIChildWnd ::GetMDIFrame

Appelez cette fonction pour renvoyer le cadre parent MDI.

CMDIFrameWnd* GetMDIFrame();

Valeur de retour

Pointeur vers la fenêtre de cadre parent MDI.

Notes

Le cadre retourné est deux parents supprimés de la CMDIChildWnd fenêtre de type MDICLIENT qui gère l’objet CMDIChildWnd . Appelez la fonction membre GetParent pour renvoyer le parent MDICLIENT immédiat de l’objet CMDIChildWnd en tant que pointeur temporaire CWnd .

Exemple

Consultez l’exemple de CMDIFrameWnd ::MDISetMenu.

CMDIChildWnd ::MDIActivate

Appelez cette fonction membre pour activer une fenêtre enfant MDI indépendamment de la fenêtre frame MDI.

void MDIActivate();

Notes

Lorsque le cadre devient actif, la fenêtre enfant qui a été activée pour la dernière fois est également activée.

Exemple

Consultez l’exemple pour CMDIFrameWnd ::GetWindowMenuPopup.

CMDIChildWnd ::MDIDestroy

Appelez cette fonction membre pour détruire une fenêtre enfant MDI.

void MDIDestroy();

Notes

La fonction membre supprime le titre de la fenêtre enfant de la fenêtre frame et désactive la fenêtre enfant.

Exemple

// CMainFrame::OnCloseWindow() is a menu command handler for
// CMainFrame class, which in turn is a CMDIFrameWnd-derived
// class. It closes and destroys the current active MDI child window.
void CMainFrame::OnCloseWindow()
{
   CMDIChildWnd *child = MDIGetActive();
   if (child)
      child->MDIDestroy();
}

CMDIChildWnd ::MDIMaximize

Appelez cette fonction membre pour optimiser une fenêtre enfant MDI.

void MDIMaximize();

Notes

Lorsqu’une fenêtre enfant est agrandie, Windows le redimensionne pour que sa zone cliente remplisse la zone cliente de la fenêtre frame. Windows place le menu Contrôle de la fenêtre enfant dans la barre de menus du cadre afin que l’utilisateur puisse restaurer ou fermer la fenêtre enfant et ajouter le titre de la fenêtre enfant au titre de la fenêtre frame-window.

Exemple

// CMainFrame::OnMaximizeWindow() is a menu command handler for
// CMainFrame class, which in turn is a CMDIFrameWnd-derived
// class. It maximizes the current active MDI child window.
void CMainFrame::OnMaximizeWindow()
{
   BOOL maximized;
   CMDIChildWnd *child = MDIGetActive(&maximized);
   if (child && (!maximized))
      child->MDIMaximize(); // or MDIMaximize(child);
}

CMDIChildWnd ::MDIRestore

Appelez cette fonction membre pour restaurer une fenêtre enfant MDI à partir d’une taille agrandie ou réduite.

void MDIRestore();

Exemple

// CMainFrame::OnRestoreWindow() is a menu command handler for
// CMainFrame class, which in turn is a CMDIFrameWnd-derived class.
// It restores the current active MDI child window from maximized
// or minimized size.
void CMainFrame::OnRestoreWindow()
{
   BOOL maximized;
   CMDIChildWnd *child = MDIGetActive(&maximized);
   if (child && (maximized || child->IsIconic()))
      child->MDIRestore(); // or MDIRestore(child);
}

CMDIChildWnd ::SetHandles

Définit les handles des ressources de menu et d’accélérateur.

void SetHandles(
    HMENU hMenu,
    HACCEL hAccel);

Paramètres

hMenu
Handle d’une ressource de menu.

hAccel
Handle d’une ressource accélérateur.

Notes

Appelez cette fonction pour définir les ressources de menu et d’accélérateur utilisées par l’objet de fenêtre enfant MDI.

Voir aussi

Exemple MFC MDI
Exemple MFC MDIDOCVW
Exemple SNAPVW MFC
CFrameWnd, classe
Graphique hiérarchique
CWnd, classe
CMDIFrameWnd, classe