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