dlls/directmanipulation/directmanipulation.c

   1 /*
   2  * Copyright 2019 Alistair Leslie-Hughes
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18 #define COBJMACROS
  19
  20 #include <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "oleidl.h"
  25 #include "rpcproxy.h"
  26 #include "wine/heap.h"
  27 #include "wine/debug.h"
  28
  29 #include "directmanipulation.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(manipulation);
  32
  33 struct directmanipulation
  34 {
  35     IDirectManipulationManager2 IDirectManipulationManager2_iface;
  36     IDirectManipulationUpdateManager *updatemanager;
  37     LONG ref;
  38 };
  39
  40 struct directupdatemanager
  41 {
  42     IDirectManipulationUpdateManager IDirectManipulationUpdateManager_iface;
  43     LONG ref;
  44 };
  45
  46 static inline struct directmanipulation *impl_from_IDirectManipulationManager2(IDirectManipulationManager2 *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct directmanipulation, IDirectManipulationManager2_iface);
  49 }
  50
  51 static inline struct directupdatemanager *impl_from_IDirectManipulationUpdateManager(IDirectManipulationUpdateManager *iface)
  52 {
  53     return CONTAINING_RECORD(iface, struct directupdatemanager, IDirectManipulationUpdateManager_iface);
  54 }
  55
  56 static HRESULT WINAPI update_manager_QueryInterface(IDirectManipulationUpdateManager *iface, REFIID riid,void **ppv)
  57 {
  58     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
  59
  60     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
  61
  62     if (IsEqualGUID(riid, &IID_IUnknown) ||
  63         IsEqualGUID(riid, &IID_IDirectManipulationUpdateManager)) {
  64         IUnknown_AddRef(iface);
  65         *ppv = iface;
  66         return S_OK;
  67     }
  68
  69     FIXME("(%p)->(%s,%p), not found\n", This, debugstr_guid(riid), ppv);
  70     return E_NOINTERFACE;
  71 }
  72
  73 ULONG WINAPI update_manager_AddRef(IDirectManipulationUpdateManager *iface)
  74 {
  75     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
  76     ULONG ref = InterlockedIncrement(&This->ref);
  77
  78     TRACE("(%p) ref=%u\n", This, ref);
  79
  80     return ref;
  81 }
  82
  83 ULONG WINAPI update_manager_Release(IDirectManipulationUpdateManager *iface)
  84 {
  85     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
  86     ULONG ref = InterlockedDecrement(&This->ref);
  87
  88     TRACE("(%p) ref=%u\n", This, ref);
  89
  90     if (!ref)
  91     {
  92         heap_free(This);
  93     }
  94     return ref;
  95 }
  96
  97 static HRESULT WINAPI update_manager_RegisterWaitHandleCallback(IDirectManipulationUpdateManager *iface, HANDLE handle,
  98             IDirectManipulationUpdateHandler *handler, DWORD *cookie)
  99 {
 100     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
 101     FIXME("%p, %p, %p, %p\n", This, handle, handler, cookie);
 102     return E_NOTIMPL;
 103 }
 104
 105 static HRESULT WINAPI update_manager_UnregisterWaitHandleCallback(IDirectManipulationUpdateManager *iface, DWORD cookie)
 106 {
 107     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
 108     FIXME("%p, %x\n", This, cookie);
 109     return E_NOTIMPL;
 110 }
 111
 112 static HRESULT WINAPI update_manager_Update(IDirectManipulationUpdateManager *iface, IDirectManipulationFrameInfoProvider *provider)
 113 {
 114     struct directupdatemanager *This = impl_from_IDirectManipulationUpdateManager(iface);
 115     FIXME("%p, %p\n", This, provider);
 116     return E_NOTIMPL;
 117 }
 118
 119 struct IDirectManipulationUpdateManagerVtbl updatemanagerVtbl =
 120 {
 121     update_manager_QueryInterface,
 122     update_manager_AddRef,
 123     update_manager_Release,
 124     update_manager_RegisterWaitHandleCallback,
 125     update_manager_UnregisterWaitHandleCallback,
 126     update_manager_Update
 127 };
 128
 129 static HRESULT create_update_manager(IDirectManipulationUpdateManager **obj)
 130 {
 131     struct directupdatemanager *object;
 132
 133     object = heap_alloc(sizeof(*object));
 134     if(!object)
 135         return E_OUTOFMEMORY;
 136
 137     object->IDirectManipulationUpdateManager_iface.lpVtbl = &updatemanagerVtbl;
 138     object->ref = 1;
 139
 140     *obj = &object->IDirectManipulationUpdateManager_iface;
 141
 142     return S_OK;
 143 }
 144
 145 struct primarycontext
 146 {
 147     IDirectManipulationPrimaryContent IDirectManipulationPrimaryContent_iface;
 148     IDirectManipulationContent IDirectManipulationContent_iface;
 149     LONG ref;
 150 };
 151
 152 static inline struct primarycontext *impl_from_IDirectManipulationPrimaryContent(IDirectManipulationPrimaryContent *iface)
 153 {
 154     return CONTAINING_RECORD(iface, struct primarycontext, IDirectManipulationPrimaryContent_iface);
 155 }
 156
 157 static inline struct primarycontext *impl_from_IDirectManipulationContent(IDirectManipulationContent *iface)
 158 {
 159     return CONTAINING_RECORD(iface, struct primarycontext, IDirectManipulationContent_iface);
 160 }
 161
 162 static HRESULT WINAPI primary_QueryInterface(IDirectManipulationPrimaryContent *iface, REFIID riid, void **ppv)
 163 {
 164     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 165     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 166
 167     if (IsEqualGUID(riid, &IID_IUnknown) ||
 168         IsEqualGUID(riid, &IID_IDirectManipulationPrimaryContent))
 169     {
 170         IDirectManipulationPrimaryContent_AddRef(&This->IDirectManipulationPrimaryContent_iface);
 171         *ppv = &This->IDirectManipulationPrimaryContent_iface;
 172         return S_OK;
 173     }
 174     else if(IsEqualGUID(riid, &IID_IDirectManipulationContent))
 175     {
 176         IUnknown_AddRef(iface);
 177         *ppv = &This->IDirectManipulationContent_iface;
 178         return S_OK;
 179     }
 180
 181     FIXME("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppv);
 182     return E_NOINTERFACE;
 183 }
 184
 185 static ULONG WINAPI primary_AddRef(IDirectManipulationPrimaryContent *iface)
 186 {
 187     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 188     ULONG ref = InterlockedIncrement(&This->ref);
 189
 190     TRACE("(%p) ref=%u\n", This, ref);
 191
 192     return ref;
 193 }
 194
 195 static ULONG WINAPI primary_Release(IDirectManipulationPrimaryContent *iface)
 196 {
 197     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 198     ULONG ref = InterlockedDecrement(&This->ref);
 199
 200     TRACE("(%p) ref=%u\n", This, ref);
 201
 202     if (!ref)
 203     {
 204         heap_free(This);
 205     }
 206     return ref;
 207 }
 208
 209 static HRESULT WINAPI primary_SetSnapInterval(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_MOTION_TYPES motion,
 210             float interval, float offset)
 211 {
 212     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 213     FIXME("%p, %d, %f, %f\n", This, motion, interval, offset);
 214     return E_NOTIMPL;
 215 }
 216
 217 static HRESULT WINAPI primary_SetSnapPoints(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_MOTION_TYPES motion,
 218             const float *points, DWORD count)
 219 {
 220     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 221     FIXME("%p, %d, %p, %d\n", This, motion, points, count);
 222     return E_NOTIMPL;
 223 }
 224
 225 static HRESULT WINAPI primary_SetSnapType(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_MOTION_TYPES motion,
 226             DIRECTMANIPULATION_SNAPPOINT_TYPE type)
 227 {
 228     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 229     FIXME("%p, %d, %d\n", This, motion, type);
 230     return E_NOTIMPL;
 231 }
 232
 233 static HRESULT WINAPI primary_SetSnapCoordinate(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_MOTION_TYPES motion,
 234             DIRECTMANIPULATION_SNAPPOINT_COORDINATE coordinate, float origin)
 235 {
 236     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 237     FIXME("%p, %d, %d, %f\n", This, motion, coordinate, origin);
 238     return E_NOTIMPL;
 239 }
 240
 241 static HRESULT WINAPI primary_SetZoomBoundaries(IDirectManipulationPrimaryContent *iface, float minimum, float maximum)
 242 {
 243     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 244     FIXME("%p, %f, %f\n", This, minimum, maximum);
 245     return E_NOTIMPL;
 246 }
 247
 248 static HRESULT WINAPI primary_SetHorizontalAlignment(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_HORIZONTALALIGNMENT alignment)
 249 {
 250     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 251     FIXME("%p, %d\n", This, alignment);
 252     return E_NOTIMPL;
 253 }
 254
 255 static HRESULT WINAPI primary_SetVerticalAlignment(IDirectManipulationPrimaryContent *iface, DIRECTMANIPULATION_VERTICALALIGNMENT alignment)
 256 {
 257     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 258     FIXME("%p, %d\n", This, alignment);
 259     return E_NOTIMPL;
 260 }
 261
 262 static HRESULT WINAPI primary_GetInertiaEndTransform(IDirectManipulationPrimaryContent *iface, float *matrix, DWORD count)
 263 {
 264     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 265     FIXME("%p,  %p, %d\n", This, matrix, count);
 266     return E_NOTIMPL;
 267 }
 268
 269 static HRESULT WINAPI primary_GetCenterPoint(IDirectManipulationPrimaryContent *iface, float *x, float *y)
 270 {
 271     struct primarycontext *This = impl_from_IDirectManipulationPrimaryContent(iface);
 272     FIXME("%p, %p, %p\n", This, x, y);
 273     return E_NOTIMPL;
 274 }
 275
 276 static const IDirectManipulationPrimaryContentVtbl primaryVtbl =
 277 {
 278     primary_QueryInterface,
 279     primary_AddRef,
 280     primary_Release,
 281     primary_SetSnapInterval,
 282     primary_SetSnapPoints,
 283     primary_SetSnapType,
 284     primary_SetSnapCoordinate,
 285     primary_SetZoomBoundaries,
 286     primary_SetHorizontalAlignment,
 287     primary_SetVerticalAlignment,
 288     primary_GetInertiaEndTransform,
 289     primary_GetCenterPoint
 290 };
 291
 292
 293 static HRESULT WINAPI content_QueryInterface(IDirectManipulationContent *iface, REFIID riid, void **ppv)
 294 {
 295     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 296     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 297
 298     return IDirectManipulationPrimaryContent_QueryInterface(&This->IDirectManipulationPrimaryContent_iface,
 299             riid, ppv);
 300 }
 301
 302 static ULONG WINAPI content_AddRef(IDirectManipulationContent *iface)
 303 {
 304     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 305     return IDirectManipulationPrimaryContent_AddRef(&This->IDirectManipulationPrimaryContent_iface);
 306 }
 307
 308 static ULONG WINAPI content_Release(IDirectManipulationContent *iface)
 309 {
 310     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 311     return IDirectManipulationPrimaryContent_Release(&This->IDirectManipulationPrimaryContent_iface);
 312 }
 313
 314 static HRESULT WINAPI content_GetContentRect(IDirectManipulationContent *iface, RECT *size)
 315 {
 316     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 317     FIXME("%p, %p\n", This, size);
 318     return E_NOTIMPL;
 319 }
 320
 321 static HRESULT WINAPI content_SetContentRect(IDirectManipulationContent *iface, const RECT *size)
 322 {
 323     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 324     FIXME("%p, %p\n", This, size);
 325     return S_OK;
 326 }
 327
 328 static HRESULT WINAPI content_GetViewport(IDirectManipulationContent *iface, REFIID riid, void **object)
 329 {
 330     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 331     FIXME("%p, %s, %p\n", This, debugstr_guid(riid), object);
 332     return E_NOTIMPL;
 333 }
 334
 335 static HRESULT WINAPI content_GetTag(IDirectManipulationContent *iface, REFIID riid, void **object, UINT32 *id)
 336 {
 337     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 338     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(riid), object, id);
 339     return E_NOTIMPL;
 340 }
 341
 342 static HRESULT WINAPI content_SetTag(IDirectManipulationContent *iface, IUnknown *object, UINT32 id)
 343 {
 344     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 345     FIXME("%p, %p, %d\n", This, object, id);
 346     return E_NOTIMPL;
 347 }
 348
 349 static HRESULT WINAPI content_GetOutputTransform(IDirectManipulationContent *iface,
 350                     float *matrix, DWORD count)
 351 {
 352     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 353     FIXME("%p, %p, %d\n", This, matrix, count);
 354     return E_NOTIMPL;
 355 }
 356
 357 static HRESULT WINAPI content_GetContentTransform(IDirectManipulationContent *iface,
 358                     float *matrix, DWORD count)
 359 {
 360     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 361     FIXME("%p, %p, %d\n", This, matrix, count);
 362     return E_NOTIMPL;
 363 }
 364
 365 static HRESULT WINAPI content_SyncContentTransform(IDirectManipulationContent *iface,
 366                     const float *matrix, DWORD count)
 367 {
 368     struct primarycontext *This = impl_from_IDirectManipulationContent(iface);
 369     FIXME("%p, %p, %d\n", This, matrix, count);
 370     return E_NOTIMPL;
 371 }
 372
 373 static const IDirectManipulationContentVtbl contentVtbl =
 374 {
 375     content_QueryInterface,
 376     content_AddRef,
 377     content_Release,
 378     content_GetContentRect,
 379     content_SetContentRect,
 380     content_GetViewport,
 381     content_GetTag,
 382     content_SetTag,
 383     content_GetOutputTransform,
 384     content_GetContentTransform,
 385     content_SyncContentTransform
 386 };
 387
 388 struct directviewport
 389 {
 390     IDirectManipulationViewport2 IDirectManipulationViewport2_iface;
 391     LONG ref;
 392 };
 393
 394 static inline struct directviewport *impl_from_IDirectManipulationViewport2(IDirectManipulationViewport2 *iface)
 395 {
 396     return CONTAINING_RECORD(iface, struct directviewport, IDirectManipulationViewport2_iface);
 397 }
 398
 399 static HRESULT WINAPI viewport_QueryInterface(IDirectManipulationViewport2 *iface, REFIID riid, void **ppv)
 400 {
 401     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 402     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppv);
 403
 404     if (IsEqualGUID(riid, &IID_IUnknown) ||
 405         IsEqualGUID(riid, &IID_IDirectManipulationViewport) ||
 406         IsEqualGUID(riid, &IID_IDirectManipulationViewport2))
 407     {
 408         IDirectManipulationViewport2_AddRef(&This->IDirectManipulationViewport2_iface);
 409         *ppv = &This->IDirectManipulationViewport2_iface;
 410         return S_OK;
 411     }
 412
 413     FIXME("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppv);
 414     return E_NOINTERFACE;
 415 }
 416
 417 static ULONG WINAPI viewport_AddRef(IDirectManipulationViewport2 *iface)
 418 {
 419     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 420     ULONG ref = InterlockedIncrement(&This->ref);
 421
 422     TRACE("(%p) ref=%u\n", This, ref);
 423
 424     return ref;
 425 }
 426
 427 static ULONG WINAPI viewport_Release(IDirectManipulationViewport2 *iface)
 428 {
 429     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 430     ULONG ref = InterlockedDecrement(&This->ref);
 431
 432     TRACE("(%p) ref=%u\n", This, ref);
 433
 434     if (!ref)
 435     {
 436         heap_free(This);
 437     }
 438     return ref;
 439 }
 440
 441 static HRESULT WINAPI viewport_Enable(IDirectManipulationViewport2 *iface)
 442 {
 443     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 444     FIXME("%p\n", This);
 445     return E_NOTIMPL;
 446 }
 447
 448 static HRESULT WINAPI viewport_Disable(IDirectManipulationViewport2 *iface)
 449 {
 450     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 451     FIXME("%p\n", This);
 452     return E_NOTIMPL;
 453 }
 454
 455 static HRESULT WINAPI viewport_SetContact(IDirectManipulationViewport2 *iface, UINT32 id)
 456 {
 457     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 458     FIXME("%p, %d\n", This, id);
 459     return E_NOTIMPL;
 460 }
 461
 462 static HRESULT WINAPI viewport_ReleaseContact(IDirectManipulationViewport2 *iface, UINT32 id)
 463 {
 464     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 465     FIXME("%p, %d\n", This, id);
 466     return E_NOTIMPL;
 467 }
 468
 469 static HRESULT WINAPI viewport_ReleaseAllContacts(IDirectManipulationViewport2 *iface)
 470 {
 471     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 472     FIXME("%p\n", This);
 473     return E_NOTIMPL;
 474 }
 475
 476 static HRESULT WINAPI viewport_GetStatus(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_STATUS *status)
 477 {
 478     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 479     FIXME("%p, %p\n", This, status);
 480     return E_NOTIMPL;
 481 }
 482
 483 static HRESULT WINAPI viewport_GetTag(IDirectManipulationViewport2 *iface, REFIID riid, void **object, UINT32 *id)
 484 {
 485     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 486     FIXME("%p, %s, %p, %p\n", This, debugstr_guid(riid), object, id);
 487     return E_NOTIMPL;
 488 }
 489
 490 static HRESULT WINAPI viewport_SetTag(IDirectManipulationViewport2 *iface, IUnknown *object, UINT32 id)
 491 {
 492     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 493     FIXME("%p, %p, %u\n", This, object, id);
 494     return E_NOTIMPL;
 495 }
 496
 497 static HRESULT WINAPI viewport_GetViewportRect(IDirectManipulationViewport2 *iface, RECT *viewport)
 498 {
 499     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 500     FIXME("%p, %p\n", This, viewport);
 501     return E_NOTIMPL;
 502 }
 503
 504 static HRESULT WINAPI viewport_SetViewportRect(IDirectManipulationViewport2 *iface, const RECT *viewport)
 505 {
 506     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 507     FIXME("%p, %p\n", This, viewport);
 508     return S_OK;
 509 }
 510
 511 static HRESULT WINAPI viewport_ZoomToRect(IDirectManipulationViewport2 *iface, const float left,
 512                     const float top, const float right, const float bottom, BOOL animate)
 513 {
 514     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 515     FIXME("%p, %f, %f, %f, %f, %d\n", This, left, top, right, bottom, animate);
 516     return E_NOTIMPL;
 517 }
 518
 519 static HRESULT WINAPI viewport_SetViewportTransform(IDirectManipulationViewport2 *iface,
 520                     const float *matrix, DWORD count)
 521 {
 522     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 523     FIXME("%p, %p, %d\n", This, matrix, count);
 524     return E_NOTIMPL;
 525 }
 526
 527 static HRESULT WINAPI viewport_SyncDisplayTransform(IDirectManipulationViewport2 *iface,
 528                     const float *matrix, DWORD count)
 529 {
 530     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 531     FIXME("%p, %p, %d\n", This, matrix, count);
 532     return E_NOTIMPL;
 533 }
 534
 535 static HRESULT WINAPI viewport_GetPrimaryContent(IDirectManipulationViewport2 *iface, REFIID riid, void **object)
 536 {
 537     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 538     TRACE("%p, %s, %p\n", This, debugstr_guid(riid), object);
 539     if(IsEqualGUID(riid, &IID_IDirectManipulationPrimaryContent))
 540     {
 541         struct primarycontext *primary;
 542         TRACE("IDirectManipulationPrimaryContent\n");
 543         primary = heap_alloc( sizeof(*primary));
 544         if(!primary)
 545             return E_OUTOFMEMORY;
 546
 547         primary->IDirectManipulationPrimaryContent_iface.lpVtbl = &primaryVtbl;
 548         primary->IDirectManipulationContent_iface.lpVtbl = &contentVtbl;
 549         primary->ref = 1;
 550
 551         *object = &primary->IDirectManipulationPrimaryContent_iface;
 552
 553         return S_OK;
 554     }
 555     else
 556         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 557     return E_NOTIMPL;
 558 }
 559
 560 static HRESULT WINAPI viewport_AddContent(IDirectManipulationViewport2 *iface, IDirectManipulationContent *content)
 561 {
 562     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 563     FIXME("%p, %p\n", This, content);
 564     return E_NOTIMPL;
 565 }
 566
 567 static HRESULT WINAPI viewport_RemoveContent(IDirectManipulationViewport2 *iface, IDirectManipulationContent *content)
 568 {
 569     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 570     FIXME("%p, %p\n", This, content);
 571     return E_NOTIMPL;
 572 }
 573
 574 static HRESULT WINAPI viewport_SetViewportOptions(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_VIEWPORT_OPTIONS options)
 575 {
 576     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 577     FIXME("%p, %d\n", This, options);
 578     return S_OK;
 579 }
 580
 581 static HRESULT WINAPI viewport_AddConfiguration(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_CONFIGURATION configuration)
 582 {
 583     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 584     FIXME("%p, %d\n", This, configuration);
 585     return E_NOTIMPL;
 586 }
 587
 588 static HRESULT WINAPI viewport_RemoveConfiguration(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_CONFIGURATION configuration)
 589 {
 590     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 591     FIXME("%p, %d\n", This, configuration);
 592     return E_NOTIMPL;
 593 }
 594
 595 static HRESULT WINAPI viewport_ActivateConfiguration(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_CONFIGURATION configuration)
 596 {
 597     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 598     FIXME("%p, %d\n", This, configuration);
 599     return S_OK;
 600 }
 601
 602 static HRESULT WINAPI viewport_SetManualGesture(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_GESTURE_CONFIGURATION configuration)
 603 {
 604     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 605     FIXME("%p, %d\n", This, configuration);
 606     return E_NOTIMPL;
 607 }
 608
 609 static HRESULT WINAPI viewport_SetChaining(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_MOTION_TYPES enabledTypes)
 610 {
 611     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 612     FIXME("%p, %d\n", This, enabledTypes);
 613     return E_NOTIMPL;
 614 }
 615
 616 static HRESULT WINAPI viewport_AddEventHandler(IDirectManipulationViewport2 *iface, HWND window,
 617                     IDirectManipulationViewportEventHandler *eventHandler, DWORD *cookie)
 618 {
 619     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 620     FIXME("%p, %p, %p, %p\n", This, window, eventHandler, cookie);
 621     return E_NOTIMPL;
 622 }
 623
 624 static HRESULT WINAPI viewport_RemoveEventHandler(IDirectManipulationViewport2 *iface, DWORD cookie)
 625 {
 626     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 627     FIXME("%p, %d\n", This, cookie);
 628     return E_NOTIMPL;
 629 }
 630
 631 static HRESULT WINAPI viewport_SetInputMode(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_INPUT_MODE mode)
 632 {
 633     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 634     FIXME("%p, %d\n", This, mode);
 635     return E_NOTIMPL;
 636 }
 637
 638 static HRESULT WINAPI viewport_SetUpdateMode(IDirectManipulationViewport2 *iface, DIRECTMANIPULATION_INPUT_MODE mode)
 639 {
 640     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 641     FIXME("%p, %d\n", This, mode);
 642     return E_NOTIMPL;
 643 }
 644
 645 static HRESULT WINAPI viewport_Stop(IDirectManipulationViewport2 *iface)
 646 {
 647     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 648     FIXME("%p\n", This);
 649     return E_NOTIMPL;
 650 }
 651
 652 static HRESULT WINAPI viewport_Abandon(IDirectManipulationViewport2 *iface)
 653 {
 654     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 655     FIXME("%p\n", This);
 656     return E_NOTIMPL;
 657 }
 658
 659 static HRESULT WINAPI viewport_AddBehavior(IDirectManipulationViewport2 *iface, IUnknown *behavior, DWORD *cookie)
 660 {
 661     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 662     FIXME("%p, %p, %p\n", This, behavior, cookie);
 663     return E_NOTIMPL;
 664 }
 665
 666 static HRESULT WINAPI viewport_RemoveBehavior(IDirectManipulationViewport2 *iface, DWORD cookie)
 667 {
 668     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 669     FIXME("%p, %d\n", This, cookie);
 670     return E_NOTIMPL;
 671 }
 672
 673 static HRESULT WINAPI viewport_RemoveAllBehaviors(IDirectManipulationViewport2 *iface)
 674 {
 675     struct directviewport *This = impl_from_IDirectManipulationViewport2(iface);
 676     FIXME("%p\n", This);
 677     return E_NOTIMPL;
 678 }
 679
 680 static const IDirectManipulationViewport2Vtbl viewportVtbl =
 681 {
 682     viewport_QueryInterface,
 683     viewport_AddRef,
 684     viewport_Release,
 685     viewport_Enable,
 686     viewport_Disable,
 687     viewport_SetContact,
 688     viewport_ReleaseContact,
 689     viewport_ReleaseAllContacts,
 690     viewport_GetStatus,
 691     viewport_GetTag,
 692     viewport_SetTag,
 693     viewport_GetViewportRect,
 694     viewport_SetViewportRect,
 695     viewport_ZoomToRect,
 696     viewport_SetViewportTransform,
 697     viewport_SyncDisplayTransform,
 698     viewport_GetPrimaryContent,
 699     viewport_AddContent,
 700     viewport_RemoveContent,
 701     viewport_SetViewportOptions,
 702     viewport_AddConfiguration,
 703     viewport_RemoveConfiguration,
 704     viewport_ActivateConfiguration,
 705     viewport_SetManualGesture,
 706     viewport_SetChaining,
 707     viewport_AddEventHandler,
 708     viewport_RemoveEventHandler,
 709     viewport_SetInputMode,
 710     viewport_SetUpdateMode,
 711     viewport_Stop,
 712     viewport_Abandon,
 713     viewport_AddBehavior,
 714     viewport_RemoveBehavior,
 715     viewport_RemoveAllBehaviors
 716 };
 717
 718 static HRESULT create_viewport(IDirectManipulationViewport2 **obj)
 719 {
 720     struct directviewport *object;
 721
 722     object = heap_alloc(sizeof(*object));
 723     if(!object)
 724         return E_OUTOFMEMORY;
 725
 726     object->IDirectManipulationViewport2_iface.lpVtbl = &viewportVtbl;
 727     object->ref = 1;
 728
 729     *obj = &object->IDirectManipulationViewport2_iface;
 730
 731     return S_OK;
 732 }
 733
 734 static HRESULT WINAPI direct_manip_QueryInterface(IDirectManipulationManager2 *iface, REFIID riid, void **ppv)
 735 {
 736     if (IsEqualGUID(riid, &IID_IUnknown) ||
 737         IsEqualGUID(riid, &IID_IDirectManipulationManager) ||
 738         IsEqualGUID(riid, &IID_IDirectManipulationManager2)) {
 739         IUnknown_AddRef(iface);
 740         *ppv = iface;
 741         return S_OK;
 742     }
 743
 744     FIXME("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
 745     return E_NOINTERFACE;
 746 }
 747
 748 static ULONG WINAPI direct_manip_AddRef(IDirectManipulationManager2 *iface)
 749 {
 750     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 751     ULONG ref = InterlockedIncrement(&This->ref);
 752
 753     TRACE("(%p) ref=%u\n", This, ref);
 754
 755     return ref;
 756 }
 757
 758 static ULONG WINAPI direct_manip_Release(IDirectManipulationManager2 *iface)
 759 {
 760     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 761     ULONG ref = InterlockedDecrement(&This->ref);
 762
 763     TRACE("(%p) ref=%u\n", This, ref);
 764
 765     if (!ref)
 766     {
 767         if(This->updatemanager)
 768             IDirectManipulationUpdateManager_Release(This->updatemanager);
 769         heap_free(This);
 770     }
 771     return ref;
 772 }
 773
 774 static HRESULT WINAPI direct_manip_Activate(IDirectManipulationManager2 *iface, HWND window)
 775 {
 776     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 777     FIXME("%p, %p\n", This, window);
 778     return E_NOTIMPL;
 779 }
 780
 781 static HRESULT WINAPI direct_manip_Deactivate(IDirectManipulationManager2 *iface, HWND window)
 782 {
 783     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 784     FIXME("%p, %p\n", This, window);
 785     return E_NOTIMPL;
 786 }
 787
 788 static HRESULT WINAPI direct_manip_RegisterHitTestTarget(IDirectManipulationManager2 *iface, HWND window,
 789                 HWND hittest, DIRECTMANIPULATION_HITTEST_TYPE type)
 790 {
 791     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 792     FIXME("%p, %p, %p, %d\n", This, window, hittest, type);
 793     return E_NOTIMPL;
 794 }
 795
 796 static HRESULT WINAPI direct_manip_ProcessInput(IDirectManipulationManager2 *iface, const MSG *msg, BOOL *handled)
 797 {
 798     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 799     FIXME("%p, %p, %p\n", This, msg, handled);
 800     return E_NOTIMPL;
 801 }
 802
 803 static HRESULT WINAPI direct_manip_GetUpdateManager(IDirectManipulationManager2 *iface, REFIID riid, void **obj)
 804 {
 805     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 806     HRESULT hr = E_FAIL;
 807
 808     TRACE("%p, %s, %p\n", This, debugstr_guid(riid), obj);
 809
 810     *obj = NULL;
 811     if(IsEqualGUID(riid, &IID_IDirectManipulationUpdateManager))
 812     {
 813         if(!This->updatemanager)
 814         {
 815             hr = create_update_manager(&This->updatemanager);
 816         }
 817         else
 818         {
 819             hr = S_OK;
 820         }
 821
 822         if(hr == S_OK)
 823         {
 824             IDirectManipulationUpdateManager_AddRef(This->updatemanager);
 825             *obj = This->updatemanager;
 826         }
 827     }
 828     else
 829         FIXME("Interface %s currently not supported.\n", debugstr_guid(riid));
 830
 831     return hr;
 832 }
 833
 834 static HRESULT WINAPI direct_manip_CreateViewport(IDirectManipulationManager2 *iface, IDirectManipulationFrameInfoProvider *frame,
 835                 HWND window, REFIID riid, void **obj)
 836 {
 837     HRESULT hr = E_NOTIMPL;
 838     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 839     TRACE("%p, %p, %p, %s, %p\n", This, frame, window, debugstr_guid(riid), obj);
 840
 841     if(IsEqualGUID(riid, &IID_IDirectManipulationViewport) ||
 842        IsEqualGUID(riid, &IID_IDirectManipulationViewport2) )
 843     {
 844         hr = create_viewport( (IDirectManipulationViewport2**)obj);
 845     }
 846     else
 847         FIXME("Unsupported interface %s\n", debugstr_guid(riid));
 848     return hr;
 849 }
 850
 851 static HRESULT WINAPI direct_manip_CreateContent(IDirectManipulationManager2 *iface, IDirectManipulationFrameInfoProvider *frame,
 852                 REFCLSID clsid, REFIID riid, void **obj)
 853 {
 854     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 855     FIXME("%p, %p,  %s, %p\n", This, frame, debugstr_guid(riid), obj);
 856     return E_NOTIMPL;
 857 }
 858
 859 static HRESULT WINAPI direct_manip_CreateBehavior(IDirectManipulationManager2 *iface, REFCLSID clsid, REFIID riid, void **obj)
 860 {
 861     struct directmanipulation *This = impl_from_IDirectManipulationManager2(iface);
 862     FIXME("%p, %s,  %s, %p\n", This, debugstr_guid(clsid), debugstr_guid(riid), obj);
 863     return E_NOTIMPL;
 864 }
 865
 866 static const struct IDirectManipulationManager2Vtbl directmanipVtbl =
 867 {
 868     direct_manip_QueryInterface,
 869     direct_manip_AddRef,
 870     direct_manip_Release,
 871     direct_manip_Activate,
 872     direct_manip_Deactivate,
 873     direct_manip_RegisterHitTestTarget,
 874     direct_manip_ProcessInput,
 875     direct_manip_GetUpdateManager,
 876     direct_manip_CreateViewport,
 877     direct_manip_CreateContent,
 878     direct_manip_CreateBehavior
 879 };
 880
 881 static HRESULT WINAPI DirectManipulation_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
 882 {
 883     struct directmanipulation *object;
 884     HRESULT ret;
 885
 886     TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv);
 887
 888     *ppv = NULL;
 889
 890     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
 891     if (!object)
 892         return E_OUTOFMEMORY;
 893
 894     object->IDirectManipulationManager2_iface.lpVtbl = &directmanipVtbl;
 895     object->ref = 1;
 896
 897     ret = direct_manip_QueryInterface(&object->IDirectManipulationManager2_iface, riid, ppv);
 898     direct_manip_Release(&object->IDirectManipulationManager2_iface);
 899
 900     return ret;
 901 }
 902
 903 struct directcompositor
 904 {
 905     IDirectManipulationCompositor2 IDirectManipulationCompositor2_iface;
 906     IDirectManipulationFrameInfoProvider IDirectManipulationFrameInfoProvider_iface;
 907     IDirectManipulationUpdateManager *manager;
 908     LONG ref;
 909 };
 910
 911 static inline struct directcompositor *impl_from_IDirectManipulationCompositor2(IDirectManipulationCompositor2 *iface)
 912 {
 913     return CONTAINING_RECORD(iface, struct directcompositor, IDirectManipulationCompositor2_iface);
 914 }
 915
 916 static inline struct directcompositor *impl_from_IDirectManipulationFrameInfoProvider(IDirectManipulationFrameInfoProvider *iface)
 917 {
 918     return CONTAINING_RECORD(iface, struct directcompositor, IDirectManipulationFrameInfoProvider_iface);
 919 }
 920
 921 static HRESULT WINAPI compositor_QueryInterface(IDirectManipulationCompositor2 *iface, REFIID riid, void **ppv)
 922 {
 923     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 924
 925     if (IsEqualGUID(riid, &IID_IUnknown) ||
 926         IsEqualGUID(riid, &IID_IDirectManipulationCompositor) ||
 927         IsEqualGUID(riid, &IID_IDirectManipulationCompositor2))
 928     {
 929         IUnknown_AddRef(iface);
 930         *ppv = iface;
 931         return S_OK;
 932     }
 933     else if(IsEqualGUID(riid, &IID_IDirectManipulationFrameInfoProvider))
 934     {
 935         IUnknown_AddRef(iface);
 936         *ppv = &This->IDirectManipulationFrameInfoProvider_iface;
 937         return S_OK;
 938     }
 939
 940     FIXME("(%p)->(%s,%p),not found\n", iface, debugstr_guid(riid), ppv);
 941     return E_NOINTERFACE;
 942 }
 943
 944 static ULONG WINAPI compositor_AddRef(IDirectManipulationCompositor2 *iface)
 945 {
 946     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 947     ULONG ref = InterlockedIncrement(&This->ref);
 948
 949     TRACE("(%p) ref=%u\n", This, ref);
 950
 951     return ref;
 952 }
 953
 954 static ULONG WINAPI compositor_Release(IDirectManipulationCompositor2 *iface)
 955 {
 956     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 957     ULONG ref = InterlockedDecrement(&This->ref);
 958
 959     TRACE("(%p) ref=%u\n", This, ref);
 960
 961     if (!ref)
 962     {
 963         if(This->manager)
 964             IDirectManipulationUpdateManager_Release(This->manager);
 965         heap_free(This);
 966     }
 967     return ref;
 968 }
 969
 970 static HRESULT WINAPI compositor_AddContent(IDirectManipulationCompositor2 *iface, IDirectManipulationContent *content,
 971                 IUnknown *device, IUnknown *parent, IUnknown *child)
 972 {
 973     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 974     FIXME("%p, %p, %p, %p, %p\n", This, content, device, parent, child);
 975     return E_NOTIMPL;
 976 }
 977
 978 static HRESULT WINAPI compositor_RemoveContent(IDirectManipulationCompositor2 *iface, IDirectManipulationContent *content)
 979 {
 980     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 981     FIXME("%p, %p\n", This, content);
 982     return E_NOTIMPL;
 983 }
 984
 985 static HRESULT WINAPI compositor_SetUpdateManager(IDirectManipulationCompositor2 *iface, IDirectManipulationUpdateManager *manager)
 986 {
 987     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
 988     TRACE("%p, %p\n", This, manager);
 989
 990     if(!manager)
 991         return E_INVALIDARG;
 992
 993     This->manager = manager;
 994     IDirectManipulationUpdateManager_AddRef(This->manager);
 995     return S_OK;
 996 }
 997
 998 static HRESULT WINAPI compositor_Flush(IDirectManipulationCompositor2 *iface)
 999 {
1000     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
1001     FIXME("%p\n", This);
1002     return E_NOTIMPL;
1003 }
1004
1005 static HRESULT WINAPI compositor_AddContentWithCrossProcessChaining(IDirectManipulationCompositor2 *iface,
1006                 IDirectManipulationPrimaryContent *content, IUnknown *device, IUnknown *parentvisual, IUnknown *childvisual)
1007 {
1008     struct directcompositor *This = impl_from_IDirectManipulationCompositor2(iface);
1009     FIXME("%p %p %p %p %p\n", This, content, device, parentvisual, childvisual);
1010     return E_NOTIMPL;
1011 }
1012
1013 static const struct IDirectManipulationCompositor2Vtbl compositorVtbl =
1014 {
1015     compositor_QueryInterface,
1016     compositor_AddRef,
1017     compositor_Release,
1018     compositor_AddContent,
1019     compositor_RemoveContent,
1020     compositor_SetUpdateManager,
1021     compositor_Flush,
1022     compositor_AddContentWithCrossProcessChaining
1023 };
1024
1025 static HRESULT WINAPI provider_QueryInterface(IDirectManipulationFrameInfoProvider *iface, REFIID riid, void **ppv)
1026 {
1027     struct directcompositor *This = impl_from_IDirectManipulationFrameInfoProvider(iface);
1028     return IDirectManipulationCompositor2_QueryInterface(&This->IDirectManipulationCompositor2_iface, riid, ppv);
1029 }
1030
1031 static ULONG WINAPI provider_AddRef(IDirectManipulationFrameInfoProvider *iface)
1032 {
1033     struct directcompositor *This = impl_from_IDirectManipulationFrameInfoProvider(iface);
1034     return IDirectManipulationCompositor2_AddRef(&This->IDirectManipulationCompositor2_iface);
1035 }
1036
1037 static ULONG WINAPI provider_Release(IDirectManipulationFrameInfoProvider *iface)
1038 {
1039     struct directcompositor *This = impl_from_IDirectManipulationFrameInfoProvider(iface);
1040     return IDirectManipulationCompositor2_Release(&This->IDirectManipulationCompositor2_iface);
1041 }
1042
1043 static HRESULT WINAPI provider_GetNextFrameInfo(IDirectManipulationFrameInfoProvider *iface, ULONGLONG *time,
1044             ULONGLONG *process, ULONGLONG *composition)
1045 {
1046     struct directcompositor *This = impl_from_IDirectManipulationFrameInfoProvider(iface);
1047     FIXME("%p, %p, %p, %p\n", This, time, process, composition);
1048     return E_NOTIMPL;
1049 }
1050
1051 static const struct IDirectManipulationFrameInfoProviderVtbl providerVtbl =
1052 {
1053     provider_QueryInterface,
1054     provider_AddRef,
1055     provider_Release,
1056     provider_GetNextFrameInfo
1057 };
1058
1059 static HRESULT WINAPI DirectCompositor_CreateInstance(IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
1060 {
1061     struct directcompositor *object;
1062     HRESULT ret;
1063
1064     TRACE("(%p, %s, %p)\n", outer, debugstr_guid(riid), ppv);
1065
1066     *ppv = NULL;
1067
1068     object = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*object));
1069     if (!object)
1070         return E_OUTOFMEMORY;
1071
1072     object->IDirectManipulationCompositor2_iface.lpVtbl = &compositorVtbl;
1073     object->IDirectManipulationFrameInfoProvider_iface.lpVtbl = &providerVtbl;
1074     object->ref = 1;
1075
1076     ret = compositor_QueryInterface(&object->IDirectManipulationCompositor2_iface, riid, ppv);
1077     compositor_Release(&object->IDirectManipulationCompositor2_iface);
1078
1079     return ret;
1080 }
1081
1082 static HRESULT WINAPI ClassFactory_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv)
1083 {
1084     *ppv = NULL;
1085
1086     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IClassFactory, riid)) {
1087         *ppv = iface;
1088     }
1089
1090     if(*ppv) {
1091         IUnknown_AddRef((IUnknown*)*ppv);
1092         return S_OK;
1093     }
1094
1095     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
1096     return E_NOINTERFACE;
1097 }
1098
1099 static ULONG WINAPI ClassFactory_AddRef(IClassFactory *iface)
1100 {
1101     TRACE("(%p)\n", iface);
1102     return 2;
1103 }
1104
1105 static ULONG WINAPI ClassFactory_Release(IClassFactory *iface)
1106 {
1107     TRACE("(%p)\n", iface);
1108     return 1;
1109 }
1110
1111 static HRESULT WINAPI ClassFactory_LockServer(IClassFactory *iface, BOOL fLock)
1112 {
1113     TRACE("(%p)->(%x)\n", iface, fLock);
1114     return S_OK;
1115 }
1116
1117 static const IClassFactoryVtbl DirectFactoryVtbl = {
1118     ClassFactory_QueryInterface,
1119     ClassFactory_AddRef,
1120     ClassFactory_Release,
1121     DirectManipulation_CreateInstance,
1122     ClassFactory_LockServer
1123 };
1124
1125 static const IClassFactoryVtbl DirectCompositorVtbl = {
1126     ClassFactory_QueryInterface,
1127     ClassFactory_AddRef,
1128     ClassFactory_Release,
1129     DirectCompositor_CreateInstance,
1130     ClassFactory_LockServer
1131 };
1132
1133 static IClassFactory direct_factory = { &DirectFactoryVtbl };
1134 static IClassFactory compositor_factory = { &DirectCompositorVtbl };
1135
1136 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
1137 {
1138     if(IsEqualGUID(&CLSID_DirectManipulationManager, rclsid) ||
1139        IsEqualGUID(&CLSID_DirectManipulationSharedManager, rclsid) ) {
1140         TRACE("(CLSID_DirectManipulationManager %s %p)\n", debugstr_guid(riid), ppv);
1141         return IClassFactory_QueryInterface(&direct_factory, riid, ppv);
1142     }
1143     else if(IsEqualGUID(&CLSID_DCompManipulationCompositor, rclsid)) {
1144         TRACE("(CLSID_DCompManipulationCompositor %s %p)\n", debugstr_guid(riid), ppv);
1145         return IClassFactory_QueryInterface(&compositor_factory, riid, ppv);
1146     }
1147
1148     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1149     return CLASS_E_CLASSNOTAVAILABLE;
1150 }