dll/directx/ddraw/Surface/surface_main.c

   1 /* $Id$
   2  *
   3  * COPYRIGHT:            See COPYING in the top level directory
   4  * PROJECT:              ReactOS DirectX
   5  * FILE:                 ddraw/surface/surface_main.c
   6  * PURPOSE:              IDirectDrawSurface7 Implementation
   7  * PROGRAMMER:           Magnus Olsen, Maarten Bosma
   8  *
   9  */
  10
  11 #include "rosdraw.h"
  12
  13
  14 /* FIXME adding hal and hel stub
  15     DestroySurface;
  16     SetClipList;
  17     AddAttachedSurface;
  18     GetFlipStatus;
  19     SetOverlayPosition;
  20     SetPalette;
  21 */
  22
  23 LPDDRAWI_DDRAWSURFACE_INT
  24 internal_directdrawsurface_int_alloc(LPDDRAWI_DDRAWSURFACE_INT This)
  25 {
  26     LPDDRAWI_DDRAWSURFACE_INT  newThis;
  27     DxHeapMemAlloc(newThis, sizeof(DDRAWI_DDRAWSURFACE_INT));
  28     if (newThis)
  29     {
  30         newThis->lpLcl = This->lpLcl;
  31         newThis->lpLink = This;
  32     }
  33     return  newThis;
  34 }
  35
  36 HRESULT WINAPI Main_DDrawSurface_Initialize (LPDDRAWI_DDRAWSURFACE_INT iface, LPDIRECTDRAW pDD, LPDDSURFACEDESC2 pDDSD2)
  37 {
  38     return DDERR_ALREADYINITIALIZED;
  39 }
  40
  41 ULONG WINAPI Main_DDrawSurface_AddRef(LPDDRAWI_DDRAWSURFACE_INT This)
  42 {
  43
  44     DX_WINDBG_trace();
  45
  46     if (This!=NULL)
  47     {
  48         This->dwIntRefCnt++;
  49         This->lpLcl->dwLocalRefCnt++;
  50
  51         if (This->lpLcl->lpGbl != NULL)
  52         {
  53             This->lpLcl->lpGbl->dwRefCnt++;
  54         }
  55     }
  56     return This->dwIntRefCnt;
  57
  58 }
  59
  60 HRESULT WINAPI
  61 Main_DDrawSurface_QueryInterface(LPDDRAWI_DDRAWSURFACE_INT This, REFIID riid, LPVOID* ppObj)
  62 {
  63     HRESULT retVal = DD_OK;
  64     *ppObj = NULL;
  65
  66     DX_WINDBG_trace();
  67
  68     _SEH2_TRY
  69     {
  70         if (IsEqualGUID(&IID_IDirectDrawSurface7, riid))
  71         {
  72             if (This->lpVtbl != &DirectDrawSurface7_Vtable)
  73             {
  74                 This = internal_directdrawsurface_int_alloc(This);
  75                 if (!This)
  76                 {
  77                     retVal = DDERR_OUTOFVIDEOMEMORY;
  78                     _SEH2_LEAVE;
  79                 }
  80             }
  81             This->lpVtbl = &DirectDrawSurface7_Vtable;
  82             *ppObj = This;
  83             Main_DDrawSurface_AddRef(This);
  84         }
  85         else if (IsEqualGUID(&IID_IDirectDrawSurface4, riid))
  86         {
  87             if (This->lpVtbl != &DirectDrawSurface4_Vtable)
  88             {
  89                 This = internal_directdrawsurface_int_alloc(This);
  90                 if (!This)
  91                 {
  92                     retVal = DDERR_OUTOFVIDEOMEMORY;
  93                     _SEH2_LEAVE;
  94                 }
  95             }
  96             This->lpVtbl = &DirectDrawSurface4_Vtable;
  97             *ppObj = This;
  98             Main_DDrawSurface_AddRef(This);
  99         }
 100         else if (IsEqualGUID(&IID_IDirectDrawSurface3, riid))
 101         {
 102             if (This->lpVtbl != &DirectDrawSurface3_Vtable)
 103             {
 104                 This = internal_directdrawsurface_int_alloc(This);
 105                 if (!This)
 106                 {
 107                     retVal = DDERR_OUTOFVIDEOMEMORY;
 108                     _SEH2_LEAVE;
 109                 }
 110             }
 111             This->lpVtbl = &DirectDrawSurface3_Vtable;
 112             *ppObj = This;
 113             Main_DDrawSurface_AddRef(This);
 114         }
 115         else if (IsEqualGUID(&IID_IDirectDrawSurface2, riid))
 116         {
 117             if (This->lpVtbl != &DirectDrawSurface2_Vtable)
 118             {
 119                 This = internal_directdrawsurface_int_alloc(This);
 120                 if (!This)
 121                 {
 122                     retVal = DDERR_OUTOFVIDEOMEMORY;
 123                     _SEH2_LEAVE;
 124                 }
 125             }
 126             This->lpVtbl = &DirectDrawSurface2_Vtable;
 127             *ppObj = This;
 128             Main_DDrawSurface_AddRef(This);
 129         }
 130         else if (IsEqualGUID(&IID_IDirectDrawSurface, riid))
 131         {
 132             if (This->lpVtbl != &DirectDrawSurface_Vtable)
 133             {
 134                 This = internal_directdrawsurface_int_alloc(This);
 135                 if (!This)
 136                 {
 137                     retVal = DDERR_OUTOFVIDEOMEMORY;
 138                     _SEH2_LEAVE;
 139                 }
 140             }
 141             This->lpVtbl = &DirectDrawSurface_Vtable;
 142             *ppObj = This;
 143             Main_DDrawSurface_AddRef(This);
 144         }
 145         else if (IsEqualGUID(&IID_IDirectDrawColorControl, riid))
 146         {
 147             if (This->lpVtbl != &DirectDrawColorControl_Vtable)
 148             {
 149                 This = internal_directdrawsurface_int_alloc(This);
 150                 if (!This)
 151                 {
 152                     retVal = DDERR_OUTOFVIDEOMEMORY;
 153                     _SEH2_LEAVE;
 154                 }
 155             }
 156             This->lpVtbl = &DirectDrawColorControl_Vtable;
 157             *ppObj = This;
 158             Main_DDrawSurface_AddRef(This);
 159         }
 160         else if (IsEqualGUID(&IID_IDirectDrawGammaControl, riid))
 161         {
 162             if (This->lpVtbl != &DirectDrawGammaControl_Vtable)
 163             {
 164                 This = internal_directdrawsurface_int_alloc(This);
 165                 if (!This)
 166                 {
 167                     retVal = DDERR_OUTOFVIDEOMEMORY;
 168                     _SEH2_LEAVE;
 169                 }
 170             }
 171             This->lpVtbl = &DirectDrawGammaControl_Vtable;
 172             *ppObj = This;
 173             Main_DDrawSurface_AddRef(This);
 174         }
 175         else if (IsEqualGUID(&IID_IDirectDrawSurfaceKernel, riid))
 176         {
 177             if (This->lpVtbl != &DirectDrawSurfaceKernel_Vtable)
 178             {
 179                 This = internal_directdrawsurface_int_alloc(This);
 180                 if (!This)
 181                 {
 182                     retVal = DDERR_OUTOFVIDEOMEMORY;
 183                     _SEH2_LEAVE;
 184                 }
 185             }
 186             This->lpVtbl = &DirectDrawSurfaceKernel_Vtable;
 187             *ppObj = This;
 188             Main_DDrawSurface_AddRef(This);
 189         }
 190         else if (IsEqualGUID(&IID_IDirect3D, riid))
 191         {
 192             if (This->lpVtbl != &IDirect3D_Vtbl)
 193             {
 194                 This = internal_directdrawsurface_int_alloc(This);
 195                 if (!This)
 196                 {
 197                     retVal = DDERR_OUTOFVIDEOMEMORY;
 198                     _SEH2_LEAVE;
 199                 }
 200             }
 201             This->lpVtbl = &IDirect3D_Vtbl;
 202             *ppObj = This;
 203             Main_DDrawSurface_AddRef(This);
 204         }
 205         else if (IsEqualGUID(&IID_IDirect3D2, riid))
 206         {
 207             if (This->lpVtbl != &IDirect3D2_Vtbl)
 208             {
 209                 This = internal_directdrawsurface_int_alloc(This);
 210                 if (!This)
 211                 {
 212                     retVal = DDERR_OUTOFVIDEOMEMORY;
 213                     _SEH2_LEAVE;
 214                 }
 215             }
 216             This->lpVtbl = &IDirect3D2_Vtbl;
 217             *ppObj = This;
 218             Main_DDrawSurface_AddRef(This);
 219         }
 220         else if (IsEqualGUID(&IID_IDirect3D3, riid))
 221         {
 222             if (This->lpVtbl != &IDirect3D3_Vtbl)
 223             {
 224                 This = internal_directdrawsurface_int_alloc(This);
 225                 if (!This)
 226                 {
 227                     retVal = DDERR_OUTOFVIDEOMEMORY;
 228                     _SEH2_LEAVE;
 229                 }
 230             }
 231             This->lpVtbl = &IDirect3D3_Vtbl;
 232             *ppObj = This;
 233             Main_DDrawSurface_AddRef(This);
 234         }
 235         else if (IsEqualGUID(&IID_IDirect3D7, riid))
 236         {
 237             if (This->lpVtbl != &IDirect3D7_Vtbl)
 238             {
 239                 This = internal_directdrawsurface_int_alloc(This);
 240                 if (!This)
 241                 {
 242                     retVal = DDERR_OUTOFVIDEOMEMORY;
 243                     _SEH2_LEAVE;
 244                 }
 245             }
 246             This->lpVtbl = &IDirect3D7_Vtbl;
 247             *ppObj = This;
 248             Main_DDrawSurface_AddRef(This);
 249         }
 250         else
 251         {
 252             DX_STUB_str("E_NOINTERFACE");
 253             retVal = E_NOINTERFACE;
 254         }
 255     }
 256     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 257     {
 258     }
 259     _SEH2_END;
 260     return retVal;
 261 }
 262
 263
 264
 265 ULONG WINAPI Main_DDrawSurface_Release(LPDDRAWI_DDRAWSURFACE_INT This)
 266 {
 267     /* FIXME
 268        This is not right exiame how it should be done
 269      */
 270     ULONG ret = --This->dwIntRefCnt;
 271     if(!ret)
 272     {
 273         DX_STUB_str("Release is a bit simplistic right now\n");
 274         AcquireDDThreadLock();
 275         DxHeapMemFree(This);
 276         ReleaseDDThreadLock();
 277     }
 278     return ret;
 279 }
 280
 281 ULONG WINAPI Main_DDrawSurface_Release4(LPDDRAWI_DDRAWSURFACE_INT This)
 282 {
 283     ULONG ref = Main_DDrawSurface_Release(This) ;
 284
 285     if(ref == 0) Main_DirectDraw_Release(This->lpLcl->lpSurfMore->lpDD_int);
 286
 287     return ref;
 288 }
 289
 290 HRESULT WINAPI Main_DDrawSurface_Blt(LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT rdst,
 291                                      LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
 292 {
 293     DDHAL_BLTDATA mDdBlt;
 294
 295     DX_WINDBG_trace();
 296
 297     if (ThisDest == NULL)
 298     {
 299         return DDERR_INVALIDPARAMS;
 300     }
 301
 302     /* Zero out members in DDHAL_BLTDATA */
 303     ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
 304     ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
 305
 306     /* Check if we got HAL support for this api */
 307     if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 308           DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
 309     {
 310         mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
 311     }
 312     /* Check if we got HEL support for this api */
 313     else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 314           DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
 315     {
 316         mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt;
 317     }
 318
 319     if (mDdBlt.Blt == NULL)
 320     {
 321         /* This API is unsupported */
 322         return DDERR_UNSUPPORTED;
 323     }
 324
 325     /* Prepare for draw, if we do not reset the DdResetVisrgn some graphics card will not draw on the screen */
 326     if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
 327     {
 328         DX_STUB_str("DdResetVisrgn failed");
 329     }
 330
 331     mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 332     mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
 333     ThisDest->lpLcl->lpSurfMore->slist[0]->hDC = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 334
 335     /* Setup Src */
 336     if (( ThisSrc != NULL ) )
 337     {
 338
 339         mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
 340         ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC = ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 341
 342         if (rsrc != NULL)
 343         {
 344             memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
 345         }
 346         else
 347         {
 348             if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
 349                 (RECT *)&mDdBlt.rSrc))
 350             {
 351                 DX_STUB_str("GetWindowRect failed");
 352             }
 353         }
 354
 355     /* FIXME
 356     *  compare so we do not write too far
 357     *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
 358     *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
 359     *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
 360     */
 361
 362     }
 363
 364     /* Setup dest */
 365     if (rdst != NULL)
 366     {
 367         memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
 368     }
 369     else
 370     {
 371         if (!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
 372             (RECT *)&mDdBlt.rDest))
 373         {
 374             DX_STUB_str("GetWindowRect failed");
 375         }
 376     }
 377
 378     /* FIXME
 379     *  compare so we do not write too far
 380     *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
 381     *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
 382     *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
 383     */
 384
 385
 386     /* setup bltFX */
 387     if (lpbltfx != NULL)
 388     {
 389         memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
 390     }
 391
 392     /* setup value that are not config yet */
 393     mDdBlt.dwFlags = dwFlags;
 394     mDdBlt.IsClipped = FALSE;
 395     mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
 396
 397
 398      /* FIXME
 399         BltData.dwRectCnt
 400         BltData.dwROPFlags
 401         BltData.IsClipped
 402         BltData.prDestRects
 403         BltData.rOrigDest
 404         BltData.rOrigSrc
 405         BltData.ddRVal
 406     */
 407
 408     if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
 409     {
 410         DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
 411         return DDERR_NOBLTHW;
 412      }
 413
 414     return mDdBlt.ddRVal;
 415 }
 416
 417
 418 HRESULT WINAPI
 419 Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT prect,
 420                         LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
 421 {
 422     DDHAL_LOCKDATA mdLock;
 423
 424     DX_WINDBG_trace();
 425
 426     DX_WINDBG_trace_res( (DWORD)ThisDest->lpLcl->lpGbl->wWidth, (DWORD)ThisDest->lpLcl->lpGbl->wHeight, (DWORD)ThisDest->lpLcl->lpGbl->lPitch, (DWORD) 0);
 427
 428      /* Zero out members in DDHAL_LOCKDATA */
 429     ZeroMemory(&mdLock, sizeof(DDHAL_LOCKDATA));
 430
 431      /* Check if we got HAL support for this api */
 432     if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 433         DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
 434     {
 435         mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Lock;
 436     }
 437     /* Check if we got HEL support for this api */
 438     else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 439           DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
 440     {
 441         mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock;
 442     }
 443
 444     if (mdLock.Lock == NULL)
 445     {
 446         /* This api are unsupported */
 447         return DDERR_UNSUPPORTED;
 448     }
 449
 450     if (events != NULL)
 451     {
 452         return DDERR_INVALIDPARAMS;
 453     }
 454
 455     /* FIXME add a check see if lock suport or not */
 456
 457     if (prect!=NULL)
 458     {
 459         mdLock.bHasRect = TRUE;
 460         memcpy(&mdLock.rArea,prect,sizeof(RECTL));
 461     }
 462     else
 463     {
 464         mdLock.bHasRect = FALSE;
 465     }
 466
 467     //FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary
 468
 469     mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
 470     mdLock.dwFlags = flags;
 471     mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
 472     mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 473     mdLock.lpSurfData = NULL;
 474
 475
 476     if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
 477     {
 478       DX_STUB_str("Here DdResetVisrgn lock");
 479       // return DDERR_UNSUPPORTED;
 480     }
 481
 482     if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
 483     {
 484       DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
 485       return DDERR_UNSUPPORTED;
 486     }
 487
 488     // FIXME ??? is this right ??
 489
 490     if (pDDSD != NULL)
 491     {
 492         ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
 493         pDDSD->dwSize = sizeof(DDSURFACEDESC2);
 494
 495         //if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
 496         //{
 497         //    ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
 498         //    // FIXME the interanl mddsdPrimary shall be DDSURFACEDESC2
 499         //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
 500         //    pDDSD->dwSize = sizeof(DDSURFACEDESC2);
 501         //}
 502         //if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
 503         //{
 504         //    RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
 505         //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
 506         //    pDDSD->dwSize = sizeof(DDSURFACEDESC);
 507         //}
 508
 509
 510         pDDSD->lpSurface = (LPVOID)  mdLock.lpSurfData;
 511
 512         pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
 513         pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;
 514
 515         pDDSD->ddpfPixelFormat.dwRGBBitCount = ThisDest->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
 516         pDDSD->lPitch = ThisDest->lpLcl->lpGbl->lPitch;
 517         pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;
 518     }
 519
 520     return mdLock.ddRVal;
 521 }
 522
 523
 524 HRESULT WINAPI Main_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT pRect)
 525 {
 526     DDHAL_UNLOCKDATA mdUnLock;
 527
 528     DX_WINDBG_trace();
 529
 530     /* Zero out members in DDHAL_UNLOCKDATA */
 531     ZeroMemory(&mdUnLock, sizeof(DDHAL_UNLOCKDATA));
 532
 533      /* Check if we got HAL support for this api */
 534     if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 535         DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
 536     {
 537         mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Unlock;
 538     }
 539     /* Check if we got HEL support for this api */
 540     else if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 541           DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
 542     {
 543         mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock;
 544     }
 545
 546     if (mdUnLock.Unlock == NULL)
 547     {
 548         /* This api are unsupported */
 549         return DDERR_UNSUPPORTED;
 550     }
 551
 552     mdUnLock.ddRVal = DDERR_NOTPALETTIZED;
 553     mdUnLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 554     mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
 555
 556     if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
 557     {
 558         DX_STUB_str("DdResetVisrgn fail");
 559         //return DDERR_UNSUPPORTED; /* this can fail */
 560     }
 561
 562     if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
 563     {
 564         DX_STUB_str("unLock fail");
 565         return DDERR_UNSUPPORTED;
 566     }
 567
 568     return mdUnLock.ddRVal;
 569 }
 570
 571 HRESULT WINAPI
 572 Main_DDrawSurface_AddAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT iface,
 573                                           LPDDRAWI_DDRAWSURFACE_INT pAttach)
 574 {
 575
 576    // LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
 577    // LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;
 578
 579    DX_WINDBG_trace();
 580
 581    DX_STUB;
 582 }
 583
 584 HRESULT WINAPI
 585 Main_DDrawSurface_GetAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT This,
 586                                      LPDDSCAPS2 pCaps,
 587                                      LPDDRAWI_DDRAWSURFACE_INT* ppSurface)
 588 {
 589     /* FIXME hacked */
 590
 591
 592     DX_WINDBG_trace();
 593
 594     *ppSurface = This->lpLcl->lpGbl->lpDD->dsList;
 595
 596
 597     return DD_OK;
 598 }
 599
 600 HRESULT WINAPI
 601 Main_DDrawSurface_GetBltStatus(LPDDRAWI_DDRAWSURFACE_INT This, DWORD dwFlags)
 602 {
 603
 604         DX_WINDBG_trace();
 605
 606         if (!(This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_FLIP))
 607         {
 608                 return DDERR_GENERIC;
 609         }
 610
 611         DX_STUB;
 612 }
 613
 614 HRESULT WINAPI
 615 Main_DDrawSurface_GetCaps(LPDDRAWI_DDRAWSURFACE_INT This, LPDDSCAPS2 pCaps)
 616 {
 617
 618         DX_WINDBG_trace();
 619
 620     if (This == NULL)
 621     {
 622        return DDERR_INVALIDOBJECT;
 623     }
 624
 625     if (pCaps == NULL)
 626     {
 627        return DDERR_INVALIDPARAMS;
 628     }
 629
 630     RtlZeroMemory(pCaps,sizeof(DDSCAPS2));
 631
 632         pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;
 633
 634     return DD_OK;
 635 }
 636
 637 HRESULT WINAPI
 638 Main_DDrawSurface_GetClipper(LPDDRAWI_DDRAWSURFACE_INT This,
 639                                   LPDIRECTDRAWCLIPPER* ppClipper)
 640 {
 641
 642         DX_WINDBG_trace();
 643
 644     if (This == NULL)
 645     {
 646        return DDERR_INVALIDOBJECT;
 647     }
 648
 649     if (ppClipper == NULL)
 650     {
 651        return DDERR_INVALIDPARAMS;
 652     }
 653
 654     if (This->lpLcl->lp16DDClipper == NULL)
 655     {
 656         return DDERR_NOCLIPPERATTACHED;
 657     }
 658
 659     *ppClipper = (LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper;
 660
 661     return DD_OK;
 662 }
 663
 664 HRESULT WINAPI
 665 Main_DDrawSurface_SetClipper (LPDDRAWI_DDRAWSURFACE_INT This,
 666                                   LPDIRECTDRAWCLIPPER pDDClipper)
 667 {
 668
 669         DX_WINDBG_trace();
 670
 671     if (This == NULL)
 672     {
 673        return DDERR_INVALIDOBJECT;
 674     }
 675
 676     if(pDDClipper == NULL)
 677     {
 678         if(!This->lpLcl->lp16DDClipper)
 679             return DDERR_NOCLIPPERATTACHED;
 680
 681         DirectDrawClipper_Release((LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper);
 682         This->lpLcl->lp16DDClipper = NULL;
 683         return DD_OK;
 684     }
 685
 686     // FIXME: Check Surface type and return DDERR_INVALIDSURFACETYPE
 687
 688     DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)pDDClipper);
 689     This->lpLcl->lp16DDClipper = (LPDDRAWI_DDRAWCLIPPER_INT)pDDClipper;
 690
 691     return DD_OK;
 692 }
 693
 694 HRESULT WINAPI
 695 Main_DDrawSurface_GetDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC *phDC)
 696 {
 697
 698         DX_WINDBG_trace();
 699
 700     if (This == NULL)
 701     {
 702        return DDERR_INVALIDOBJECT;
 703     }
 704
 705     if (phDC == NULL)
 706     {
 707        return DDERR_INVALIDPARAMS;
 708     }
 709
 710
 711     *phDC = (HDC)This->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 712
 713     return DD_OK;
 714 }
 715
 716 HRESULT WINAPI
 717 Main_DDrawSurface_GetPixelFormat(LPDDRAWI_DDRAWSURFACE_INT This,
 718                                  LPDDPIXELFORMAT pDDPixelFormat)
 719 {
 720     HRESULT retVale = DDERR_INVALIDPARAMS;
 721
 722     DX_WINDBG_trace();
 723
 724     if (pDDPixelFormat != NULL)
 725     {
 726         if (This->lpLcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
 727         {
 728             memcpy(pDDPixelFormat,&This->lpLcl->lpGbl->ddpfSurface,sizeof(DDPIXELFORMAT));
 729         }
 730         else
 731         {
 732             memcpy(pDDPixelFormat,&This->lpLcl->lpSurfMore->
 733                               lpDD_lcl->lpGbl->vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
 734         }
 735         retVale = DD_OK;
 736     }
 737
 738   return retVale;
 739 }
 740
 741 HRESULT WINAPI
 742 Main_DDrawSurface_GetSurfaceDesc(LPDDRAWI_DDRAWSURFACE_INT This,
 743                                       LPDDSURFACEDESC2 pDDSD)
 744 {
 745     DWORD dwSize;
 746
 747         DX_WINDBG_trace();
 748
 749     dwSize =  pDDSD->dwSize;
 750
 751     if ((dwSize != sizeof(DDSURFACEDESC)) &&
 752         (dwSize != sizeof(DDSURFACEDESC2)))
 753     {
 754            return DDERR_GENERIC;
 755     }
 756
 757         ZeroMemory(pDDSD,dwSize);
 758
 759         if (dwSize == sizeof(DDSURFACEDESC))
 760         {
 761                 LPDDSURFACEDESC lpDS = (LPDDSURFACEDESC) pDDSD;
 762                 memcpy(&lpDS->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
 763                 memcpy(&lpDS->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
 764                 memcpy(&lpDS->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
 765                 memcpy(&lpDS->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
 766                 memcpy(&lpDS->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
 767                 memcpy(&lpDS->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
 768
 769                 lpDS->dwAlphaBitDepth = This->lpLcl->dwAlpha;
 770                 lpDS->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
 771
 772                 /* FIXME setting the flags right */
 773                 // lpDS->dwFlags = This->lpLcl->dwFlags;
 774
 775                 lpDS->dwHeight = This->lpLcl->lpGbl->wHeight;
 776                 lpDS->dwWidth =  This->lpLcl->lpGbl->wWidth;
 777
 778                 /* This two are a union in lpDS  and in This->lpLcl->lpGbl
 779                   so I comment out lPitch
 780                   lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
 781                 */
 782                 lpDS->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
 783
 784
 785                 /* This tree are a union */
 786                 //lpDS->dwMipMapCount
 787                 //lpDS->dwRefreshRate
 788                 //lpDS->dwZBufferBitDepth
 789
 790                 /* Unknown */
 791                 // lpDS->dwReserved
 792                 // lpDS->lpSurface
 793         }
 794         else
 795         {
 796                 memcpy(&pDDSD->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
 797
 798                 /*
 799                    pDDSD->dwEmptyFaceColor is a union to ddckCKDestOverlay
 800         */
 801                 memcpy(&pDDSD->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
 802                 memcpy(&pDDSD->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
 803                 memcpy(&pDDSD->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
 804
 805                 /*
 806                    pDDSD->dwFVF is a union to ddpfPixelFormat
 807                 */
 808                 memcpy(&pDDSD->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
 809                 memcpy(&pDDSD->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
 810
 811
 812                 pDDSD->dwAlphaBitDepth = This->lpLcl->dwAlpha;
 813                 pDDSD->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
 814
 815                 /* FIXME setting the flags right */
 816                 // lpDS->dwFlags = This->lpLcl->dwFlags;
 817
 818                 pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
 819                 pDDSD->dwWidth =  This->lpLcl->lpGbl->wWidth;
 820
 821                 /* This two are a union in lpDS  and in This->lpLcl->lpGbl
 822                   so I comment out lPitch
 823                   lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
 824                 */
 825                 pDDSD->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
 826
 827                 /* This tree are a union */
 828                 // pDDSD->dwMipMapCount
 829                 // pDDSD->dwRefreshRate
 830                 // pDDSD->dwSrcVBHandle
 831
 832                 /* Unknown */
 833                 // lpDS->dwReserved
 834                 // lpDS->lpSurface
 835                 // pDDSD->dwTextureStage
 836         }
 837
 838     return DD_OK;
 839 }
 840
 841 HRESULT WINAPI
 842 Main_DDrawSurface_ReleaseDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC hDC)
 843 {
 844         DX_WINDBG_trace();
 845
 846     if (This == NULL)
 847     {
 848        return DDERR_INVALIDOBJECT;
 849     }
 850
 851     if (hDC == NULL)
 852     {
 853        return DDERR_INVALIDPARAMS;
 854     }
 855
 856     /* FIXME check if surface exits or not */
 857
 858
 859     if ((HDC)This->lpLcl->hDC == NULL)
 860     {
 861         return DDERR_GENERIC;
 862     }
 863
 864     return DD_OK;
 865 }
 866
 867 HRESULT WINAPI
 868 Main_DDrawSurface_SetColorKey (LPDDRAWI_DDRAWSURFACE_INT This,
 869                                    DWORD dwFlags, LPDDCOLORKEY pCKey)
 870 {
 871
 872         DDHAL_SETCOLORKEYDATA ColorKeyData;
 873
 874         DX_WINDBG_trace();
 875
 876     ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;
 877
 878         if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
 879         {
 880
 881                 ColorKeyData.lpDD = This->lpLcl->lpGbl->lpDD;
 882                 ColorKeyData.SetColorKey =      This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetColorKey;
 883
 884                 //ColorKeyData.lpDDSurface = &This->lpLcl->hDDSurface;
 885                 ColorKeyData.dwFlags = dwFlags;
 886                 /* FIXME
 887                    ColorKeyData.ckNew = ?
 888                    add / move dwFlags to This->lpLcl->dwFlags ??
 889              */
 890
 891                 if (ColorKeyData.SetColorKey(&ColorKeyData) == DDHAL_DRIVER_HANDLED )
 892                 {
 893                     return  ColorKeyData.ddRVal;
 894                 }
 895         }
 896         return DDERR_COLORKEYNOTSET;
 897 }
 898
 899
 900
 901 HRESULT WINAPI
 902 Main_DDrawSurface_SetOverlayPosition (LPDDRAWI_DDRAWSURFACE_INT This, LONG X, LONG Y)
 903 {
 904
 905         DDHAL_SETOVERLAYPOSITIONDATA OverLayPositionData;
 906
 907         DX_WINDBG_trace();
 908
 909     OverLayPositionData.ddRVal = DDERR_COLORKEYNOTSET;
 910
 911         if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
 912         {
 913
 914                 OverLayPositionData.lpDD = This->lpLcl->lpGbl->lpDD;
 915                 OverLayPositionData.SetOverlayPosition = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetOverlayPosition;
 916
 917                 //OverLayPositionData.lpDDSrcSurface = This->lpLcl->lpSurfaceOverlaying->lpLcl->hDDSurface;
 918                 //OverLayPositionData.lpDDDestSurface = This->lpLcl->hDDSurface;
 919
 920                 OverLayPositionData.lXPos = X;
 921                 OverLayPositionData.lYPos = Y;
 922
 923
 924                 /* FIXME
 925                    Should X and Y be save ??
 926              */
 927
 928                 if (OverLayPositionData.SetOverlayPosition(&OverLayPositionData) == DDHAL_DRIVER_HANDLED )
 929                 {
 930                     return  OverLayPositionData.ddRVal;
 931                 }
 932         }
 933
 934         return DDERR_GENERIC;
 935 }