dlls/ddraw/dsurface/main.c

   1 /*              DirectDrawSurface base implementation
   2  *
   3  * Copyright 1997-2000 Marcus Meissner
   4  * Copyright 1998-2000 Lionel Ulmer (most of Direct3D stuff)
   5  * Copyright 2000-2001 TransGaming Technologies Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21 #include "config.h"
  22
  23 #include <assert.h>
  24 #include <string.h>
  25
  26 #define NONAMELESSUNION
  27 #define NONAMELESSSTRUCT
  28 #include "winerror.h"
  29 #include "mesa_private.h"
  30 #include "wine/debug.h"
  31 #include "ddraw_private.h"
  32 #include "dsurface/main.h"
  33 #include "ddraw/main.h"
  34 #include "dsurface/thunks.h"
  35
  36 WINE_DEFAULT_DEBUG_CHANNEL(ddraw);
  37
  38 /** Creation/Destruction functions */
  39
  40 HRESULT
  41 Main_DirectDrawSurface_Construct(IDirectDrawSurfaceImpl *This,
  42                                  IDirectDrawImpl *pDD,
  43                                  const DDSURFACEDESC2 *pDDSD)
  44 {
  45     TRACE("(%p)->(%p,%p)\n", This, pDD, pDDSD);
  46
  47     if (pDDSD != &This->surface_desc) {
  48         This->surface_desc.dwSize = sizeof(This->surface_desc);
  49         DD_STRUCT_COPY_BYSIZE(&(This->surface_desc),pDDSD);
  50     }
  51     This->uniqueness_value = 1; /* unchecked */
  52     This->ref = 1;
  53
  54     This->local.lpSurfMore = &This->more;
  55     This->local.lpGbl = &This->global;
  56     This->local.dwProcessId = GetCurrentProcessId();
  57     This->local.dwFlags = 0; /* FIXME */
  58     This->local.ddsCaps.dwCaps = This->surface_desc.ddsCaps.dwCaps;
  59     /* FIXME: more local stuff */
  60     This->more.lpDD_lcl = &pDD->local;
  61     This->more.ddsCapsEx.dwCaps2 = This->surface_desc.ddsCaps.dwCaps2;
  62     This->more.ddsCapsEx.dwCaps3 = This->surface_desc.ddsCaps.dwCaps3;
  63     This->more.ddsCapsEx.dwCaps4 = This->surface_desc.ddsCaps.dwCaps4;
  64     /* FIXME: more more stuff */
  65     This->gmore = &This->global_more;
  66     This->global.u3.lpDD = pDD->local.lpGbl;
  67     /* FIXME: more global stuff */
  68
  69     This->final_release = Main_DirectDrawSurface_final_release;
  70     This->late_allocate = Main_DirectDrawSurface_late_allocate;
  71     This->attach = Main_DirectDrawSurface_attach;
  72     This->detach = Main_DirectDrawSurface_detach;
  73     This->lock_update = Main_DirectDrawSurface_lock_update;
  74     This->unlock_update = Main_DirectDrawSurface_unlock_update;
  75     This->lose_surface = Main_DirectDrawSurface_lose_surface;
  76     This->set_palette    = Main_DirectDrawSurface_set_palette;
  77     This->update_palette = Main_DirectDrawSurface_update_palette;
  78     This->get_display_window = Main_DirectDrawSurface_get_display_window;
  79     This->get_gamma_ramp = Main_DirectDrawSurface_get_gamma_ramp;
  80     This->set_gamma_ramp = Main_DirectDrawSurface_set_gamma_ramp;
  81
  82     ICOM_INIT_INTERFACE(This, IDirectDrawSurface3,
  83                         DDRAW_IDDS3_Thunk_VTable);
  84     ICOM_INIT_INTERFACE(This, IDirectDrawGammaControl,
  85                         DDRAW_IDDGC_VTable);
  86
  87     /* There is no generic implementation of IDDS7 or texture */
  88
  89     Main_DirectDraw_AddSurface(pDD, This);
  90     return DD_OK;
  91 }
  92
  93 void Main_DirectDrawSurface_final_release(IDirectDrawSurfaceImpl* This)
  94 {
  95     Main_DirectDraw_RemoveSurface(This->ddraw_owner, This);
  96 }
  97
  98 HRESULT Main_DirectDrawSurface_late_allocate(IDirectDrawSurfaceImpl* This)
  99 {
 100     return DD_OK;
 101 }
 102
 103 static void Main_DirectDrawSurface_Destroy(IDirectDrawSurfaceImpl* This)
 104 {
 105     if (This->palette) {
 106         IDirectDrawPalette_Release(ICOM_INTERFACE(This->palette, IDirectDrawPalette));
 107         This->palette = NULL;
 108     }
 109     This->final_release(This);
 110     if (This->private != This+1) HeapFree(GetProcessHeap(), 0, This->private);
 111     if (This->tex_private) HeapFree(GetProcessHeap(), 0, This->tex_private);
 112     HeapFree(GetProcessHeap(), 0, This);
 113 }
 114
 115 void Main_DirectDrawSurface_ForceDestroy(IDirectDrawSurfaceImpl* This)
 116 {
 117     WARN("destroying surface %p with refcnt %lu\n", This, This->ref);
 118     Main_DirectDrawSurface_Destroy(This);
 119 }
 120
 121 ULONG WINAPI Main_DirectDrawSurface_Release(LPDIRECTDRAWSURFACE7 iface)
 122 {
 123     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 124
 125     TRACE("(%p)->(): decreasing from %ld\n", This, This->ref);
 126
 127     if (--This->ref == 0)
 128     {
 129         if (This->aux_release)
 130             This->aux_release(This->aux_ctx, This->aux_data);
 131         Main_DirectDrawSurface_Destroy(This);
 132
 133         TRACE("released surface %p\n", This);
 134
 135         return 0;
 136     }
 137
 138     return This->ref;
 139 }
 140
 141 ULONG WINAPI Main_DirectDrawSurface_AddRef(LPDIRECTDRAWSURFACE7 iface)
 142 {
 143     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 144
 145     TRACE("(%p)->(): increasing from %ld\n", This, This->ref);
 146
 147     return ++This->ref;
 148 }
 149
 150 HRESULT WINAPI
 151 Main_DirectDrawSurface_QueryInterface(LPDIRECTDRAWSURFACE7 iface, REFIID riid,
 152                                       LPVOID* ppObj)
 153 {
 154     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 155     TRACE("(%p)->(%s,%p)\n", This, debugstr_guid(riid), ppObj);
 156
 157     *ppObj = NULL;
 158
 159     if (IsEqualGUID(&IID_IUnknown, riid)
 160         || IsEqualGUID(&IID_IDirectDrawSurface7, riid)
 161         || IsEqualGUID(&IID_IDirectDrawSurface4, riid))
 162     {
 163         This->ref++;
 164         *ppObj = ICOM_INTERFACE(This, IDirectDrawSurface7);
 165         return S_OK;
 166     }
 167     else if (IsEqualGUID(&IID_IDirectDrawSurface, riid)
 168              || IsEqualGUID(&IID_IDirectDrawSurface2, riid)
 169              || IsEqualGUID(&IID_IDirectDrawSurface3, riid))
 170     {
 171         This->ref++;
 172         *ppObj = ICOM_INTERFACE(This, IDirectDrawSurface3);
 173         return S_OK;
 174     }
 175     else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
 176     {
 177         This->ref++;
 178         *ppObj = ICOM_INTERFACE(This, IDirectDrawGammaControl);
 179         return S_OK;
 180     }
 181 #ifdef HAVE_OPENGL
 182     /* interfaces following here require OpenGL */
 183     if( !opengl_initialized )
 184         return E_NOINTERFACE;
 185
 186     if ( IsEqualGUID( &IID_D3DDEVICE_OpenGL, riid ) ||
 187           IsEqualGUID( &IID_IDirect3DHALDevice, riid) )
 188     {
 189         IDirect3DDeviceImpl *d3ddevimpl;
 190         HRESULT ret_value;
 191
 192         ret_value = d3ddevice_create(&d3ddevimpl, This->ddraw_owner, This);
 193         if (FAILED(ret_value)) return ret_value;
 194
 195         *ppObj = ICOM_INTERFACE(d3ddevimpl, IDirect3DDevice);
 196         TRACE(" returning Direct3DDevice interface at %p.\n", *ppObj);
 197
 198         This->ref++; /* No idea if this is correct.. Need to check using real Windows */
 199         return ret_value;
 200     }
 201     else if (IsEqualGUID( &IID_IDirect3DTexture, riid ) ||
 202              IsEqualGUID( &IID_IDirect3DTexture2, riid ))
 203     {
 204         HRESULT ret_value = S_OK;
 205
 206         if ((This->surface_desc.ddsCaps.dwCaps & DDSCAPS_TEXTURE) == 0) return E_NOINTERFACE;
 207
 208         /* In case the texture surface was created before the D3D creation */
 209         if (This->tex_private == NULL) {
 210             if (This->ddraw_owner->d3d_private == NULL) {
 211                 ERR("Texture created with no D3D object yet.. Not supported !\n");
 212                 return E_NOINTERFACE;
 213             }
 214
 215             ret_value = This->ddraw_owner->d3d_create_texture(This->ddraw_owner, This, FALSE, This->mip_main);
 216             if (FAILED(ret_value)) return ret_value;
 217         }
 218         if (IsEqualGUID( &IID_IDirect3DTexture, riid )) {
 219             *ppObj = ICOM_INTERFACE(This, IDirect3DTexture);
 220             TRACE(" returning Direct3DTexture interface at %p.\n", *ppObj);
 221         } else {
 222             *ppObj = ICOM_INTERFACE(This, IDirect3DTexture2);
 223             TRACE(" returning Direct3DTexture2 interface at %p.\n", *ppObj);
 224         }
 225         This->ref++;
 226         return ret_value;
 227     }
 228 #endif
 229
 230     return E_NOINTERFACE;
 231 }
 232
 233 /*** Callbacks */
 234
 235 BOOL
 236 Main_DirectDrawSurface_attach(IDirectDrawSurfaceImpl *This,
 237                               IDirectDrawSurfaceImpl *to)
 238 {
 239     return TRUE;
 240 }
 241
 242 BOOL Main_DirectDrawSurface_detach(IDirectDrawSurfaceImpl *This)
 243 {
 244     return TRUE;
 245 }
 246
 247 void
 248 Main_DirectDrawSurface_lock_update(IDirectDrawSurfaceImpl* This, LPCRECT pRect,
 249         DWORD dwFlags)
 250 {
 251 }
 252
 253 void
 254 Main_DirectDrawSurface_unlock_update(IDirectDrawSurfaceImpl* This,
 255                                      LPCRECT pRect)
 256 {
 257 }
 258
 259 void
 260 Main_DirectDrawSurface_lose_surface(IDirectDrawSurfaceImpl* This)
 261 {
 262 }
 263
 264 void
 265 Main_DirectDrawSurface_set_palette(IDirectDrawSurfaceImpl* This,
 266                                    IDirectDrawPaletteImpl* pal)
 267 {
 268 }
 269
 270 void
 271 Main_DirectDrawSurface_update_palette(IDirectDrawSurfaceImpl* This,
 272                                       IDirectDrawPaletteImpl* pal,
 273                                       DWORD dwStart, DWORD dwCount,
 274                                       LPPALETTEENTRY palent)
 275 {
 276 }
 277
 278 HWND
 279 Main_DirectDrawSurface_get_display_window(IDirectDrawSurfaceImpl* This)
 280 {
 281     return 0;
 282 }
 283
 284 HRESULT
 285 Main_DirectDrawSurface_get_gamma_ramp(IDirectDrawSurfaceImpl* This,
 286                                       DWORD dwFlags,
 287                                       LPDDGAMMARAMP lpGammaRamp)
 288 {
 289     HDC hDC;
 290     HRESULT hr;
 291     hr = This->get_dc(This, &hDC);
 292     if (FAILED(hr)) return hr;
 293     hr = GetDeviceGammaRamp(hDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
 294     This->release_dc(This, hDC);
 295     return hr;
 296 }
 297
 298 HRESULT
 299 Main_DirectDrawSurface_set_gamma_ramp(IDirectDrawSurfaceImpl* This,
 300                                       DWORD dwFlags,
 301                                       LPDDGAMMARAMP lpGammaRamp)
 302 {
 303     HDC hDC;
 304     HRESULT hr;
 305     hr = This->get_dc(This, &hDC);
 306     if (FAILED(hr)) return hr;
 307     hr = SetDeviceGammaRamp(hDC, lpGammaRamp) ? DD_OK : DDERR_UNSUPPORTED;
 308     This->release_dc(This, hDC);
 309     return hr;
 310 }
 311
 312
 313 /*** Interface functions */
 314
 315 HRESULT WINAPI
 316 Main_DirectDrawSurface_AddAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
 317                                           LPDIRECTDRAWSURFACE7 pAttach)
 318 {
 319     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 320     IDirectDrawSurfaceImpl* surf = ICOM_OBJECT(IDirectDrawSurfaceImpl,
 321                                                IDirectDrawSurface7, pAttach);
 322
 323     TRACE("(%p)->(%p)\n",This,pAttach);
 324
 325     /* Does windows check this? */
 326     if (surf == This)
 327         return DDERR_CANNOTATTACHSURFACE; /* unchecked */
 328
 329     /* Does windows check this? */
 330     if (surf->ddraw_owner != This->ddraw_owner)
 331         return DDERR_CANNOTATTACHSURFACE; /* unchecked */
 332
 333     if (surf->surface_owner != NULL)
 334         return DDERR_SURFACEALREADYATTACHED; /* unchecked */
 335
 336     /* TODO MSDN: "You can attach only z-buffer surfaces with this method."
 337      * But apparently backbuffers and mipmaps can be attached too. */
 338
 339     /* Set MIPMAPSUBLEVEL if this seems to be one */
 340     if (This->surface_desc.ddsCaps.dwCaps &
 341         surf->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) {
 342         surf->surface_desc.ddsCaps.dwCaps2 |= DDSCAPS2_MIPMAPSUBLEVEL;
 343         /* FIXME: we should probably also add to dwMipMapCount of this
 344          * and all parent surfaces (update create_texture if you do) */
 345     }
 346
 347     /* Callback to allow the surface to do something special now that it is
 348      * attached. (e.g. maybe the Z-buffer tells the renderer to use it.) */
 349     if (!surf->attach(surf, This))
 350         return DDERR_CANNOTATTACHSURFACE;
 351
 352     /* check: Where should it go in the chain? This puts it on the head. */
 353     if (This->attached)
 354         This->attached->prev_attached = surf;
 355     surf->next_attached = This->attached;
 356     surf->prev_attached = NULL;
 357     This->attached = surf;
 358     surf->surface_owner = This;
 359
 360     IDirectDrawSurface7_AddRef(pAttach);
 361
 362     return DD_OK;
 363 }
 364
 365 /* MSDN: "not currently implemented." */
 366 HRESULT WINAPI
 367 Main_DirectDrawSurface_AddOverlayDirtyRect(LPDIRECTDRAWSURFACE7 iface,
 368                                            LPRECT pRect)
 369 {
 370     TRACE("(%p)->(%p)\n",iface,pRect);
 371     return DDERR_UNSUPPORTED; /* unchecked */
 372 }
 373
 374 /* MSDN: "not currently implemented." */
 375 HRESULT WINAPI
 376 Main_DirectDrawSurface_BltBatch(LPDIRECTDRAWSURFACE7 iface,
 377                                 LPDDBLTBATCH pBatch, DWORD dwCount,
 378                                 DWORD dwFlags)
 379 {
 380     TRACE("(%p)->(%p,%ld,%08lx)\n",iface,pBatch,dwCount,dwFlags);
 381     return DDERR_UNSUPPORTED; /* unchecked */
 382 }
 383
 384 HRESULT WINAPI
 385 Main_DirectDrawSurface_ChangeUniquenessValue(LPDIRECTDRAWSURFACE7 iface)
 386 {
 387     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 388     volatile IDirectDrawSurfaceImpl* vThis = This;
 389
 390     TRACE("(%p)\n",This);
 391     /* A uniquness value of 0 is apparently special.
 392      * This needs to be checked. */
 393     while (1)
 394     {
 395         DWORD old_uniqueness_value = vThis->uniqueness_value;
 396         DWORD new_uniqueness_value = old_uniqueness_value+1;
 397
 398         if (old_uniqueness_value == 0) break;
 399         if (new_uniqueness_value == 0) new_uniqueness_value = 1;
 400
 401         if (InterlockedCompareExchange((LONG*)&vThis->uniqueness_value,
 402                                        old_uniqueness_value,
 403                                        new_uniqueness_value)
 404             == old_uniqueness_value)
 405             break;
 406     }
 407
 408     return DD_OK;
 409 }
 410
 411 HRESULT WINAPI
 412 Main_DirectDrawSurface_DeleteAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
 413                                              DWORD dwFlags,
 414                                              LPDIRECTDRAWSURFACE7 pAttach)
 415 {
 416     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 417     IDirectDrawSurfaceImpl* surf = ICOM_OBJECT(IDirectDrawSurfaceImpl,
 418                                                IDirectDrawSurface7, pAttach);
 419
 420     TRACE("(%p)->(%08lx,%p)\n",This,dwFlags,pAttach);
 421
 422     if (!surf || (surf->surface_owner != This))
 423         return DDERR_SURFACENOTATTACHED; /* unchecked */
 424
 425     surf->detach(surf);
 426
 427     /* Remove MIPMAPSUBLEVEL if this seemed to be one */
 428     if (This->surface_desc.ddsCaps.dwCaps &
 429         surf->surface_desc.ddsCaps.dwCaps & DDSCAPS_MIPMAP) {
 430         surf->surface_desc.ddsCaps.dwCaps2 &= ~DDSCAPS2_MIPMAPSUBLEVEL;
 431         /* FIXME: we should probably also subtract from dwMipMapCount of this
 432          * and all parent surfaces */
 433     }
 434
 435     if (surf->next_attached)
 436         surf->next_attached->prev_attached = surf->prev_attached;
 437     if (surf->prev_attached)
 438         surf->prev_attached->next_attached = surf->next_attached;
 439     if (This->attached == surf)
 440         This->attached = surf->next_attached;
 441
 442     IDirectDrawSurface7_Release(pAttach);
 443
 444     return DD_OK;
 445 }
 446
 447 HRESULT WINAPI
 448 Main_DirectDrawSurface_EnumAttachedSurfaces(LPDIRECTDRAWSURFACE7 iface,
 449                                             LPVOID context,
 450                                             LPDDENUMSURFACESCALLBACK7 cb)
 451 {
 452     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 453     IDirectDrawSurfaceImpl* surf;
 454
 455     TRACE("(%p)->(%p,%p)\n",This,context,cb);
 456
 457     for (surf = This->attached; surf != NULL; surf = surf->next_attached)
 458     {
 459         /* check: != DDENUMRET_OK or == DDENUMRET_CANCEL? */
 460         if (cb(ICOM_INTERFACE(surf, IDirectDrawSurface7), &surf->surface_desc,
 461                context) == DDENUMRET_CANCEL)
 462             break;
 463     }
 464
 465     return DD_OK;
 466 }
 467
 468 HRESULT WINAPI
 469 Main_DirectDrawSurface_EnumOverlayZOrders(LPDIRECTDRAWSURFACE7 iface,
 470                                           DWORD dwFlags, LPVOID context,
 471                                           LPDDENUMSURFACESCALLBACK7 cb)
 472 {
 473     TRACE("(%p)->(%08lx,%p,%p)\n",iface,dwFlags,context,cb);
 474     return DD_OK;
 475 }
 476
 477 BOOL Main_DirectDrawSurface_flip_data(IDirectDrawSurfaceImpl* front,
 478                                       IDirectDrawSurfaceImpl* back,
 479                                       DWORD dwFlags)
 480 {
 481     /* uniqueness_value? */
 482     /* This is necessary. But is it safe? */
 483     {
 484         HDC tmp = front->hDC;
 485         front->hDC = back->hDC;
 486         back->hDC = tmp;
 487     }
 488
 489     {
 490         BOOL tmp = front->dc_in_use;
 491         front->dc_in_use = back->dc_in_use;
 492         back->dc_in_use = tmp;
 493     }
 494
 495     {
 496         FLATPTR tmp = front->global.fpVidMem;
 497         front->global.fpVidMem = back->global.fpVidMem;
 498         back->global.fpVidMem = tmp;
 499     }
 500
 501     {
 502         ULONG_PTR tmp = front->global_more.hKernelSurface;
 503         front->global_more.hKernelSurface = back->global_more.hKernelSurface;
 504         back->global_more.hKernelSurface = tmp;
 505     }
 506
 507     return TRUE;
 508 }
 509
 510 HRESULT WINAPI
 511 Main_DirectDrawSurface_Flip(LPDIRECTDRAWSURFACE7 iface,
 512                             LPDIRECTDRAWSURFACE7 override, DWORD dwFlags)
 513 {
 514     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 515     IDirectDrawSurfaceImpl* target;
 516     HRESULT hr;
 517
 518     TRACE("(%p)->(%p,%08lx)\n",This,override,dwFlags);
 519
 520     /* MSDN: "This method can be called only for a surface that has the
 521      * DDSCAPS_FLIP and DDSCAPS_FRONTBUFFER capabilities." */
 522     if ((This->surface_desc.ddsCaps.dwCaps&(DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
 523         != (DDSCAPS_FLIP|DDSCAPS_FRONTBUFFER))
 524         return DDERR_NOTFLIPPABLE;
 525
 526     if (This->aux_flip)
 527         if (This->aux_flip(This->aux_ctx, This->aux_data))
 528             return DD_OK;
 529
 530     /* 1. find the flip target */
 531     /* XXX I don't think this algorithm works for more than 1 backbuffer. */
 532     if (override == NULL)
 533     {
 534         static DDSCAPS2 back_caps = { DDSCAPS_BACKBUFFER };
 535         LPDIRECTDRAWSURFACE7 tgt;
 536
 537         hr = IDirectDrawSurface7_GetAttachedSurface(iface, &back_caps, &tgt);
 538         if (FAILED(hr)) return DDERR_NOTFLIPPABLE; /* unchecked */
 539
 540         target = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 541                              tgt);
 542         IDirectDrawSurface7_Release(tgt);
 543     }
 544     else
 545     {
 546         BOOL on_chain = FALSE;
 547         IDirectDrawSurfaceImpl* surf;
 548
 549         /* MSDN: "The method fails if the specified [override] surface is not
 550          * a member of the flipping chain." */
 551
 552         /* Verify that override is on this flip chain. We assume that
 553          * surf is the head of the flipping chain, because it's the front
 554          * buffer. */
 555         target = ICOM_OBJECT(IDirectDrawSurfaceImpl, IDirectDrawSurface7,
 556                              override);
 557
 558         /* Either target is (indirectly) attached to This or This is
 559          * (indirectly) attached to target. */
 560         for (surf = target; surf != NULL; surf = surf->surface_owner)
 561         {
 562             if (surf == This)
 563             {
 564                 on_chain = TRUE;
 565                 break;
 566             }
 567         }
 568
 569         if (!on_chain)
 570             return DDERR_INVALIDPARAMS; /* unchecked */
 571     }
 572
 573     TRACE("flip to backbuffer: %p\n",target);
 574     if (This->flip_data(This, target, dwFlags))
 575         This->flip_update(This, dwFlags);
 576
 577     return DD_OK;
 578 }
 579
 580 static PrivateData* find_private_data(IDirectDrawSurfaceImpl *This,
 581                                       REFGUID tag)
 582 {
 583     PrivateData* data;
 584     for (data = This->private_data; data != NULL; data = data->next)
 585     {
 586         if (IsEqualGUID(&data->tag, tag)) break;
 587     }
 588
 589     return data;
 590 }
 591
 592 HRESULT WINAPI
 593 Main_DirectDrawSurface_FreePrivateData(LPDIRECTDRAWSURFACE7 iface, REFGUID tag)
 594 {
 595     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 596     PrivateData *data;
 597
 598     data = find_private_data(This, tag);
 599     if (data == NULL) return DDERR_NOTFOUND;
 600
 601     if (data->prev)
 602         data->prev->next = data->next;
 603     if (data->next)
 604         data->next->prev = data->prev;
 605
 606     if (data->flags & DDSPD_IUNKNOWNPTR)
 607     {
 608         if (data->ptr.object != NULL)
 609             IUnknown_Release(data->ptr.object);
 610     }
 611     else
 612         HeapFree(GetProcessHeap(), 0, data->ptr.data);
 613
 614     HeapFree(GetProcessHeap(), 0, data);
 615
 616     return DD_OK;
 617 }
 618
 619 HRESULT WINAPI
 620 Main_DirectDrawSurface_GetAttachedSurface(LPDIRECTDRAWSURFACE7 iface,
 621                                           LPDDSCAPS2 pCaps,
 622                                           LPDIRECTDRAWSURFACE7* ppSurface)
 623 {
 624     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 625     IDirectDrawSurfaceImpl* surf;
 626     IDirectDrawSurfaceImpl* found = NULL;
 627     DDSCAPS2 our_caps;
 628
 629     if (TRACE_ON(ddraw)) {
 630         TRACE("(%p)->Looking for caps: %lx,%lx,%lx,%lx output: %p\n",This,pCaps->dwCaps, pCaps->dwCaps2,
 631               pCaps->dwCaps3, pCaps->dwCaps4, ppSurface);
 632         TRACE("   Caps are : "); DDRAW_dump_DDSCAPS2(pCaps); TRACE("\n");
 633     }
 634
 635     our_caps = *pCaps;
 636     if ((This->ddraw_owner->local.dwLocalFlags & DDRAWILCL_DIRECTDRAW7) == 0) {
 637         /* As this is not a DirectDraw7 application, remove the garbage that some games
 638            put in the new fields of the DDSCAPS2 structure. */
 639         our_caps.dwCaps2 = 0;
 640         our_caps.dwCaps3 = 0;
 641         our_caps.dwCaps4 = 0;
 642         if (TRACE_ON(ddraw)) {
 643             TRACE("   Real caps are : "); DDRAW_dump_DDSCAPS2(&our_caps); TRACE("\n");
 644         }
 645     }
 646
 647     for (surf = This->attached; surf != NULL; surf = surf->next_attached)
 648     {
 649         if (TRACE_ON(ddraw)) {
 650             TRACE("Surface: (%p) caps: %lx,%lx,%lx,%lx \n",surf ,
 651                   surf->surface_desc.ddsCaps.dwCaps,
 652                   surf->surface_desc.ddsCaps.dwCaps2,
 653                   surf->surface_desc.ddsCaps.dwCaps3,
 654                   surf->surface_desc.ddsCaps.dwCaps4);
 655             TRACE("   Surface caps are : "); DDRAW_dump_DDSCAPS2(&(surf->surface_desc.ddsCaps)); TRACE("\n");
 656         }
 657         if (((surf->surface_desc.ddsCaps.dwCaps & our_caps.dwCaps) == our_caps.dwCaps) &&
 658             ((surf->surface_desc.ddsCaps.dwCaps2 & our_caps.dwCaps2) == our_caps.dwCaps2))
 659         {
 660             /* MSDN: "This method fails if more than one surface is attached
 661              * that matches the capabilities requested." */
 662             if (found != NULL)
 663             {
 664                 FIXME("More than one attached surface matches requested caps.  What should we do here?\n");
 665                 /* Previous code returned 'DDERR_NOTFOUND'.  That appears not
 666                    to be correct, given what 3DMark expects from MipMapped surfaces.
 667                    We shall just continue instead. */
 668             }
 669
 670             found = surf;
 671         }
 672     }
 673
 674     if (found == NULL) {
 675         TRACE("Did not find any valid surface\n");
 676         return DDERR_NOTFOUND;
 677     }
 678
 679     *ppSurface = ICOM_INTERFACE(found, IDirectDrawSurface7);
 680
 681     if (TRACE_ON(ddraw)) {
 682         TRACE("Returning surface %p with description : \n", *ppSurface);
 683         DDRAW_dump_surface_desc(&(found->surface_desc));
 684     }
 685
 686     /* XXX d3dframe.cpp sometimes AddRefs things that it gets from us. */
 687     IDirectDrawSurface7_AddRef(ICOM_INTERFACE(found, IDirectDrawSurface7));
 688     return DD_OK;
 689 }
 690
 691 HRESULT WINAPI
 692 Main_DirectDrawSurface_GetBltStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
 693 {
 694     TRACE("(%p)->(%08lx)\n",iface,dwFlags);
 695
 696     switch (dwFlags)
 697     {
 698     case DDGBS_CANBLT:
 699     case DDGBS_ISBLTDONE:
 700         return DD_OK;
 701
 702     default:
 703         return DDERR_INVALIDPARAMS;
 704     }
 705 }
 706
 707 HRESULT WINAPI
 708 Main_DirectDrawSurface_GetCaps(LPDIRECTDRAWSURFACE7 iface, LPDDSCAPS2 pCaps)
 709 {
 710     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 711
 712     TRACE("(%p)->(%p)\n",This,pCaps);
 713     *pCaps = This->surface_desc.ddsCaps;
 714     return DD_OK;
 715 }
 716
 717 HRESULT WINAPI
 718 Main_DirectDrawSurface_GetClipper(LPDIRECTDRAWSURFACE7 iface,
 719                                   LPDIRECTDRAWCLIPPER* ppClipper)
 720 {
 721     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 722
 723     TRACE("(%p)->(%p)\n",This,ppClipper);
 724     if (This->clipper == NULL)
 725         return DDERR_NOCLIPPERATTACHED;
 726
 727     *ppClipper = ICOM_INTERFACE(This->clipper, IDirectDrawClipper);
 728     IDirectDrawClipper_AddRef(ICOM_INTERFACE(This->clipper,
 729                                              IDirectDrawClipper));
 730     return DD_OK;
 731 }
 732
 733 HRESULT WINAPI
 734 Main_DirectDrawSurface_GetColorKey(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags,
 735                                    LPDDCOLORKEY pCKey)
 736 {
 737     /* There is a DDERR_NOCOLORKEY error, but how do we know if a color key
 738      * isn't there? That's like saying that an int isn't there. (Which MS
 739      * has done in other docs.) */
 740
 741     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 742
 743     TRACE("(%p)->(%08lx,%p)\n",This,dwFlags,pCKey);
 744     if (TRACE_ON(ddraw)) {
 745         TRACE(" - colorkey flags : ");
 746         DDRAW_dump_colorkeyflag(dwFlags);
 747     }
 748
 749     switch (dwFlags)
 750     {
 751     case DDCKEY_DESTBLT:
 752         *pCKey = This->surface_desc.ddckCKDestBlt;
 753         break;
 754
 755     case DDCKEY_DESTOVERLAY:
 756         *pCKey = This->surface_desc.u3.ddckCKDestOverlay;
 757         break;
 758
 759     case DDCKEY_SRCBLT:
 760         *pCKey = This->surface_desc.ddckCKSrcBlt;
 761         break;
 762
 763     case DDCKEY_SRCOVERLAY:
 764         *pCKey = This->surface_desc.ddckCKSrcOverlay;
 765         break;
 766
 767     default:
 768         return DDERR_INVALIDPARAMS;
 769     }
 770
 771     return DD_OK;
 772 }
 773
 774 /* XXX We need to do something with the DC if the surface gets lost. */
 775 HRESULT WINAPI
 776 Main_DirectDrawSurface_GetDC(LPDIRECTDRAWSURFACE7 iface, HDC *phDC)
 777 {
 778     DDSURFACEDESC2 ddsd;
 779     HRESULT hr;
 780     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 781
 782     TRACE("(%p)->(%p)\n",This,phDC);
 783     CHECK_LOST(This);
 784
 785     LOCK_OBJECT(This);
 786
 787     if (This->dc_in_use)
 788     {
 789         UNLOCK_OBJECT(This);
 790         return DDERR_DCALREADYCREATED;
 791     }
 792
 793     /* Lock as per MSDN.
 794      * Strange: Lock lists DDERR_SURFACEBUSY as an error, meaning that another
 795      * thread has it locked, but GetDC does not. */
 796     ddsd.dwSize = sizeof(ddsd);
 797     hr = IDirectDrawSurface7_Lock(iface, NULL, &ddsd, 0, 0);
 798     if (FAILED(hr))
 799     {
 800         UNLOCK_OBJECT(This);
 801         return hr;
 802     }
 803
 804     hr = This->get_dc(This, &This->hDC);
 805     if (SUCCEEDED(hr))
 806     {
 807         TRACE("returning %p\n",This->hDC);
 808
 809         *phDC = This->hDC;
 810         This->dc_in_use = TRUE;
 811     }
 812     else WARN("No DC! Prepare for trouble\n");
 813
 814     UNLOCK_OBJECT(This);
 815     return hr;
 816 }
 817
 818 HRESULT WINAPI
 819 Main_DirectDrawSurface_GetDDInterface(LPDIRECTDRAWSURFACE7 iface, LPVOID* pDD)
 820 {
 821     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 822
 823     TRACE("(%p)->(%p)\n",This,pDD);
 824     *pDD = ICOM_INTERFACE(This->ddraw_owner, IDirectDraw7);
 825     IDirectDraw7_AddRef(ICOM_INTERFACE(This->ddraw_owner, IDirectDraw7));
 826     return DD_OK;
 827 }
 828
 829 HRESULT WINAPI
 830 Main_DirectDrawSurface_GetFlipStatus(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
 831 {
 832     /* XXX: DDERR_INVALIDSURFACETYPE */
 833
 834     TRACE("(%p)->(%08lx)\n",iface,dwFlags);
 835     switch (dwFlags)
 836     {
 837     case DDGFS_CANFLIP:
 838     case DDGFS_ISFLIPDONE:
 839         return DD_OK;
 840
 841     default:
 842         return DDERR_INVALIDPARAMS;
 843     }
 844 }
 845
 846 HRESULT WINAPI
 847 Main_DirectDrawSurface_GetLOD(LPDIRECTDRAWSURFACE7 iface, LPDWORD pdwMaxLOD)
 848 {
 849     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 850
 851     TRACE("(%p)->(%p)\n",This,pdwMaxLOD);
 852     CHECK_TEXTURE(This);
 853
 854     *pdwMaxLOD = This->max_lod;
 855     return DD_OK;
 856 }
 857
 858 HRESULT WINAPI
 859 Main_DirectDrawSurface_GetOverlayPosition(LPDIRECTDRAWSURFACE7 iface,
 860                                           LPLONG pX, LPLONG pY)
 861 {
 862     return DDERR_NOTAOVERLAYSURFACE;
 863 }
 864
 865 HRESULT WINAPI
 866 Main_DirectDrawSurface_GetPalette(LPDIRECTDRAWSURFACE7 iface,
 867                                   LPDIRECTDRAWPALETTE* ppPalette)
 868 {
 869     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 870
 871     TRACE("(%p)->(%p)\n",This,ppPalette);
 872     if (This->palette == NULL)
 873         return DDERR_NOPALETTEATTACHED;
 874
 875     *ppPalette = ICOM_INTERFACE(This->palette, IDirectDrawPalette);
 876     IDirectDrawPalette_AddRef(ICOM_INTERFACE(This->palette,
 877                                              IDirectDrawPalette));
 878     return DD_OK;
 879 }
 880
 881 HRESULT WINAPI
 882 Main_DirectDrawSurface_GetPixelFormat(LPDIRECTDRAWSURFACE7 iface,
 883                                       LPDDPIXELFORMAT pDDPixelFormat)
 884 {
 885     /* What is DDERR_INVALIDSURFACETYPE for here? */
 886     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 887
 888     TRACE("(%p)->(%p)\n",This,pDDPixelFormat);
 889     DD_STRUCT_COPY_BYSIZE(pDDPixelFormat,&This->surface_desc.u4.ddpfPixelFormat);
 890     return DD_OK;
 891 }
 892
 893 HRESULT WINAPI
 894 Main_DirectDrawSurface_GetPriority(LPDIRECTDRAWSURFACE7 iface,
 895                                    LPDWORD pdwPriority)
 896 {
 897     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 898
 899     TRACE("(%p)->(%p)\n",This,pdwPriority);
 900     CHECK_TEXTURE(This);
 901
 902     *pdwPriority = This->priority;
 903     return DD_OK;
 904 }
 905
 906 HRESULT WINAPI
 907 Main_DirectDrawSurface_GetPrivateData(LPDIRECTDRAWSURFACE7 iface,
 908                                       REFGUID tag, LPVOID pBuffer,
 909                                       LPDWORD pcbBufferSize)
 910 {
 911     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 912     PrivateData* data;
 913
 914     data = find_private_data(This, tag);
 915     if (data == NULL) return DDERR_NOTFOUND;
 916
 917     /* This may not be right. */
 918     if ((data->flags & DDSPD_VOLATILE)
 919         && data->uniqueness_value != This->uniqueness_value)
 920         return DDERR_EXPIRED;
 921
 922     if (*pcbBufferSize < data->size)
 923     {
 924         *pcbBufferSize = data->size;
 925         return DDERR_MOREDATA;
 926     }
 927
 928     if (data->flags & DDSPD_IUNKNOWNPTR)
 929     {
 930         *(LPUNKNOWN *)pBuffer = data->ptr.object;
 931         IUnknown_AddRef(data->ptr.object);
 932     }
 933     else
 934     {
 935         memcpy(pBuffer, data->ptr.data, data->size);
 936     }
 937
 938     return DD_OK;
 939 }
 940
 941 HRESULT WINAPI
 942 Main_DirectDrawSurface_GetSurfaceDesc(LPDIRECTDRAWSURFACE7 iface,
 943                                       LPDDSURFACEDESC2 pDDSD)
 944 {
 945     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 946
 947     TRACE("(%p)->(%p)\n",This,pDDSD);
 948     if ((pDDSD->dwSize < sizeof(DDSURFACEDESC)) ||
 949         (pDDSD->dwSize > sizeof(DDSURFACEDESC2))) {
 950         ERR("Impossible/Strange struct size %ld.\n",pDDSD->dwSize);
 951         return DDERR_GENERIC;
 952     }
 953
 954     DD_STRUCT_COPY_BYSIZE(pDDSD,&This->surface_desc);
 955     if (TRACE_ON(ddraw)) {
 956       DDRAW_dump_surface_desc(pDDSD);
 957     }
 958     return DD_OK;
 959 }
 960
 961 HRESULT WINAPI
 962 Main_DirectDrawSurface_GetUniquenessValue(LPDIRECTDRAWSURFACE7 iface,
 963                                           LPDWORD pValue)
 964 {
 965     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 966
 967     TRACE("(%p)->(%p)\n",This,pValue);
 968     *pValue = This->uniqueness_value;
 969     return DD_OK;
 970 }
 971
 972 HRESULT WINAPI
 973 Main_DirectDrawSurface_Initialize(LPDIRECTDRAWSURFACE7 iface,
 974                                   LPDIRECTDRAW pDD, LPDDSURFACEDESC2 pDDSD)
 975 {
 976     TRACE("(%p)->(%p,%p)\n",iface,pDD,pDDSD);
 977     return DDERR_ALREADYINITIALIZED;
 978 }
 979
 980 HRESULT WINAPI
 981 Main_DirectDrawSurface_IsLost(LPDIRECTDRAWSURFACE7 iface)
 982 {
 983     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 984
 985     TRACE("(%p) is%s lost\n",This, (This->lost ? "" : " not"));
 986     return This->lost ? DDERR_SURFACELOST : DD_OK;
 987 }
 988
 989
 990 /* XXX This doesn't actually do any locking or keep track of the locked
 991  * rectangles. The behaviour is poorly documented. */
 992 HRESULT WINAPI
 993 Main_DirectDrawSurface_Lock(LPDIRECTDRAWSURFACE7 iface, LPRECT prect,
 994                             LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE h)
 995 {
 996     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
 997
 998     if (TRACE_ON(ddraw)) {
 999         TRACE("(%p)->Lock(%p,%p,%08lx,%08lx)\n",This,prect,pDDSD,flags,(DWORD)h);
1000         TRACE(" - locking flags : "); DDRAW_dump_lockflag(flags);
1001     }
1002     if (WARN_ON(ddraw)) {
1003         if (flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY)) {
1004             WARN(" - unsupported locking flag : "); DDRAW_dump_lockflag(flags & ~(DDLOCK_WAIT|DDLOCK_READONLY|DDLOCK_WRITEONLY));
1005         }
1006     }
1007
1008     /* First, copy the Surface description */
1009     DD_STRUCT_COPY_BYSIZE(pDDSD,&(This->surface_desc));
1010
1011     /* Used to optimize the D3D Device locking */
1012     This->lastlocktype = flags & (DDLOCK_READONLY|DDLOCK_WRITEONLY);
1013
1014     /* If asked only for a part, change the surface pointer.
1015      * (Not documented.) */
1016     if (prect != NULL) {
1017         TRACE(" lprect: %ldx%ld-%ldx%ld\n",
1018                 prect->left,prect->top,prect->right,prect->bottom);
1019         /* First do some sanity checkings on the rectangle we receive.
1020            DungeonSiege seems to gives us once a very bad rectangle for example */
1021         if ((prect->top < 0) ||
1022             (prect->left < 0) ||
1023             (prect->bottom < 0) ||
1024             (prect->right < 0) ||
1025             (prect->left >= prect->right) ||
1026             (prect->top >= prect->bottom) ||
1027             (prect->left >= This->surface_desc.dwWidth) ||
1028             (prect->right > This->surface_desc.dwWidth) ||
1029             (prect->top >= This->surface_desc.dwHeight) ||
1030             (prect->bottom > This->surface_desc.dwHeight)) {
1031             ERR(" Invalid values in LPRECT !!!\n");
1032             return DDERR_INVALIDPARAMS;
1033         }
1034
1035         This->lock_update(This, prect, flags);
1036
1037         pDDSD->lpSurface = (char *)This->surface_desc.lpSurface
1038             + prect->top * This->surface_desc.u1.lPitch
1039             + prect->left * GET_BPP(This->surface_desc);
1040     } else {
1041         This->lock_update(This, NULL, flags);
1042     }
1043
1044     TRACE("locked surface returning description : \n");
1045     if (TRACE_ON(ddraw)) DDRAW_dump_surface_desc(pDDSD);
1046
1047     return DD_OK;
1048 }
1049
1050 HRESULT WINAPI
1051 Main_DirectDrawSurface_PageLock(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
1052 {
1053     /* Some surface types should return DDERR_CANTPAGELOCK. */
1054     return DD_OK;
1055 }
1056
1057 HRESULT WINAPI
1058 Main_DirectDrawSurface_PageUnlock(LPDIRECTDRAWSURFACE7 iface, DWORD dwFlags)
1059 {
1060     /* Some surface types should return DDERR_CANTPAGEUNLOCK, and we should
1061      * keep track so we can return DDERR_NOTPAGELOCKED as appropriate. */
1062     return DD_OK;
1063 }
1064
1065 HRESULT WINAPI
1066 Main_DirectDrawSurface_ReleaseDC(LPDIRECTDRAWSURFACE7 iface, HDC hDC)
1067 {
1068     HRESULT hr;
1069     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1070
1071     TRACE("(%p)->(%p)\n",This,hDC);
1072
1073     if (!This->dc_in_use || This->hDC != hDC)
1074         return DDERR_INVALIDPARAMS;
1075
1076     This->release_dc(This, hDC);
1077
1078     hr = IDirectDrawSurface7_Unlock(iface, NULL);
1079     if (FAILED(hr)) return hr;
1080
1081     This->dc_in_use = FALSE;
1082     This->hDC = 0;
1083
1084     return DD_OK;
1085 }
1086
1087 /* Restore */
1088
1089 HRESULT WINAPI
1090 Main_DirectDrawSurface_SetClipper(LPDIRECTDRAWSURFACE7 iface,
1091                                   LPDIRECTDRAWCLIPPER pDDClipper)
1092 {
1093     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1094
1095     TRACE("(%p)->(%p)\n",This,pDDClipper);
1096     if (pDDClipper == ICOM_INTERFACE(This->clipper, IDirectDrawClipper))
1097         return DD_OK;
1098
1099     if (This->clipper != NULL)
1100         IDirectDrawClipper_Release(ICOM_INTERFACE(This->clipper,
1101                                                   IDirectDrawClipper));
1102
1103     This->clipper = ICOM_OBJECT(IDirectDrawClipperImpl, IDirectDrawClipper,
1104                                 pDDClipper);
1105     if (pDDClipper != NULL)
1106         IDirectDrawClipper_AddRef(pDDClipper);
1107
1108     return DD_OK;
1109 }
1110
1111 HRESULT WINAPI
1112 Main_DirectDrawSurface_SetColorKey(LPDIRECTDRAWSURFACE7 iface,
1113                                    DWORD dwFlags, LPDDCOLORKEY pCKey)
1114 {
1115     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1116
1117     TRACE("(%p)->(%08lx,%p)\n",This,dwFlags,pCKey);
1118
1119     if (TRACE_ON(ddraw)) {
1120         TRACE(" - colorkey flags : ");
1121         DDRAW_dump_colorkeyflag(dwFlags);
1122     }
1123
1124     if ((dwFlags & DDCKEY_COLORSPACE) != 0) {
1125         FIXME(" colorkey value not supported (%08lx) !\n", dwFlags);
1126         return DDERR_INVALIDPARAMS;
1127     }
1128
1129     /* TODO: investigate if this function can take multiple bits set at the same
1130              time (ie setting multiple colorkey values at the same time with only
1131              one API call).
1132     */
1133     if (pCKey) {
1134         switch (dwFlags & ~DDCKEY_COLORSPACE) {
1135             case DDCKEY_DESTBLT:
1136                 This->surface_desc.ddckCKDestBlt = *pCKey;
1137                 This->surface_desc.dwFlags |= DDSD_CKDESTBLT;
1138                 break;
1139
1140             case DDCKEY_DESTOVERLAY:
1141                 This->surface_desc.u3.ddckCKDestOverlay = *pCKey;
1142                 This->surface_desc.dwFlags |= DDSD_CKDESTOVERLAY;
1143                 break;
1144
1145             case DDCKEY_SRCOVERLAY:
1146                 This->surface_desc.ddckCKSrcOverlay = *pCKey;
1147                 This->surface_desc.dwFlags |= DDSD_CKSRCOVERLAY;
1148                 break;
1149
1150             case DDCKEY_SRCBLT:
1151                 This->surface_desc.ddckCKSrcBlt = *pCKey;
1152                 This->surface_desc.dwFlags |= DDSD_CKSRCBLT;
1153                 break;
1154
1155             default:
1156                 return DDERR_INVALIDPARAMS;
1157         }
1158     } else {
1159         switch (dwFlags & ~DDCKEY_COLORSPACE) {
1160             case DDCKEY_DESTBLT:
1161                 This->surface_desc.dwFlags &= ~DDSD_CKDESTBLT;
1162                 break;
1163
1164             case DDCKEY_DESTOVERLAY:
1165                 This->surface_desc.dwFlags &= ~DDSD_CKDESTOVERLAY;
1166                 break;
1167
1168             case DDCKEY_SRCOVERLAY:
1169                 This->surface_desc.dwFlags &= ~DDSD_CKSRCOVERLAY;
1170                 break;
1171
1172             case DDCKEY_SRCBLT:
1173                 This->surface_desc.dwFlags &= ~DDSD_CKSRCBLT;
1174                 break;
1175
1176             default:
1177                 return DDERR_INVALIDPARAMS;
1178         }
1179     }
1180
1181     if (This->aux_setcolorkey_cb) This->aux_setcolorkey_cb(This, dwFlags, pCKey);
1182
1183     return DD_OK;
1184 }
1185
1186 HRESULT WINAPI
1187 Main_DirectDrawSurface_SetLOD(LPDIRECTDRAWSURFACE7 iface, DWORD dwMaxLOD)
1188 {
1189     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1190
1191     TRACE("(%p)->(%08lx)\n",This,dwMaxLOD);
1192     CHECK_TEXTURE(This);
1193
1194     This->max_lod = dwMaxLOD;
1195     return DD_OK;
1196 }
1197
1198 HRESULT WINAPI
1199 Main_DirectDrawSurface_SetOverlayPosition(LPDIRECTDRAWSURFACE7 iface,
1200                                           LONG X, LONG Y)
1201 {
1202     return DDERR_NOTAOVERLAYSURFACE;
1203 }
1204
1205 HRESULT WINAPI
1206 Main_DirectDrawSurface_SetPalette(LPDIRECTDRAWSURFACE7 iface,
1207                                   LPDIRECTDRAWPALETTE pPalette)
1208 {
1209     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1210
1211     TRACE("(%p)->(%p)\n",This,pPalette);
1212     if (pPalette == ICOM_INTERFACE(This->palette, IDirectDrawPalette))
1213         return DD_OK;
1214
1215     if (This->palette != NULL) {
1216         if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1217             This->palette->global.dwFlags &= ~DDPCAPS_PRIMARYSURFACE;
1218         IDirectDrawPalette_Release(ICOM_INTERFACE(This->palette,
1219                                                   IDirectDrawPalette));
1220     }
1221
1222     This->palette = ICOM_OBJECT(IDirectDrawPaletteImpl, IDirectDrawPalette,
1223                                 pPalette);
1224     if (pPalette != NULL) {
1225         IDirectDrawPalette_AddRef(pPalette);
1226         if (This->surface_desc.ddsCaps.dwCaps & DDSCAPS_PRIMARYSURFACE)
1227             This->palette->global.dwFlags |= DDPCAPS_PRIMARYSURFACE;
1228     }
1229
1230     This->set_palette(This, This->palette);
1231
1232     return DD_OK;
1233 }
1234
1235 HRESULT WINAPI
1236 Main_DirectDrawSurface_SetPriority(LPDIRECTDRAWSURFACE7 iface,
1237                                    DWORD dwPriority)
1238 {
1239     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1240
1241     TRACE("(%p)->(%08lx)\n",This,dwPriority);
1242     CHECK_TEXTURE(This);
1243
1244     This->priority = dwPriority;
1245     return DD_OK;
1246 }
1247
1248 /* Be careful when locking this: it is risky to call the object's AddRef
1249  * or Release holding a lock. */
1250 HRESULT WINAPI
1251 Main_DirectDrawSurface_SetPrivateData(LPDIRECTDRAWSURFACE7 iface,
1252                                       REFGUID tag, LPVOID pData,
1253                                       DWORD cbSize, DWORD dwFlags)
1254 {
1255     PrivateData* data;
1256     ICOM_THIS(IDirectDrawSurfaceImpl, iface);
1257
1258     data = find_private_data(This, tag);
1259     if (data == NULL)
1260     {
1261         data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*data));
1262         if (data == NULL) return DDERR_OUTOFMEMORY;
1263
1264         data->tag = *tag;
1265         data->flags = dwFlags;
1266         data->uniqueness_value = This->uniqueness_value;
1267
1268         if (dwFlags & DDSPD_IUNKNOWNPTR)
1269         {
1270             data->ptr.object = (LPUNKNOWN)pData;
1271             data->size = sizeof(LPUNKNOWN);
1272             IUnknown_AddRef(data->ptr.object);
1273         }
1274         else
1275         {
1276             data->ptr.data = HeapAlloc(GetProcessHeap(), 0, cbSize);
1277             if (data->ptr.data == NULL)
1278             {
1279                 HeapFree(GetProcessHeap(), 0, data);
1280                 return DDERR_OUTOFMEMORY;
1281             }
1282         }
1283
1284         /* link it in */
1285         data->next = This->private_data;
1286         data->prev = NULL;
1287         if (This->private_data)
1288             This->private_data->prev = data;
1289         This->private_data = data;
1290
1291         return DD_OK;
1292     }
1293     else
1294     {
1295         /* I don't actually know how windows handles this case. The only
1296          * reason I don't just call FreePrivateData is because I want to
1297          * guarantee SetPrivateData working when using LPUNKNOWN or data
1298          * that is no larger than the old data. */
1299
1300         return E_FAIL;
1301     }
1302 }
1303
1304 /* SetSurfaceDesc */
1305
1306 HRESULT WINAPI
1307 Main_DirectDrawSurface_Unlock(LPDIRECTDRAWSURFACE7 iface, LPRECT pRect)
1308 {
1309     ICOM_THIS(IDirectDrawSurfaceImpl,iface);
1310
1311     TRACE("(%p)->Unlock(%p)\n",This,pRect);
1312
1313     This->unlock_update(This, pRect);
1314     if (This->aux_unlock)
1315         This->aux_unlock(This->aux_ctx, This->aux_data, pRect);
1316
1317     return DD_OK;
1318 }
1319
1320 HRESULT WINAPI
1321 Main_DirectDrawSurface_UpdateOverlay(LPDIRECTDRAWSURFACE7 iface,
1322                                      LPRECT pSrcRect,
1323                                      LPDIRECTDRAWSURFACE7 pDstSurface,
1324                                      LPRECT pDstRect, DWORD dwFlags,
1325                                      LPDDOVERLAYFX pFX)
1326 {
1327     return DDERR_UNSUPPORTED;
1328 }
1329
1330 /* MSDN: "not currently implemented." */
1331 HRESULT WINAPI
1332 Main_DirectDrawSurface_UpdateOverlayDisplay(LPDIRECTDRAWSURFACE7 iface,
1333                                             DWORD dwFlags)
1334 {
1335     return DDERR_UNSUPPORTED;
1336 }
1337
1338 HRESULT WINAPI
1339 Main_DirectDrawSurface_UpdateOverlayZOrder(LPDIRECTDRAWSURFACE7 iface,
1340                                            DWORD dwFlags,
1341                                            LPDIRECTDRAWSURFACE7 pDDSRef)
1342 {
1343     return DDERR_NOTAOVERLAYSURFACE;
1344 }