Como manipular eventos do PowerPoint 2000 ou PowerPoint 2002 eventos usando o Visual C++ .NET 2002 ou Visual C++ .NET 2003 e Microsoft Foundation Classes

Observação Microsoft Visual C++ .NET (2002) oferece suporte o modelo de código gerenciado que é fornecido pelo Microsoft .NET Framework e o modelo de código do Windows de Microsoft nativo não gerenciado. As informações neste artigo se aplicam somente ao código do Visual C++ não gerenciado.

Este artigo descreve como manipular eventos do Microsoft PowerPoint 2000 ou PowerPoint 2002 eventos usando o Microsoft Visual C++ .NET 2002 ou Visual C++ .NET 2003 e Microsoft Foundation Classes.

Eventos do PowerPoint

PowerPoint aciona eventos em resposta às ações do usuário ou em resposta a alguns métodos que são chamados por meio de automação. O objeto de aplicativo no modelo de objeto do PowerPoint dispara esses eventos em sua interface de saída, EApplication .

Para exibir esta interface e seus métodos, você pode usar o Visualizador do objeto OLE/COM, da seguinte maneira:

1. No menu Ferramentas no Visual Studio. NET, selecione OLE/COM objeto visualizador .
2. Expanda o nó para Bibliotecas de tipos e selecione a Biblioteca de objetos do Microsoft PowerPoint na lista.
3. No menu objeto , selecione Exibir para abrir a biblioteca no Visualizador do ITypeLib.
4. Expanda o nó para coclass Application e selecione EApplication .

Observe que EApplication é derivada de IDispatch e não é a dispinterface costuma ser usado como uma interface de origem. Se a interface de origem for um dispinterface, você pode determinar os identificadores de despacho (DISPIDs) para seus métodos usando o Visualizador do objeto OLE/COM. No entanto, como EApplication não é um dispinterface, você não pode determinar os DISPIDs para eventos de PowerPoint examinando a biblioteca de tipos.

A tabela a seguir lista os DISPIDs para os eventos que expõem os modelos de objeto do PowerPoint 2000 e PowerPoint 2002:



Você pode coletor de um evento de PowerPoint em seu aplicativo de C++ chamando IConnectionPointContainer::FindConnectionPoint encontrar o ponto de conexão para a interface de evento desejado e, em seguida, IConnectionPoint::Advise com a interface IUnknown de sua implementação para que o evento.

Criar um aplicativo de C++ para manipular eventos do PowerPoint

1. Crie um novo aplicativo de diálogo caixa com base usando o Assistente de aplicativos MFC (Microsoft Foundation Classes) no Visual C++ .NET. Nome do seu projeto PPTEventsDemo e aceite as configurações padrão. A caixa de diálogo é criada por padrão, juntamente com os arquivos Ppteventsdemodlg.cpp e Ppteventsdemodlg.h correspondentes.
2. Adicione três botões à sua caixa de diálogo e nomeie os botões Iniciar o PowerPoint , estabelecer conexões ponto e registrar coletor e Cancelar o registro do coletor e do limpar , respectivamente. Adicione uma caixa de listagem à caixa de diálogo. A caixa de listagem exibe os nomes dos eventos de medida que eles ocorrem.
3. Na janela Project explorer no Class View, clique com o botão direito do mouse PPTEventsDemo , aponte para Adicionar e, em seguida, clique em Add Class . Na caixa de diálogo Add Class , selecione classe do MFC da TypeLibrary e clique em Abrir . Isso inicia o Add Class do Assistente de TypeLib.
4. Selecione a biblioteca de objetos do Microsoft PowerPoint 10.0 (para o PowerPoint 2002) ou biblioteca de objetos Microsoft PowerPoint 9.0 (para o PowerPoint 2000) na lista drop-down TypeLibraries disponíveis . A caixa de lista de interfaces exibe todas as interfaces que expõe a biblioteca de tipos. Selecione _Application e clique no > botão. Aceite os padrões e em seguida, clique em Concluir . Isso gera a classe de wrapper CApplication , que é derivada do COleDispatchDriver . A implementação e a definição dessa classe está disponível no arquivo capplication.h.
5. No Visual Studio. NET, clique em Modo de exibição de recurso no menu Exibir para mostrar a caixa de diálogo PPTEventsDemo . Clique duas vezes o PowerPoint de inicialização para mostrar a janela código View Ppteventsdemodlg.cpp, onde um manipulador de eventos vazio foi inserido para o evento Click do botão. Adicione o seguinte código ao manipulador para o botão Inicialização PowerPoint :

     if(!pptapp.CreateDispatch("Powerpoint.Application"))
     {
            AfxMessageBox("Could not create Powerpoint object.");
            return;
     }
   
     pptapp.put_Visible((long) 1);
   
   					

