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