Classe CMDIFrameWnd

Fornece a funcionalidade de uma janela de quadro MDI (interface de documento múltiplo) do Windows, além dos membros para gerenciar a janela.

Sintaxe

class CMDIFrameWnd : public CFrameWnd

Membros

Construtores públicos

Nome	Descrição
CMDIFrameWnd::CMDIFrameWnd	Constrói um CMDIFrameWnd.

Métodos públicos

Nome	Descrição
CMDIFrameWnd::CreateClient	Cria uma janela MDICLIENT do Windows para esse CMDIFrameWnd. Chamado pela função de membro OnCreate de CWnd.
CMDIFrameWnd::CreateNewChild	Cria uma nova janela filho.
CMDIFrameWnd::GetWindowMenuPopup	Retorna o menu pop-up do Windows.
CMDIFrameWnd::MDIActivate	Ativa uma janela filho diferente da MDI.
CMDIFrameWnd::MDICascade	Organiza todas as janelas filho em cascata.
CMDIFrameWnd::MDIGetActive	Recupera a janela filho da MDI ativa no momento, juntamente com um sinalizador que indica se o filho está maximizado.
CMDIFrameWnd::MDIIconArrange	Organiza todas as janelas filho minimizadas do documento.
CMDIFrameWnd::MDIMaximize	Maximiza uma janela filho da MDI.
CMDIFrameWnd::MDINext	Ativa a janela filho imediatamente atrás da janela filho ativa no momento e coloca a janela filho ativa no momento atrás de todas as outras janelas filho.
CMDIFrameWnd::MDIPrev	Ativa a janela filho anterior e coloca a janela filho ativa no momento imediatamente atrás dela.
CMDIFrameWnd::MDIRestore	Restaura uma janela filho da MDI do tamanho maximizado ou minimizado.
CMDIFrameWnd::MDISetMenu	Substitui o menu de uma janela com moldura da interface MDI, o menu pop-up do Windows ou ambos.
CMDIFrameWnd::MDITile	Organiza todas as janelas filho em um formato organizado lado a lado.

Comentários

Para criar uma janela com moldura útil da interface MDI para o aplicativo, derive uma classe de CMDIFrameWnd. Adicione variáveis de membro à classe derivada para armazenar os dados específicos do aplicativo. Implemente funções membro do manipulador de mensagens e um mapa de mensagens na classe derivada para especificar o que acontecerá quando as mensagens forem direcionadas para a janela.

Você pode construir uma janela com moldura da interface MDI, chamando a função de membro Criar ou LoadFrame de CFrameWnd.

Antes de chamar Create ou LoadFrame, será necessário construir o objeto de janela com moldura no heap, usando o novo operador new do C++. Antes de chamar Create você também poderá registrar uma classe de janela com a função global AfxRegisterWndClass para definir os estilos de ícone e classe para o quadro.

Use a função membro Create para passar os parâmetros de criação do quadro como argumentos imediatos.

LoadFrame exige menos argumentos do que Create e, em vez disso, recupera a maioria dos valores padrão dos recursos incluindo a legenda, o ícone, a tabela de aceleradores e o menu do quadro. Para serem acessados pelo LoadFrame, todos esses recursos deverão ter a mesma ID do recurso (por exemplo, IDR_MAINFRAME).

Embora MDIFrameWnd seja derivado de CFrameWnd, uma classe de janela com moldura derivada de CMDIFrameWnd não precisa ser declarada com o DECLARE_DYNCREATE.

A classe CMDIFrameWnd herda grande parte da implementação padrão do CFrameWnd. Para obter uma lista detalhada desses recursos, consulte a descrição de classe CFrameWnd. A classe CMDIFrameWnd tem os seguintes recursos adicionais:

• Em uma janela com moldura da interface MDI, a janela com moldura gerencia a janela MDICLIENT, reposicionando-a em conjunto com as barras de controle. A janela cliente da interface MDI é o pai direto das janelas com moldura filho da MDI. Os estilos de janela WS_HSCROLL e WS_VSCROLL especificados em um CMDIFrameWnd se aplicam à janela cliente da interface MDI, em vez da janela de mainframe, para que o usuário possa rolar a área do cliente da MDI (como no Gerenciador de Programas do Windows, por exemplo).

• Uma janela com moldura da interface MDI tem um menu padrão usado como a barra de menus, quando não há janelas filho da MDI ativas. Quando há um filho da interface MDI ativo, a barra de menus da janela com moldura da MDI é substituída automaticamente pelo menu da janela filho da MDI.

• Uma janela com moldura da interface MDI funciona em conjunto com a janela filho da MDI atual, se houver. Por exemplo, as mensagens de comando são delegadas para o filho da interface MDI atualmente ativo, antes da janela com moldura da MDI.

