Share via

CMDIFrameWnd, classe

  • Article

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

Syntaxe

class CMDIFrameWnd : public CFrameWnd

Membres

Constructeurs publics

Nom Description
CMDIFrameWnd ::CMDIFrameWnd Construit un objet CMDIFrameWnd.

Méthodes publiques

Nom Description
CMDIFrameWnd ::CreateClient Crée une fenêtre Windows MDICLIENT pour cela CMDIFrameWnd. Appelé par la OnCreate fonction membre de CWnd.
CMDIFrameWnd ::CreateNewChild Crée une fenêtre enfant.
CMDIFrameWnd ::GetWindowMenuPopup Retourne le menu contextuel Fenêtre.
CMDIFrameWnd ::MDIActivate Active une autre fenêtre enfant MDI.
CMDIFrameWnd ::MDICascade Organise toutes les fenêtres enfants dans un format en cascade.
CMDIFrameWnd ::MDIGetActive Récupère la fenêtre enfant MDI actuellement active, ainsi qu’un indicateur indiquant si l’enfant est agrandi ou non.
CMDIFrameWnd ::MDIIconArrange Organise toutes les fenêtres enfants de document réduites.
CMDIFrameWnd ::MDIMaximize Agrandit une fenêtre enfant MDI.
CMDIFrameWnd ::MDINext Active la fenêtre enfant immédiatement derrière la fenêtre enfant active et place la fenêtre enfant active derrière toutes les autres fenêtres enfants.
CMDIFrameWnd ::MDIPrev Active la fenêtre enfant précédente et place la fenêtre enfant active immédiatement derrière elle.
CMDIFrameWnd ::MDIRestore Restaure une fenêtre enfant MDI à partir d’une taille agrandie ou réduite.
CMDIFrameWnd ::MDISetMenu Remplace le menu d’une fenêtre cadre MDI, le menu contextuel Fenêtre, ou les deux.
CMDIFrameWnd ::MDITile Organise toutes les fenêtres enfants dans un format en mosaïque.

Notes

Pour créer une fenêtre d’image MDI utile pour votre application, dérivez une classe de CMDIFrameWnd. 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.

Vous pouvez construire une fenêtre frame MDI en appelant la fonction membre Create ou LoadFrame de CFrameWnd.

Avant d’appeler Create ou LoadFrame, vous devez construire l’objet de fenêtre frame 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.

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

Bien qu’elle MDIFrameWnd soit dérivée de CFrameWnd, une classe de fenêtre frame dérivée de CMDIFrameWnd n’a pas besoin d’être déclarée avec DECLARE_DYNCREATE.

La CMDIFrameWnd 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 CMDIFrameWnd classe a les fonctionnalités supplémentaires suivantes :

  • Une fenêtre frame MDI gère la fenêtre MDICLIENT, la repositionnant conjointement avec les barres de contrôle. La fenêtre cliente MDI est le parent direct des fenêtres d’images enfants MDI. Les styles de fenêtre WS_HSCROLL et WS_VSCROLL spécifiés sur une CMDIFrameWnd application à la fenêtre cliente MDI plutôt que dans la fenêtre du cadre principal afin que l’utilisateur puisse faire défiler la zone cliente MDI (comme dans le Gestionnaire de programmes Windows, par exemple).

  • Une fenêtre frame MDI possède un menu par défaut utilisé comme barre de menus lorsqu’il n’existe aucune fenêtre enfant MDI active. Lorsqu’il existe un enfant MDI actif, la barre de menus de la fenêtre frame MDI est automatiquement remplacée par le menu de la fenêtre enfant MDI.

  • Une fenêtre frame MDI fonctionne conjointement avec la fenêtre enfant MDI actuelle, s’il en existe une. Par exemple, les messages de commande sont délégués à l’enfant MDI actif avant la fenêtre frame MDI.

  • Une fenêtre frame MDI a des gestionnaires par défaut pour les commandes de menu Fenêtre standard suivantes :

    • ID_WINDOW_TILE_VERT

    • ID_WINDOW_TILE_HORZ

    • ID_WINDOW_CASCADE

    • ID_WINDOW_ARRANGE

  • Une fenêtre frame MDI a également une implémentation de ID_WINDOW_NEW, qui crée un cadre et une vue sur le document actif. Une application peut remplacer ces implémentations de commandes par défaut pour personnaliser la gestion des fenêtres MDI.

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 CMDIFrameWnd, consultez Frame Windows.

