Adicionando vários modos de exibição para um único documento

  • Artigo

Em um aplicativo de interface de documento único (SDI) criado com a biblioteca Microsoft Foundation Class (MFC), cada tipo de documento está associado um tipo de exibição único.Em alguns casos, é desejável ter a capacidade de alternar o modo de exibição atual de um documento com um novo modo de exibição.

DicaDica

Para obter procedimentos adicionais sobre a implementação de vários modos de exibição para um único documento, consulte CDocument::AddView e COLETAR exemplo MFC.

Você pode implementar essa funcionalidade, adicionando um novo CView-derivado de classe e código adicional para alternar os modos de exibição dinamicamente para um aplicativo do MFC existente.

As etapas são:

  • Modificar a classe de aplicativo existente

  • Criar e modificar a nova classe de modo de exibição

  • Criar e anexar o novo modo de exibição

  • Implementar a função de comutação

  • Adicionar suporte para alternar o modo de exibição

O restante deste tópico pressupõe o seguinte:

  • O nome do CWinApp-objeto derivado é CMyWinApp, e CMyWinApp é declarado e definidos no MYWINAPP.H e MYWINAPP.CPP.

  • CNewViewé o nome da nova CView-derivado de objeto, e CNewView é declarado e definidos no NEWVIEW.H e NEWVIEW.CPP.

Modificar a classe de aplicativo existente

Para o aplicativo alternar entre modos de exibição, você precisa modificar a classe de aplicativo adicionando variáveis de membro para armazenar os modos de exibição e um método para alterá-los.

Adicione o seguinte código para a declaração do CMyWinApp em MYWINAPP.H:

CView* m_pOldView;
CView* m_pNewView;
CView* SwitchView( );

As novas variáveis de membro m_pOldView e m_pNewView, aponte para modo de exibição atual e o recém-criado.O novo método (SwitchView) alterna os modos de exibição quando solicitado pelo usuário.O corpo do método será discutido posteriormente neste tópico em implementar a função de comutação.

Última modificação na classe de aplicativo requer incluindo um novo arquivo de cabeçalho que define uma mensagem do Windows (WM_INITIALUPDATE) que é usado na função de comutação.

Insira a seguinte linha na seção incluir MYWINAPP.CPP:

#include <AFXPRIV.H>

Salvar as alterações e continuar para a próxima etapa.

Criar e modificar a nova classe de modo de exibição

Criar nova classe de modo de exibição é feita fácil usando o A nova classe comando disponível no modo de exibição de classe.O único requisito para essa classe é que ele deriva de CView.Adicione essa nova classe para o aplicativo.Para obter informações específicas sobre a adição de uma nova classe ao projeto, consulte Adicionar uma classe de.

Depois de adicionar a classe ao projeto, você precisará alterar a acessibilidade de alguns membros de classe de modo de exibição.

Modificar NEWVIEW.H alterando o especificador de acesso de protected para pública para o construtor e destruidor.Isso permite que a classe para ser criados e destruídos dinamicamente e modificar a aparência do modo de exibição antes de ser visível.

Salvar as alterações e continuar para a próxima etapa.

Criar e anexar o novo modo de exibição

Para criar e anexar o novo modo de exibição, você precisará modificar o InitInstance função de sua classe de aplicativo.A modificação adiciona novo código que cria um novo objeto de exibição e, em seguida, inicializa os dois m_pOldView e m_pNewView com os dois objetos de exibição existentes.

Porque o novo modo de exibição é criado dentro do InitInstance função, modos novos e existentes persistem durante a vida útil do aplicativo.No entanto, o aplicativo pode facilmente criar nova exibição dinamicamente.

Inserir este código após a chamada para ProcessShellCommand:

CView* pActiveView = ((CFrameWnd*) m_pMainWnd)->GetActiveView();
m_pOldView = pActiveView;
m_pNewView = (CView*) new CNewView;
if (NULL == m_pNewView)
   return FALSE;

CDocument* pCurrentDoc = ((CFrameWnd*)m_pMainWnd)->GetActiveDocument();

// Initialize a CCreateContext to point to the active document.
// With this context, the new view is added to the document
// when the view is created in CView::OnCreate().
CCreateContext newContext;
newContext.m_pNewViewClass = NULL;
newContext.m_pNewDocTemplate = NULL;
newContext.m_pLastView = NULL;
newContext.m_pCurrentFrame = NULL;
newContext.m_pCurrentDoc = pCurrentDoc;

// The ID of the initial active view is AFX_IDW_PANE_FIRST.
// Incrementing this value by one for additional views works
// in the standard document/view case but the technique cannot
// be extended for the CSplitterWnd case.
UINT viewID = AFX_IDW_PANE_FIRST + 1;
CRect rect(0, 0, 0, 0); // Gets resized later.

// Create the new view. In this example, the view persists for
// the life of the application. The application automatically
// deletes the view when the application is closed.
m_pNewView->Create(NULL, _T("AnyWindowName"), WS_CHILD, rect, m_pMainWnd, viewID, &newContext);

// When a document template creates a view, the WM_INITIALUPDATE
// message is sent automatically. However, this code must
// explicitly send the message, as follows.
m_pNewView->SendMessage(WM_INITIALUPDATE, 0, 0);

Salvar as alterações e continuar para a próxima etapa.

Implementar a função de comutação

Na etapa anterior, você adicionou o código criado e inicializado um novo objeto de exibição.A última informação importante é implementar o método de switching, SwitchView.

No final do arquivo de implementação de sua classe de aplicativo (MYWINAPP.CPP), adicionar a seguinte definição de método:

CView* CMyWinApp::SwitchView( )
{
   CView* pActiveView = ((CFrameWnd*) m_pMainWnd)->GetActiveView();

   CView* pNewView = NULL;
   if(pActiveView == m_pOldView)
      pNewView = m_pNewView;
   else
      pNewView = m_pOldView;

   // Exchange view window IDs so RecalcLayout() works.
   #ifndef _WIN32
   UINT temp = ::GetWindowWord(pActiveView->m_hWnd, GWW_ID);
   ::SetWindowWord(pActiveView->m_hWnd, GWW_ID, ::GetWindowWord(pNewView->m_hWnd, GWW_ID));
   ::SetWindowWord(pNewView->m_hWnd, GWW_ID, temp);
   #else
   UINT temp = ::GetWindowLong(pActiveView->m_hWnd, GWL_ID);
   ::SetWindowLong(pActiveView->m_hWnd, GWL_ID, ::GetWindowLong(pNewView->m_hWnd, GWL_ID));
   ::SetWindowLong(pNewView->m_hWnd, GWL_ID, temp);
   #endif

   pActiveView->ShowWindow(SW_HIDE);
   pNewView->ShowWindow(SW_SHOW);
   ((CFrameWnd*) m_pMainWnd)->SetActiveView(pNewView);
   ((CFrameWnd*) m_pMainWnd)->RecalcLayout();
   pNewView->Invalidate();
   return pActiveView;
}

Salvar as alterações e continuar para a próxima etapa.

Adicionar suporte para alternar o modo de exibição

A etapa final envolve adicionar código que chama o SwitchView método quando o aplicativo precisa alternar entre modos de exibição.Isso pode ser feito de várias maneiras: adicionar um novo item de menu para o usuário escolher ou alternar os modos de exibição internamente quando determinadas condições forem atendidas.

Para obter mais informações sobre a adição de novos itens de menu e as funções de manipulador de comando, consulte manipuladores de comandos e notificações de controle.

Consulte também

Conceitos

Arquitetura de exibição de documentos