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