reactos/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
 268     /* FIXME
 269        This is not right exiame how it should be done
 270      */
 271     DX_STUB_str("FIXME This is not right exiame how it should be done\n");
 272     return This->dwIntRefCnt;
 273 }
 274
 275
 276 HRESULT WINAPI Main_DDrawSurface_Blt(LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT rdst,
 277                                      LPDDRAWI_DDRAWSURFACE_INT ThisSrc, LPRECT rsrc, DWORD dwFlags, LPDDBLTFX lpbltfx)
 278 {
 279     DDHAL_BLTDATA mDdBlt;
 280
 281     DX_WINDBG_trace();
 282
 283     if (ThisDest == NULL)
 284     {
 285         return DDERR_INVALIDPARAMS;
 286     }
 287
 288     /* Zero out members in DDHAL_BLTDATA */
 289     ZeroMemory(&mDdBlt, sizeof(DDHAL_BLTDATA));
 290     ZeroMemory(&mDdBlt.bltFX, sizeof(DDBLTFX));
 291
 292     /* Check if we got HAL support for this api */
 293     if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 294           DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
 295     {
 296         mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Blt;
 297     }
 298     /* Check if we got HEL support for this api */
 299     else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 300           DDHAL_SURFCB32_BLT) == DDHAL_SURFCB32_BLT)
 301     {
 302         mDdBlt.Blt = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Blt;
 303     }
 304
 305     if (mDdBlt.Blt == NULL)
 306     {
 307         /* This API is unsupported */
 308         return DDERR_UNSUPPORTED;
 309     }
 310
 311     /* Prepare for draw, if we do not reset the DdResetVisrgn some graphics card will not draw on the screen */
 312     if (!DdResetVisrgn( ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
 313     {
 314         DX_STUB_str("DdResetVisrgn failed");
 315     }
 316
 317     mDdBlt.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 318     mDdBlt.lpDDDestSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
 319     ThisDest->lpLcl->lpSurfMore->slist[0]->hDC = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 320
 321     /* Setup Src */
 322     if (( ThisSrc != NULL ) )
 323     {
 324
 325         mDdBlt.lpDDSrcSurface = ThisSrc->lpLcl->lpSurfMore->slist[0];
 326         ThisSrc->lpLcl->lpSurfMore->slist[0]->hDC = ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 327
 328         if (rsrc != NULL)
 329         {
 330             memmove(&mDdBlt.rSrc, rsrc, sizeof (RECTL));
 331         }
 332         else
 333         {
 334             if(!GetWindowRect((HWND)ThisSrc->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
 335                 (RECT *)&mDdBlt.rSrc))
 336             {
 337                 DX_STUB_str("GetWindowRect failed");
 338             }
 339         }
 340
 341     /* FIXME
 342     *  compare so we do not write too far
 343     *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
 344     *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
 345     *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
 346     */
 347
 348     }
 349
 350     /* Setup dest */
 351     if (rdst != NULL)
 352     {
 353         memmove(&mDdBlt.rDest, rdst, sizeof (RECTL));
 354     }
 355     else
 356     {
 357         if (!GetWindowRect((HWND)ThisDest->lpLcl->lpSurfMore->lpDD_lcl->hWnd,
 358             (RECT *)&mDdBlt.rDest))
 359         {
 360             DX_STUB_str("GetWindowRect failed");
 361         }
 362     }
 363
 364     /* FIXME
 365     *  compare so we do not write too far
 366     *  ThisDest->lpLcl->lpGbl->wWidth; <- surface max width
 367     *  ThisDest->lpLcl->lpGbl->wHeight <- surface max heght
 368     *  ThisDest->lpLcl->lpGbl->lPitch  <- surface bpp
 369     */
 370
 371
 372     /* setup bltFX */
 373     if (lpbltfx != NULL)
 374     {
 375         memmove(&mDdBlt.bltFX, lpbltfx, sizeof (DDBLTFX));
 376     }
 377
 378     /* setup value that are not config yet */
 379     mDdBlt.dwFlags = dwFlags;
 380     mDdBlt.IsClipped = FALSE;
 381     mDdBlt.bltFX.dwSize = sizeof(DDBLTFX);
 382
 383
 384      /* FIXME
 385         BltData.dwRectCnt
 386         BltData.dwROPFlags
 387         BltData.IsClipped
 388         BltData.prDestRects
 389         BltData.rOrigDest
 390         BltData.rOrigSrc
 391         BltData.ddRVal
 392     */
 393
 394     if (mDdBlt.Blt(&mDdBlt) != DDHAL_DRIVER_HANDLED)
 395     {
 396         DX_STUB_str("mDdBlt DDHAL_DRIVER_HANDLED");
 397         return DDERR_NOBLTHW;
 398      }
 399
 400     return mDdBlt.ddRVal;
 401 }
 402
 403
 404 HRESULT WINAPI
 405 Main_DDrawSurface_Lock (LPDDRAWI_DDRAWSURFACE_INT ThisDest, LPRECT prect,
 406                         LPDDSURFACEDESC2 pDDSD, DWORD flags, HANDLE events)
 407 {
 408     DDHAL_LOCKDATA mdLock;
 409
 410     DX_WINDBG_trace();
 411
 412     DX_WINDBG_trace_res( (DWORD)ThisDest->lpLcl->lpGbl->wWidth, (DWORD)ThisDest->lpLcl->lpGbl->wHeight, (DWORD)ThisDest->lpLcl->lpGbl->lPitch, (DWORD) 0);
 413
 414      /* Zero out members in DDHAL_LOCKDATA */
 415     ZeroMemory(&mdLock, sizeof(DDHAL_LOCKDATA));
 416
 417      /* Check if we got HAL support for this api */
 418     if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 419         DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
 420     {
 421         mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Lock;
 422     }
 423     /* Check if we got HEL support for this api */
 424     else if (( ThisDest->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 425           DDHAL_SURFCB32_LOCK) == DDHAL_SURFCB32_LOCK)
 426     {
 427         mdLock.Lock = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Lock;
 428     }
 429
 430     if (mdLock.Lock == NULL)
 431     {
 432         /* This api are unsupported */
 433         return DDERR_UNSUPPORTED;
 434     }
 435
 436     if (events != NULL)
 437     {
 438         return DDERR_INVALIDPARAMS;
 439     }
 440
 441     /* FIXME add a check see if lock suport or not */
 442
 443     if (prect!=NULL)
 444     {
 445         mdLock.bHasRect = TRUE;
 446         memcpy(&mdLock.rArea,prect,sizeof(RECTL));
 447     }
 448     else
 449     {
 450         mdLock.bHasRect = FALSE;
 451     }
 452
 453     //FIXME check if it primary or not and use primary or pixelformat data, at moment it is hardcode to primary
 454
 455     mdLock.ddRVal = DDERR_CANTLOCKSURFACE;
 456     mdLock.dwFlags = flags;
 457     mdLock.lpDDSurface = ThisDest->lpLcl->lpSurfMore->slist[0];
 458     mdLock.lpDD = ThisDest->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 459     mdLock.lpSurfData = NULL;
 460
 461
 462     if (!DdResetVisrgn(ThisDest->lpLcl->lpSurfMore->slist[0], NULL))
 463     {
 464       DX_STUB_str("Here DdResetVisrgn lock");
 465       // return DDERR_UNSUPPORTED;
 466     }
 467
 468     if (mdLock.Lock(&mdLock)!= DDHAL_DRIVER_HANDLED)
 469     {
 470       DX_STUB_str("Here DDHAL_DRIVER_HANDLED lock");
 471       return DDERR_UNSUPPORTED;
 472     }
 473
 474     // FIXME ??? is this right ??
 475
 476     if (pDDSD != NULL)
 477     {
 478         ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
 479         pDDSD->dwSize = sizeof(DDSURFACEDESC2);
 480
 481         //if (pDDSD->dwSize == sizeof(DDSURFACEDESC2))
 482         //{
 483         //    ZeroMemory(pDDSD,sizeof(DDSURFACEDESC2));
 484         //    // FIXME the interanl mddsdPrimary shall be DDSURFACEDESC2
 485         //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
 486         //    pDDSD->dwSize = sizeof(DDSURFACEDESC2);
 487         //}
 488         //if (pDDSD->dwSize == sizeof(DDSURFACEDESC))
 489         //{
 490         //    RtlZeroMemory(pDDSD,sizeof(DDSURFACEDESC));
 491         //    memcpy(pDDSD,&This->Surf->mddsdPrimary,sizeof(DDSURFACEDESC));
 492         //    pDDSD->dwSize = sizeof(DDSURFACEDESC);
 493         //}
 494
 495
 496         pDDSD->lpSurface = (LPVOID)  mdLock.lpSurfData;
 497
 498         pDDSD->dwHeight = ThisDest->lpLcl->lpGbl->wHeight;
 499         pDDSD->dwWidth = ThisDest->lpLcl->lpGbl->wWidth;
 500
 501         pDDSD->ddpfPixelFormat.dwRGBBitCount = ThisDest->lpLcl->lpGbl->lpDD->lpModeInfo->dwBPP;// .lpModeInfo->dwBPP; //This->lpLcl->lpGbl->lPitch/ 8;
 502         pDDSD->lPitch = ThisDest->lpLcl->lpGbl->lPitch;
 503         pDDSD->dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_PITCH;
 504     }
 505
 506     return mdLock.ddRVal;
 507 }
 508
 509
 510 HRESULT WINAPI Main_DDrawSurface_Unlock (LPDDRAWI_DDRAWSURFACE_INT This, LPRECT pRect)
 511 {
 512     DDHAL_UNLOCKDATA mdUnLock;
 513
 514     DX_WINDBG_trace();
 515
 516     /* Zero out members in DDHAL_UNLOCKDATA */
 517     ZeroMemory(&mdUnLock, sizeof(DDHAL_UNLOCKDATA));
 518
 519      /* Check if we got HAL support for this api */
 520     if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HALDDSurface.dwFlags &
 521         DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
 522     {
 523         mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HALDDSurface.Unlock;
 524     }
 525     /* Check if we got HEL support for this api */
 526     else if (( This->lpLcl->lpGbl->lpDD->lpDDCBtmp->HELDDSurface.dwFlags &
 527           DDHAL_SURFCB32_UNLOCK) == DDHAL_SURFCB32_UNLOCK)
 528     {
 529         mdUnLock.Unlock = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl->lpDDCBtmp->HELDDSurface.Unlock;
 530     }
 531
 532     if (mdUnLock.Unlock == NULL)
 533     {
 534         /* This api are unsupported */
 535         return DDERR_UNSUPPORTED;
 536     }
 537
 538     mdUnLock.ddRVal = DDERR_NOTPALETTIZED;
 539     mdUnLock.lpDD = This->lpLcl->lpSurfMore->lpDD_lcl->lpGbl;
 540     mdUnLock.lpDDSurface = This->lpLcl->lpSurfMore->slist[0];
 541
 542     if (!DdResetVisrgn( mdUnLock.lpDDSurface, NULL))
 543     {
 544         DX_STUB_str("DdResetVisrgn fail");
 545         //return DDERR_UNSUPPORTED; /* this can fail */
 546     }
 547
 548     if (mdUnLock.Unlock(&mdUnLock)!= DDHAL_DRIVER_HANDLED)
 549     {
 550         DX_STUB_str("unLock fail");
 551         return DDERR_UNSUPPORTED;
 552     }
 553
 554     return mdUnLock.ddRVal;
 555 }
 556
 557 HRESULT WINAPI
 558 Main_DDrawSurface_AddAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT iface,
 559                                           LPDDRAWI_DDRAWSURFACE_INT pAttach)
 560 {
 561
 562    // LPDDRAWI_DDRAWSURFACE_INT This = (LPDDRAWI_DDRAWSURFACE_INT)iface;
 563    // LPDDRAWI_DDRAWSURFACE_INT That = (LPDDRAWI_DDRAWSURFACE_INT)pAttach;
 564
 565    DX_WINDBG_trace();
 566
 567    DX_STUB;
 568 }
 569
 570 HRESULT WINAPI
 571 Main_DDrawSurface_GetAttachedSurface(LPDDRAWI_DDRAWSURFACE_INT This,
 572                                      LPDDSCAPS2 pCaps,
 573                                      LPDDRAWI_DDRAWSURFACE_INT* ppSurface)
 574 {
 575     /* FIXME hacked */
 576
 577
 578     DX_WINDBG_trace();
 579
 580     *ppSurface = This->lpLcl->lpGbl->lpDD->dsList;
 581
 582
 583     return DD_OK;
 584 }
 585
 586 HRESULT WINAPI
 587 Main_DDrawSurface_GetBltStatus(LPDDRAWI_DDRAWSURFACE_INT This, DWORD dwFlags)
 588 {
 589
 590         DX_WINDBG_trace();
 591
 592         if (!(This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_FLIP))
 593         {
 594                 return DDERR_GENERIC;
 595         }
 596
 597         DX_STUB;
 598 }
 599
 600 HRESULT WINAPI
 601 Main_DDrawSurface_GetCaps(LPDDRAWI_DDRAWSURFACE_INT This, LPDDSCAPS2 pCaps)
 602 {
 603
 604         DX_WINDBG_trace();
 605
 606     if (This == NULL)
 607     {
 608        return DDERR_INVALIDOBJECT;
 609     }
 610
 611     if (pCaps == NULL)
 612     {
 613        return DDERR_INVALIDPARAMS;
 614     }
 615
 616     RtlZeroMemory(pCaps,sizeof(DDSCAPS2));
 617
 618         pCaps->dwCaps = This->lpLcl->ddsCaps.dwCaps;
 619
 620     return DD_OK;
 621 }
 622
 623 HRESULT WINAPI
 624 Main_DDrawSurface_GetClipper(LPDDRAWI_DDRAWSURFACE_INT This,
 625                                   LPDIRECTDRAWCLIPPER* ppClipper)
 626 {
 627
 628         DX_WINDBG_trace();
 629
 630     if (This == NULL)
 631     {
 632        return DDERR_INVALIDOBJECT;
 633     }
 634
 635     if (ppClipper == NULL)
 636     {
 637        return DDERR_INVALIDPARAMS;
 638     }
 639
 640     if (This->lpLcl->lp16DDClipper == NULL)
 641     {
 642         return DDERR_NOCLIPPERATTACHED;
 643     }
 644
 645     *ppClipper = (LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper;
 646
 647     return DD_OK;
 648 }
 649
 650 HRESULT WINAPI
 651 Main_DDrawSurface_SetClipper (LPDDRAWI_DDRAWSURFACE_INT This,
 652                                   LPDIRECTDRAWCLIPPER pDDClipper)
 653 {
 654
 655         DX_WINDBG_trace();
 656
 657     if (This == NULL)
 658     {
 659        return DDERR_INVALIDOBJECT;
 660     }
 661
 662     if(pDDClipper == NULL)
 663     {
 664         if(!This->lpLcl->lp16DDClipper)
 665             return DDERR_NOCLIPPERATTACHED;
 666
 667         DirectDrawClipper_Release((LPDIRECTDRAWCLIPPER)This->lpLcl->lp16DDClipper);
 668         This->lpLcl->lp16DDClipper = NULL;
 669         return DD_OK;
 670     }
 671
 672     // FIXME: Check Surface type and return DDERR_INVALIDSURFACETYPE
 673
 674     DirectDrawClipper_AddRef((LPDIRECTDRAWCLIPPER)pDDClipper);
 675     This->lpLcl->lp16DDClipper = (LPDDRAWI_DDRAWCLIPPER_INT)pDDClipper;
 676
 677     return DD_OK;
 678 }
 679
 680 HRESULT WINAPI
 681 Main_DDrawSurface_GetDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC *phDC)
 682 {
 683
 684         DX_WINDBG_trace();
 685
 686     if (This == NULL)
 687     {
 688        return DDERR_INVALIDOBJECT;
 689     }
 690
 691     if (phDC == NULL)
 692     {
 693        return DDERR_INVALIDPARAMS;
 694     }
 695
 696
 697     *phDC = (HDC)This->lpLcl->lpSurfMore->lpDD_lcl->hDC;
 698
 699     return DD_OK;
 700 }
 701
 702 HRESULT WINAPI
 703 Main_DDrawSurface_GetPixelFormat(LPDDRAWI_DDRAWSURFACE_INT This,
 704                                  LPDDPIXELFORMAT pDDPixelFormat)
 705 {
 706     HRESULT retVale = DDERR_INVALIDPARAMS;
 707
 708     DX_WINDBG_trace();
 709
 710     if (pDDPixelFormat != NULL)
 711     {
 712         if (This->lpLcl->dwFlags & DDRAWISURF_HASPIXELFORMAT)
 713         {
 714             memcpy(pDDPixelFormat,&This->lpLcl->lpGbl->ddpfSurface,sizeof(DDPIXELFORMAT));
 715         }
 716         else
 717         {
 718             memcpy(pDDPixelFormat,&This->lpLcl->lpSurfMore->
 719                               lpDD_lcl->lpGbl->vmiData.ddpfDisplay,sizeof(DDPIXELFORMAT));
 720         }
 721         retVale = DD_OK;
 722     }
 723
 724   return retVale;
 725 }
 726
 727 HRESULT WINAPI
 728 Main_DDrawSurface_GetSurfaceDesc(LPDDRAWI_DDRAWSURFACE_INT This,
 729                                       LPDDSURFACEDESC2 pDDSD)
 730 {
 731     DWORD dwSize;
 732
 733         DX_WINDBG_trace();
 734
 735     dwSize =  pDDSD->dwSize;
 736
 737     if ((dwSize != sizeof(DDSURFACEDESC)) &&
 738         (dwSize != sizeof(DDSURFACEDESC2)))
 739     {
 740            return DDERR_GENERIC;
 741     }
 742
 743         ZeroMemory(pDDSD,dwSize);
 744
 745         if (dwSize == sizeof(DDSURFACEDESC))
 746         {
 747                 LPDDSURFACEDESC lpDS = (LPDDSURFACEDESC) pDDSD;
 748                 memcpy(&lpDS->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
 749                 memcpy(&lpDS->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
 750                 memcpy(&lpDS->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
 751                 memcpy(&lpDS->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
 752                 memcpy(&lpDS->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
 753                 memcpy(&lpDS->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
 754
 755                 lpDS->dwAlphaBitDepth = This->lpLcl->dwAlpha;
 756                 lpDS->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
 757
 758                 /* FIXME setting the flags right */
 759                 // lpDS->dwFlags = This->lpLcl->dwFlags;
 760
 761                 lpDS->dwHeight = This->lpLcl->lpGbl->wHeight;
 762                 lpDS->dwWidth =  This->lpLcl->lpGbl->wWidth;
 763
 764                 /* This two are a union in lpDS  and in This->lpLcl->lpGbl
 765                   so I comment out lPitch
 766                   lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
 767                 */
 768                 lpDS->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
 769
 770
 771                 /* This tree are a union */
 772                 //lpDS->dwMipMapCount
 773                 //lpDS->dwRefreshRate
 774                 //lpDS->dwZBufferBitDepth
 775
 776                 /* Unknown */
 777                 // lpDS->dwReserved
 778                 // lpDS->lpSurface
 779         }
 780         else
 781         {
 782                 memcpy(&pDDSD->ddckCKDestBlt, &This->lpLcl->ddckCKDestBlt, sizeof(DDCOLORKEY));
 783
 784                 /*
 785                    pDDSD->dwEmptyFaceColor is a union to ddckCKDestOverlay
 786         */
 787                 memcpy(&pDDSD->ddckCKDestOverlay, &This->lpLcl->ddckCKDestOverlay, sizeof(DDCOLORKEY));
 788                 memcpy(&pDDSD->ddckCKSrcBlt, &This->lpLcl->ddckCKSrcBlt, sizeof(DDCOLORKEY));
 789                 memcpy(&pDDSD->ddckCKSrcOverlay, &This->lpLcl->ddckCKSrcOverlay, sizeof(DDCOLORKEY));
 790
 791                 /*
 792                    pDDSD->dwFVF is a union to ddpfPixelFormat
 793                 */
 794                 memcpy(&pDDSD->ddpfPixelFormat, &This->lpLcl->lpGbl->ddpfSurface, sizeof(DDPIXELFORMAT));
 795                 memcpy(&pDDSD->ddsCaps, &This->lpLcl->ddsCaps, sizeof(DDSCAPS));
 796
 797
 798                 pDDSD->dwAlphaBitDepth = This->lpLcl->dwAlpha;
 799                 pDDSD->dwBackBufferCount = This->lpLcl->dwBackBufferCount;
 800
 801                 /* FIXME setting the flags right */
 802                 // lpDS->dwFlags = This->lpLcl->dwFlags;
 803
 804                 pDDSD->dwHeight = This->lpLcl->lpGbl->wHeight;
 805                 pDDSD->dwWidth =  This->lpLcl->lpGbl->wWidth;
 806
 807                 /* This two are a union in lpDS  and in This->lpLcl->lpGbl
 808                   so I comment out lPitch
 809                   lpDS->lPitch = This->lpLcl->lpGbl->lPitch;
 810                 */
 811                 pDDSD->dwLinearSize = This->lpLcl->lpGbl->dwLinearSize;
 812
 813                 /* This tree are a union */
 814                 // pDDSD->dwMipMapCount
 815                 // pDDSD->dwRefreshRate
 816                 // pDDSD->dwSrcVBHandle
 817
 818                 /* Unknown */
 819                 // lpDS->dwReserved
 820                 // lpDS->lpSurface
 821                 // pDDSD->dwTextureStage
 822         }
 823
 824     return DD_OK;
 825 }
 826
 827 HRESULT WINAPI
 828 Main_DDrawSurface_ReleaseDC(LPDDRAWI_DDRAWSURFACE_INT This, HDC hDC)
 829 {
 830         DX_WINDBG_trace();
 831
 832     if (This == NULL)
 833     {
 834        return DDERR_INVALIDOBJECT;
 835     }
 836
 837     if (hDC == NULL)
 838     {
 839        return DDERR_INVALIDPARAMS;
 840     }
 841
 842     /* FIXME check if surface exits or not */
 843
 844
 845     if ((HDC)This->lpLcl->hDC == NULL)
 846     {
 847         return DDERR_GENERIC;
 848     }
 849
 850     return DD_OK;
 851 }
 852
 853 HRESULT WINAPI
 854 Main_DDrawSurface_SetColorKey (LPDDRAWI_DDRAWSURFACE_INT This,
 855                                    DWORD dwFlags, LPDDCOLORKEY pCKey)
 856 {
 857
 858         DDHAL_SETCOLORKEYDATA ColorKeyData;
 859
 860         DX_WINDBG_trace();
 861
 862     ColorKeyData.ddRVal = DDERR_COLORKEYNOTSET;
 863
 864         if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETCOLORKEY)
 865         {
 866
 867                 ColorKeyData.lpDD = This->lpLcl->lpGbl->lpDD;
 868                 ColorKeyData.SetColorKey =      This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetColorKey;
 869
 870                 //ColorKeyData.lpDDSurface = &This->lpLcl->hDDSurface;
 871                 ColorKeyData.dwFlags = dwFlags;
 872                 /* FIXME
 873                    ColorKeyData.ckNew = ?
 874                    add / move dwFlags to This->lpLcl->dwFlags ??
 875              */
 876
 877                 if (ColorKeyData.SetColorKey(&ColorKeyData) == DDHAL_DRIVER_HANDLED )
 878                 {
 879                     return  ColorKeyData.ddRVal;
 880                 }
 881         }
 882         return DDERR_COLORKEYNOTSET;
 883 }
 884
 885
 886
 887 HRESULT WINAPI
 888 Main_DDrawSurface_SetOverlayPosition (LPDDRAWI_DDRAWSURFACE_INT This, LONG X, LONG Y)
 889 {
 890
 891         DDHAL_SETOVERLAYPOSITIONDATA OverLayPositionData;
 892
 893         DX_WINDBG_trace();
 894
 895     OverLayPositionData.ddRVal = DDERR_COLORKEYNOTSET;
 896
 897         if (This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.dwFlags & DDHAL_SURFCB32_SETOVERLAYPOSITION)
 898         {
 899
 900                 OverLayPositionData.lpDD = This->lpLcl->lpGbl->lpDD;
 901                 OverLayPositionData.SetOverlayPosition = This->lpLcl->lpGbl->lpDD->lpDDCBtmp->cbDDSurfaceCallbacks.SetOverlayPosition;
 902
 903                 //OverLayPositionData.lpDDSrcSurface = This->lpLcl->lpSurfaceOverlaying->lpLcl->hDDSurface;
 904                 //OverLayPositionData.lpDDDestSurface = This->lpLcl->hDDSurface;
 905
 906                 OverLayPositionData.lXPos = X;
 907                 OverLayPositionData.lYPos = Y;
 908
 909
 910                 /* FIXME
 911                    Should X and Y be save ??
 912              */
 913
 914                 if (OverLayPositionData.SetOverlayPosition(&OverLayPositionData) == DDHAL_DRIVER_HANDLED )
 915                 {
 916                     return  OverLayPositionData.ddRVal;
 917                 }
 918         }
 919
 920         return DDERR_GENERIC;
 921 }