trunk/Src/Win32/TabletPC/InkCollectorEvents.cpp

   1 // InkCollectorEvents.cpp
   2 //
   3 /////////////////////////////////////////////////////////////////////////////
   4 //
   5 // Copyright (c) 2005 David Ward
   6 //
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 #include "..\Common\WinCommon.h"
  10 #include "InkCollectorEvents.h"
  11
  12 /////////////////////////////////////////////////////////////////////////////
  13
  14 // IUnknown Interface
  15
  16 HRESULT __stdcall CInkCollectorEvents::QueryInterface(REFIID riid,  void **ppvObject)
  17 {
  18
  19         // Validate the input
  20         if (NULL == ppvObject)
  21         {
  22                 return E_POINTER;
  23         }
  24
  25         // This object only supports IDispatch/_IInkCollectorEvents
  26         if ((riid == IID_IUnknown)
  27                 || (riid == IID_IDispatch)
  28                 || (riid == DIID__IInkCollectorEvents))
  29         {
  30                 *ppvObject = (IDispatch *) this;
  31
  32                 // Note: we do not AddRef here because the lifetime
  33                 //  of this object does not depend on reference counting
  34                 //  but on the duration of the connection set up by
  35                 //  the user of this class.
  36
  37                 return S_OK;
  38         }
  39         else if (riid == IID_IMarshal)
  40         {
  41                 // Assert that the free threaded marshaller has been
  42                 // initialized.  It is necessary to call Init() before
  43                 // invoking this method.
  44                 assert(NULL != m_punkFTM);
  45
  46                 // Use free threaded marshalling.
  47                 return m_punkFTM->QueryInterface(riid, ppvObject);
  48         }
  49
  50         return E_NOINTERFACE;
  51 }
  52
  53 /////////////////////////////////////////////////////////////////////////////
  54
  55 ULONG STDMETHODCALLTYPE CInkCollectorEvents::AddRef()
  56 {
  57         // Note: we do not AddRef here because the lifetime
  58         // of this object depends on the duration of the connection
  59         // set up by the derived class.
  60         return 1;
  61 }
  62
  63 /////////////////////////////////////////////////////////////////////////////
  64
  65 ULONG STDMETHODCALLTYPE CInkCollectorEvents::Release()
  66 {
  67         return 1;
  68 }
  69
  70 /////////////////////////////////////////////////////////////////////////////
  71
  72 // IDispatch Interface
  73
  74 HRESULT CInkCollectorEvents::GetTypeInfoCount(UINT* pctinfo)
  75 {
  76         // Not needs for processing events.
  77         return E_NOTIMPL;
  78 }
  79
  80 /////////////////////////////////////////////////////////////////////////////
  81
  82 HRESULT CInkCollectorEvents::GetTypeInfo(  UINT itinfo, LCID lcid,  ITypeInfo** pptinfo)
  83 {
  84         // Not needs for processing events.
  85         return E_NOTIMPL;
  86 }
  87
  88 /////////////////////////////////////////////////////////////////////////////
  89
  90 HRESULT CInkCollectorEvents::GetIDsOfNames( REFIID riid, LPOLESTR* rgszNames, UINT cNames,
  91                                                  LCID lcid,      DISPID* rgdispid)
  92 {
  93         // Not needs for processing events.
  94         return E_NOTIMPL;
  95 }
  96
  97 /////////////////////////////////////////////////////////////////////////////
  98
  99 // Translates from IDispatch to the virtual functions
 100
 101 HRESULT CInkCollectorEvents::Invoke(  DISPID dispidMember,  REFIID riid,  LCID lcid,
 102                                   WORD /*wFlags*/,        DISPPARAMS* pdispparams,  VARIANT* pvarResult,
 103                                   EXCEPINFO* /*pexcepinfo*/,   UINT* /*puArgErr*/)
 104 {
 105         switch(dispidMember)
 106         {
 107         case DISPID_ICEStroke:
 108                 Stroke(
 109                         (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 110                         (IInkStrokeDisp*) pdispparams->rgvarg[1].pdispVal,
 111                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 112                 break;
 113
 114         case DISPID_ICECursorDown:
 115                 CursorDown(
 116                         (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 117                         (IInkStrokeDisp*) pdispparams->rgvarg[0].pdispVal);
 118                 break;
 119
 120         case DISPID_ICENewPackets:
 121                 NewPackets(
 122                         (IInkCursor*) pdispparams->rgvarg[3].pdispVal,
 123                         (IInkStrokeDisp*) pdispparams->rgvarg[2].pdispVal,
 124                         pdispparams->rgvarg[1].lVal,
 125                         pdispparams->rgvarg[0].pvarVal);
 126                 break;
 127
 128         case DISPID_IPEDblClick:
 129                 DblClick(
 130                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 131                 break;
 132
 133         case DISPID_IPEMouseMove:
 134                 MouseMove(
 135                         (InkMouseButton) pdispparams->rgvarg[4].lVal,
 136                         (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 137                         pdispparams->rgvarg[2].lVal,
 138                         pdispparams->rgvarg[1].lVal,
 139                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 140                 break;
 141
 142         case DISPID_IPEMouseDown:
 143                 MouseDown(
 144                         (InkMouseButton) pdispparams->rgvarg[4].lVal,
 145                         (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 146                         pdispparams->rgvarg[2].lVal,
 147                         pdispparams->rgvarg[1].lVal,
 148                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 149                 break;
 150
 151         case DISPID_IPEMouseUp:
 152                 MouseUp(
 153                         (InkMouseButton) pdispparams->rgvarg[4].lVal,
 154                         (InkShiftKeyModifierFlags) pdispparams->rgvarg[3].lVal,
 155                         pdispparams->rgvarg[2].lVal,
 156                         pdispparams->rgvarg[1].lVal,
 157                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 158                 break;
 159
 160         case DISPID_IPEMouseWheel:
 161                 MouseWheel(
 162                         (InkMouseButton) pdispparams->rgvarg[5].lVal,
 163                         (InkShiftKeyModifierFlags) pdispparams->rgvarg[4].lVal,
 164                         pdispparams->rgvarg[3].lVal,
 165                         pdispparams->rgvarg[2].lVal,
 166                         pdispparams->rgvarg[1].lVal,
 167                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 168                 break;
 169
 170         case DISPID_ICENewInAirPackets:
 171                 NewInAirPackets(
 172                         (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 173                         pdispparams->rgvarg[1].lVal,
 174                         pdispparams->rgvarg[0].pvarVal);
 175                 break;
 176
 177         case DISPID_ICECursorButtonDown:
 178                 CursorButtonDown(
 179                         (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 180                         (IInkCursorButton*) pdispparams->rgvarg[0].pdispVal);
 181                 break;
 182
 183         case DISPID_ICECursorButtonUp:
 184                 CursorButtonUp(
 185                         (IInkCursor*) pdispparams->rgvarg[1].pdispVal,
 186                         (IInkCursorButton*) pdispparams->rgvarg[0].pdispVal);
 187                 break;
 188
 189         case DISPID_ICECursorInRange:
 190                 CursorInRange(
 191                         (IInkCursor*) pdispparams->rgvarg[2].pdispVal,
 192                         (VARIANT_BOOL) pdispparams->rgvarg[1].iVal,
 193                         pdispparams->rgvarg[0]);
 194                 break;
 195
 196         case DISPID_ICECursorOutOfRange:
 197                 CursorOutOfRange(
 198                         (IInkCursor*) pdispparams->rgvarg[0].pdispVal);
 199                 break;
 200
 201         case DISPID_ICESystemGesture:
 202                 SystemGesture(
 203                         (IInkCursor*) pdispparams->rgvarg[6].pdispVal,
 204                         (InkSystemGesture) pdispparams->rgvarg[5].lVal,
 205                         pdispparams->rgvarg[4].lVal,
 206                         pdispparams->rgvarg[3].lVal,
 207                         pdispparams->rgvarg[2].lVal,
 208                         pdispparams->rgvarg[1].bstrVal,
 209                         pdispparams->rgvarg[0].lVal);
 210                 break;
 211
 212         case DISPID_ICEGesture:
 213                 Gesture(
 214                         (IInkCursor*) pdispparams->rgvarg[3].pdispVal,
 215                         (IInkStrokes*) pdispparams->rgvarg[2].pdispVal,
 216                         pdispparams->rgvarg[1],
 217                         (VARIANT_BOOL *)pdispparams->rgvarg[0].pboolVal);
 218                 break;
 219
 220         case DISPID_ICETabletAdded:
 221                 TabletAdded(
 222                         (IInkTablet*) pdispparams->rgvarg[0].pdispVal);
 223                 break;
 224
 225         case DISPID_ICETabletRemoved:
 226                 TabletRemoved(
 227                         pdispparams->rgvarg[0].lVal);
 228                 break;
 229
 230         default:
 231                 break;
 232         }
 233
 234         return S_OK;
 235 }
 236
 237 /////////////////////////////////////////////////////////////////////////////
 238
 239 CInkCollectorEvents::CInkCollectorEvents() :    m_pIConnectionPoint(NULL),
 240                                                                                                 m_punkFTM(NULL)
 241 {
 242 }
 243
 244 /////////////////////////////////////////////////////////////////////////////
 245
 246 CInkCollectorEvents::~CInkCollectorEvents()
 247 {
 248         UnadviseInkCollector();
 249
 250         if (m_punkFTM != NULL)
 251                 m_punkFTM->Release();
 252 }
 253
 254 /////////////////////////////////////////////////////////////////////////////
 255
 256 // Set up free threaded marshaller.
 257
 258 HRESULT CInkCollectorEvents::Init()
 259 {
 260         return CoCreateFreeThreadedMarshaler(this, &m_punkFTM);
 261 }
 262
 263 /////////////////////////////////////////////////////////////////////////////
 264
 265 // Set up connection between sink and Ink Collector
 266 HRESULT CInkCollectorEvents::AdviseInkCollector( IInkCollector *pIInkCollector)
 267 {
 268         HRESULT hr = S_OK;
 269
 270         // Check to ensure that the sink is not currently connected
 271         // with another Ink Collector...
 272         if (NULL == m_pIConnectionPoint)
 273         {
 274                 // Get the connection point container
 275                 IConnectionPointContainer *pIConnectionPointContainer;
 276                 hr = pIInkCollector->QueryInterface(
 277                         IID_IConnectionPointContainer,
 278                         (void **) &pIConnectionPointContainer);
 279
 280                 if (FAILED(hr))
 281                 {
 282                         return hr;
 283                 }
 284
 285                 // Find the connection point for Ink Collector events
 286                 hr = pIConnectionPointContainer->FindConnectionPoint(
 287                         __uuidof(_IInkCollectorEvents), &m_pIConnectionPoint);
 288
 289                 if (SUCCEEDED(hr))
 290                 {
 291                         // Hook up sink to connection point
 292                         hr = m_pIConnectionPoint->Advise(this, &m_dwCookie);
 293                 }
 294
 295                 if (FAILED(hr))
 296                 {
 297                         // Clean up after an error.
 298                         if (m_pIConnectionPoint)
 299                         {
 300                                 m_pIConnectionPoint->Release();
 301                                 m_pIConnectionPoint = NULL;
 302                         }
 303                 }
 304
 305                 // We don't need the connection point container any more.
 306                 pIConnectionPointContainer->Release();
 307         }
 308         // If the sink is already connected to an Ink Collector, return a
 309         // failure; only one Ink Collector can be attached at any given time.
 310         else
 311         {
 312                 hr = E_FAIL;
 313         }
 314
 315         return hr;
 316 }
 317
 318
 319 /////////////////////////////////////////////////////////////////////////////
 320
 321 // Remove the connection of the event sink to the Ink Collector
 322
 323 HRESULT CInkCollectorEvents::UnadviseInkCollector()
 324 {
 325         HRESULT hr = S_OK;
 326
 327         // Unadvise if connected
 328         if (m_pIConnectionPoint != NULL)
 329         {
 330                 hr = m_pIConnectionPoint->Unadvise(m_dwCookie);
 331                 m_pIConnectionPoint->Release();
 332                 m_pIConnectionPoint = NULL;
 333         }
 334
 335         return hr;
 336 }
 337
 338 /////////////////////////////////////////////////////////////////////////////