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

Nota Microsoft Visual C++ .NET (2002) suporta o modelo de código gerido que é fornecido pelo Microsoft .NET Framework e o modelo de código do Microsoft Windows nativo não gerido. As informações neste artigo aplicam-se apenas ao código de Visual C++ não gerido.

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

Eventos do PowerPoint

O PowerPoint é accionado eventos em resposta às acções do utilizador ou em resposta a alguns métodos que são chamados através de automatização. O objecto de aplicação no modelo de objecto do PowerPoint é accionado estes eventos na respectiva interface de saída, EApplication .

Para ver esta interface e respectivos métodos, pode utilizar o Visualizador de objectos OLE/COM, da seguinte forma:

1. No menu Ferramentas no Visual Studio. NET, seleccione O Visualizador de objectos OLE/COM .
2. Expanda o nó para Bibliotecas de tipos e seleccione Microsoft PowerPoint Object Library na lista.
3. No menu de objecto , seleccione Ver para abrir a biblioteca no ITypeLib Viewer.
4. Expanda o nó coclass aplicações e seleccione EApplication .

Tenha em atenção que EApplication deriva de IDispatch e não a dispinterface é normalmente utilizado como uma interface de origem. Se a interface de origem for um dispinterface, pode determinar os identificadores de distribuição (DISPID) para os respectivos métodos utilizando o Visualizador de objectos OLE/COM. No entanto, uma vez que EApplication não é um dispinterface, não é possível determinar DISPID para eventos do PowerPoint examinando a biblioteca de tipos.

A tabela seguinte lista DISPID para os eventos que expõem os modelos de objecto do PowerPoint 2000 e PowerPoint 2002:



Pode receber um evento do PowerPoint na aplicação C++ chamando IConnectionPointContainer::FindConnectionPoint localizar o ponto de ligação para a interface de evento pretendido e, em seguida, IConnectionPoint::Advise com a interface IUnknown de implementação para esse evento.

Criar uma aplicação C++ para processar eventos do PowerPoint

1. Criar uma nova aplicação baseado na caixa de diálogo utilizando o Assistente de aplicação Microsoft Foundation Classes (MFC) no Visual C++. NET. Nome do projecto PPTEventsDemo e, em seguida, aceite as predefinições. A caixa de diálogo é criada por predefinição, juntamente com os ficheiros Ppteventsdemodlg.cpp e Ppteventsdemodlg.h correspondentes.
2. Adicione três botões para a caixa de diálogo e atribua o nome botões Iniciar o PowerPoint , ponto de ligação estabelecer e sink de registo e sink de anular o registo e são limpar , respectivamente. Adicione uma caixa de listagem à caixa de diálogo. A caixa de listagem apresenta os nomes dos eventos à medida que estas vão ocorrendo.
3. Na janela de Explorador de projecto na vista de classe, clique com o botão direito do rato PPTEventsDemo , aponte para Adicionar e, em seguida, clique em Adicionar classe . Na caixa de diálogo Adicionar classe , seleccione a classe MFC de TypeLibrary e clique em Abrir . Este procedimento inicia a classe de adicionar a partir do assistente TypeLib.
4. Seleccione a biblioteca de objectos do Microsoft PowerPoint 10.0 (para o PowerPoint 2002) ou Microsoft PowerPoint 9.0 biblioteca de objectos (para o PowerPoint 2000) da lista pendente TypeLibraries disponíveis . A caixa de lista de interfaces apresenta todas as interfaces que expõe a biblioteca de tipos. Seleccione _Application e, em seguida, clique na > botão. Aceite as predefinições e clique em Concluir . Isto gera a classe de wrapper CApplication , que deriva COleDispatchDriver . A implementação e a definição desta classe está disponível no ficheiro Capplication.h.
5. No Visual Studio. NET, clique em Vista de recursos , no menu Ver para apresentar a caixa de diálogo PPTEventsDemo . Faça duplo clique em Iniciar o PowerPoint para mostrar a janela Vista de código Ppteventsdemodlg.cpp, onde foi inserido um processador de eventos vazia para o evento Click do botão. Adicione o seguinte código ao processador para o botão Iniciar 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 ao processador para o botão ponto de ligação estabelecer e registar sink :

   ///*********************** 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 para uma rotina de tratamento do botão sink de anular o registo e são 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. Adicionar o seguinte código à parte inferior do construtor da classe CPPTEventsDemoDlg :

   	m_pConnectionPoint = NULL;
   	pptapp = NULL;
   					