6. Adicione o seguinte código para o manipulador do botão de ponto de conexão estabelecer e registrar o coletor :

   ///*********************** Start of code to get connection point **************
         //  Declare the events that you want to catch.
         // 
         //  Look for the coclass for Application in the Msppt9.olb typelib,
         //  then look for the word "source." The EApplication interface
         //  is the next search target. When you find it, you will see the 
         //  following GUID for the event interface.
         //  914934C2-5A91-11CF-8700-00AA0060263B
   	 static const GUID IID_IEApplication =
   	 {0x914934C2,0x5A91,0x11CF, {0x87,0x00,0x00,0xAA,0x00,0x60,0x26,0x3b}};
   
         //  Steps for setting up events.
         // 1. Get the IConnectionPointContainer interface of the server.
         // 2. Call IConnectionPointContainer::FindConnectionPoint()
         //    to find the event that you want to catch.
         // 3. Call IConnectionPoint::Advise() with the IUnknown
         //    interface of your implementation of the events.
   
         HRESULT hr;
   
         // Get the (PPT) IConnectionPointContainer interface of the server.
         IConnectionPointContainer *pConnPtContainer;
         hr = pptapp.m_lpDispatch->QueryInterface(
            IID_IConnectionPointContainer,
            (void **)&pConnPtContainer
         );
   	  if(FAILED(hr)) AfxMessageBox("Couldn't get IConnectionPointContainer interface.");
         ASSERT(!FAILED(hr));
   
         // Find a connection point for the events that you are interested in.
         hr = pConnPtContainer->FindConnectionPoint(
       	 IID_IEApplication,
            &m_pConnectionPoint
         );
   	  if(FAILED(hr)) AfxMessageBox("Couldn't find connection point via event GUID.");
         ASSERT(!FAILED(hr));
   
         //Instantiate the sink object.
         m_sink = new CMyPPTEventsHandler();
   
         //Update the list box when you obtain the events in the event handler.
         m_sink->m_pListBox = m_listBox;
   
        // Get the IUnknown interface of your event implementation.
         LPUNKNOWN pUnk = NULL;
         pUnk = m_sink->GetInterface(&IID_IUnknown);
         ASSERT(pUnk);
   
         // Setup advisory connection.
         hr = m_pConnectionPoint->Advise(pUnk, &m_sink->cookie);  
         ASSERT(!FAILED(hr));  
   
         // Release the IConnectionPointContainer interface.
         pConnPtContainer->Release();
   // *********************** End of code to get connection point ******************
   
   					

7. Adicione o seguinte código um manipulador para o botão Cancelar o registro do coletor e do limpar :

   //Use the cookie to unregister the sink.
           m_pConnectionPoint->Unadvise(m_sink->cookie);
   	m_pConnectionPoint->Release();
   //Detach the application object from the server.
   	pptapp.DetachDispatch();
   
   
   					

8. Adicione o seguinte código para a parte inferior do construtor da classe CPPTEventsDemoDlg :

   	m_pConnectionPoint = NULL;
   	pptapp = NULL;
   					

9. Antes de retornar de CPPTEventsDemoDlg::OnInitDialog , adicione a seguinte linha de código:

         //Get the MFC class pointer for the list box on the dialog box.
         m_listBox = (CListBox*) GetDlgItem(IDC_LIST1);
   					

10. Certifique-se que você coloque as seguintes instruções # include no início do arquivo Ppteventsdemodlg.cpp:

    #include "stdafx.h"
    #include "CApplication.h"
    #include "MyPPTEventsHandler.h"
    #include "PPTEventsDemo.h"
    #include "PPTEventsDemoDlg.h"
    					

11. Frente declarar as seguintes classes no arquivo Ppteventsdemodlg.h:

    class CMyPPTEventsHandler;
    class CApplication;
    					

12. Adicione as seguintes declarações como membros privados CPPTEventsDemoDlg :

            IConnectionPoint* m_pConnectionPoint;
    	CApplication pptapp;
    	CMyPPTEventsHandler* m_sink;
    	CListBox* m_listBox; 
    					