• Uma janela com moldura da interface MDI tem manipuladores padrão para os seguintes comandos de menu padrão do Windows:

  • ID_WINDOW_TILE_VERT

  • ID_WINDOW_TILE_HORZ

  • ID_WINDOW_CASCADE

  • ID_WINDOW_ARRANGE

• Uma janela com moldura da interface MDI também tem uma implementação de ID_WINDOW_NEW, que cria um novo quadro e a exibição no documento atual. Um aplicativo pode substituir essas implementações de comando padrão para personalizar o tratamento de janela da interface MDI.

Não use o operador delete do C++ para destruir uma janela com moldura. Use o CWnd::DestroyWindow em vez disso. A implementação CFrameWnd de PostNcDestroy excluirá o objeto C++ quando a janela for destruída. Quando o usuário fechar a janela com moldura, o manipulador OnClose padrão chamará DestroyWindow.

Para obter mais informações sobre CMDIFrameWnd, confira Janelas com Moldura.

Hierarquia de herança

CObject

CCmdTarget

CWnd

CFrameWnd

CMDIFrameWnd

Requisitos

Cabeçalho: afxwin.h

CMDIFrameWnd::CMDIFrameWnd

Constrói um objeto CMDIFrameWnd.

CMDIFrameWnd();

Comentários

Chame a função de membro Create ou LoadFrame para criar a janela com moldura visível da interface MDI.

Exemplo

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

Cria a janela cliente da interface MDI que gerencia os objetos CMDIChildWnd.

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

Parâmetros

lpCreateStruct
Um ponteiro longo para uma estrutura CREATESTRUCT.

pWindowMenu
Um ponteiro para o menu pop-up do Windows.

Valor de Devolução

Diferente de zero se tiver êxito; caso contrário, 0.

Comentários

Essa função de membro deve ser chamada, se você substituir a função de membro OnCreate diretamente.

Exemplo

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

Cria uma nova janela filho.

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

Parâmetros

pClass
A classe em tempo de execução da janela filho a ser criada.

nResource
A ID dos recursos compartilhados associados à janela filho.

hMenu
O menu da janela filho.

hAccel
O acelerador da janela filho.

Comentários

Use essa função para criar as janelas filho de uma janela com moldura da interface MDI.

Exemplo

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

Chame essa função de membro para obter um identificador para o menu pop-up atual chamado "Janela" (o menu pop-up com itens de menu para gerenciamento de janelas da interface MDI).

virtual HMENU GetWindowMenuPopup(HMENU hMenuBar);

Parâmetros

hMenuBar
A barra de menus atual.

Valor de Devolução

O menu pop-up do Windows, se houver. Caso contrário, NULL.

Comentários

A implementação padrão procura um menu pop-up que contém os comandos de menu padrão do Windows, como ID_WINDOW_NEW e ID_WINDOW_TILE_HORZ.

Substitua essa função de membro, se você tiver um menu Janela que não use as IDs de comando do menu padrão.

Exemplo

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

Ativa uma janela filho diferente da MDI.

void MDIActivate(CWnd* pWndActivate);

Parâmetros

pWndActivate
Aponta para a janela filho da interface MDI a ser ativada.

Comentários

Essa função de membro envia a mensagem WM_MDIACTIVATE para a janela filho que está sendo ativada e a janela filho que está sendo desativada.

Essa é a mesma mensagem enviada, se o usuário alterar o foco para uma janela filho da interface MDI usando o mouse ou teclado.

Observação

Uma janela filho da interface MDI é ativada independentemente da janela com moldura da MDI. Quando o quadro se torna ativo, a janela filho ativada pela última vez com uma chamada recebe uma mensagem , para desenhar uma janela com moldura ativa e a barra de legenda, mas não recebe outra mensagem WM_MDIACTIVATE.

Exemplo

Consulte o exemplo para CMDIFrameWnd::GetWindowMenuPopup.

CMDIFrameWnd::MDICascade

Organiza todas as janelas filho da interface MDI em cascata.

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

Parâmetros

nType
Especifica um sinalizador em cascata. Somente o seguinte sinalizador pode ser especificado: MDITILE_SKIPDISABLED, o que impede que as janelas filho da interface MDI desabilitadas sejam organizadas em cascata.

Comentários

A primeira versão de MDICascade, sem parâmetros, organiza em cascata todas as janelas filho da interface MDI, incluindo as desabilitadas. Opcionalmente, a segunda versão não organiza em cascata as janelas filho da interface MDI, se você especificar MDITILE_SKIPDISABLED para o parâmetro nType.

Exemplo

// 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 a janela filho da interface MDI ativa no momento, juntamente com um sinalizador que indica se a janela filho está maximizada.

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

Parâmetros

pbMaximized
Um ponteiro para um valor retornado BOOL. Defina como TRUE no retorno, se a janela estiver maximizada. Caso contrário, FALSE.

