Voorbeeld van C++ gebeurtenissinks

Dit programma laat zien hoe u een toepassing kunt bouwen waarmee InkCollector-gebeurtenissen worden vastgelegd met behulp van alleen C++. Met dit programma wordt een InkCollector--object gemaakt voor inkt -enable het venster. Er wordt een berichtvak weergegeven wanneer een stroke gebeurtenis wordt ontvangen.

Een wrapper definiëren voor inkcollector-gebeurtenissen

De InkCollectorEvents klasse verzorgt het doorgeven van gebeurtenissen van de inktverzamelaar aan de gebruiker van deze klasse. Met de methode AdviseInkCollector wordt de verbinding ingesteld tussen het object InkCollector en deze klasse. De methode Invoke converteert de IDispatch gebeurtenismelding naar een aanroep naar een virtuele functie die de gebruiker van deze klasse kan overschrijven om een bepaalde gebeurtenis te verwerken.

Notitie

U moet meer doen dan alleen de virtuele functie aan te passen in de event handler om die gebeurtenis te kunnen afhandelen. Voor alle gebeurtenissen behalve de standaardgebeurtenissen moet u de SetEventInterest methode van de inktverzamelaar aanroepen om een gebeurtenis te garanderen. Ten tweede organiseert dit object zichzelf als vrij draadbaar, zodat alle geïmplementeerde gebeurtenisbehandelaars ook vrij draadbaar moeten zijn. Van bijzonder belang is het gebruik van Windows-API's, wat kan leiden tot een switch naar een andere thread omdat de gebeurtenis-handler niet gegarandeerd wordt uitgevoerd op dezelfde thread als het venster dat is verbonden met de inktverzamelaar.

 