9. Antes de devolver a partir do 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 coloque as seguintes instruções # include no início do ficheiro Ppteventsdemodlg.cpp:

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

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

    class CMyPPTEventsHandler;
    class CApplication;
    					

12. Adicione as declarações seguintes como membros de privada para CPPTEventsDemoDlg :

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

13. Na vista de classe do Explorador de projecto, clique com o botão direito do rato PPTEventsDemo , aponte para Adicionar e, em seguida, clique em Adicionar classe . Na caixa de diálogo AddClass , seleccione MFC classe em modelos e, em seguida, clique em Abrir . Tipo CMyPPTEventsHandler para o nome de classe, seleccione CCmdTarget para a classe base e, em seguida, seleccione automatização . Para outros campos, aceite as predefinições. Clique em Concluir . Isto cria uma nova classe MFC de CMyPPTEventsHandler deriva CCmdTarget . Esta classe é definido no ficheiro Myppteventshandler.h e é implementado em Myppteventshandler.cpp. Esta é a classe de Processador de eventos que contém os métodos que são chamados em resposta as eventos do PowerPoint.
    
    
14. Isto cria um novo ficheiro em Myppteventshandler.h, frente declarar a seguinte classe:

    class CPresentation;
    					

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

    DWORD cookie;   
    CListBox* m_pListBox; 
    					

16. Isto 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);
    
    					

    estes são os processadores de eventos de PowerPoint.
    
    NOTA: Os seguintes processadores de 4 eventos não estão disponíveis no PowerPoint 2000 e não denominam-se o cliente tiver 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. Isto cria uma nova substituir todo o conteúdo do 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 ;
    }
    
    					

    Note que o valor da constante IID_IMyPPTEventsHandler estático é alterado do valor que gerou originalmente 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}};
    					

    este é o GUID para a interface de eventos saída EApplication para a classe PowerPoint aplicações . Além disso, note que o mapa de envio para esta classe mapeia DISPID dos eventos para os métodos de rotina de tratamento de eventos.
    
    
18. Isto cria um novo ficheiro em Ppteventsdemo.cpp, adicione a seguinte instrução # include

    #include "CApplication.h"
    					

    antes do seguinte:

    #include "PPTEventsDemoDlg.h" 
    					

19. Isto cria um novo adicionar as seguintes linhas de código na parte superior do método InitInstance do ficheiro Ppteventsdemoapp.cpp:

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

Testar a aplicação

1. Prima F5 para compilar e executar o programa. A caixa de diálogo é apresentada.
2. Clique em Iniciar o PowerPoint . O PowerPoint é iniciado e fica visível.
3. Clique em estabelecer ponto de ligação e sink de registo para configurar os "event sinks".
4. Crie uma nova apresentação no PowerPoint. Lançar o WindowActivate NewPresentation , PresentationNewSlide , SlideSelectionChange e WindowSelectionChange eventos.
5. Inicie a apresentação de diapositivos e reproduzi-lo até ao fim. Os eventos SlideShowBegin SlideShowNextSlide e SlideShowEnd despoletado.
6. Guarde a apresentação. Os eventos PresentationBeforeSave e PresentationSave despoletado.
7. Feche a apresentação. Desencadeado de evento PresentationClose , e os eventos que foram accionados pelo PowerPoint 2002 e processados pelo programa aparecem na caixa de listagem.
   
   NOTA: Estes são os eventos que o PowerPoint 2002 é accionado. Poderá não ver alguns destes eventos no PowerPoint 2000.
   
8. Clique em sink de anular o registo e são Clean Up para desligar os "event sinks".
9. Feche a caixa de diálogo.

Para obter informações adicionais, clique nos números de artigo existentes abaixo para visualizar os artigos na Microsoft Knowledge Base: Para obter mais informações sobre automatização do Office, consulte o seguinte site de suporte do Microsoft Office Development: