Classe CMDIChildWnd

Fornece a funcionalidade de uma janela filho da interface de múltiplos documentos (MDI) do Windows, juntamente com membros para gerir a janela.

Sintaxe

class CMDIChildWnd : public CFrameWnd

Membros

Construtores Públicos

Métodos Públicos

Observações

Uma janela filha MDI assemelha-se muito a uma janela típica de frame, exceto que a janela filha MDI aparece dentro de uma janela de frame MDI em vez de no ambiente de trabalho. Uma janela filha MDI não tem uma barra de menus própria, mas partilha o menu da janela de frames MDI. O framework altera automaticamente o menu de frames MDI para representar a janela filha MDI atualmente ativa.

Para criar uma janela MDI filho útil para a sua aplicação, derive uma classe a partir de CMDIChildWnd. Adicione variáveis membro à classe derivada para armazenar dados específicos da sua aplicação. Implemente funções membros do manipulador de mensagens e um mapa de mensagens na classe derivada para especificar o que acontece quando as mensagens são direcionadas para a janela.

Existem três formas de construir uma janela filha MDI:

• Construa-o diretamente usando Create.

• Construa-o diretamente usando LoadFrame.

• Constroi-o indiretamente através de um modelo de documento.

Antes de chamar Create ou LoadFrame, deve construir o objeto frame-window no heap usando o operador C++ new . Antes de chamar Create , também podes registar uma classe janela com a função global AfxRegisterWndClass para definir os estilos de ícone e classe para o frame.

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

LoadFrame requer menos argumentos do que Create, e em vez disso recupera a maioria dos seus valores predefinidos de recursos, incluindo a legenda do frame, o ícone, a tabela aceleradora e o menu. Para serem acessíveis por LoadFrame, todos estes recursos devem ter o mesmo ID de recurso (por exemplo, IDR_MAINFRAME).

Quando um CMDIChildWnd objeto contém vistas e documentos, estes são criados indiretamente pelo framework em vez de diretamente pelo programador. O CDocTemplate objeto orquestra a criação da moldura, a criação das vistas contendas e a ligação das vistas ao documento apropriado. Os parâmetros do CDocTemplate construtor especificam a CRuntimeClass das três classes envolvidas (documento, quadro e visualização). Um objeto é usado pela framework para criar dinamicamente novas frames quando especificado pelo utilizador (por exemplo, usando o comando File New CRuntimeClass ou o comando MDI Window New).

Uma classe frame-window derivada de CMDIChildWnd deve ser declarada com DECLARE_DYNCREATE para que o mecanismo de RUNTIME_CLASS acima funcione corretamente.

A CMDIChildWnd classe herda grande parte da sua implementação padrão de CFrameWnd. Para uma lista detalhada destas características, consulte a descrição da classe CFrameWnd . A CMDIChildWnd classe tem as seguintes características adicionais:

• Em conjunto com a CMultiDocTemplate classe, múltiplos CMDIChildWnd objetos do mesmo modelo de documento partilham o mesmo menu, poupando recursos do sistema Windows.

• O menu da janela filha do MDI atualmente ativo substitui totalmente o menu da janela da moldura do MDI, e a legenda da janela filha do MDI atualmente ativa é adicionada à legenda da janela da moldura do MDI. Para mais exemplos de funções de janela filho MDI implementadas em conjunto com uma janela de quadro MDI, veja a descrição da CMDIFrameWnd classe.

Não use o operador C++ delete para destruir uma janela de frame. Utilize CWnd::DestroyWindow em substituição. A CFrameWnd implementação de PostNcDestroy apagará o objeto C++ quando a janela for destruída. Quando o utilizador fecha a janela de frame, o handler por defeito OnClose chama DestroyWindow.

Para mais informações sobre CMDIChildWnd, veja Janelas Enquadradas.

Hierarquia de herança

CObject

CCmdTarget

CWnd

CFrameWnd

CMDIChildWnd

Requerimentos

Cabeçalho: afxwin.h

CMDIChildWnd::CMDIChildWnd

Chamada para construir um CMDIChildWnd objeto.

CMDIChildWnd();

Observações

Chamada Create para criar a janela visível.

Example

Veja o exemplo de CMDIChildWnd::Create.

CMDIChildWnd::Create

Chame esta função membro para criar uma janela filho do Windows MDI e anexá-la ao CMDIChildWnd objeto.

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);

Parâmetros

lpszClassName
Aponta para uma cadeia de caracteres com terminação nula que nomeia a classe Windows (uma estrutura WNDCLASS ). O nome da classe pode ser qualquer nome registado na função global AfxRegisterWndClass . Deverá ser NULL para um standard CMDIChildWnd.

lpszWindowName
Aponta para uma cadeia de caracteres com terminação nula que representa o nome da janela. Usado como texto para a barra de título.

dwStyle
Especifica os atributos de estilo da janela. O estilo WS_CHILD é obrigatório.

retângulo
Contém o tamanho e a posição da janela. O rectDefault valor permite ao Windows especificar o tamanho e a posição do novo CMDIChildWnd.

pParentWnd
Especifica o pai da janela. Se for NULL, é usada a janela principal da aplicação.

pContext
Especifica uma estrutura CCreateContext . Este parâmetro pode ser NULL.

Valor de retorno

Não nulo se for bem-sucedido; caso contrário, 0.

Observações

A janela de frame filho MDI atualmente ativa pode determinar a legenda da janela de frame pai. Esta funcionalidade é desativada ao desligar a parte de estilo FWS_ADDTOTITLE da janela de moldura criança.

O framework chama esta função membro em resposta a um comando de utilizador para criar uma janela filha, e o framework usa o parâmetro pContext para ligar corretamente a janela filha à aplicação. Quando chamas Create, pContext pode ser NULL.

Exemplo 1

Este exemplo de handler de comandos de menu invoca Create para criar uma janela filha 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
}

Exemplo 2

O código de exemplo chama ao Create método de CHelloWnd, uma classe derivada 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
}

Este exemplo mostra a Create implementação da 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

Chame esta função para devolver o quadro pai MDI.

CMDIFrameWnd* GetMDIFrame();

Valor de retorno

Um apontador para a janela do quadro pai do MDI.

Observações

O frame devolvido é dois pais removidos do CMDIChildWnd e é o pai da janela do tipo MDICLIENT que gere o CMDIChildWnd objeto. Chame a função membro GetParent para devolver o CMDIChildWnd pai MDICLIENT imediato do objeto como ponteiro temporário CWnd .

Example

Veja o exemplo do CMDIFrameWnd::MDISetMenu.

CMDIChildWnd::MDIActivate

Chame esta função membro para ativar uma janela filho MDI independentemente da janela de frames MDI.

void MDIActivate();

Observações

Quando o frame se torna ativo, a janela filha que foi ativada pela última vez também será ativada.

Example

Veja o exemplo do CMDIFrameWnd::GetWindowMenuPopup.

CMDIChildWnd::MDIDestroy

Chame esta função membro para destruir uma janela filho do MDI.

void MDIDestroy();

Observações

A função membro remove o título da janela filho da janela de moldura e desativa a janela filha.

Example

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

Chame esta função membro para maximizar uma janela filho MDI.

void MDIMaximize();

Observações

Quando uma janela filha é maximizada, o Windows redimensiona-a para que a sua área cliente preencha a área cliente da janela de frame. O Windows coloca o menu de Controlo da janela filha na barra de menu da moldura para que o utilizador possa restaurar ou fechar a janela filha e adiciona o título da janela filha ao título da janela da moldura.

Example

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

Chame esta função membro para restaurar uma janela filho MDI a partir do tamanho maximizado ou minimizado.

void MDIRestore();

Example

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

Define os controlos para os recursos do menu e acelerador.

void SetHandles(
    HMENU hMenu,
    HACCEL hAccel);

Parâmetros

hMenu
O nome de um recurso de menu.

hAccel
A alavanca de um recurso acelerador.

Observações

Chame esta função para definir os recursos do menu e do acelerador usados pelo objeto janela filho do MDI.

Consulte também

Exemplo MFC de MDI
Exemplo MFC MDIDOCVW
Exemplo MFC SNAPVW
Classe CFrameWnd
Gráfico de Hierarquia
Classe CWnd
Classe CMDrameWnd