// Invoke translates from IDispatch to an event callout
//  that can be overridden by a subclass of this class.
STDMETHOD(Invoke)(
   DISPID dispidMember, 
    REFIID riid,
    LCID lcid, 
    WORD /*wFlags*/, 
    DISPPARAMS* pdispparams, 
    VARIANT* pvarResult,
    EXCEPINFO* /*pexcepinfo*/, 
    UINT* /*puArgErr*/)
{
    switch(dispidMember)
    {
        case DISPID_ICEStroke:
            Stroke(
                (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
                (IInkStrokeDisp*) pdispparams->rgvarg[1].pdispVal,
                (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
            break;
        ...
    }
    return S_OK;
}

virtual void Stroke(
    IInkCursor* Cursor,
    IInkStrokeDisp* Stroke,
    VARIANT_BOOL *Cancel)
{
    // This is a place holder designed to be overridden by
    //  user of this class.
    return;
}
...

De methode Init roept CoCreateFreeThreadedMarshaler aan om een gratis threaded marshaler in te stellen.

// Init: set up free threaded marshaller.
HRESULT Init()
{
    return CoCreateFreeThreadedMarshaler(this, &m_punkFTM);
}

Met de methode AdviseInkCollector wordt de verbinding ingesteld tussen het object InkCollector en deze klasse. Als eerste wordt een verbindingspunt naar de inktverzamelaar opgehaald. Vervolgens wordt een pointer naar de IInkCollectorEvents opgehaald, zodat een adviesverbinding met de besturing tot stand kan worden gebracht.

// Set up connection between sink and InkCollector
HRESULT AdviseInkCollector(
    IInkCollector *pIInkCollector)
{
    // Get the connection point container
    IConnectionPointContainer *pIConnectionPointContainer;
    HRESULT hr = pIInkCollector->QueryInterface(IID_IConnectionPointContainer, (void **) &pIConnectionPointContainer);
        
    if (FAILED(hr))
        ...
    
    // Find the connection point for Ink Collector events
    hr = pIConnectionPointContainer->FindConnectionPoint(__uuidof(_IInkCollectorEvents), &m_pIConnectionPoint);
        
    if (SUCCEEDED(hr))
    {
        // Hook up sink to connection point
        hr = m_pIConnectionPoint->Advise(this, &m_dwCookie);
    }
    
    if (FAILED(hr))
        ...
    
    // Don't need the connection point container any more.
    pIConnectionPointContainer->Release();
    return hr;
}

Met de methode UnadviseInkCollector worden de verbindingen die het object heeft met het besturingselement vrijgegeven.

// Remove the connection of the sink to the Ink Collector
HRESULT UnadviseInkCollector()
{
    HRESULT hr = m_pIConnectionPoint->Unadvise(m_dwCookie);m_pIConnectionPoint->Release();
m_pIConnectionPoint = NULL;
    return hr;
}

Het definiëren van een handler voor inktsamenelaar gebeurtenissen

De CMyInkEvents-klasse overschrijft het standaardgedrag van de Stroke-gebeurtenishandler van de InkCollectorEvents-klasse. Met de methode Stroke wordt een berichtvak weergegeven wanneer de InkCollector een Stroke gebeurtenis ontvangt.

class CMyInkEvents : public InkCollectorEvents
{
public:

    // Event: Stroke
    virtual void Stroke(
        IInkCursor* Cursor,
        IInkStrokeDisp* Stroke,
        VARIANT_BOOL *Cancel)
    {
        // Demonstrate that the event notification was received.
        MessageBox(m_hWnd, "Stroke Event", "Event Received", MB_OK);
    }
    
    CMyInkEvents()
    {
        m_hWnd = NULL;
    }
    
    HRESULT Init(
        HWND hWnd)
    {
        m_hWnd = hWnd;
        return InkCollectorEvents::Init();
    }    
    
    HWND m_hWnd;
};

Een ink collector-wrapper definiëren

De Init-methode van de klasse CMyInkCollector declareert en initialiseert een CMyInkEvents-object. Vervolgens wordt een InkCollector--object gemaakt en worden de inkcollector en de gebeurtenishandler gekoppeld. Ten slotte wordt de InkCollector- aan het venster gekoppeld en ingeschakeld.

// Handle all initialization
HRESULT Init(
HWND hWnd)
{
    // Initialize event sink. This consists of setting
    //  up the free threaded marshaler.
    HRESULT hr = m_InkEvents.Init(hWnd);

    if (FAILED(hr))
        ...

    // Create the ink collector
    hr = CoCreateInstance(CLSID_InkCollector, NULL, CLSCTX_ALL, IID_IInkCollector, (void **) &m_pInkCollector);

    if (FAILED(hr))
        ...

    // Set up connection between Ink Collector and our event sink
    hr = m_InkEvents.AdviseInkCollector(m_pInkCollector);

    if (FAILED(hr))
        ...

    // Attach Ink Collector to window
    hr = m_pInkCollector->put_hWnd((long) hWnd);

    if (FAILED(hr))
        ...

    // Allow Ink Collector to receive input.
    return m_pInkCollector->put_Enabled(VARIANT_TRUE);
}

Toegang tot de tablet-pc-interfaces en de wrapperklassen

Neem eerst de headers op voor Tablet PC Automation-interfaces. Deze worden geïnstalleerd met het Microsoft<entity type="reg"/> Windows<entity type="reg"/> XP Tablet PC Edition Development Kit 1.7.

#include <msinkaut.h>
#include <msinkaut_i.c>

Neem vervolgens de headers voor de wrapper-klassen op en InkCollector gebeurtenis-handler is gedefinieerd.

#include "TpcConpt.h"
#include "EventSink.h"

De wrapperklassen aanroepen

Wanneer het venster wordt gemaakt, maakt de windowprocedure een inktverzamelaar-wrapper aan en initialiseert de wrapper. Wanneer het venster wordt vernietigd, verwijdert de vensterprocedure de inktverzamelaar-wrapper. De inktverzamelaar-wrapper verwerkt het maken en verwijderen van de bijbehorende gebeurtenishandler.

case WM_CREATE:

    // Allocate and initialize memory for object
    pmic = new CMyInkCollector();

    if (pmic != NULL)
    {
        // Real initialization. This consists of creating
        //  an ink collector object and attaching it to
        //  the current window. 
        if (SUCCEEDED(pmic->Init(hWnd)))
        {
            return 0;
        }
        
        // Failure free resources.
        delete pmic;
        pmic = NULL;
    }
    
    return -1;
...
case WM_DESTROY:
    // The destructor for the object handles releasing the
    //  InkCollector and disconnecting the InkCollector
    //  from the object's event sink. 
    delete pmic;
    pmic = NULL;
    PostQuitMessage(0);
    break;