Hiérarchie d'héritage

CObject

CCmdTarget

CWnd

CFrameWnd

CMDIFrameWnd

Spécifications

En-tête : afxwin.h

CMDIFrameWnd ::CMDIFrameWnd

Construit un objet CMDIFrameWnd.

CMDIFrameWnd();

Notes

Appelez la Create fonction ou LoadFrame membre pour créer la fenêtre de cadre MDI visible.

Exemple

// Create main MDI Frame window. CMainFrame is a CMDIFrameWnd-derived
// class. The default CFrameWnd::PostNcDestroy() handler will delete this
// object when destroyed.
CMainFrame *pMainFrame = new CMainFrame;

CMDIFrameWnd ::CreateClient

Crée la fenêtre du client MDI qui gère les CMDIChildWnd objets.

virtual BOOL CreateClient(
    LPCREATESTRUCT lpCreateStruct,
    CMenu* pWindowMenu);

Paramètres

lpCreateStruct
Pointeur long vers une structure CREATESTRUCT .

pWindowMenu
Pointeur vers le menu contextuel Fenêtre.

Valeur de retour

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

Notes

Cette fonction membre doit être appelée si vous remplacez directement la OnCreate fonction membre.

Exemple

// The code below is from winmdi.cpp. It shows how to
// call CMDIFrameWnd::CreateClient(). CMainFrame is a
// CMDIFrameWnd-derived class.
BOOL CMainFrame::OnCreateClient(LPCREATESTRUCT lpcs, CCreateContext * /*pContext*/)
{
   CMenu *pMenu = NULL;
   if (m_hMenuDefault == NULL)
   {
      // default implementation for MFC V1 backward compatibility
      pMenu = GetMenu();
      ASSERT(pMenu != NULL);
      // This is attempting to guess which sub-menu is the Window menu.
      // The Windows user interface guidelines say that the right-most
      // menu on the menu bar should be Help and Window should be one
      // to the left of that.
      int iMenu = pMenu->GetMenuItemCount() - 2;

      // If this assertion fails, your menu bar does not follow the guidelines
      // so you will have to override this function and call CreateClient
      // appropriately or use the MFC V2 MDI functionality.
      ASSERT(iMenu >= 0);
      pMenu = pMenu->GetSubMenu(iMenu);
      ASSERT(pMenu != NULL);
   }

   return CreateClient(lpcs, pMenu);
}

CMDIFrameWnd ::CreateNewChild

Crée une fenêtre enfant.

CMDIChildWnd* CreateNewChild(
    CRuntimeClass* pClass,
    UINT nResource,
    HMENU hMenu = NULL,
    HACCEL hAccel = NULL);

Paramètres

pClass
Classe d’exécution de la fenêtre enfant à créer.

nResource
ID des ressources partagées associées à la fenêtre enfant.

hMenu
Menu de la fenêtre enfant.

hAccel
Accélérateur de la fenêtre enfant.

Notes

Utilisez cette fonction pour créer des fenêtres enfants d’une fenêtre frame MDI.

Exemple

// CMainFrame is a CMDIFrameWnd-derived class,
// OnNewDraw is a menu command handler,
// CDrawFrame is a CMDIChildWnd-derived class.
void CMainFrame::OnNewDraw()
{
   CreateNewChild(RUNTIME_CLASS(CDrawFrame), IDR_DRAW, m_hDrawMenu,
                  m_hDrawAccel);
}

CMDIFrameWnd ::GetWindowMenuPopup

Appelez cette fonction membre pour obtenir un handle dans le menu contextuel actuel nommé « Fenêtre » (menu contextuel avec des éléments de menu pour la gestion des fenêtres MDI).

virtual HMENU GetWindowMenuPopup(HMENU hMenuBar);

Paramètres

hMenuBar
Barre de menus active.

Valeur de retour

Le menu contextuel Fenêtre s’il en existe un ; sinon NULL.

Notes

L’implémentation par défaut recherche un menu contextuel contenant des commandes de menu Fenêtre standard telles que ID_WINDOW_NEW et ID_WINDOW_TILE_HORZ.

Remplacez cette fonction membre si vous disposez d’un menu Fenêtre qui n’utilise pas les ID de commande de menu standard.

Exemple

// CMainFrame::OnActivateFirstMDIChild() is a menu command handler for
// CMainFrame class, which in turn is a CMDIFrameWnd-derived class.
// It looks for the caption of the first created MDI child window from
// the Window popup menu, and then activate the child window.
void CMainFrame::OnActivateFirstMDIChild()
{
   // Get handle to the Window pop-up menu.
   CMenu *menubar = GetMenu();
   CMenu *wmenu = CMenu::FromHandle(GetWindowMenuPopup(menubar->GetSafeHmenu()));
   if (wmenu == NULL)
      return;

   // Get the caption of the first created MDI child window.
   CString caption;
   if (!wmenu->GetMenuString(AFX_IDM_FIRST_MDICHILD, caption, MF_BYCOMMAND))
      return;

   // Get the actual name of the first created MDI child window by
   // getting rid of the number and space, e.g. "&1 MDI 1".
   int pos = caption.FindOneOf(_T(" "));
   if (pos == -1)
      return;

   caption = caption.Right(caption.GetLength() - (pos + 1));

   // Get the CWnd* of the first created MDI child window by comparing
   // the caption of each MDI child window in the MDI application.
   // Activate the first created MDI child window if found.
   CMDIChildWnd *child = MDIGetActive();
   do
   {
      CString str;
      child->GetWindowText(str);
      if (str == caption)
      {
         child->MDIActivate(); // or MDIActivate(child);
         break;
      }

      child = (CMDIChildWnd*)child->GetWindow(GW_HWNDNEXT);
   } while (child);
}

CMDIFrameWnd ::MDIActivate

Active une autre fenêtre enfant MDI.

void MDIActivate(CWnd* pWndActivate);

Paramètres

pWndActivate
Pointe vers la fenêtre enfant MDI à activer.

Notes

Cette fonction membre envoie le message WM_MDIACTIVATE à la fois à la fenêtre enfant activée et à la fenêtre enfant désactivée.

Il s’agit du même message envoyé si l’utilisateur modifie le focus sur une fenêtre enfant MDI à l’aide de la souris ou du clavier.

Remarque

Une fenêtre enfant MDI est activée indépendamment de la fenêtre frame MDI. Lorsque le cadre devient actif, la fenêtre enfant qui a été activée pour la dernière fois est envoyée à un message WM_NCACTIVATE pour dessiner un cadre de fenêtre actif et légende barre, mais elle ne reçoit pas un autre message WM_MDIACTIVATE.

Exemple

Consultez l’exemple pour CMDIFrameWnd ::GetWindowMenuPopup.

CMDIFrameWnd ::MDICascade

Organise toutes les fenêtres enfants MDI au format cascade.

void MDICascade();
void MDICascade(int nType);

Paramètres

nType
Spécifie un indicateur en cascade. Seul l’indicateur suivant peut être spécifié : MDITILE_SKIPDISABLED, ce qui empêche la cascade des fenêtres enfants MDI désactivées.

Notes

La première version de MDICascade, sans paramètres, cascade toutes les fenêtres enfants MDI, y compris les fenêtres désactivées. La deuxième version ne met pas en cascade les fenêtres enfants MDI désactivées en cascade si vous spécifiez MDITILE_SKIPDISABLED pour le paramètre nType .

Exemple

// CMainFrame::OnWindowCommand() is a menu command handler for
// CMainFrame class, which is a CMDIFrameWnd-derived
// class. It handles menu commands for the Windows pop-up menu.
// Its entries in the message map are of the following form:
//    ON_COMMAND_EX(ID_WINDOW_ARRANGE, &CMainFrame::OnWindowCommand)
BOOL CMainFrame::OnWindowCommand(UINT nID)
{
   switch (nID)
   {
   case ID_WINDOW_ARRANGE: // For Window\Arrange Icons menu item, arrange
      MDIIconArrange();    // all minimized document child windows.
      break;

   case ID_WINDOW_CASCADE: // For Window\Cascade menu item, arrange
      MDICascade();        // all the MDI child windows in a cascade format.
      break;

   case ID_WINDOW_TILE_HORZ:       // For Window\Tile Horizontal menu item,
      MDITile(MDITILE_HORIZONTAL); // tile MDI child windows so that
      break;                       // one window appears above another.

   case ID_WINDOW_TILE_VERT:     // For Window\Tile Vertical menu item,
      MDITile(MDITILE_VERTICAL); // tile MDI child windows so that
      break;                     // one window appears beside another.
   }

   return TRUE;
}

