InkOverlayEv.h

C:\home\SVGCats_src\src\InkOverlayEv.h

[目次 | 型・クラス・構造体 | マクロ]

目次

型・クラス・構造体一覧

マクロ一覧


   1|/* 
   2|* This file was made by refering from Tablet PC SDK.
   3|* "E:\Program Files\Microsoft Tablet PC Platform SDK\Samples\EventSink\TpcConpt.h"
   4|*/
   5|
   6|#ifndef INKOVERLEYEV_H
   7|#define INKOVERLEYEV_H
   8|
   9|class InkOverlayEvents : public _IInkOverlayEvents
  10|{
  11|public:
  12|
  13|    //
  14|    // 1. <<< IUnknown Interface >>> =========================================
  15|    //
  16|	HRESULT __stdcall QueryInterface(
  17|		REFIID riid,
  18|        void **ppvObject)
  19|    {
  20|
  21|        // Validate the input
  22|        if (NULL == ppvObject)
  23|        {
  24|            return E_POINTER;
  25|        }
  26|
  27|        // This object only supports IDispatch/_IInkOverlayEvents
  28|        if ((riid == IID_IUnknown)
  29|            || (riid == IID_IDispatch)
  30|            || (riid == DIID__IInkOverlayEvents))
  31|        {
  32|            *ppvObject = (IDispatch *) this;
  33|
  34|            // Note: we do not AddRef here because the lifetime
  35|            //  of this object does not depend on reference counting
  36|            //  but on the duration of the connection set up by
  37|            //  the user of this class.
  38|
  39|            return S_OK;
  40|        }
  41|        else if (riid == IID_IMarshal)
  42|        {
  43|            // Assert that the free threaded marshaller has been
  44|            // initialized.  It is necessary to call Init() before
  45|            // invoking this method.
  46|            ASSERT(NULL != m_punkFTM);
  47|
  48|            // Use free threaded marshalling.
  49|            return m_punkFTM->QueryInterface(riid, ppvObject);
  50|        }
  51|
  52|        return E_NOINTERFACE;
  53|    }
  54|
  55|    virtual ULONG STDMETHODCALLTYPE AddRef()
  56|    {
  57|
  58|        // Note: we do not AddRef here because the lifetime
  59|        //  of this object does not depend on reference counting
  60|        //  but on the duration of the connection set up by
  61|        //  the user of this class.
  62|        return 1;
  63|    }
  64|
  65|    virtual ULONG STDMETHODCALLTYPE Release()
  66|    {
  67|
  68|        // Note: we do not do Release here because the lifetime
  69|        //  of this object does not depend on reference counting
  70|        //  but on the duration of the connection set up by
  71|        //  the user of this class.
  72|        return 1;
  73|    }
  74|
  75|
  76|    //
  77|    // 2. <<< IDispatch Interface >>> =========================================
  78|    //
  79|    STDMETHOD(GetTypeInfoCount)(UINT* pctinfo)
  80|    {
  81|        // This method is not needed for processing events.
  82|        return E_NOTIMPL;
  83|    }
  84|
  85|    STDMETHOD(GetTypeInfo)(
  86|        UINT itinfo,
  87|        LCID lcid,
  88|        ITypeInfo** pptinfo)
  89|    {
  90|        // This method is not needed for processing events.
  91|        return E_NOTIMPL;
  92|    }
  93|
  94|    STDMETHOD(GetIDsOfNames)(
  95|        REFIID riid,
  96|        LPOLESTR* rgszNames,
  97|        UINT cNames,
  98|        LCID lcid,
  99|        DISPID* rgdispid)
 100|    {
 101|        // This method is not needed for processing events.
 102|        return E_NOTIMPL;
 103|    }
 104|
 105|    // Invoke translates from IDispatch to an event callout
 106|    //  that can be overriden by a subclass of this class.
 107|    STDMETHOD(Invoke)(
 108|        DISPID dispidMember,
 109|        REFIID riid,
 110|        LCID lcid,
 111|        WORD /*wFlags*/,
 112|        DISPPARAMS* pdispparams,
 113|        VARIANT* pvarResult,
 114|        EXCEPINFO* /*pexcepinfo*/,
 115|        UINT* /*puArgErr*/)
 116|    {
 117|        switch(dispidMember)
 118|        {
 119|            case DISPID_ICEStroke:
 120|                Stroke(
 121|                    (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 122|                    (IInkStrokeDisp*) pdispparams->rgvarg[1].pdispVal,
 123|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 124|                break;
 125|
 126|            case DISPID_ICECursorDown:
 127|                CursorDown(
 128|                    (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 129|                    (IInkStrokeDisp*) pdispparams->rgvarg[0].pdispVal);
 130|                break;
 131|
 132|            case DISPID_ICENewPackets:
 133|                NewPackets(
 134|                    (IInkCursor*) pdispparams->rgvarg[3].pdispVal,
 135|                    (IInkStrokeDisp*) pdispparams->rgvarg[2].pdispVal,
 136|                    pdispparams->rgvarg[1].lVal,
 137|                    pdispparams->rgvarg[0].pvarVal);
 138|                break;
 139|
 140|            case DISPID_IOEStrokesDeleting:
 141|                StrokesDeleting(
 142|                    (IInkStrokes*)pdispparams->rgvarg[0].pboolVal);
 143|                break;
 144|
 145|            case DISPID_IPEDblClick:
 146|                DblClick(
 147|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 148|                break;
 149|
 150|            case DISPID_IPEMouseMove:
 151|                MouseMove(
 152|                    (InkMouseButton) pdispparams->rgvarg[4].lVal,
 153|                    (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 154|                    pdispparams->rgvarg[2].lVal,
 155|                    pdispparams->rgvarg[1].lVal,
 156|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 157|                break;
 158|
 159|            case DISPID_IPEMouseDown:
 160|                MouseDown(
 161|                    (InkMouseButton) pdispparams->rgvarg[4].lVal,
 162|                    (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 163|                    pdispparams->rgvarg[2].lVal,
 164|                    pdispparams->rgvarg[1].lVal,
 165|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 166|                break;
 167|
 168|            case DISPID_IPEMouseUp:
 169|                MouseUp(
 170|                    (InkMouseButton) pdispparams->rgvarg[4].lVal,
 171|                    (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 172|                    pdispparams->rgvarg[2].lVal,
 173|                    pdispparams->rgvarg[1].lVal,
 174|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 175|                break;
 176|
 177|            case DISPID_IPEMouseWheel:
 178|                MouseWheel(
 179|                    (InkMouseButton) pdispparams->rgvarg[5].lVal,
 180|                    (InkShiftKeyModifierFlags) pdispparams->rgvarg[4].lVal,
 181|                    pdispparams->rgvarg[3].lVal,
 182|                    pdispparams->rgvarg[2].lVal,
 183|                    pdispparams->rgvarg[1].lVal,
 184|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 185|                break;
 186|
 187|            case DISPID_ICENewInAirPackets:
 188|                NewInAirPackets(
 189|                    (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 190|                    pdispparams->rgvarg[1].lVal,
 191|                    pdispparams->rgvarg[0].pvarVal);
 192|                break;
 193|
 194|            case DISPID_ICECursorButtonDown:
 195|                CursorButtonDown(
 196|                    (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 197|                    (IInkCursorButton*) pdispparams->rgvarg[0].pdispVal);
 198|                break;
 199|
 200|            case DISPID_ICECursorButtonUp:
 201|                CursorButtonUp(
 202|                    (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 203|                    (IInkCursorButton*) pdispparams->rgvarg[0].pdispVal);
 204|                break;
 205|
 206|            case DISPID_ICECursorInRange:
 207|                CursorInRange(
 208|                    (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 209|                    (VARIANT_BOOL) pdispparams->rgvarg[1].iVal,
 210|                    pdispparams->rgvarg[0]);
 211|                break;
 212|
 213|            case DISPID_ICECursorOutOfRange:
 214|                CursorOutOfRange(
 215|                    (IInkCursor*) pdispparams->rgvarg[0].pdispVal);
 216|                break;
 217|
 218|            case DISPID_ICESystemGesture:
 219|                SystemGesture(
 220|                    (IInkCursor*) pdispparams->rgvarg[6].pdispVal,
 221|                    (InkSystemGesture) pdispparams->rgvarg[5].lVal,
 222|                    pdispparams->rgvarg[4].lVal,
 223|                    pdispparams->rgvarg[3].lVal,
 224|                    pdispparams->rgvarg[2].lVal,
 225|                    pdispparams->rgvarg[1].bstrVal,
 226|                    pdispparams->rgvarg[0].lVal);
 227|                break;
 228|
 229|            case DISPID_ICEGesture:
 230|                Gesture(
 231|                    (IInkCursor*) pdispparams->rgvarg[3].pdispVal,
 232|                    (IInkStrokes*) pdispparams->rgvarg[2].pdispVal,
 233|                    pdispparams->rgvarg[1],
 234|                    (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 235|                break;
 236|
 237|            case DISPID_ICETabletAdded:
 238|                TabletAdded(
 239|                    (IInkTablet*) pdispparams->rgvarg[0].pdispVal);
 240|                break;
 241|
 242|            case DISPID_ICETabletRemoved:
 243|                TabletRemoved(
 244|                    pdispparams->rgvarg[0].lVal);
 245|                break;
 246|
 247|            default:
 248|                break;
 249|        }
 250|
 251|        return S_OK;
 252|    }
 253|
 254|
 255|    //
 256|    // 3. <<< Events - overridden functions >>> =========================
 257|    //
 258|
 259|    virtual void Stroke(
 260|        IInkCursor* Cursor,
 261|        IInkStrokeDisp* Stroke,
 262|        VARIANT_BOOL *Cancel)
 263|    {
 264|        ASSERT( m_obj != NULL );
 265|        m_obj->OnStroke( Cursor, Stroke, Cancel );
 266|        return;
 267|    }
 268|
 269|    virtual void CursorDown(
 270|        IInkCursor* Cursor,
 271|        IInkStrokeDisp* Stroke)
 272|    {
 273|        ASSERT( m_obj != NULL );
 274|        m_obj->OnCursorDown( Cursor, Stroke );
 275|        return;
 276|    }
 277|
 278|    virtual void NewPackets(
 279|        IInkCursor* Cursor,
 280|        IInkStrokeDisp* Stroke,
 281|        long PacketCount,
 282|        VARIANT* PacketData)
 283|    {
 284|        ASSERT( m_obj != NULL );
 285|        m_obj->OnNewPackets( Cursor, Stroke, PacketCount, PacketData );
 286|        return;
 287|    }
 288|
 289|    virtual void StrokesDeleting(
 290|        IInkStrokes* Strokes)
 291|    {
 292|        ASSERT( m_obj != NULL );
 293|        m_obj->OnStrokesDeleting( Strokes );
 294|        return;
 295|    }
 296|
 297|    virtual void DblClick(
 298|        VARIANT_BOOL *Cancel)
 299|    {
 300|        // This is a place holder designed to be overridden by
 301|        //  user of this class.
 302|        return;
 303|    }
 304|
 305|    virtual void MouseMove(
 306|        InkMouseButton Button,
 307|        InkShiftKeyModifierFlags Shift,
 308|        long pX,
 309|        long pY,
 310|        VARIANT_BOOL *Cancel)
 311|    {
 312|        // This is a place holder designed to be overridden by
 313|        //  user of this class.
 314|        return;
 315|    }
 316|
 317|    virtual void MouseDown(
 318|        InkMouseButton Button,
 319|        InkShiftKeyModifierFlags Shift,
 320|        long pX,
 321|        long pY,
 322|        VARIANT_BOOL *Cancel)
 323|    {
 324|        // This is a place holder designed to be overridden by
 325|        //  user of this class.
 326|        return;
 327|    }
 328|
 329|    virtual void MouseUp(
 330|        InkMouseButton Button,
 331|        InkShiftKeyModifierFlags Shift,
 332|        long pX,
 333|        long pY,
 334|        VARIANT_BOOL *Cancel)
 335|    {
 336|        // This is a place holder designed to be overridden by
 337|        //  user of this class.
 338|        return;
 339|    }
 340|
 341|    virtual void MouseWheel(
 342|        InkMouseButton Button,
 343|        InkShiftKeyModifierFlags Shift,
 344|        long Delta,
 345|        long X,
 346|        long Y,
 347|        VARIANT_BOOL *Cancel)
 348|    {
 349|        // This is a place holder designed to be overridden by
 350|        //  user of this class.
 351|        return;
 352|    }
 353|
 354|    virtual void NewInAirPackets(
 355|        IInkCursor* Cursor,
 356|        long lPacketCount,
 357|        VARIANT* PacketData)
 358|    {
 359|        // This is a place holder designed to be overridden by
 360|        //  user of this class.
 361|        return;
 362|    }
 363|
 364|    virtual void CursorButtonDown(
 365|        IInkCursor* Cursor,
 366|        IInkCursorButton* Button)
 367|    {
 368|        // This is a place holder designed to be overridden by
 369|        //  user of this class.
 370|        return;
 371|    }
 372|
 373|    virtual void CursorButtonUp(
 374|        IInkCursor* Cursor,
 375|        IInkCursorButton* Button)
 376|    {
 377|        // This is a place holder designed to be overridden by
 378|        //  user of this class.
 379|        return;
 380|    }
 381|
 382|    virtual void CursorInRange(
 383|        IInkCursor* Cursor,
 384|        VARIANT_BOOL NewCursor,
 385|        VARIANT ButtonsState)
 386|    {
 387|        // This is a place holder designed to be overridden by
 388|        //  user of this class.
 389|        return;
 390|    }
 391|
 392|    virtual void CursorOutOfRange(
 393|        IInkCursor* Cursor)
 394|    {
 395|        // This is a place holder designed to be overridden by
 396|        //  user of this class.
 397|        return;
 398|    }
 399|
 400|    virtual void SystemGesture(
 401|        IInkCursor* Cursor,
 402|        InkSystemGesture Id,
 403|        long X,
 404|        long Y,
 405|        long Modifier,
 406|        BSTR Character,
 407|        long CursorMode)
 408|    {
 409|        ASSERT( m_obj != NULL );
 410|        m_obj->OnSystemGesture( Cursor, Id, X, Y, Modifier, Character, CursorMode );
 411|        return;
 412|    }
 413|
 414|    virtual void Gesture(
 415|        IInkCursor* Cursor,
 416|        IInkStrokes* Strokes,
 417|        VARIANT Gestures,
 418|        VARIANT_BOOL* Cancel)
 419|    {
 420|        // This is a place holder designed to be overridden by
 421|        //  user of this class.
 422|        return;
 423|    }
 424|
 425|    virtual void TabletAdded(
 426|        IInkTablet* Tablet)
 427|    {
 428|        // This is a place holder designed to be overridden by
 429|        //  user of this class.
 430|        return;
 431|    }
 432|
 433|    virtual void TabletRemoved(
 434|        long TabletId)
 435|    {
 436|        // This is a place holder designed to be overridden by
 437|        //  user of this class.
 438|        return;
 439|    }
 440|
 441|
 442|    //
 443|    // 4. <<< Methods >>> ============================================
 444|    //
 445|
 446|    // Constructor: initialize memory to null.
 447|    InkOverlayEvents()
 448|    {
 449|        m_pIConnectionPoint = NULL;
 450|        m_punkFTM = NULL;
 451|        m_obj = NULL;
 452|    }
 453|
 454|    // Destructor: free resources
 455|    ~InkOverlayEvents()
 456|    {
 457|        UnadviseInkOverlay();
 458|
 459|        if (m_punkFTM != NULL)
 460|        {
 461|            m_punkFTM->Release();
 462|        }
 463|    }
 464|
 465|    // Init: set up free threaded marshaller.
 466|    // It is necessary to call this method before using
 467|    // this class to handle events.
 468|    HRESULT Init()
 469|    {
 470|        return CoCreateFreeThreadedMarshaler(this, &m_punkFTM);
 471|    }
 472|
 473|    // Set up connection between sink and Ink Collector
 474|    HRESULT AdviseInkOverlay(
 475|        IInkOverlay *pIInkOverlay)
 476|    {
 477|        HRESULT hr = S_OK;
 478|
 479|        // Check to ensure that the sink is not currently connected
 480|        // with another Ink Collector...
 481|        if (NULL == m_pIConnectionPoint)
 482|        {
 483|            // Get the connection point container
 484|            IConnectionPointContainer *pIConnectionPointContainer;
 485|            hr = pIInkOverlay->QueryInterface(
 486|                IID_IConnectionPointContainer,
 487|                (void **) &pIConnectionPointContainer);
 488|
 489|            if (FAILED(hr))
 490|            {
 491|                return hr;
 492|            }
 493|
 494|            // Find the connection point for Ink Collector events
 495|            hr = pIConnectionPointContainer->FindConnectionPoint(
 496|                __uuidof(_IInkOverlayEvents), &m_pIConnectionPoint);
 497|
 498|            if (SUCCEEDED(hr))
 499|            {
 500|                // Hook up sink to connection point
 501|                hr = m_pIConnectionPoint->Advise(this, &m_dwCookie);
 502|            }
 503|
 504|            if (FAILED(hr))
 505|            {
 506|                // Clean up after an error.
 507|                if (m_pIConnectionPoint)
 508|                {
 509|                    m_pIConnectionPoint->Release();
 510|                    m_pIConnectionPoint = NULL;
 511|                }
 512|            }
 513|
 514|            // We don't need the connection point container any more.
 515|            pIConnectionPointContainer->Release();
 516|        }
 517|        // If the sink is already connected to an Ink Collector, return a
 518|        // failure; only one Ink Collector can be attached at any given time.
 519|        else
 520|        {
 521|            hr = E_FAIL;
 522|        }
 523|
 524|        return hr;
 525|    }
 526|
 527|    // Remove the connection of the sink to the Ink Collector
 528|    HRESULT UnadviseInkOverlay()
 529|    {
 530|        HRESULT hr = S_OK;
 531|
 532|        // If there the ink collector is connected to the sink,
 533|        // remove it.  Otherwise, do nothing (there is nothing
 534|        // to unadvise).
 535|        if (m_pIConnectionPoint != NULL)
 536|        {
 537|            hr = m_pIConnectionPoint->Unadvise(m_dwCookie);
 538|            m_pIConnectionPoint->Release();
 539|            m_pIConnectionPoint = NULL;
 540|        }
 541|
 542|        return hr;
 543|    }
 544|
 545|private:
 546|
 547|    //
 548|    //  5. <<< Data Members >>> ============================================
 549|    //
 550|
 551|    // Connection point on InkOverlay
 552|    IConnectionPoint *m_pIConnectionPoint;
 553|
 554|    // Cookie returned from advise
 555|    DWORD m_dwCookie;
 556|
 557|    // Free threaded marshaler.
 558|    IUnknown *m_punkFTM;
 559|
 560|public:
 561|    // owner
 562|    CChildView*  m_obj;  // You can access directly.
 563|};
 564|
 565|
 566|
 567|#endif
 568| 
 569|