13. No modo de classe no Project Explorer, clique com o botão direito do mouse PPTEventsDemo , aponte para Add e, em seguida, clique em Add Class . Na caixa de diálogo AddClass , selecione classe do MFC em modelos e, em seguida, clique em Abrir . Tipo CMyPPTEventsHandler para o nome de classe, selecione CCmdTarget para a classe base e, em seguida, selecione automação . Para outros campos, aceite os padrões. Clique em Concluir . Isso cria uma nova classe MFC CMyPPTEventsHandler que é derivada de CCmdTarget . Essa classe é definida no arquivo Myppteventshandler.h e é implementada em Myppteventshandler.cpp. Essa é a classe de Manipulador de eventos que contém métodos que são chamados em resposta a eventos PowerPoint.
    
    
14. Isso cria um novo arquivo em Myppteventshandler.h, declarar frente a seguinte classe:

    class CPresentation;
    					

15. Isso cria um novo arquivo em Myppteventshandler.h, adicionar os seguintes membros para as declarações públicas na classe CMyPPTEventsHandler :

    DWORD cookie;   
    CListBox* m_pListBox; 
    					

16. Isso cria um novo adicionar os seguintes métodos para as declarações protegidos na classe CMyPPTEventsHandler :

            void WindowSelectionChange(LPDISPATCH Pres);
    	void WindowBeforeRightClick(LPDISPATCH Pres, VARIANT_BOOL* Cancel);
    	void WindowBeforeDoubleClick(LPDISPATCH Pres, VARIANT_BOOL* Cancel);
    	void PresentationClose ( LPDISPATCH Pres);
    	void PresentationSave( LPDISPATCH Pres);
    	void PresentationOpen( LPDISPATCH Pres);
    	void NewPresentation( LPDISPATCH Pres);
    	void PresentationNewSlide( LPDISPATCH Pres);
    	void WindowActivate( LPDISPATCH Pres,LPDISPATCH Wn);
    	void WindowDeactivate(LPDISPATCH Pres, LPDISPATCH Wn);
    	void SlideShowBegin(LPDISPATCH Wn);
    	void SlideShowNextBuild( LPDISPATCH Wn);
    	void SlideShowNextSlide( LPDISPATCH Wn);
    	void SlideShowEnd( LPDISPATCH Pres);
    	void PresentationPrint(LPDISPATCH Pres);
    	void SlideSelectionChanged(LPDISPATCH SldRange);
    	void ColorSchemeChanged(LPDISPATCH SldRange);
    	void PresentationBeforeSave(LPDISPATCH Pres, VARIANT_BOOL * Cancel);
    	void SlideShowNextClick(LPDISPATCH Wn, LPDISPATCH nEffect);
    	void PresentationPrint(LPDISPATCH Pres);
    
    					

    são os manipuladores de evento do PowerPoint.
    
    Observação: Os seguintes manipuladores de 4 eventos não estão disponíveis no PowerPoint 2000 e não são chamados se o cliente possui o PowerPoint 2000:

    
    	void SlideSelectionChanged(LPDISPATCH SldRange);
    	void ColorSchemeChanged(LPDISPATCH SldRange);
    	void PresentationBeforeSave(LPDISPATCH Pres, VARIANT_BOOL * Cancel);
    	void SlideShowNextClick(LPDISPATCH Wn, LPDISPATCH nEffect);
    					

