Przykład ujścia zdarzeń języka C++

W tym programie pokazano, jak utworzyć aplikację, która przechwytuje zdarzenia InkCollector przy użyciu tylko języka C++. Ten program współtworzy obiekt InkCollector do pisma odk -enable okna. Wyświetla okno komunikatu za każdym razem, gdy zostanie odebrane zdarzenie pociągnięcia.

Definiowanie powłoki dla zdarzeń zbierania tuszu

Klasa InkCollectorEvents obsługuje przekazywanie zdarzeń z kolektora atramentu do użytkownika tej klasy. Metoda AdviseInkCollector konfiguruje połączenie między obiektem InkCollector a tą klasą. Metoda Invoke przekształca powiadomienie wydarzenia IDispatch w wywołanie funkcji wirtualnej, którą użytkownik tej klasy może nadpisać, aby przetworzyć określone zdarzenie.

Notatka

Aby uzyskać to zdarzenie, należy zrobić więcej niż przedefiniować funkcję wirtualną obsługi zdarzeń. W przypadku wszystkich zdarzeń z wyjątkiem domyślnych należy wywołać metodę SetEventInterest kolektora tuszu, aby zagwarantować uzyskanie zdarzenia. Po drugie, ten obiekt obsługuje marshaling dla wątków wolnych, więc wszystkie zaimplementowane procedury obsługi zdarzeń muszą również obsługiwać wolne wątki. Szczególnie ważne jest użycie interfejsów API systemu Windows, co może spowodować przełączenie do innego wątku, ponieważ nie ma gwarancji, że program obsługi zdarzeń będzie uruchomiony w tym samym wątku co okno połączone z komponentem zbierającym atrament.

 

// 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;
}
...

Metoda Init wywołuje CoCreateFreeThreadedMarshaler w celu skonfigurowania wolnego marshalera wątkowego.

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

Metoda AdviseInkCollector konfiguruje połączenie między obiektem InkCollector a tą klasą. Najpierw pobiera punkt połączenia z modułem zbierającym atrament. Następnie pobiera wskaźnik do IInkCollectorEvents, aby mógł ustanowić połączenie doradcze z kontrolką.

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

Metoda UnadviseInkCollector zwalnia połączenia, jakie obiekt ma z kontrolą.

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

Definiowanie procedury obsługi zdarzeń kolektora pisma ręcznego

Klasa CMyInkEvents zastępuje domyślne zachowanie programu obsługi zdarzeń Stroke klasy InkCollectorEvents. Metoda Stroke wyświetla okno komunikatu, gdy InkCollector odbiera zdarzenie Stroke.

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

Definiowanie otoki kolektora tuszu

Metoda Init klasy CMyInkCollector deklaruje i inicjuje obiekt CMyInkEvents. Następnie tworzy obiekt InkCollector i kojarzy kolekcjoner atramentu oraz procedurę obsługi zdarzeń. Na koniec InkCollector jest przymocowany do okna i uruchamiany.

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

Uzyskiwanie dostępu do interfejsów tabletów i klas wrapper.

Najpierw dołącz nagłówki dla interfejsów automatyzacji komputerów tabletowych. Są one instalowane z Microsoft<entity type="reg"/> Windows<entity type="reg"/> XP Tablet PC Edition Development Kit 1.7.

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

Następnie należy uwzględnić nagłówki dla klas opakujących, a program obsługi zdarzeń InkCollector został zdefiniowany z oznaczeniami .

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

Wywoływanie klas opakowujących

pl-PL: Po utworzeniu okna procedura okna tworzy powłokę zbierającą tusz i inicjuje ją. Gdy okno zostanie zamknięte, procedura okna usuwa opakowanie kolektora atramentu. Opakowanie kolektora atramentu obsługuje tworzenie i usuwanie skojarzonego z nim programu obsługi zdarzeń.

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;