dll/directx/ddraw/Surface/surface_main.c

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