17. Isso cria um novo substituir todo o conteúdo de Myppteventshandler.cpp com o seguinte:

    // MyPPTEventsHandler.cpp : implementation file.
    // 
    
    #include "stdafx.h"
    #include "PPTEventsDemo.h"
    #include "MyPPTEventsHandler.h"
    
    
    // CMyPPTEventsHandler.
    
    IMPLEMENT_DYNAMIC(CMyPPTEventsHandler, CCmdTarget)
    CMyPPTEventsHandler::CMyPPTEventsHandler()
    {
    	EnableAutomation();
    }
    
    CMyPPTEventsHandler::~CMyPPTEventsHandler()
    {
    }
    
    
    void CMyPPTEventsHandler::OnFinalRelease()
    {
    	// When the last reference for an Automation object is released,
    	// OnFinalRelease is called. The base class automatically
    	// deletes the object. Add additional cleanup required for your
    	// object before you call the base class.
    
    	CCmdTarget::OnFinalRelease();
    }
    
    
    BEGIN_MESSAGE_MAP(CMyPPTEventsHandler, CCmdTarget)
    END_MESSAGE_MAP()
    
    
    BEGIN_DISPATCH_MAP(CMyPPTEventsHandler, CCmdTarget)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"WindowSelectionChange",2001,WindowSelectionChange,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler , "WindowBeforeRightClick", 2002 ,WindowBeforeRightClick, VT_EMPTY , VTS_DISPATCH VTS_BOOL)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler , "WindowBeforeDoubleClick", 2003 ,WindowBeforeDoubleClick, VT_EMPTY, VTS_DISPATCH VTS_BOOL)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationClose",2004,PresentationClose,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationSave",2005,PresentationSave,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationOpen",2006,PresentationOpen,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"NewPresentation",2007,NewPresentation,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationNewSlide",2008,PresentationNewSlide,VT_EMPTY, VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"WindowActivate",2009,WindowActivate,VT_EMPTY, VTS_DISPATCH VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"WindowDeactivate",2010,WindowDeactivate,VT_EMPTY, VTS_DISPATCH VTS_DISPATCH)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideShowBegin",2011,SlideShowBegin,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideShowNextBuild",2012,SlideShowNextBuild,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideShowNextSlide",2013,SlideShowNextSlide,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideShowEnd",2014,SlideShowEnd,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationPrint",2015,PresentationPrint,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideSelectionChanged",2016,SlideSelectionChanged,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"ColorSchemeChanged",2017,ColorSchemeChanged,VT_EMPTY, VTS_DISPATCH )
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"PresentationBeforeSave",2018,PresentationBeforeSave,VT_EMPTY, VTS_DISPATCH VTS_BOOL)
    	DISP_FUNCTION_ID(CMyPPTEventsHandler,"SlideShowNextClick",2019,SlideShowNextClick,VT_EMPTY, VTS_DISPATCH VTS_DISPATCH )
    	
    END_DISPATCH_MAP()
    
    //The GUUID is different from the one originally generated by Class Wizard. This GUUID is the same as the one for the EApplication outgoing event interface.
    static const IID IID_IMyPPTEventsHandler =
    {0x914934C2,0x5A91,0x11CF, {0x87,0x00,0x00,0xAA,0x00,0x60,0x26,0x3b}};
    
    
    BEGIN_INTERFACE_MAP(CMyPPTEventsHandler, CCmdTarget)
    	INTERFACE_PART(CMyPPTEventsHandler, IID_IMyPPTEventsHandler, Dispatch)
    END_INTERFACE_MAP()
    
    
    // CMyPPTEventsHandler message handlers.
    
    void CMyPPTEventsHandler::WindowSelectionChange(LPDISPATCH Pres)
    {
    	m_pListBox->AddString("WindowSelectionChange");
    	return ; 
    }
    void CMyPPTEventsHandler::WindowBeforeRightClick(LPDISPATCH Pres, VARIANT_BOOL* Cancel)
    {
        m_pListBox->AddString("WindowBeforeRightClick");
    	return ;
    }
    
    void CMyPPTEventsHandler::WindowBeforeDoubleClick(LPDISPATCH Pres, VARIANT_BOOL* Cancel)
    {
    	m_pListBox->AddString("WindowBeforeDoubleClick");
    	return;
    }
    
    void CMyPPTEventsHandler::PresentationClose ( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("PresentationClose");
    	return ;
    }
    
    void CMyPPTEventsHandler::PresentationSave( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("PresentationSave");
    	return ;
    }
    
    
    
    void CMyPPTEventsHandler::PresentationOpen( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("PresentationOpen");
    	return ;
    }
    void CMyPPTEventsHandler::NewPresentation( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("NewPresentation");
    	return ;
    }
    
    void CMyPPTEventsHandler::PresentationNewSlide( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("PresentationNewSlide");
    	return ;
    }
    
    
    void CMyPPTEventsHandler::WindowActivate( LPDISPATCH Pres,LPDISPATCH Wn)
    {
    	m_pListBox->AddString("WindowActivate");
    	return ;
    }
    
    
    void CMyPPTEventsHandler::WindowDeactivate(LPDISPATCH Pres, LPDISPATCH Wn)
    {
    	m_pListBox->AddString("WindowDeactivate");
    	return ;
    }
    
    
    void  CMyPPTEventsHandler::SlideShowBegin(LPDISPATCH Wn)
    {
    	m_pListBox->AddString("SlideShowBegin");
    	return;
    }
    
    
    void  CMyPPTEventsHandler::SlideShowNextBuild( LPDISPATCH Wn)
    {
    	m_pListBox->AddString("SlideShowNextBuild");
    	return ;
    
    }
    
    
    void CMyPPTEventsHandler::SlideShowNextSlide( LPDISPATCH Wn)
    {
    	m_pListBox->AddString("SlideShowNextSlide");
    	return ;
    }
    
    void CMyPPTEventsHandler::SlideShowEnd( LPDISPATCH Pres)
    {
    	m_pListBox->AddString("SlideShowEnd");
    	return;
    }
    
    void CMyPPTEventsHandler::PresentationPrint(LPDISPATCH Pres)
    {
    	m_pListBox->AddString("PresentationPrint");
    	return;
    }
    
    //The following events are not available for PowerPoint 2000.
    void CMyPPTEventsHandler::SlideSelectionChanged(LPDISPATCH SldRange)
    {
    	m_pListBox->AddString("SlideSelectionChanged");
    	return ;
    }
    
    void CMyPPTEventsHandler::ColorSchemeChanged(LPDISPATCH SldRange)
    {
    	m_pListBox->AddString("ColorSchemeChanged");
    	return ;
    }
    
    void CMyPPTEventsHandler::PresentationBeforeSave(LPDISPATCH Pres, VARIANT_BOOL * Cancel)
    {
    	m_pListBox->AddString("PresentationBeforeSave");
    	return;
    }
    
    void CMyPPTEventsHandler::SlideShowNextClick(LPDISPATCH Wn, LPDISPATCH nEffect)
    {
    	m_pListBox->AddString("SlideShowNextClick");
    	return ;
    }
    
    					

    Observe que o valor da constante IID_IMyPPTEventsHandler estático é alterado do valor que originalmente gerou o Assistente de classe. O valor é alterado para o seguinte:

    static const IID IID_IMyPPTEventsHandler =
    {0x914934C2,0x5A91,0x11CF, {0x87,0x00,0x00,0xAA,0x00,0x60,0x26,0x3b}};
    					

    é o GUID para a interface de evento EApplication saída para a classe de aplicativo do PowerPoint. Além disso, observe que a expedição mapear para essa classe mapeia DISPIDs dos eventos para os métodos de manipulador de eventos.
    
    