Valor de Devolução

Um ponteiro para a janela filho MDI ativa.

Exemplo

Confira o exemplo para CMDIChildWnd::MDIMaximize.

CMDIFrameWnd::MDIIconArrange

Organiza todas as janelas filho minimizadas do documento.

void MDIIconArrange();

Comentários

Isso não afeta janelas filho que não estão minimizadas.

Exemplo

Confira o exemplo para CMDIFrameWnd::MDICascade.

CMDIFrameWnd::MDIMaximize

Maximiza a janela filho da interface MDI especificada.

void MDIMaximize(CWnd* pWnd);

Parâmetros

pWnd
Aponta para a janela a ser maximizada.

Comentários

Quando uma janela filho é maximizada, o Windows a redimensiona para fazer com que a área de cliente preencha a janela cliente. O Windows coloca o menu Controle da janela filho na barra de menus do quadro, para que o usuário possa restaurar ou fechar a janela filho. Ele também adiciona o título da janela filho ao título da janela com moldura.

Se outra janela filho da interface MDI estiver ativada quando a janela filho da MDI ativa no momento estiver maximizada, o Windows restaurará o filho ativo no momento e maximizará a janela filho recém-ativada.

Exemplo

Confira o exemplo para CMDIChildWnd::MDIMaximize.

CMDIFrameWnd::MDINext

Ativa a janela filho imediatamente atrás da janela filho ativa no momento e coloca a janela filho ativa no momento atrás de todas as outras janelas filho.

void MDINext();

Comentários

Se a janela filho da interface MDI ativa no momento estiver maximizada, a função de membro restaurará o filho ativo no momento e maximizará o filho recém-ativado.

Exemplo

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

Ativa a janela filho anterior e coloca a janela filho ativa no momento imediatamente atrás dela.

void MDIPrev();

Comentários

Se a janela filho da interface MDI ativa no momento estiver maximizada, a função de membro restaurará o filho ativo no momento e maximizará o filho recém-ativado.

CMDIFrameWnd::MDIRestore

Restaura uma janela filho da MDI do tamanho maximizado ou minimizado.

void MDIRestore(CWnd* pWnd);

Parâmetros

pWnd
Aponta para a janela a ser restaurada.

Exemplo

Confira o exemplo para CMDIChildWnd::MDIRestore.

CMDIFrameWnd::MDISetMenu

Substitui o menu de uma janela com moldura da interface MDI, o menu pop-up do Windows ou ambos.

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

Parâmetros

pFrameMenu
Especifica o menu do novo menu de janela com moldura. Se NULL, o menu não será alterado.

pWindowMenu
Especifica o menu do novo menu pop-up do Windows. Se NULL, o menu não será alterado.

Valor de Devolução

Um ponteiro para o menu de janela com moldura substituído por esta mensagem. O ponteiro pode ser temporário e não deve ser armazenado para uso posterior.

Comentários

Depois de chamar MDISetMenu, um aplicativo deve chamar a função de membro DrawMenuBar de CWnd para atualizar a barra de menus.

Se essa chamada substituir o menu pop-up do Windows, os itens de menu da janela filho da interface MDI serão removidos do menu Janela anterior e adicionados ao novo menu pop-up do Windows.

Se uma janela filho da interface MDI for maximizada e essa chamada substituir o menu de janela com moldura da MDI, o menu Controle e os controles de restauração serão removidos do menu anterior da janela com moldura e adicionados ao novo menu.

Não chame essa função de membro, se você usar a estrutura para gerenciar as janelas filho da interface MDI.

Exemplo

// 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 as janelas filho em um formato organizado lado a lado.

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

Parâmetros

nType
Especifica um sinalizador de bloco. Esse parâmetro pode usar qualquer um dos sinalizadores a seguir:

• MDITILE_HORIZONTAL Organiza lado a lado as janelas filho da interface MDI para que uma janela seja exibida acima da outra.

• MDITILE_SKIPDISABLED Impede que as janelas filho da interface MDI desabilitadas sejam organizadas lado a lado.

• MDITILE_VERTICAL Organiza lado a lado as janelas filho da interface MDI para que uma janela seja exibida ao lado da outra.

Comentários

A primeira versão de MDITile, sem parâmetros, dimensiona as janelas verticalmente no Windows versão 3.1 e posteriores. A segundo versão organiza lado a lado as janelas vertical ou horizontalmente, dependendo do valor do parâmetro nType.

Exemplo

Confira o exemplo para CMDIFrameWnd::MDICascade.

Confira também

MDI de exemplo do MFC
MFC Sample MDIDOCVW
MFC Sample SNAPVW
Classe CFrameWnd
Gráfico da hierarquia
Classe CWnd
Classe CMDIChildWnd