CMDIFrameWnd ::MDIGetActive

Récupère la fenêtre enfant MDI active actuelle, ainsi qu’un indicateur indiquant si la fenêtre enfant est agrandie.

CMDIChildWnd* MDIGetActive(BOOL* pbMaximized = NULL) const;

Paramètres

pbMaximized
Pointeur vers une valeur de retour BOOL. Affectez la valeur TRUE au retour si la fenêtre est agrandie ; sinon FALSE.

Valeur de retour

Pointeur vers la fenêtre enfant MDI active.

Exemple

Consultez l’exemple de CMDIChildWnd ::MDIMaximize.

CMDIFrameWnd ::MDIIconArrange

Organise toutes les fenêtres enfants de document réduites.

void MDIIconArrange();

Notes

Elle n’affecte pas les fenêtres enfants qui ne sont pas réduites.

Exemple

Consultez l’exemple de CMDIFrameWnd ::MDICascade.

CMDIFrameWnd ::MDIMaximize

Agrandit la fenêtre enfant MDI spécifiée.

void MDIMaximize(CWnd* pWnd);

Paramètres

Pwnd
Pointe vers la fenêtre pour optimiser.

Notes

Lorsqu’une fenêtre enfant est agrandie, Windows le redimensionne pour que sa zone cliente remplisse la fenêtre cliente. 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. Il ajoute également le titre de la fenêtre enfant au titre de la fenêtre cadre.

Si une autre fenêtre enfant MDI est activée lorsque la fenêtre enfant MDI active est agrandie, Windows restaure l’enfant actif et agrandit la fenêtre enfant nouvellement activée.

Exemple

Consultez l’exemple de CMDIChildWnd ::MDIMaximize.

CMDIFrameWnd ::MDINext

Active la fenêtre enfant immédiatement derrière la fenêtre enfant active et place la fenêtre enfant active derrière toutes les autres fenêtres enfants.

void MDINext();

Notes

Si la fenêtre enfant MDI active est agrandie, la fonction membre restaure l’enfant actif et agrandit l’enfant qui vient d’être activé.

Exemple

// CMainFrame::OnActivateNextWindow() is a menu command handler for
// CMainFrame class, which in turn is a CMDIFrameWnd-derived class.
// It activates the child window immediately behind the currently
// active child window and places the currently active child window
// behind all other child windows.
void CMainFrame::OnActivateNextWindow()
{
   MDINext();
}

CMDIFrameWnd ::MDIPrev

Active la fenêtre enfant précédente et place la fenêtre enfant active immédiatement derrière elle.

void MDIPrev();

Notes

Si la fenêtre enfant MDI active est agrandie, la fonction membre restaure l’enfant actif et agrandit l’enfant qui vient d’être activé.

CMDIFrameWnd ::MDIRestore

Restaure une fenêtre enfant MDI à partir d’une taille agrandie ou réduite.

void MDIRestore(CWnd* pWnd);

Paramètres

Pwnd
Pointe vers la fenêtre à restaurer.

Exemple

Consultez l’exemple de CMDIChildWnd ::MDIRestore.

CMDIFrameWnd ::MDISetMenu

Remplace le menu d’une fenêtre cadre MDI, le menu contextuel Fenêtre, ou les deux.

CMenu* MDISetMenu(
    CMenu* pFrameMenu,
    CMenu* pWindowMenu);

Paramètres

pFrameMenu
Spécifie le menu du nouveau menu frame-window. Si la valeur est NULL, le menu n’est pas modifié.

pWindowMenu
Spécifie le menu du nouveau menu contextuel Fenêtre. Si la valeur est NULL, le menu n’est pas modifié.

Valeur de retour

