dlls/ddraw/ddraw_thunks.c

   1 /* Direct Draw Thunks and old vtables
   2  * Copyright 2000 TransGaming Technologies Inc.
   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
  19 #include "config.h"
  20 #include "wine/port.h"
  21
  22 #include <assert.h>
  23 #include <stdarg.h>
  24 #include <string.h>
  25 #include <stdlib.h>
  26
  27 #define COBJMACROS
  28 #define NONAMELESSUNION
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winerror.h"
  33 #include "wingdi.h"
  34 #include "wine/exception.h"
  35
  36 #include "ddraw.h"
  37 #include "d3d.h"
  38
  39 #include "ddraw_private.h"
  40 #include "wine/debug.h"
  41
  42 WINE_DEFAULT_DEBUG_CHANNEL(ddraw_thunk);
  43 WINE_DECLARE_DEBUG_CHANNEL(ddraw);
  44
  45 static inline IDirectDrawImpl *ddraw_from_ddraw1(IDirectDraw *iface)
  46 {
  47     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw_vtbl));
  48 }
  49
  50 static inline IDirectDrawImpl *ddraw_from_ddraw2(IDirectDraw2 *iface)
  51 {
  52     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw2_vtbl));
  53 }
  54
  55 static inline IDirectDrawImpl *ddraw_from_ddraw3(IDirectDraw3 *iface)
  56 {
  57     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw3_vtbl));
  58 }
  59
  60 static inline IDirectDrawImpl *ddraw_from_ddraw4(IDirectDraw4 *iface)
  61 {
  62     return (IDirectDrawImpl *)((char*)iface - FIELD_OFFSET(IDirectDrawImpl, IDirectDraw4_vtbl));
  63 }
  64
  65 static HRESULT WINAPI
  66 IDirectDrawImpl_QueryInterface(LPDIRECTDRAW This, REFIID iid, LPVOID *ppObj)
  67 {
  68     return IDirectDraw7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawImpl,
  69                                                           IDirectDraw,
  70                                                           IDirectDraw7, This),
  71                                        iid, ppObj);
  72 }
  73
  74 static HRESULT WINAPI
  75 IDirectDraw2Impl_QueryInterface(LPDIRECTDRAW2 This, REFIID iid, LPVOID *ppObj)
  76 {
  77     return IDirectDraw7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawImpl,
  78                                                           IDirectDraw2,
  79                                                           IDirectDraw7, This),
  80                                        iid, ppObj);
  81 }
  82
  83 static HRESULT WINAPI
  84 IDirectDraw3Impl_QueryInterface(LPDIRECTDRAW3 This, REFIID iid, LPVOID *ppObj)
  85 {
  86     return IDirectDraw7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawImpl,
  87                                                           IDirectDraw3,
  88                                                           IDirectDraw7, This),
  89                                        iid, ppObj);
  90 }
  91
  92 static HRESULT WINAPI
  93 IDirectDraw4Impl_QueryInterface(LPDIRECTDRAW4 This, REFIID iid, LPVOID *ppObj)
  94 {
  95     return IDirectDraw7_QueryInterface(COM_INTERFACE_CAST(IDirectDrawImpl,
  96                                                           IDirectDraw4,
  97                                                           IDirectDraw7, This),
  98                                        iid, ppObj);
  99 }
 100
 101 static ULONG WINAPI
 102 IDirectDrawImpl_AddRef(LPDIRECTDRAW iface)
 103 {
 104     IDirectDrawImpl *This = ddraw_from_ddraw1(iface);
 105     ULONG ref = InterlockedIncrement(&This->ref1);
 106
 107     TRACE("(%p) : incrementing IDirectDraw refcount from %u.\n", This, ref -1);
 108
 109     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 110
 111     return ref;
 112 }
 113
 114 static ULONG WINAPI
 115 IDirectDraw2Impl_AddRef(LPDIRECTDRAW2 iface)
 116 {
 117     IDirectDrawImpl *This = ddraw_from_ddraw2(iface);
 118     ULONG ref = InterlockedIncrement(&This->ref2);
 119
 120     TRACE("(%p) : incrementing IDirectDraw2 refcount from %u.\n", This, ref -1);
 121
 122     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 123
 124     return ref;
 125 }
 126
 127 static ULONG WINAPI
 128 IDirectDraw3Impl_AddRef(LPDIRECTDRAW3 iface)
 129 {
 130     IDirectDrawImpl *This = ddraw_from_ddraw3(iface);
 131     ULONG ref = InterlockedIncrement(&This->ref3);
 132
 133     TRACE("(%p) : incrementing IDirectDraw3 refcount from %u.\n", This, ref -1);
 134
 135     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 136
 137     return ref;
 138 }
 139
 140 static ULONG WINAPI
 141 IDirectDraw4Impl_AddRef(LPDIRECTDRAW4 iface)
 142 {
 143     IDirectDrawImpl *This = ddraw_from_ddraw4(iface);
 144     ULONG ref = InterlockedIncrement(&This->ref4);
 145
 146     TRACE("(%p) : incrementing IDirectDraw4 refcount from %u.\n", This, ref -1);
 147
 148     if(ref == 1) InterlockedIncrement(&This->numIfaces);
 149
 150     return ref;
 151 }
 152
 153 static ULONG WINAPI
 154 IDirectDrawImpl_Release(LPDIRECTDRAW iface)
 155 {
 156     IDirectDrawImpl *This = ddraw_from_ddraw1(iface);
 157     ULONG ref = InterlockedDecrement(&This->ref1);
 158
 159     TRACE_(ddraw)("(%p)->() decrementing IDirectDraw refcount from %u.\n", This, ref +1);
 160
 161     if(ref == 0)
 162     {
 163         ULONG ifacecount = InterlockedDecrement(&This->numIfaces);
 164         if(ifacecount == 0) IDirectDrawImpl_Destroy(This);
 165     }
 166
 167     return ref;
 168 }
 169
 170 static ULONG WINAPI
 171 IDirectDraw2Impl_Release(LPDIRECTDRAW2 iface)
 172 {
 173     IDirectDrawImpl *This = ddraw_from_ddraw2(iface);
 174     ULONG ref = InterlockedDecrement(&This->ref2);
 175
 176     TRACE_(ddraw)("(%p)->() decrementing IDirectDraw2 refcount from %u.\n", This, ref +1);
 177
 178     if(ref == 0)
 179     {
 180         ULONG ifacecount = InterlockedDecrement(&This->numIfaces);
 181         if(ifacecount == 0) IDirectDrawImpl_Destroy(This);
 182     }
 183
 184     return ref;
 185 }
 186
 187 static ULONG WINAPI
 188 IDirectDraw3Impl_Release(LPDIRECTDRAW3 iface)
 189 {
 190     IDirectDrawImpl *This = ddraw_from_ddraw3(iface);
 191     ULONG ref = InterlockedDecrement(&This->ref3);
 192
 193     TRACE_(ddraw)("(%p)->() decrementing IDirectDraw3 refcount from %u.\n", This, ref +1);
 194
 195     if(ref == 0)
 196     {
 197         ULONG ifacecount = InterlockedDecrement(&This->numIfaces);
 198         if(ifacecount == 0) IDirectDrawImpl_Destroy(This);
 199     }
 200
 201     return ref;
 202 }
 203
 204 static ULONG WINAPI
 205 IDirectDraw4Impl_Release(LPDIRECTDRAW4 iface)
 206 {
 207     IDirectDrawImpl *This = ddraw_from_ddraw4(iface);
 208     ULONG ref = InterlockedDecrement(&This->ref4);
 209
 210     TRACE_(ddraw)("(%p)->() decrementing IDirectDraw4 refcount from %u.\n", This, ref +1);
 211
 212     if(ref == 0)
 213     {
 214         ULONG ifacecount = InterlockedDecrement(&This->numIfaces);
 215         if(ifacecount == 0) IDirectDrawImpl_Destroy(This);
 216     }
 217
 218     return ref;
 219 }
 220
 221 static HRESULT WINAPI
 222 IDirectDrawImpl_Compact(LPDIRECTDRAW This)
 223 {
 224     return IDirectDraw7_Compact(COM_INTERFACE_CAST(IDirectDrawImpl,
 225                                                    IDirectDraw, IDirectDraw7,
 226                                                    This));
 227 }
 228
 229 static HRESULT WINAPI
 230 IDirectDraw2Impl_Compact(LPDIRECTDRAW2 This)
 231 {
 232     return IDirectDraw7_Compact(COM_INTERFACE_CAST(IDirectDrawImpl,
 233                                                    IDirectDraw2, IDirectDraw7,
 234                                                    This));
 235 }
 236
 237     static HRESULT WINAPI
 238 IDirectDraw3Impl_Compact(LPDIRECTDRAW3 This)
 239 {
 240     return IDirectDraw7_Compact(COM_INTERFACE_CAST(IDirectDrawImpl,
 241                                                    IDirectDraw3, IDirectDraw7,
 242                                                    This));
 243 }
 244
 245 static HRESULT WINAPI
 246 IDirectDraw4Impl_Compact(LPDIRECTDRAW4 This)
 247 {
 248     return IDirectDraw7_Compact(COM_INTERFACE_CAST(IDirectDrawImpl,
 249                                                    IDirectDraw4, IDirectDraw7,
 250                                                    This));
 251 }
 252
 253 static HRESULT WINAPI
 254 IDirectDrawImpl_CreateClipper(LPDIRECTDRAW This, DWORD dwFlags,
 255                               LPDIRECTDRAWCLIPPER *ppClipper,
 256                               IUnknown *pUnkOuter)
 257 {
 258     return IDirectDraw7_CreateClipper(COM_INTERFACE_CAST(IDirectDrawImpl,
 259                                                          IDirectDraw,
 260                                                          IDirectDraw7,
 261                                                          This),
 262                                       dwFlags, ppClipper, pUnkOuter);
 263 }
 264
 265 static HRESULT WINAPI
 266 IDirectDraw2Impl_CreateClipper(LPDIRECTDRAW2 This, DWORD dwFlags,
 267                                LPDIRECTDRAWCLIPPER *ppClipper,
 268                                IUnknown *pUnkOuter)
 269 {
 270     return IDirectDraw7_CreateClipper(COM_INTERFACE_CAST(IDirectDrawImpl,
 271                                                          IDirectDraw2,
 272                                                          IDirectDraw7,
 273                                                          This),
 274                                       dwFlags, ppClipper, pUnkOuter);
 275 }
 276
 277 static HRESULT WINAPI
 278 IDirectDraw3Impl_CreateClipper(LPDIRECTDRAW3 This, DWORD dwFlags,
 279                                LPDIRECTDRAWCLIPPER *ppClipper,
 280                                IUnknown *pUnkOuter)
 281 {
 282     return IDirectDraw7_CreateClipper(COM_INTERFACE_CAST(IDirectDrawImpl,
 283                                                          IDirectDraw3,
 284                                                          IDirectDraw7,
 285                                                          This),
 286                                       dwFlags, ppClipper, pUnkOuter);
 287 }
 288
 289 static HRESULT WINAPI
 290 IDirectDraw4Impl_CreateClipper(LPDIRECTDRAW4 This, DWORD dwFlags,
 291                                LPDIRECTDRAWCLIPPER *ppClipper,
 292                                IUnknown *pUnkOuter)
 293 {
 294     return IDirectDraw7_CreateClipper(COM_INTERFACE_CAST(IDirectDrawImpl,
 295                                                          IDirectDraw4,
 296                                                          IDirectDraw7,
 297                                                          This),
 298                                       dwFlags, ppClipper, pUnkOuter);
 299 }
 300
 301 static HRESULT WINAPI
 302 IDirectDrawImpl_CreatePalette(LPDIRECTDRAW This, DWORD dwFlags,
 303                               LPPALETTEENTRY pEntries,
 304                               LPDIRECTDRAWPALETTE *ppPalette,
 305                               IUnknown *pUnkOuter)
 306 {
 307     HRESULT hr;
 308     hr = IDirectDraw7_CreatePalette(COM_INTERFACE_CAST(IDirectDrawImpl,
 309                                                          IDirectDraw,
 310                                                          IDirectDraw7,
 311                                                          This),
 312                                       dwFlags, pEntries, ppPalette, pUnkOuter);
 313     if(SUCCEEDED(hr) && *ppPalette)
 314     {
 315         IDirectDrawPaletteImpl *impl = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, *ppPalette);
 316         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 317                              IDirectDraw,
 318                              IDirectDraw7,
 319                              This));
 320         impl->ifaceToRelease = NULL;
 321
 322     }
 323     return hr;
 324 }
 325
 326 static HRESULT WINAPI
 327 IDirectDraw2Impl_CreatePalette(LPDIRECTDRAW2 This, DWORD dwFlags,
 328                                LPPALETTEENTRY pEntries,
 329                                LPDIRECTDRAWPALETTE *ppPalette,
 330                                IUnknown *pUnkOuter)
 331 {
 332     HRESULT hr;
 333     hr = IDirectDraw7_CreatePalette(COM_INTERFACE_CAST(IDirectDrawImpl,
 334                                                          IDirectDraw2,
 335                                                          IDirectDraw7,
 336                                                          This),
 337                                       dwFlags, pEntries, ppPalette, pUnkOuter);
 338     if(SUCCEEDED(hr) && *ppPalette)
 339     {
 340         IDirectDrawPaletteImpl *impl = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, *ppPalette);
 341         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 342                              IDirectDraw2,
 343                              IDirectDraw7,
 344                              This));
 345         impl->ifaceToRelease = NULL;
 346     }
 347     return hr;
 348 }
 349
 350 static HRESULT WINAPI
 351 IDirectDraw3Impl_CreatePalette(LPDIRECTDRAW3 This, DWORD dwFlags,
 352                                LPPALETTEENTRY pEntries,
 353                                LPDIRECTDRAWPALETTE *ppPalette,
 354                                IUnknown *pUnkOuter)
 355 {
 356     HRESULT hr;
 357     hr = IDirectDraw7_CreatePalette(COM_INTERFACE_CAST(IDirectDrawImpl,
 358                                                          IDirectDraw3,
 359                                                          IDirectDraw7,
 360                                                          This),
 361                                       dwFlags, pEntries, ppPalette, pUnkOuter);
 362     if(SUCCEEDED(hr) && *ppPalette)
 363     {
 364         IDirectDrawPaletteImpl *impl = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, *ppPalette);
 365         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 366                              IDirectDraw3,
 367                              IDirectDraw7,
 368                              This));
 369         IDirectDraw4_AddRef(This);
 370         impl->ifaceToRelease = (IUnknown *) This;
 371     }
 372     return hr;
 373 }
 374
 375 static HRESULT WINAPI
 376 IDirectDraw4Impl_CreatePalette(LPDIRECTDRAW4 This, DWORD dwFlags,
 377                                LPPALETTEENTRY pEntries,
 378                                LPDIRECTDRAWPALETTE *ppPalette,
 379                                IUnknown *pUnkOuter)
 380 {
 381     HRESULT hr;
 382     hr = IDirectDraw7_CreatePalette(COM_INTERFACE_CAST(IDirectDrawImpl,
 383                                                          IDirectDraw4,
 384                                                          IDirectDraw7,
 385                                                          This),
 386                                       dwFlags, pEntries, ppPalette, pUnkOuter);
 387     if(SUCCEEDED(hr) && *ppPalette)
 388     {
 389         IDirectDrawPaletteImpl *impl = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette, *ppPalette);
 390         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 391                              IDirectDraw4,
 392                              IDirectDraw7,
 393                              This));
 394         IDirectDraw4_AddRef(This);
 395         impl->ifaceToRelease = (IUnknown *) This;
 396     }
 397     return hr;
 398 }
 399
 400 /* Must set all attached surfaces (e.g. mipmaps) versions as well */
 401 static void set_surf_version(IDirectDrawSurfaceImpl *surf, int version)
 402 {
 403     int i;
 404     TRACE("%p->version(%d) = %d\n", surf, surf->version, version);
 405     surf->version = version;
 406     for(i = 0; i < MAX_COMPLEX_ATTACHED; i++)
 407     {
 408         if(!surf->complex_array[i]) break;
 409         set_surf_version(surf->complex_array[i], version);
 410     }
 411     while( (surf = surf->next_attached) )
 412     {
 413         set_surf_version(surf, version);
 414     }
 415 }
 416
 417 static HRESULT WINAPI
 418 IDirectDrawImpl_CreateSurface(LPDIRECTDRAW This, LPDDSURFACEDESC pSDesc,
 419                               LPDIRECTDRAWSURFACE *ppSurface,
 420                               IUnknown *pUnkOuter)
 421 {
 422     LPDIRECTDRAWSURFACE7 pSurface7;
 423     IDirectDrawSurfaceImpl *impl;
 424     HRESULT hr;
 425
 426     /* Remove front buffer flag, this causes failure in v7, and its added to normal
 427      * primaries anyway
 428      */
 429     pSDesc->ddsCaps.dwCaps &= ~DDSCAPS_FRONTBUFFER;
 430     /* the LPDDSURFACEDESC -> LPDDSURFACEDESC2 conversion should be ok,
 431      * since the data layout is the same */
 432     hr = IDirectDraw7_CreateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 433                                                        IDirectDraw,
 434                                                        IDirectDraw7,
 435                                                        This),
 436                                     (LPDDSURFACEDESC2)pSDesc, &pSurface7, pUnkOuter);
 437
 438     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 439      * IDirectDrawSurface vtable layout at the beginning  */
 440     *ppSurface = (LPDIRECTDRAWSURFACE) COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 441                                     IDirectDrawSurface7, IDirectDrawSurface3,
 442                                     pSurface7);
 443
 444     impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, pSurface7);
 445     if(SUCCEEDED(hr) && impl)
 446     {
 447         set_surf_version(impl, 1);
 448         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 449                              IDirectDraw,
 450                              IDirectDraw7,
 451                              This));
 452         impl->ifaceToRelease = NULL;
 453     }
 454
 455     return hr;
 456 }
 457
 458 static HRESULT WINAPI
 459 IDirectDraw2Impl_CreateSurface(LPDIRECTDRAW2 This, LPDDSURFACEDESC pSDesc,
 460                                LPDIRECTDRAWSURFACE *ppSurface,
 461                                IUnknown *pUnkOuter)
 462 {
 463     LPDIRECTDRAWSURFACE7 pSurface7;
 464     IDirectDrawSurfaceImpl *impl;
 465     HRESULT hr;
 466
 467     hr = IDirectDraw7_CreateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 468                                                        IDirectDraw2,
 469                                                        IDirectDraw7,
 470                                                        This),
 471                                     (LPDDSURFACEDESC2)pSDesc, &pSurface7, pUnkOuter);
 472
 473     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 474      * IDirectDrawSurface vtable layout at the beginning  */
 475     *ppSurface = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 476                                     IDirectDrawSurface7, IDirectDrawSurface3,
 477                                     pSurface7);
 478
 479     impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, pSurface7);
 480     if(SUCCEEDED(hr) && impl)
 481     {
 482         set_surf_version(impl, 2);
 483         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 484                              IDirectDraw2,
 485                              IDirectDraw7,
 486                              This));
 487         impl->ifaceToRelease = NULL;
 488     }
 489
 490     return hr;
 491 }
 492
 493 static HRESULT WINAPI
 494 IDirectDraw3Impl_CreateSurface(LPDIRECTDRAW3 This, LPDDSURFACEDESC pSDesc,
 495                                LPDIRECTDRAWSURFACE *ppSurface,
 496                                IUnknown *pUnkOuter)
 497 {
 498     LPDIRECTDRAWSURFACE7 pSurface7;
 499     IDirectDrawSurfaceImpl *impl;
 500     HRESULT hr;
 501
 502     hr = IDirectDraw7_CreateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 503                                                        IDirectDraw3,
 504                                                        IDirectDraw7,
 505                                                        This),
 506                                     (LPDDSURFACEDESC2)pSDesc, &pSurface7, pUnkOuter);
 507
 508     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 509      * IDirectDrawSurface vtable layout at the beginning  */
 510     *ppSurface = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 511                                     IDirectDrawSurface7, IDirectDrawSurface3,
 512                                     pSurface7);
 513
 514     impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, pSurface7);
 515     if(SUCCEEDED(hr) && impl)
 516     {
 517         set_surf_version(impl, 3);
 518         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 519                              IDirectDraw3,
 520                              IDirectDraw7,
 521                              This));
 522         IDirectDraw3_AddRef(This);
 523         impl->ifaceToRelease = (IUnknown *) This;
 524     }
 525
 526     return hr;
 527 }
 528
 529 static HRESULT WINAPI
 530 IDirectDraw4Impl_CreateSurface(LPDIRECTDRAW4 This, LPDDSURFACEDESC2 pSDesc,
 531                                LPDIRECTDRAWSURFACE4 *ppSurface,
 532                                IUnknown *pUnkOuter)
 533 {
 534     HRESULT hr;
 535     IDirectDrawSurfaceImpl *impl;
 536
 537     hr = IDirectDraw7_CreateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 538                                                        IDirectDraw4,
 539                                                        IDirectDraw7,
 540                                                         This),
 541                                     pSDesc,
 542                                     (LPDIRECTDRAWSURFACE7 *)ppSurface,
 543                                     pUnkOuter);
 544     impl = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7, *ppSurface);
 545     if(SUCCEEDED(hr) && impl)
 546     {
 547         set_surf_version(impl, 4);
 548         IDirectDraw7_Release(COM_INTERFACE_CAST(IDirectDrawImpl,
 549                              IDirectDraw4,
 550                              IDirectDraw7,
 551                              This));
 552         IDirectDraw4_AddRef(This);
 553         impl->ifaceToRelease = (IUnknown *) This;
 554     }
 555     return hr;
 556 }
 557
 558 static HRESULT WINAPI
 559 IDirectDrawImpl_DuplicateSurface(LPDIRECTDRAW This, LPDIRECTDRAWSURFACE pSrc,
 560                                  LPDIRECTDRAWSURFACE *ppDst)
 561 {
 562     LPDIRECTDRAWSURFACE7 pDst7;
 563     HRESULT hr;
 564
 565     hr = IDirectDraw7_DuplicateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 566                                                           IDirectDraw,
 567                                                           IDirectDraw7, This),
 568                                        COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 569                                                           IDirectDrawSurface3,
 570                                                           IDirectDrawSurface7,
 571                                                           pSrc),
 572                                        &pDst7);
 573
 574     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 575      * IDirectDrawSurface vtable layout at the beginning  */
 576     *ppDst = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 577                                 IDirectDrawSurface3, pDst7);
 578
 579     return hr;
 580 }
 581
 582 static HRESULT WINAPI
 583 IDirectDraw2Impl_DuplicateSurface(LPDIRECTDRAW2 This, LPDIRECTDRAWSURFACE pSrc,
 584                                   LPDIRECTDRAWSURFACE *ppDst)
 585 {
 586     LPDIRECTDRAWSURFACE7 pDst7;
 587     HRESULT hr;
 588
 589     hr = IDirectDraw7_DuplicateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 590                                                           IDirectDraw2,
 591                                                           IDirectDraw7, This),
 592                                        COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 593                                                           IDirectDrawSurface3,
 594                                                           IDirectDrawSurface7,
 595                                                           pSrc),
 596                                        &pDst7);
 597
 598     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 599      * IDirectDrawSurface vtable layout at the beginning  */
 600     *ppDst = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 601                                 IDirectDrawSurface3, pDst7);
 602
 603     return hr;
 604 }
 605
 606 static HRESULT WINAPI
 607 IDirectDraw3Impl_DuplicateSurface(LPDIRECTDRAW3 This, LPDIRECTDRAWSURFACE pSrc,
 608                                   LPDIRECTDRAWSURFACE *ppDst)
 609 {
 610     LPDIRECTDRAWSURFACE7 pDst7;
 611     HRESULT hr;
 612
 613     hr = IDirectDraw7_DuplicateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 614                                                           IDirectDraw3,
 615                                                           IDirectDraw7, This),
 616                                        COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 617                                                           IDirectDrawSurface3,
 618                                                           IDirectDrawSurface7,
 619                                                           pSrc),
 620                                        &pDst7);
 621
 622     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 623      * IDirectDrawSurface vtable layout at the beginning  */
 624     *ppDst = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 625                                 IDirectDrawSurface3, pDst7);
 626
 627     return hr;
 628 }
 629
 630 static HRESULT WINAPI
 631 IDirectDraw4Impl_DuplicateSurface(LPDIRECTDRAW4 This,
 632                                   LPDIRECTDRAWSURFACE4 pSrc,
 633                                   LPDIRECTDRAWSURFACE4 *ppDst)
 634 {
 635     return IDirectDraw7_DuplicateSurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 636                                                             IDirectDraw4,
 637                                                             IDirectDraw7,
 638                                                             This),
 639                                          (LPDIRECTDRAWSURFACE7)pSrc,
 640                                          (LPDIRECTDRAWSURFACE7 *)ppDst);
 641 }
 642
 643 struct displaymodescallback_context
 644 {
 645     LPDDENUMMODESCALLBACK func;
 646     LPVOID context;
 647 };
 648
 649 static HRESULT CALLBACK
 650 EnumDisplayModesCallbackThunk(LPDDSURFACEDESC2 pDDSD2, LPVOID context)
 651 {
 652     DDSURFACEDESC DDSD;
 653     struct displaymodescallback_context *cbcontext = context;
 654
 655     memcpy(&DDSD,pDDSD2,sizeof(DDSD));
 656     DDSD.dwSize = sizeof(DDSD);
 657
 658     return cbcontext->func(&DDSD, cbcontext->context);
 659 }
 660
 661 static HRESULT WINAPI
 662 IDirectDrawImpl_EnumDisplayModes(LPDIRECTDRAW This, DWORD dwFlags,
 663                                  LPDDSURFACEDESC pDDSD, LPVOID context,
 664                                  LPDDENUMMODESCALLBACK cb)
 665 {
 666     struct displaymodescallback_context cbcontext;
 667
 668     cbcontext.func    = cb;
 669     cbcontext.context = context;
 670
 671     return IDirectDraw7_EnumDisplayModes(COM_INTERFACE_CAST(IDirectDrawImpl,
 672                                                             IDirectDraw,
 673                                                             IDirectDraw7,
 674                                                             This),
 675                                          dwFlags, (LPDDSURFACEDESC2)pDDSD, &cbcontext,
 676                                          EnumDisplayModesCallbackThunk);
 677 }
 678
 679 static HRESULT WINAPI
 680 IDirectDraw2Impl_EnumDisplayModes(LPDIRECTDRAW2 This, DWORD dwFlags,
 681                                   LPDDSURFACEDESC pDDSD, LPVOID context,
 682                                   LPDDENUMMODESCALLBACK cb)
 683 {
 684     struct displaymodescallback_context cbcontext;
 685
 686     cbcontext.func    = cb;
 687     cbcontext.context = context;
 688
 689     return IDirectDraw7_EnumDisplayModes(COM_INTERFACE_CAST(IDirectDrawImpl,
 690                                                             IDirectDraw2,
 691                                                             IDirectDraw7,
 692                                                             This),
 693                                          dwFlags, (LPDDSURFACEDESC2)pDDSD, &cbcontext,
 694                                          EnumDisplayModesCallbackThunk);
 695 }
 696
 697 static HRESULT WINAPI
 698 IDirectDraw3Impl_EnumDisplayModes(LPDIRECTDRAW3 This, DWORD dwFlags,
 699                                   LPDDSURFACEDESC pDDSD, LPVOID context,
 700                                   LPDDENUMMODESCALLBACK cb)
 701 {
 702     struct displaymodescallback_context cbcontext;
 703
 704     cbcontext.func    = cb;
 705     cbcontext.context = context;
 706
 707     return IDirectDraw7_EnumDisplayModes(COM_INTERFACE_CAST(IDirectDrawImpl,
 708                                                             IDirectDraw3,
 709                                                             IDirectDraw7,
 710                                                             This),
 711                                          dwFlags, (LPDDSURFACEDESC2)pDDSD, &cbcontext,
 712                                          EnumDisplayModesCallbackThunk);
 713 }
 714
 715 static HRESULT WINAPI
 716 IDirectDraw4Impl_EnumDisplayModes(LPDIRECTDRAW4 This, DWORD dwFlags,
 717                                   LPDDSURFACEDESC2 pDDSD, LPVOID context,
 718                                   LPDDENUMMODESCALLBACK2 cb)
 719 {
 720     return IDirectDraw7_EnumDisplayModes(COM_INTERFACE_CAST(IDirectDrawImpl,
 721                                                             IDirectDraw4,
 722                                                             IDirectDraw7,
 723                                                             This),
 724                                          dwFlags, pDDSD, context, cb);
 725 }
 726
 727 struct surfacescallback_context
 728 {
 729     LPDDENUMSURFACESCALLBACK func;
 730     LPVOID context;
 731 };
 732
 733 static HRESULT CALLBACK
 734 EnumSurfacesCallbackThunk(LPDIRECTDRAWSURFACE7 pSurf, LPDDSURFACEDESC2 pDDSD,
 735                           LPVOID context)
 736 {
 737     struct surfacescallback_context *cbcontext = context;
 738
 739     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 740      * IDirectDrawSurface vtable layout at the beginning  */
 741     return cbcontext->func((LPDIRECTDRAWSURFACE)
 742                            COM_INTERFACE_CAST(IDirectDrawSurfaceImpl,
 743                                               IDirectDrawSurface7,
 744                                               IDirectDrawSurface3, pSurf),
 745                            (LPDDSURFACEDESC)pDDSD, cbcontext->context);
 746 }
 747
 748 static HRESULT WINAPI
 749 IDirectDrawImpl_EnumSurfaces(LPDIRECTDRAW This, DWORD dwFlags,
 750                              LPDDSURFACEDESC pDDSD, LPVOID context,
 751                              LPDDENUMSURFACESCALLBACK cb)
 752 {
 753     struct surfacescallback_context cbcontext;
 754
 755     cbcontext.func    = cb;
 756     cbcontext.context = context;
 757
 758     return IDirectDraw7_EnumSurfaces(COM_INTERFACE_CAST(IDirectDrawImpl,
 759                                                         IDirectDraw,
 760                                                         IDirectDraw7, This),
 761                                      dwFlags, (LPDDSURFACEDESC2)pDDSD,
 762                                      &cbcontext, EnumSurfacesCallbackThunk);
 763 }
 764
 765 static HRESULT WINAPI
 766 IDirectDraw2Impl_EnumSurfaces(LPDIRECTDRAW2 This, DWORD dwFlags,
 767                               LPDDSURFACEDESC pDDSD, LPVOID context,
 768                               LPDDENUMSURFACESCALLBACK cb)
 769 {
 770     struct surfacescallback_context cbcontext;
 771
 772     cbcontext.func    = cb;
 773     cbcontext.context = context;
 774
 775     return IDirectDraw7_EnumSurfaces(COM_INTERFACE_CAST(IDirectDrawImpl,
 776                                                         IDirectDraw2,
 777                                                         IDirectDraw7, This),
 778                                      dwFlags, (LPDDSURFACEDESC2)pDDSD,
 779                                      &cbcontext, EnumSurfacesCallbackThunk);
 780 }
 781
 782 static HRESULT WINAPI
 783 IDirectDraw3Impl_EnumSurfaces(LPDIRECTDRAW3 This, DWORD dwFlags,
 784                               LPDDSURFACEDESC pDDSD, LPVOID context,
 785                               LPDDENUMSURFACESCALLBACK cb)
 786 {
 787     struct surfacescallback_context cbcontext;
 788
 789     cbcontext.func    = cb;
 790     cbcontext.context = context;
 791
 792     return IDirectDraw7_EnumSurfaces(COM_INTERFACE_CAST(IDirectDrawImpl,
 793                                                         IDirectDraw3,
 794                                                         IDirectDraw7, This),
 795                                      dwFlags, (LPDDSURFACEDESC2)pDDSD,
 796                                      &cbcontext, EnumSurfacesCallbackThunk);
 797 }
 798
 799 static HRESULT WINAPI
 800 IDirectDraw4Impl_EnumSurfaces(LPDIRECTDRAW4 This, DWORD dwFlags,
 801                               LPDDSURFACEDESC2 pDDSD, LPVOID context,
 802                               LPDDENUMSURFACESCALLBACK2 cb)
 803 {
 804     return IDirectDraw7_EnumSurfaces(COM_INTERFACE_CAST(IDirectDrawImpl,
 805                                                         IDirectDraw4,
 806                                                         IDirectDraw7, This),
 807                                      dwFlags, pDDSD, context,
 808                                      (LPDDENUMSURFACESCALLBACK7)cb);
 809 }
 810
 811 static HRESULT WINAPI
 812 IDirectDrawImpl_FlipToGDISurface(LPDIRECTDRAW This)
 813 {
 814     return IDirectDraw7_FlipToGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 815                                                             IDirectDraw,
 816                                                             IDirectDraw7,
 817                                                             This));
 818 }
 819
 820 static HRESULT WINAPI
 821 IDirectDraw2Impl_FlipToGDISurface(LPDIRECTDRAW2 This)
 822 {
 823     return IDirectDraw7_FlipToGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 824                                                             IDirectDraw2,
 825                                                             IDirectDraw7,
 826                                                             This));
 827 }
 828
 829 static HRESULT WINAPI
 830 IDirectDraw3Impl_FlipToGDISurface(LPDIRECTDRAW3 This)
 831 {
 832     return IDirectDraw7_FlipToGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 833                                                             IDirectDraw3,
 834                                                             IDirectDraw7,
 835                                                             This));
 836 }
 837
 838 static HRESULT WINAPI
 839 IDirectDraw4Impl_FlipToGDISurface(LPDIRECTDRAW4 This)
 840 {
 841     return IDirectDraw7_FlipToGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 842                                                             IDirectDraw4,
 843                                                             IDirectDraw7,
 844                                                             This));
 845 }
 846
 847 static HRESULT WINAPI
 848 IDirectDrawImpl_GetCaps(LPDIRECTDRAW This, LPDDCAPS pDDC1, LPDDCAPS pDDC2)
 849 {
 850     return IDirectDraw7_GetCaps(COM_INTERFACE_CAST(IDirectDrawImpl,
 851                                                    IDirectDraw, IDirectDraw7,
 852                                                    This), pDDC1, pDDC2);
 853 }
 854
 855 static HRESULT WINAPI
 856 IDirectDraw2Impl_GetCaps(LPDIRECTDRAW2 This, LPDDCAPS pDDC1, LPDDCAPS pDDC2)
 857 {
 858     return IDirectDraw7_GetCaps(COM_INTERFACE_CAST(IDirectDrawImpl,
 859                                                    IDirectDraw2, IDirectDraw7,
 860                                                    This), pDDC1, pDDC2);
 861 }
 862
 863 static HRESULT WINAPI
 864 IDirectDraw3Impl_GetCaps(LPDIRECTDRAW3 This, LPDDCAPS pDDC1, LPDDCAPS pDDC2)
 865 {
 866     return IDirectDraw7_GetCaps(COM_INTERFACE_CAST(IDirectDrawImpl,
 867                                                    IDirectDraw3, IDirectDraw7,
 868                                                    This), pDDC1, pDDC2);
 869 }
 870
 871 static HRESULT WINAPI
 872 IDirectDraw4Impl_GetCaps(LPDIRECTDRAW4 This, LPDDCAPS pDDC1, LPDDCAPS pDDC2)
 873 {
 874     return IDirectDraw7_GetCaps(COM_INTERFACE_CAST(IDirectDrawImpl,
 875                                                    IDirectDraw4, IDirectDraw7,
 876                                                    This), pDDC1, pDDC2);
 877 }
 878
 879 static HRESULT WINAPI
 880 IDirectDrawImpl_GetDisplayMode(LPDIRECTDRAW This, LPDDSURFACEDESC pDDSD)
 881 {
 882     return IDirectDraw7_GetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
 883                                                           IDirectDraw,
 884                                                           IDirectDraw7, This),
 885                                        (LPDDSURFACEDESC2)pDDSD);
 886 }
 887
 888 static HRESULT WINAPI
 889 IDirectDraw2Impl_GetDisplayMode(LPDIRECTDRAW2 This, LPDDSURFACEDESC pDDSD)
 890 {
 891     return IDirectDraw7_GetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
 892                                                           IDirectDraw2,
 893                                                           IDirectDraw7, This),
 894                                        (LPDDSURFACEDESC2)pDDSD);
 895 }
 896
 897 static HRESULT WINAPI
 898 IDirectDraw3Impl_GetDisplayMode(LPDIRECTDRAW3 This, LPDDSURFACEDESC pDDSD)
 899 {
 900     return IDirectDraw7_GetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
 901                                                           IDirectDraw3,
 902                                                           IDirectDraw7, This),
 903                                        (LPDDSURFACEDESC2)pDDSD);
 904 }
 905
 906 static HRESULT WINAPI
 907 IDirectDraw4Impl_GetDisplayMode(LPDIRECTDRAW4 This, LPDDSURFACEDESC2 pDDSD)
 908 {
 909     return IDirectDraw7_GetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
 910                                                           IDirectDraw4,
 911                                                           IDirectDraw7, This),
 912                                        pDDSD);
 913 }
 914
 915 static HRESULT WINAPI
 916 IDirectDrawImpl_GetFourCCCodes(LPDIRECTDRAW This, LPDWORD lpNumCodes,
 917                                LPDWORD lpCodes)
 918 {
 919     return IDirectDraw7_GetFourCCCodes(COM_INTERFACE_CAST(IDirectDrawImpl,
 920                                                           IDirectDraw,
 921                                                           IDirectDraw7,
 922                                                           This),
 923                                        lpNumCodes, lpCodes);
 924 }
 925
 926 static HRESULT WINAPI
 927 IDirectDraw2Impl_GetFourCCCodes(LPDIRECTDRAW2 This, LPDWORD lpNumCodes,
 928                                 LPDWORD lpCodes)
 929 {
 930     return IDirectDraw7_GetFourCCCodes(COM_INTERFACE_CAST(IDirectDrawImpl,
 931                                                           IDirectDraw2,
 932                                                           IDirectDraw7,
 933                                                           This),
 934                                        lpNumCodes, lpCodes);
 935 }
 936
 937 static HRESULT WINAPI
 938 IDirectDraw3Impl_GetFourCCCodes(LPDIRECTDRAW3 This, LPDWORD lpNumCodes,
 939                                 LPDWORD lpCodes)
 940 {
 941     return IDirectDraw7_GetFourCCCodes(COM_INTERFACE_CAST(IDirectDrawImpl,
 942                                                           IDirectDraw3,
 943                                                           IDirectDraw7,
 944                                                           This),
 945                                        lpNumCodes, lpCodes);
 946 }
 947
 948 static HRESULT WINAPI
 949 IDirectDraw4Impl_GetFourCCCodes(LPDIRECTDRAW4 This, LPDWORD lpNumCodes,
 950                                 LPDWORD lpCodes)
 951 {
 952     return IDirectDraw7_GetFourCCCodes(COM_INTERFACE_CAST(IDirectDrawImpl,
 953                                                           IDirectDraw4,
 954                                                           IDirectDraw7,
 955                                                           This),
 956                                        lpNumCodes, lpCodes);
 957 }
 958
 959 static HRESULT WINAPI
 960 IDirectDrawImpl_GetGDISurface(LPDIRECTDRAW This, LPDIRECTDRAWSURFACE *ppSurf)
 961 {
 962     LPDIRECTDRAWSURFACE7 pSurf7;
 963     HRESULT hr;
 964
 965     hr = IDirectDraw7_GetGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 966                                                        IDirectDraw,
 967                                                        IDirectDraw7,
 968                                                        This), &pSurf7);
 969
 970     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 971      * IDirectDrawSurface vtable layout at the beginning  */
 972     *ppSurf = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 973                                  IDirectDrawSurface3, pSurf7);
 974
 975     return hr;
 976 }
 977
 978 static HRESULT WINAPI
 979 IDirectDraw2Impl_GetGDISurface(LPDIRECTDRAW2 This, LPDIRECTDRAWSURFACE *ppSurf)
 980 {
 981     LPDIRECTDRAWSURFACE7 pSurf7;
 982     HRESULT hr;
 983
 984     hr = IDirectDraw7_GetGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
 985                                                        IDirectDraw2,
 986                                                        IDirectDraw7,
 987                                                        This), &pSurf7);
 988
 989     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
 990      * IDirectDrawSurface vtable layout at the beginning  */
 991     *ppSurf = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 992                                  IDirectDrawSurface3, pSurf7);
 993
 994     return hr;
 995 }
 996
 997 static HRESULT WINAPI
 998 IDirectDraw3Impl_GetGDISurface(LPDIRECTDRAW3 This, LPDIRECTDRAWSURFACE *ppSurf)
 999 {
1000     LPDIRECTDRAWSURFACE7 pSurf7;
1001     HRESULT hr;
1002
1003     hr = IDirectDraw7_GetGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
1004                                                        IDirectDraw3,
1005                                                        IDirectDraw7,
1006                                                        This), &pSurf7);
1007
1008     /* This coercion is safe, since the IDirectDrawSurface3 vtable has the
1009      * IDirectDrawSurface vtable layout at the beginning  */
1010     *ppSurf = (LPDIRECTDRAWSURFACE)COM_INTERFACE_CAST(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
1011                                  IDirectDrawSurface3, pSurf7);
1012
1013     return hr;
1014 }
1015
1016 static HRESULT WINAPI
1017 IDirectDraw4Impl_GetGDISurface(LPDIRECTDRAW4 This,
1018                                LPDIRECTDRAWSURFACE4 *ppSurf)
1019 {
1020     return IDirectDraw7_GetGDISurface(COM_INTERFACE_CAST(IDirectDrawImpl,
1021                                                          IDirectDraw4,
1022                                                          IDirectDraw7,
1023                                                          This),
1024                                       (LPDIRECTDRAWSURFACE7 *)ppSurf);
1025 }
1026
1027 static HRESULT WINAPI
1028 IDirectDrawImpl_GetMonitorFrequency(LPDIRECTDRAW This, LPDWORD pdwFreq)
1029 {
1030     return IDirectDraw7_GetMonitorFrequency(COM_INTERFACE_CAST(IDirectDrawImpl,
1031                                                                IDirectDraw,
1032                                                                IDirectDraw7,
1033                                                                This),
1034                                             pdwFreq);
1035 }
1036
1037 static HRESULT WINAPI
1038 IDirectDraw2Impl_GetMonitorFrequency(LPDIRECTDRAW2 This, LPDWORD pdwFreq)
1039 {
1040     return IDirectDraw7_GetMonitorFrequency(COM_INTERFACE_CAST(IDirectDrawImpl,
1041                                                                IDirectDraw2,
1042                                                                IDirectDraw7,
1043                                                                This),
1044                                             pdwFreq);
1045 }
1046
1047 static HRESULT WINAPI
1048 IDirectDraw3Impl_GetMonitorFrequency(LPDIRECTDRAW3 This, LPDWORD pdwFreq)
1049 {
1050     return IDirectDraw7_GetMonitorFrequency(COM_INTERFACE_CAST(IDirectDrawImpl,
1051                                                                IDirectDraw3,
1052                                                                IDirectDraw7,
1053                                                                This),
1054                                             pdwFreq);
1055 }
1056
1057 static HRESULT WINAPI
1058 IDirectDraw4Impl_GetMonitorFrequency(LPDIRECTDRAW4 This, LPDWORD pdwFreq)
1059 {
1060     return IDirectDraw7_GetMonitorFrequency(COM_INTERFACE_CAST(IDirectDrawImpl,
1061                                                                IDirectDraw4,
1062                                                                IDirectDraw7,
1063                                                                This),
1064                                             pdwFreq);
1065 }
1066
1067 static HRESULT WINAPI
1068 IDirectDrawImpl_GetScanLine(LPDIRECTDRAW This, LPDWORD pdwLine)
1069 {
1070     return IDirectDraw7_GetScanLine(COM_INTERFACE_CAST(IDirectDrawImpl,
1071                                                        IDirectDraw,
1072                                                        IDirectDraw7,
1073                                                        This), pdwLine);
1074 }
1075
1076 static HRESULT WINAPI
1077 IDirectDraw2Impl_GetScanLine(LPDIRECTDRAW2 This, LPDWORD pdwLine)
1078 {
1079     return IDirectDraw7_GetScanLine(COM_INTERFACE_CAST(IDirectDrawImpl,
1080                                                        IDirectDraw2,
1081                                                        IDirectDraw7,
1082                                                        This), pdwLine);
1083 }
1084
1085 static HRESULT WINAPI
1086 IDirectDraw3Impl_GetScanLine(LPDIRECTDRAW3 This, LPDWORD pdwLine)
1087 {
1088     return IDirectDraw7_GetScanLine(COM_INTERFACE_CAST(IDirectDrawImpl,
1089                                                        IDirectDraw3,
1090                                                        IDirectDraw7,
1091                                                        This), pdwLine);
1092 }
1093
1094 static HRESULT WINAPI
1095 IDirectDraw4Impl_GetScanLine(LPDIRECTDRAW4 This, LPDWORD pdwLine)
1096 {
1097     return IDirectDraw7_GetScanLine(COM_INTERFACE_CAST(IDirectDrawImpl,
1098                                                        IDirectDraw4,
1099                                                        IDirectDraw7,
1100                                                        This), pdwLine);
1101 }
1102
1103 static HRESULT WINAPI
1104 IDirectDrawImpl_GetVerticalBlankStatus(LPDIRECTDRAW This, LPBOOL lpbIsInVB)
1105 {
1106     return IDirectDraw7_GetVerticalBlankStatus(COM_INTERFACE_CAST(IDirectDrawImpl,
1107                                                                   IDirectDraw,
1108                                                                   IDirectDraw7,
1109                                                                   This),
1110                                                lpbIsInVB);
1111 }
1112
1113 static HRESULT WINAPI
1114 IDirectDraw2Impl_GetVerticalBlankStatus(LPDIRECTDRAW2 This, LPBOOL lpbIsInVB)
1115 {
1116     return IDirectDraw7_GetVerticalBlankStatus(COM_INTERFACE_CAST(IDirectDrawImpl,
1117                                                                   IDirectDraw2,
1118                                                                   IDirectDraw7,
1119                                                                   This),
1120                                                lpbIsInVB);
1121 }
1122
1123 static HRESULT WINAPI
1124 IDirectDraw3Impl_GetVerticalBlankStatus(LPDIRECTDRAW3 This, LPBOOL lpbIsInVB)
1125 {
1126     return IDirectDraw7_GetVerticalBlankStatus(COM_INTERFACE_CAST(IDirectDrawImpl,
1127                                                                   IDirectDraw3,
1128                                                                   IDirectDraw7,
1129                                                                   This),
1130                                                lpbIsInVB);
1131 }
1132
1133 static HRESULT WINAPI
1134 IDirectDraw4Impl_GetVerticalBlankStatus(LPDIRECTDRAW4 This, LPBOOL lpbIsInVB)
1135 {
1136     return IDirectDraw7_GetVerticalBlankStatus(COM_INTERFACE_CAST(IDirectDrawImpl,
1137                                                                   IDirectDraw4,
1138                                                                   IDirectDraw7,
1139                                                                   This),
1140                                                lpbIsInVB);
1141 }
1142
1143 static HRESULT WINAPI
1144 IDirectDrawImpl_Initialize(LPDIRECTDRAW iface, LPGUID pGUID)
1145 {
1146     IDirectDrawImpl *This = ddraw_from_ddraw1(iface);
1147     HRESULT ret_value;
1148
1149     ret_value = IDirectDraw7_Initialize((IDirectDraw7 *)This, pGUID);
1150
1151     return ret_value;
1152 }
1153
1154 static HRESULT WINAPI
1155 IDirectDraw2Impl_Initialize(LPDIRECTDRAW2 iface, LPGUID pGUID)
1156 {
1157     IDirectDrawImpl *This = ddraw_from_ddraw2(iface);
1158     HRESULT ret_value;
1159
1160     ret_value = IDirectDraw7_Initialize((IDirectDraw7 *)This, pGUID);
1161
1162     return ret_value;
1163 }
1164
1165 static HRESULT WINAPI
1166 IDirectDraw3Impl_Initialize(LPDIRECTDRAW3 iface, LPGUID pGUID)
1167 {
1168     IDirectDrawImpl *This = ddraw_from_ddraw3(iface);
1169     HRESULT ret_value;
1170
1171     ret_value = IDirectDraw7_Initialize((IDirectDraw7 *)This, pGUID);
1172
1173     return ret_value;
1174 }
1175
1176 static HRESULT WINAPI
1177 IDirectDraw4Impl_Initialize(LPDIRECTDRAW4 iface, LPGUID pGUID)
1178 {
1179     IDirectDrawImpl *This = ddraw_from_ddraw4(iface);
1180     HRESULT ret_value;
1181
1182     ret_value = IDirectDraw7_Initialize((IDirectDraw7 *)This, pGUID);
1183
1184     return ret_value;
1185 }
1186
1187
1188 static HRESULT WINAPI
1189 IDirectDrawImpl_RestoreDisplayMode(LPDIRECTDRAW This)
1190 {
1191     return IDirectDraw7_RestoreDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1192                                                               IDirectDraw,
1193                                                               IDirectDraw7,
1194                                                               This));
1195 }
1196
1197 static HRESULT WINAPI
1198 IDirectDraw2Impl_RestoreDisplayMode(LPDIRECTDRAW2 This)
1199 {
1200     return IDirectDraw7_RestoreDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1201                                                               IDirectDraw2,
1202                                                               IDirectDraw7,
1203                                                               This));
1204 }
1205
1206 static HRESULT WINAPI
1207 IDirectDraw3Impl_RestoreDisplayMode(LPDIRECTDRAW3 This)
1208 {
1209     return IDirectDraw7_RestoreDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1210                                                               IDirectDraw3,
1211                                                               IDirectDraw7,
1212                                                               This));
1213 }
1214
1215 static HRESULT WINAPI
1216 IDirectDraw4Impl_RestoreDisplayMode(LPDIRECTDRAW4 This)
1217 {
1218     return IDirectDraw7_RestoreDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1219                                                               IDirectDraw4,
1220                                                               IDirectDraw7,
1221                                                               This));
1222 }
1223
1224 static HRESULT WINAPI
1225 IDirectDrawImpl_SetCooperativeLevel(LPDIRECTDRAW This, HWND hWnd,
1226                                     DWORD dwFlags)
1227 {
1228     return IDirectDraw7_SetCooperativeLevel(COM_INTERFACE_CAST(IDirectDrawImpl,
1229                                                                IDirectDraw,
1230                                                                IDirectDraw7,
1231                                                                This),
1232                                             hWnd, dwFlags);
1233 }
1234
1235 static HRESULT WINAPI
1236 IDirectDraw2Impl_SetCooperativeLevel(LPDIRECTDRAW2 This, HWND hWnd,
1237                                      DWORD dwFlags)
1238 {
1239     return IDirectDraw7_SetCooperativeLevel(COM_INTERFACE_CAST(IDirectDrawImpl,
1240                                                                IDirectDraw2,
1241                                                                IDirectDraw7,
1242                                                                This),
1243                                             hWnd, dwFlags);
1244 }
1245
1246 static HRESULT WINAPI
1247 IDirectDraw3Impl_SetCooperativeLevel(LPDIRECTDRAW3 This, HWND hWnd,
1248                                      DWORD dwFlags)
1249 {
1250     return IDirectDraw7_SetCooperativeLevel(COM_INTERFACE_CAST(IDirectDrawImpl,
1251                                                                IDirectDraw3,
1252                                                                IDirectDraw7,
1253                                                                This),
1254                                             hWnd, dwFlags);
1255 }
1256
1257 static HRESULT WINAPI
1258 IDirectDraw4Impl_SetCooperativeLevel(LPDIRECTDRAW4 This, HWND hWnd,
1259                                      DWORD dwFlags)
1260 {
1261     return IDirectDraw7_SetCooperativeLevel(COM_INTERFACE_CAST(IDirectDrawImpl,
1262                                                                IDirectDraw4,
1263                                                                IDirectDraw7,
1264                                                                This),
1265                                             hWnd, dwFlags);
1266 }
1267
1268 static HRESULT WINAPI
1269 IDirectDrawImpl_SetDisplayMode(LPDIRECTDRAW This, DWORD a, DWORD b, DWORD c)
1270 {
1271     return IDirectDraw7_SetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1272                                                           IDirectDraw,
1273                                                           IDirectDraw7,
1274                                                           This),
1275                                        a, b, c, 0, 0);
1276 }
1277
1278 static HRESULT WINAPI
1279 IDirectDraw2Impl_SetDisplayMode(LPDIRECTDRAW2 This, DWORD a, DWORD b, DWORD c,
1280                                 DWORD d, DWORD e)
1281 {
1282     return IDirectDraw7_SetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1283                                                           IDirectDraw2,
1284                                                           IDirectDraw7,
1285                                                           This),
1286                                        a, b, c, d, e);
1287 }
1288
1289 static HRESULT WINAPI
1290 IDirectDraw3Impl_SetDisplayMode(LPDIRECTDRAW3 This, DWORD a, DWORD b, DWORD c,
1291                                 DWORD d, DWORD e)
1292 {
1293     return IDirectDraw7_SetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1294                                                           IDirectDraw3,
1295                                                           IDirectDraw7,
1296                                                           This),
1297                                        a, b, c, d, e);
1298 }
1299
1300 static HRESULT WINAPI
1301 IDirectDraw4Impl_SetDisplayMode(LPDIRECTDRAW4 This, DWORD a, DWORD b, DWORD c,
1302                                 DWORD d, DWORD e)
1303 {
1304     return IDirectDraw7_SetDisplayMode(COM_INTERFACE_CAST(IDirectDrawImpl,
1305                                                           IDirectDraw4,
1306                                                           IDirectDraw7,
1307                                                           This),
1308                                        a, b, c, d, e);
1309 }
1310
1311 static HRESULT WINAPI
1312 IDirectDrawImpl_WaitForVerticalBlank(LPDIRECTDRAW This, DWORD dwFlags,
1313                                      HANDLE hEvent)
1314 {
1315     return IDirectDraw7_WaitForVerticalBlank(COM_INTERFACE_CAST(IDirectDrawImpl,
1316                                                                 IDirectDraw,
1317                                                                 IDirectDraw7,
1318                                                                 This),
1319                                              dwFlags, hEvent);
1320 }
1321
1322 static HRESULT WINAPI
1323 IDirectDraw2Impl_WaitForVerticalBlank(LPDIRECTDRAW2 This, DWORD dwFlags,
1324                                       HANDLE hEvent)
1325 {
1326     return IDirectDraw7_WaitForVerticalBlank(COM_INTERFACE_CAST(IDirectDrawImpl,
1327                                                                 IDirectDraw2,
1328                                                                 IDirectDraw7,
1329                                                                 This),
1330                                              dwFlags, hEvent);
1331 }
1332
1333 static HRESULT WINAPI
1334 IDirectDraw3Impl_WaitForVerticalBlank(LPDIRECTDRAW3 This, DWORD dwFlags,
1335                                       HANDLE hEvent)
1336 {
1337     return IDirectDraw7_WaitForVerticalBlank(COM_INTERFACE_CAST(IDirectDrawImpl,
1338                                                                 IDirectDraw3,
1339                                                                 IDirectDraw7,
1340                                                                 This),
1341                                              dwFlags, hEvent);
1342 }
1343
1344 static HRESULT WINAPI
1345 IDirectDraw4Impl_WaitForVerticalBlank(LPDIRECTDRAW4 This, DWORD dwFlags,
1346                                       HANDLE hEvent)
1347 {
1348     return IDirectDraw7_WaitForVerticalBlank(COM_INTERFACE_CAST(IDirectDrawImpl,
1349                                                                 IDirectDraw4,
1350                                                                 IDirectDraw7,
1351                                                                 This),
1352                                              dwFlags, hEvent);
1353 }
1354
1355 static HRESULT WINAPI
1356 IDirectDraw2Impl_GetAvailableVidMem(LPDIRECTDRAW2 This, LPDDSCAPS pCaps,
1357                                     LPDWORD pdwTotal, LPDWORD pdwFree)
1358 {
1359     DDSCAPS2 Caps2;
1360     DDRAW_Convert_DDSCAPS_1_To_2(pCaps, &Caps2);
1361
1362     return IDirectDraw7_GetAvailableVidMem(COM_INTERFACE_CAST(IDirectDrawImpl,
1363                                                               IDirectDraw2,
1364                                                               IDirectDraw7,
1365                                                               This),
1366                                            &Caps2, pdwTotal, pdwFree);
1367 }
1368
1369 static HRESULT WINAPI
1370 IDirectDraw3Impl_GetAvailableVidMem(LPDIRECTDRAW3 This, LPDDSCAPS pCaps,
1371                                     LPDWORD pdwTotal, LPDWORD pdwFree)
1372 {
1373     DDSCAPS2 Caps2;
1374     DDRAW_Convert_DDSCAPS_1_To_2(pCaps, &Caps2);
1375
1376     return IDirectDraw7_GetAvailableVidMem(COM_INTERFACE_CAST(IDirectDrawImpl,
1377                                                               IDirectDraw3,
1378                                                               IDirectDraw7,
1379                                                               This),
1380                                            &Caps2, pdwTotal, pdwFree);
1381 }
1382
1383 static HRESULT WINAPI
1384 IDirectDraw4Impl_GetAvailableVidMem(LPDIRECTDRAW4 This, LPDDSCAPS2 pCaps,
1385                                     LPDWORD pdwTotal, LPDWORD pdwFree)
1386 {
1387     return IDirectDraw7_GetAvailableVidMem(COM_INTERFACE_CAST(IDirectDrawImpl,
1388                                                               IDirectDraw4,
1389                                                               IDirectDraw7,
1390                                                               This),
1391                                            pCaps, pdwTotal, pdwFree);
1392 }
1393
1394 static HRESULT WINAPI
1395 IDirectDraw3Impl_GetSurfaceFromDC(LPDIRECTDRAW3 This, HDC hDC,
1396                                   LPDIRECTDRAWSURFACE *pSurf)
1397 {
1398     return IDirectDraw7_GetSurfaceFromDC(COM_INTERFACE_CAST(IDirectDrawImpl,
1399                                                             IDirectDraw3,
1400                                                             IDirectDraw7,
1401                                                             This),
1402                                          hDC, (LPDIRECTDRAWSURFACE7 *)pSurf);
1403 }
1404
1405 static HRESULT WINAPI
1406 IDirectDraw4Impl_GetSurfaceFromDC(LPDIRECTDRAW4 This, HDC hDC,
1407                                   LPDIRECTDRAWSURFACE4 *pSurf)
1408 {
1409     return IDirectDraw7_GetSurfaceFromDC(COM_INTERFACE_CAST(IDirectDrawImpl,
1410                                                             IDirectDraw4,
1411                                                             IDirectDraw7,
1412                                                             This),
1413                                          hDC, (LPDIRECTDRAWSURFACE7 *)pSurf);
1414 }
1415
1416 static HRESULT WINAPI
1417 IDirectDraw4Impl_RestoreAllSurfaces(LPDIRECTDRAW4 This)
1418 {
1419     return IDirectDraw7_RestoreAllSurfaces(COM_INTERFACE_CAST(IDirectDrawImpl,
1420                                                               IDirectDraw4,
1421                                                               IDirectDraw7,
1422                                                               This));
1423 }
1424
1425 static HRESULT WINAPI
1426 IDirectDraw4Impl_TestCooperativeLevel(LPDIRECTDRAW4 This)
1427 {
1428     return IDirectDraw7_TestCooperativeLevel(COM_INTERFACE_CAST(IDirectDrawImpl,
1429                                                                 IDirectDraw4,
1430                                                                 IDirectDraw7,
1431                                                                 This));
1432 }
1433
1434 static HRESULT WINAPI
1435 IDirectDraw4Impl_GetDeviceIdentifier(LPDIRECTDRAW4 This,
1436                                      LPDDDEVICEIDENTIFIER pDDDI, DWORD dwFlags)
1437 {
1438     DDDEVICEIDENTIFIER2 DDDI2;
1439     HRESULT hr;
1440
1441     hr = IDirectDraw7_GetDeviceIdentifier(COM_INTERFACE_CAST(IDirectDrawImpl,
1442                                                              IDirectDraw4,
1443                                                              IDirectDraw7,
1444                                                              This),
1445                                           &DDDI2, dwFlags);
1446
1447     DDRAW_Convert_DDDEVICEIDENTIFIER_2_To_1(&DDDI2, pDDDI);
1448
1449     return hr;
1450 }
1451
1452 const IDirectDrawVtbl IDirectDraw1_Vtbl =
1453 {
1454     IDirectDrawImpl_QueryInterface,
1455     IDirectDrawImpl_AddRef,
1456     IDirectDrawImpl_Release,
1457     IDirectDrawImpl_Compact,
1458     IDirectDrawImpl_CreateClipper,
1459     IDirectDrawImpl_CreatePalette,
1460     IDirectDrawImpl_CreateSurface,
1461     IDirectDrawImpl_DuplicateSurface,
1462     IDirectDrawImpl_EnumDisplayModes,
1463     IDirectDrawImpl_EnumSurfaces,
1464     IDirectDrawImpl_FlipToGDISurface,
1465     IDirectDrawImpl_GetCaps,
1466     IDirectDrawImpl_GetDisplayMode,
1467     IDirectDrawImpl_GetFourCCCodes,
1468     IDirectDrawImpl_GetGDISurface,
1469     IDirectDrawImpl_GetMonitorFrequency,
1470     IDirectDrawImpl_GetScanLine,
1471     IDirectDrawImpl_GetVerticalBlankStatus,
1472     IDirectDrawImpl_Initialize,
1473     IDirectDrawImpl_RestoreDisplayMode,
1474     IDirectDrawImpl_SetCooperativeLevel,
1475     IDirectDrawImpl_SetDisplayMode,
1476     IDirectDrawImpl_WaitForVerticalBlank,
1477 };
1478
1479 const IDirectDraw2Vtbl IDirectDraw2_Vtbl =
1480 {
1481     IDirectDraw2Impl_QueryInterface,
1482     IDirectDraw2Impl_AddRef,
1483     IDirectDraw2Impl_Release,
1484     IDirectDraw2Impl_Compact,
1485     IDirectDraw2Impl_CreateClipper,
1486     IDirectDraw2Impl_CreatePalette,
1487     IDirectDraw2Impl_CreateSurface,
1488     IDirectDraw2Impl_DuplicateSurface,
1489     IDirectDraw2Impl_EnumDisplayModes,
1490     IDirectDraw2Impl_EnumSurfaces,
1491     IDirectDraw2Impl_FlipToGDISurface,
1492     IDirectDraw2Impl_GetCaps,
1493     IDirectDraw2Impl_GetDisplayMode,
1494     IDirectDraw2Impl_GetFourCCCodes,
1495     IDirectDraw2Impl_GetGDISurface,
1496     IDirectDraw2Impl_GetMonitorFrequency,
1497     IDirectDraw2Impl_GetScanLine,
1498     IDirectDraw2Impl_GetVerticalBlankStatus,
1499     IDirectDraw2Impl_Initialize,
1500     IDirectDraw2Impl_RestoreDisplayMode,
1501     IDirectDraw2Impl_SetCooperativeLevel,
1502     IDirectDraw2Impl_SetDisplayMode,
1503     IDirectDraw2Impl_WaitForVerticalBlank,
1504     IDirectDraw2Impl_GetAvailableVidMem
1505 };
1506
1507 const IDirectDraw3Vtbl IDirectDraw3_Vtbl =
1508 {
1509     IDirectDraw3Impl_QueryInterface,
1510     IDirectDraw3Impl_AddRef,
1511     IDirectDraw3Impl_Release,
1512     IDirectDraw3Impl_Compact,
1513     IDirectDraw3Impl_CreateClipper,
1514     IDirectDraw3Impl_CreatePalette,
1515     IDirectDraw3Impl_CreateSurface,
1516     IDirectDraw3Impl_DuplicateSurface,
1517     IDirectDraw3Impl_EnumDisplayModes,
1518     IDirectDraw3Impl_EnumSurfaces,
1519     IDirectDraw3Impl_FlipToGDISurface,
1520     IDirectDraw3Impl_GetCaps,
1521     IDirectDraw3Impl_GetDisplayMode,
1522     IDirectDraw3Impl_GetFourCCCodes,
1523     IDirectDraw3Impl_GetGDISurface,
1524     IDirectDraw3Impl_GetMonitorFrequency,
1525     IDirectDraw3Impl_GetScanLine,
1526     IDirectDraw3Impl_GetVerticalBlankStatus,
1527     IDirectDraw3Impl_Initialize,
1528     IDirectDraw3Impl_RestoreDisplayMode,
1529     IDirectDraw3Impl_SetCooperativeLevel,
1530     IDirectDraw3Impl_SetDisplayMode,
1531     IDirectDraw3Impl_WaitForVerticalBlank,
1532     IDirectDraw3Impl_GetAvailableVidMem,
1533     IDirectDraw3Impl_GetSurfaceFromDC,
1534 };
1535
1536 const IDirectDraw4Vtbl IDirectDraw4_Vtbl =
1537 {
1538     IDirectDraw4Impl_QueryInterface,
1539     IDirectDraw4Impl_AddRef,
1540     IDirectDraw4Impl_Release,
1541     IDirectDraw4Impl_Compact,
1542     IDirectDraw4Impl_CreateClipper,
1543     IDirectDraw4Impl_CreatePalette,
1544     IDirectDraw4Impl_CreateSurface,
1545     IDirectDraw4Impl_DuplicateSurface,
1546     IDirectDraw4Impl_EnumDisplayModes,
1547     IDirectDraw4Impl_EnumSurfaces,
1548     IDirectDraw4Impl_FlipToGDISurface,
1549     IDirectDraw4Impl_GetCaps,
1550     IDirectDraw4Impl_GetDisplayMode,
1551     IDirectDraw4Impl_GetFourCCCodes,
1552     IDirectDraw4Impl_GetGDISurface,
1553     IDirectDraw4Impl_GetMonitorFrequency,
1554     IDirectDraw4Impl_GetScanLine,
1555     IDirectDraw4Impl_GetVerticalBlankStatus,
1556     IDirectDraw4Impl_Initialize,
1557     IDirectDraw4Impl_RestoreDisplayMode,
1558     IDirectDraw4Impl_SetCooperativeLevel,
1559     IDirectDraw4Impl_SetDisplayMode,
1560     IDirectDraw4Impl_WaitForVerticalBlank,
1561     IDirectDraw4Impl_GetAvailableVidMem,
1562     IDirectDraw4Impl_GetSurfaceFromDC,
1563     IDirectDraw4Impl_RestoreAllSurfaces,
1564     IDirectDraw4Impl_TestCooperativeLevel,
1565     IDirectDraw4Impl_GetDeviceIdentifier
1566 };