18. Isso cria um novo arquivo em Ppteventsdemo.cpp, adicione a instrução a seguir # include

    #include "CApplication.h"
    					

    antes do seguinte:

    #include "PPTEventsDemoDlg.h" 
    					

19. Isso cria um novo adicionar linhas de código a seguir na parte superior do método CWinAppEx do arquivo Ppteventsdemoapp.cpp:

    if(!AfxOleInit())
    	{
    		AfxMessageBox("Unable to initialize COM");
    		return FALSE;
    	}

Teste o aplicativo

1. Pressione F5 para compilar e executar o programa. A caixa de diálogo será exibida.
2. Clique em Iniciar o PowerPoint . O PowerPoint é iniciado e se torna visível.
3. Clique em estabelecer conexões ponto e registrar coletor para configurar os receptores de evento.
4. Crie uma nova apresentação no PowerPoint. O WindowActivate , NewPresentation , PresentationNewSlide , SlideSelectionChange e WindowSelectionChange eventos acionam.
5. Inicie a apresentação de slides e executá-lo até o final. Os eventos SlideShowBegin SlideShowNextSlide e SlideShowEnd acionados.
6. Salve a apresentação. Os eventos PresentationBeforeSave e PresentationSave acionados.
7. Feche a apresentação. O evento PresentationClose é acionado, e os eventos que foram disparados pelo PowerPoint 2002 e manipulados pelo programa aparecem na caixa de listagem.
   
   Observação: Esses são os eventos que o PowerPoint 2002 é acionado. Você não pode ver alguns desses eventos no PowerPoint 2000.
   
8. Clique em Cancelar o registro do coletor e do limpeza para desconectar receptores de evento.
9. Feche a caixa de diálogo.

Para obter informações adicionais, clique nos números abaixo para ler os artigos na Base de dados de Conhecimento da Microsoft: Para obter mais informações sobre automação do Office, consulte o seguinte site Suporte Microsoft Office Development: