Compartir a través de

CMDIFrameWnd (clase)

  • Artículo

Proporciona la funcionalidad de una ventana de marco de MDI (interfaz de varios documentos) de Windows, junto con miembros para administrar la ventana.

Sintaxis

class CMDIFrameWnd : public CFrameWnd

Miembros

Constructores públicos

Nombre Descripción
CMDIFrameWnd::CMDIFrameWnd Construye un objeto CMDIFrameWnd.

Métodos públicos

Nombre Descripción
CMDIFrameWnd::CreateClient Crea una ventana MDICLIENT de Windows para CMDIFrameWnd. Es la función miembro OnCreate de CWnd quien la llama.
CMDIFrameWnd::CreateNewChild Crea una nueva ventana secundaria.
CMDIFrameWnd::GetWindowMenuPopup Devuelve el menú emergente Ventana.
CMDIFrameWnd::MDIActivate Activa otra ventana secundaria MDI.
CMDIFrameWnd::MDICascade Organiza todas las ventanas secundarias en formato en cascada.
CMDIFrameWnd::MDIGetActive Recupera la ventana secundaria MDI activa actualmente, junto con una marca que indica si el elemento secundario está maximizado o no.
CMDIFrameWnd::MDIIconArrange Organiza todas las ventanas secundarias del documento minimizadas.
CMDIFrameWnd::MDIMaximize Maximiza una ventana secundaria MDI.
CMDIFrameWnd::MDINext Activa la ventana secundaria situada inmediatamente detrás de la ventana secundaria activa actualmente y coloca esta última detrás de todas las demás ventanas secundarias.
CMDIFrameWnd::MDIPrev Activa la ventana secundaria anterior y coloca la ventana secundaria activa actualmente inmediatamente detrás de ella.
CMDIFrameWnd::MDIRestore Restaura una ventana secundaria MDI a partir del tamaño maximizado o minimizado.
CMDIFrameWnd::MDISetMenu Reemplaza el menú de una ventana de marco MDI, el menú emergente Ventana o ambos.
CMDIFrameWnd::MDITile Organiza todas las ventanas secundarias en formato en mosaico.

Comentarios

Para crear una ventana de marco MDI útil para la aplicación, derive una clase de CMDIFrameWnd. Agregue variables miembro a la clase derivada para almacenar datos específicos de la aplicación. Implemente funciones miembro de controlador de mensajes y un mapa de mensajes en la clase derivada para especificar qué ocurre cuando los mensajes se dirigen a la ventana.

Puede construir una ventana de marco MDI si llama a la función miembro Create o LoadFrame de CFrameWnd.

Antes de llamar a Create o LoadFrame, debe construir el objeto de ventana de marco en el montón mediante el operador de C++ new. Antes de llamar a Create, también puede registrar una clase de ventana con la función global AfxRegisterWndClass para establecer el icono y los estilos de clase para el marco.

Use la función miembro Create para pasar los parámetros de creación del marco como argumentos inmediatos.

LoadFrame requiere menos argumentos que Create y, en su lugar, recupera la mayoría de sus valores predeterminados de los recursos, incluido el título, el icono, la tabla de aceleradores y el menú del marco. Para que LoadFrame pueda acceder, todos estos recursos deben tener el mismo identificador de recurso (por ejemplo, IDR_MAINFRAME).

Aunque MDIFrameWnd se deriva de CFrameWnd, no es necesario declarar una clase de ventana de marco derivada de CMDIFrameWnd con DECLARE_DYNCREATE.

La clase CMDIFrameWnd hereda gran parte de su implementación predeterminada de CFrameWnd. Para obtener una lista detallada de estas características, vea la descripción de la clase CFrameWnd. La clase CMDIFrameWnd tiene las siguientes características adicionales:

  • Una ventana de marco MDI administra la ventana MDICLIENT y la cambia de posición junto con las barras de control. La ventana cliente MDI es el elemento primario directo de las ventanas de marco secundarias MDI. Los estilos de ventana WS_HSCROLL y WS_VSCROLL especificados en CMDIFrameWnd se aplican a la ventana cliente MDI en lugar de a la ventana de marco principal, de modo que el usuario pueda desplazarse por el área cliente MDI (como en el Administrador de programas de Windows, por ejemplo).

  • Una ventana de marco MDI posee un menú predeterminado que se usa como la barra de menús si no hay ventanas secundarias MDI activas. Si hay un elemento secundario MDI activo, la barra de menús de la ventana de marco MDI se reemplaza automáticamente por el menú de ventana secundario MDI.

  • Una ventana de marco MDI también funciona junto con la ventana secundaria MDI actual, si la hay. Por ejemplo, los mensajes de comando se delegan al elemento secundario MDI activo actualmente antes que a la ventana de marco MDI.

  • Una ventana de marco MDI tiene controladores predeterminados para los siguientes comandos de menú Ventana estándar:

    • ID_WINDOW_TILE_VERT

    • ID_WINDOW_TILE_HORZ

    • ID_WINDOW_CASCADE

    • ID_WINDOW_ARRANGE

  • Una ventana de marco MDI también tiene una implementación de ID_WINDOW_NEW, que crea un nuevo marco y una vista en el documento actual. Una aplicación puede invalidar estas implementaciones de comandos predeterminadas para personalizar el control de ventanas MDI.