Pointeur vers le menu frame-window remplacé par ce message. Le pointeur peut être temporaire et ne doit pas être stocké pour une utilisation ultérieure.

Notes

Après l’appel MDISetMenu, une application doit appeler la fonction membre DrawMenuBar pour mettre à jour la barre de CWnd menus.

Si cet appel remplace le menu contextuel Fenêtre, les éléments de menu de fenêtre enfant MDI sont supprimés du menu Fenêtre précédente et ajoutés au nouveau menu contextuel Fenêtre.

Si une fenêtre enfant MDI est agrandie et que cet appel remplace le menu frame-window MDI, le menu Contrôle et les contrôles de restauration sont supprimés du menu frame-window précédent et ajoutés au nouveau menu.

N’appelez pas cette fonction membre si vous utilisez l’infrastructure pour gérer vos fenêtres enfants MDI.

Exemple

// CMdiView::OnReplaceMenu() is a menu command handler for CMdiView
// class, which in turn is a CView-derived class. It loads a new
// menu resource and replaces the main application window's menu
// bar with this new menu.
void CMdiView::OnReplaceMenu()
{
   // Load a new menu resource named IDR_SHORT_MENU. m_hDefaultMenu is
   // a member variable of CMdiDoc class (a CDocument-derived class).
   // Its type is HMENU.
   CMdiDoc *pdoc = (CMdiDoc*)GetDocument();
   pdoc->m_hDefaultMenu =
       ::LoadMenu(AfxGetResourceHandle(), MAKEINTRESOURCE(IDR_SHORT_MENU));
   if (pdoc->m_hDefaultMenu == NULL)
      return;

   // Get the parent window of this view window. The parent window is
   // a CMDIChildWnd-derived class. We can then obtain the MDI parent
   // frame window using the CMDIChildWnd*. Then, replace the current
   // menu bar with the new loaded menu resource.
   CMDIFrameWnd *frame = ((CMDIChildWnd*)GetParent())->GetMDIFrame();
   frame->MDISetMenu(CMenu::FromHandle(pdoc->m_hDefaultMenu), NULL);
   frame->DrawMenuBar();
}

 

// GetDefaultMenu() is an undocumented virtual function for
// CDocument class. It allows the document to determine which
// menu to display. m_hDefaultMenu is of type HMENU. Its value
// is initialized to NULL either in the constructor or
// CDocument::OnNewDocument(). And the menu resource is destroyed
// in the destructor to avoid having too many menus loaded at once.
HMENU CMdiDoc::GetDefaultMenu()
{
   if (m_hDefaultMenu)
      return m_hDefaultMenu;

   return COleServerDoc::GetDefaultMenu();
}

// Initialize member variable(s) in the constructor. CMdiDoc is
// a CDocument-derived class.
CMdiDoc::CMdiDoc()
{
   // Use OLE compound files
   EnableCompoundFile();

   m_hDefaultMenu = NULL; // initialize to NULL
}

// Destroy menu resource in CMdiDoc's destructor. CMdiDoc is
// a CDocument-derived class.
CMdiDoc::~CMdiDoc()
{
   if (m_hDefaultMenu)
      ::DestroyMenu(m_hDefaultMenu);
}

CMDIFrameWnd ::MDITile

Organise toutes les fenêtres enfants dans un format en mosaïque.

void MDITile();
void MDITile(int nType);

Paramètres

nType
Spécifie un indicateur de mosaïques. Ce paramètre peut être l’un des indicateurs suivants :

  • MDITILE_HORIZONTAL vignettes fenêtres enfants MDI afin qu’une fenêtre apparaisse au-dessus d’une autre.

  • MDITILE_SKIPDISABLED Empêche la vignette des fenêtres enfants MDI désactivées.

  • MDITILE_VERTICAL Vignettes fenêtres enfants MDI afin qu’une fenêtre s’affiche à côté d’une autre.

Notes

La première version de MDITile, sans paramètres, vignette les fenêtres verticalement sous Windows versions 3.1 et ultérieures. Les vignettes de deuxième version s’affichent verticalement ou horizontalement, selon la valeur du paramètre nType .

Exemple

Consultez l’exemple de CMDIFrameWnd ::MDICascade.

Voir aussi

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