No use el operador de C++ delete para destruir una ventana de marco. En su lugar, use CWnd::DestroyWindow. La implementación CFrameWnd de PostNcDestroy eliminará el objeto de C++ cuando se destruya la ventana. Cuando el usuario cierra la ventana de marco, el controlador predeterminado OnClose llamará a DestroyWindow.

Para obtener más información sobre CMDIFrameWnd, vea Ventanas de marco.

Jerarquía de herencia

CObject

CCmdTarget

CWnd

CFrameWnd

CMDIFrameWnd

Requisitos

Encabezado: afxwin.h

CMDIFrameWnd::CMDIFrameWnd

Construye un objeto CMDIFrameWnd.

CMDIFrameWnd();

Comentarios

Llame a la función miembro Create o LoadFrame para crear la ventana de marco MDI visible.

Ejemplo

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

Crea la ventana cliente MDI que administra los objetos CMDIChildWnd.

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

Parámetros

lpCreateStruct
Puntero largo a una estructura CREATESTRUCT.

pWindowMenu
Puntero al menú emergente Ventana.

Valor devuelto

Si es correcta, su valor es distinto de cero. En caso contrario, es cero.

Comentarios

Se debe llamar a esta función miembro si se invalida la función miembro OnCreate directamente.

Ejemplo

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

Crea una nueva ventana secundaria.

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

Parámetros

pClass
Clase en tiempo de ejecución de la ventana secundaria que se va a crear.

nResource
Id. de los recursos compartidos asociados a la ventana secundaria.

hMenu
Menú de la ventana secundaria.

hAccel
Acelerador de la ventana secundaria.

Comentarios

Use esta función para crear ventanas secundarias de una ventana de marco MDI.

Ejemplo

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

Llame a esta función miembro para obtener un identificador del menú emergente actual de nombre "Ventana" (el menú emergente con elementos de menú para la administración de ventanas MDI).

virtual HMENU GetWindowMenuPopup(HMENU hMenuBar);

Parámetros

hMenuBar
Barra de menús actual.

Valor devuelto

Menú emergente Ventana, si existe; en caso contrario, NULL.

Comentarios

La implementación predeterminada busca un menú emergente que contenga comandos de menú Ventana estándar, como ID_WINDOW_NEW y ID_WINDOW_TILE_HORZ.

Invalide esta función miembro si tiene un menú Ventana que no usa los identificadores de comandos de menú estándar.

Ejemplo

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

Activa otra ventana secundaria MDI.

void MDIActivate(CWnd* pWndActivate);

Parámetros

pWndActivate
Apunta a la ventana secundaria MDI que se va a activar.

Comentarios

Esta función miembro envía el mensaje WM_MDIACTIVATE a la ventana secundaria que se va a activar y a la ventana secundaria que se va a desactivar.

Este es el mismo mensaje que se envía si el usuario cambia el foco a una ventana secundaria MDI mediante el mouse o el teclado.

Nota:

Una ventana secundaria MDI se activa independientemente de la ventana de marco MDI. Cuando el marco se activa, la ventana secundaria activada por última vez recibe un mensaje WM_NCACTIVATE para dibujar un marco de ventana activo y una barra de título, pero no recibe otra mensaje WM_MDIACTIVATE.

Ejemplo

Vea el ejemplo de CMDIFrameWnd::GetWindowMenuPopup.

CMDIFrameWnd::MDICascade

Organiza todas las ventanas secundarias MDI en formato en cascada.

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

Parámetros

nType
Especifica una marca de cascada. Solo se puede especificar la marca siguiente: MDITILE_SKIPDISABLED, que evita que las ventanas secundarias MDI deshabilitadas aparezcan en cascada.

Comentarios

La primera versión de MDICascade, sin parámetros, muestra en cascada todas las ventanas secundarias MDI, incluidas las deshabilitadas. Opcionalmente, la segunda versión no muestra en cascada las ventanas secundarias MDI deshabilitadas si se especifica MDITILE_SKIPDISABLED en el parámetro nType.

Ejemplo

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

Recupera la ventana secundaria MDI activa actualmente, junto con una marca que indica si el elemento secundario está maximizado.

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

Parámetros

pbMaximized
Puntero a un valor devuelto BOOL. Se establece en TRUE si la ventana está maximizada; en caso contrario, FALSE.

Valor devuelto

Puntero a la ventana secundaria MDI activa

Ejemplo

Vea el ejemplo de CMDIChildWnd::MDIMaximize.

CMDIFrameWnd::MDIIconArrange

Organiza todas las ventanas secundarias del documento minimizadas.

void MDIIconArrange();

Comentarios

No afecta a las ventanas secundarias que no están minimizadas.

Ejemplo

Vea el ejemplo de CMDIFrameWnd::MDICascade.

CMDIFrameWnd::MDIMaximize

Maximiza la ventana secundaria MDI especificada.

void MDIMaximize(CWnd* pWnd);

Parámetros

pWnd
Apunta a la ventana que se va a maximizar.

Comentarios

Cuando se maximiza una ventana secundaria, Windows cambia su tamaño para que su área cliente rellene la ventana cliente. Windows coloca el menú Control de la ventana secundaria en la barra de menús del marco para que el usuario pueda restaurar o cerrar la ventana secundaria. También agrega el título de la ventana secundaria al título de la ventana de marco.

Si se activa otra ventana secundaria MDI mientras la actual está maximizada, Windows restaura el elemento secundario activo actualmente y maximiza la ventana secundaria recién activada.

Ejemplo

Vea el ejemplo de CMDIChildWnd::MDIMaximize.

CMDIFrameWnd::MDINext

Activa la ventana secundaria situada inmediatamente detrás de la ventana secundaria activa actualmente y coloca esta última detrás de todas las demás ventanas secundarias.

void MDINext();

Comentarios

Si la ventana secundaria MDI activa actualmente está maximizada, la función miembro restaura el elemento secundario activo actualmente y maximiza el elemento secundario recién activado.

Ejemplo

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

Activa la ventana secundaria anterior y coloca la ventana secundaria activa actualmente inmediatamente detrás de ella.

void MDIPrev();

Comentarios

Si la ventana secundaria MDI activa actualmente está maximizada, la función miembro restaura el elemento secundario activo actualmente y maximiza el elemento secundario recién activado.

CMDIFrameWnd::MDIRestore

Restaura una ventana secundaria MDI a partir del tamaño maximizado o minimizado.

void MDIRestore(CWnd* pWnd);

Parámetros

pWnd
Apunta a la ventana que se va a restaurar.

Ejemplo

Vea el ejemplo de CMDIChildWnd::MDIRestore.

CMDIFrameWnd::MDISetMenu

Reemplaza el menú de una ventana de marco MDI, el menú emergente Ventana o ambos.

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

Parámetros

pFrameMenu
Especifica el menú del nuevo menú de ventana de marco. Si es NULL, el menú no se cambia.

pWindowMenu
Especifica el menú del nuevo menú emergente Ventana. Si es NULL, el menú no se cambia.

Valor devuelto

Puntero al menú de ventana de marco reemplazado por este mensaje. El puntero puede ser temporal y no se debe almacenar para su uso posterior.

Comentarios

Después de llamar a MDISetMenu, una aplicación debe llamar a la función miembro DrawMenuBar de CWnd para actualizar la barra de menús.

Si esta llamada reemplaza al menú emergente Ventana, los elementos de menú de ventana secundaria MDI se quitan del menú Ventana anterior y se agregan al nuevo menú emergente Ventana.

Si se maximiza una ventana secundaria MDI y esta llamada reemplaza al menú de ventana de marco MDI, el menú Control y los controles de restauración se quitan del menú de ventana de marco anterior y se agregan al nuevo menú.

No llame a esta función miembro si usa el marco para administrar las ventanas secundarias MDI.

Ejemplo

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

Organiza todas las ventanas secundarias en formato en mosaico.

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

Parámetros

nType
Especifica una marca de mosaico. Este parámetro puede ser cualquiera de las siguientes marcas:

  • MDITILE_HORIZONTAL Muestra en mosaico las ventanas secundarias MDI para que una ventana aparezca encima de otra.

  • MDITILE_SKIPDISABLED Evita que las ventanas secundarias MDI deshabilitadas aparezcan en mosaico.

  • MDITILE_VERTICAL Muestra en mosaico las ventanas secundarias MDI para que una ventana aparezca al lado de otra.

Comentarios

La primera versión de MDITile, sin parámetros, coloca en mosaico vertical las ventanas en Windows 3.1 y versiones posteriores. La segunda versión coloca en mosaico vertical u horizontal las ventanas, según el valor del parámetro nType.

Ejemplo

Vea el ejemplo de CMDIFrameWnd::MDICascade.

Consulte también

Ejemplo MDI de MFC
Ejemplo MDIDOCVW de MFC
Ejemplo SNAPVW de MFC
CFrameWnd (clase)
Gráfico de jerarquías
CWnd (clase)
CMDIChildWnd (clase)