subsystems/win32/win32k/ntddraw/dxeng.c

   1 /*
   2  * PROJECT:          ReactOS Win32 Subsystem
   3  * LICENSE:          GPL - See COPYING in the top level directory
   4  * FILE:             subsystems/win32/win32k/ntddraw/dxeng.c
   5  * PURPOSE:          Implementation of DxEng functions
   6  * PROGRAMMERS:      Magnus Olsen (magnus@greatlord.com)
   7  */
   8
   9 #include <w32k.h>
  10 #include <debug.h>
  11
  12 HSEMAPHORE  ghsemShareDevLock = NULL;
  13
  14 ULONG gcEngFuncs = DXENG_INDEX_DxEngLoadImage + 1;
  15 DRVFN gaEngFuncs [] =
  16 {
  17     {0, (PFN) NULL},
  18     {DXENG_INDEX_DxEngNUIsTermSrv, (PFN)DxEngNUIsTermSrv},
  19     {DXENG_INDEX_DxEngScreenAccessCheck, (PFN)DxEngScreenAccessCheck},
  20     {DXENG_INDEX_DxEngRedrawDesktop, (PFN)DxEngRedrawDesktop},
  21     {DXENG_INDEX_DxEngDispUniq, (PFN)DxEngDispUniq},
  22     {DXENG_INDEX_DxEngIncDispUniq, (PFN)DxEngIncDispUniq},
  23     {DXENG_INDEX_DxEngVisRgnUniq, (PFN)DxEngVisRgnUniq},
  24     {DXENG_INDEX_DxEngLockShareSem, (PFN)DxEngLockShareSem},
  25     {DXENG_INDEX_DxEngUnlockShareSem, (PFN)DxEngUnlockShareSem},
  26     {DXENG_INDEX_DxEngEnumerateHdev, (PFN)DxEngEnumerateHdev},
  27     {DXENG_INDEX_DxEngLockHdev, (PFN)DxEngLockHdev},
  28     {DXENG_INDEX_DxEngUnlockHdev, (PFN)DxEngUnlockHdev},
  29     {DXENG_INDEX_DxEngIsHdevLockedByCurrentThread, (PFN)DxEngIsHdevLockedByCurrentThread},
  30     {DXENG_INDEX_DxEngReferenceHdev, (PFN)DxEngReferenceHdev},
  31     {DXENG_INDEX_DxEngUnreferenceHdev, (PFN)DxEngUnreferenceHdev},
  32     {DXENG_INDEX_DxEngGetDeviceGammaRamp, (PFN)DxEngGetDeviceGammaRamp},
  33     {DXENG_INDEX_DxEngSetDeviceGammaRamp, (PFN)DxEngSetDeviceGammaRamp},
  34     {DXENG_INDEX_DxEngSpTearDownSprites, (PFN)DxEngSpTearDownSprites},
  35     {DXENG_INDEX_DxEngSpUnTearDownSprites, (PFN)DxEngSpUnTearDownSprites},
  36     {DXENG_INDEX_DxEngSpSpritesVisible, (PFN)DxEngSpSpritesVisible},
  37     {DXENG_INDEX_DxEngGetHdevData, (PFN)DxEngGetHdevData},
  38     {DXENG_INDEX_DxEngSetHdevData, (PFN)DxEngSetHdevData},
  39     {DXENG_INDEX_DxEngCreateMemoryDC, (PFN)DxEngCreateMemoryDC},
  40     {DXENG_INDEX_DxEngGetDesktopDC, (PFN)DxEngGetDesktopDC},
  41     {DXENG_INDEX_DxEngDeleteDC, (PFN)DxEngDeleteDC},
  42     {DXENG_INDEX_DxEngCleanDC, (PFN)DxEngCleanDC},
  43     {DXENG_INDEX_DxEngSetDCOwner, (PFN)DxEngSetDCOwner},
  44     {DXENG_INDEX_DxEngLockDC, (PFN)DxEngLockDC},
  45     {DXENG_INDEX_DxEngUnlockDC, (PFN)DxEngUnlockDC},
  46     {DXENG_INDEX_DxEngSetDCState, (PFN)DxEngSetDCState},
  47     {DXENG_INDEX_DxEngGetDCState, (PFN)DxEngGetDCState},
  48     {DXENG_INDEX_DxEngSelectBitmap, (PFN)DxEngSelectBitmap},
  49     {DXENG_INDEX_DxEngSetBitmapOwner, (PFN)DxEngSetBitmapOwner},
  50     {DXENG_INDEX_DxEngDeleteSurface, (PFN)DxEngDeleteSurface},
  51     {DXENG_INDEX_DxEngGetSurfaceData, (PFN)DxEngGetSurfaceData},
  52     {DXENG_INDEX_DxEngAltLockSurface, (PFN)DxEngAltLockSurface},
  53     {DXENG_INDEX_DxEngUploadPaletteEntryToSurface, (PFN)DxEngUploadPaletteEntryToSurface},
  54     {DXENG_INDEX_DxEngMarkSurfaceAsDirectDraw, (PFN)DxEngMarkSurfaceAsDirectDraw},
  55     {DXENG_INDEX_DxEngSelectPaletteToSurface, (PFN)DxEngSelectPaletteToSurface},
  56     {DXENG_INDEX_DxEngSyncPaletteTableWithDevice, (PFN)DxEngSyncPaletteTableWithDevice},
  57     {DXENG_INDEX_DxEngSetPaletteState, (PFN)DxEngSetPaletteState},
  58     {DXENG_INDEX_DxEngGetRedirectionBitmap, (PFN)DxEngGetRedirectionBitmap},
  59     {DXENG_INDEX_DxEngLoadImage, (PFN)DxEngLoadImage}
  60 };
  61
  62
  63 /*++
  64 * @name DxEngDispUniq
  65 * @implemented
  66 *
  67 * The function DxEngDispUniq returns the DisplayUniqVisrgn counter value from GDI shared memory
  68 *
  69 * @return
  70 * Returns the DisplayUniqVisrgn counter value from GDI shared memory
  71 *
  72 * @remarks.
  73 * none
  74 *
  75 *--*/
  76 ULONG
  77 APIENTRY
  78 DxEngDispUniq()
  79 {
  80     DPRINT1("ReactX Calling : DxEngDispUniq\n");
  81     return GdiHandleTable->flDeviceUniq;
  82 }
  83
  84 /*++
  85 * @name DxEngGetDeviceGammaRamp
  86 * @implemented
  87 *
  88 * The function DxEngGetDeviceGammaRamp gets the gamma ramp to dxg.sys.
  89
  90 * @param HDEV hPDev
  91 * The hdev.
  92 *
  93 * @param PGAMMARAMP Ramp
  94 * Pointer to store the gamma ramp value in.
  95 *
  96 * @return
  97 *Returns TRUE for success, FALSE for failure
  98 *
  99 * @remarks.
 100 * None
 101 *
 102 *--*/
 103 BOOL
 104 APIENTRY
 105 DxEngGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
 106 {
 107     DPRINT1("ReactX Calling : DxEngGetDeviceGammaRamp\n");
 108     return IntGetDeviceGammaRamp(hPDev, Ramp);
 109 }
 110
 111
 112 /*++
 113 * @name DxEngLockDC
 114 * @implemented
 115 *
 116 * The function DxEngLockDC locks a hdc from dxg.sys
 117 *
 118 * @param HDC hDC
 119 * The handle we want to lock
 120 *
 121 * @return
 122 * Returns PDC if lock succeeded or NULL if it failed.
 123 *
 124 * @remarks.
 125 * none
 126 *
 127 *--*/
 128 PDC
 129 APIENTRY
 130 DxEngLockDC(HDC hDC)
 131 {
 132     DPRINT1("ReactX Calling : DxEngLockDC\n");
 133     return DC_LockDc(hDC);
 134 }
 135
 136
 137 /*++
 138 * @name DxEngUnlockDC
 139 * @implemented
 140 *
 141 * The function DxEngUnlockDC unlocks a pDC (hdc) from dxg.sys.
 142
 143 * @param PDC pDC
 144 * The handle we want to unlock.
 145 *
 146 * @return
 147 * This function returns TRUE no matter what.
 148 *
 149 * @remarks.
 150 * none
 151 *
 152 *--*/
 153 BOOLEAN
 154 APIENTRY
 155 DxEngUnlockDC(PDC pDC)
 156 {
 157     DPRINT1("ReactX Calling : DxEngUnlockDC\n");
 158     DC_UnlockDc(pDC);
 159     return TRUE;
 160 }
 161
 162 /*++
 163 * @name DxEngLockShareSem
 164 * @implemented
 165 *
 166 * The function DxEngLockShareSem locks a struct of type ghsemShareDevLock that can be shared.
 167 *
 168 * @return
 169 * This function returns TRUE for success and FALSE for failure.
 170 * FALSE must mean the struct has already been locked.
 171 *
 172 * @remarks.
 173 * It is being used in various ntuser* functions and ntgdi*
 174 * ReactOS specific: It is not in use yet?
 175 *SystemResourcesList
 176 *--*/
 177 BOOLEAN
 178 APIENTRY
 179 DxEngLockShareSem()
 180 {
 181     DPRINT1("ReactX Calling : DxEngLockShareSem\n");
 182     if(!ghsemShareDevLock) ghsemShareDevLock = EngCreateSemaphore(); // Hax, should be in dllmain.c
 183     IntGdiAcquireSemaphore(ghsemShareDevLock);
 184     return TRUE;
 185 }
 186
 187 /*++
 188 * @name DxEngUnlockShareSem
 189 * @implemented
 190 *
 191 * The function DxEngUnlockShareSem unlocks the struct of type ghsemShareDevLock.
 192 *
 193 * @return
 194 * This function returns TRUE no matter what.
 195 *
 196 * @remarks.
 197 * ReactOS specific: It is not in use yet?
 198 *
 199 *--*/
 200 BOOLEAN
 201 APIENTRY
 202 DxEngUnlockShareSem()
 203 {
 204     DPRINT1("ReactX Calling : DxEngUnlockShareSem\n");
 205     IntGdiReleaseSemaphore(ghsemShareDevLock);
 206     return TRUE;
 207 }
 208
 209 /*++
 210 * @name DxEngSetDeviceGammaRamp
 211 * @implemented
 212 *
 213 * The function DxEngSetDeviceGammaRamp sets gamma ramp from dxg.sys
 214
 215 * @param HDEV hPDev
 216 * The hdev
 217 *
 218 * @param PGAMMARAMP Ramp
 219 * Value to change gamma ramp to.
 220 *
 221 * @param BOOL Test
 222 * Whether gamma should be tested. TRUE to test, FALSE to not test.
 223 *
 224 * @return
 225 *Returns TRUE for success, FALSE for failure.
 226 *
 227 * @remarks.
 228 * None
 229 *
 230 *--*/
 231 BOOLEAN
 232 APIENTRY
 233 DxEngSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
 234 {
 235     DPRINT1("ReactX Calling : DxEngSetDeviceGammaRamp\n");
 236     return IntSetDeviceGammaRamp(hPDev, Ramp, Test);
 237 }
 238
 239 /*++
 240 * @name DxEngGetHdevData
 241 * @implemented
 242 *
 243 * The function DxEngGetHdevData retrieves a value from the HDEV
 244
 245 * @param HDEV hPDev
 246 * The HDEV
 247 *
 248 * @param DXEGSHDEVDATA Type
 249 * The following typs are supported
 250 * Type                                            Purpose
 251 * DxEGShDevData_Surface      Retrieve pointer to Surface handle.
 252 * DxEGShDevData_hSpooler     See if the device is a spooler driver.
 253 * DxEGShDevData_DitherFmt    Retrieve the device iDitherFormat
 254 * DxEGShDevData_FxCaps       Retrieve the device flGraphicsCaps
 255 * DxEGShDevData_FxCaps2      Retrieve the device flGraphicsCaps2
 256 * DxEGShDevData_DrvFuncs     Retrieve the device DriverFunctions function table
 257 * DxEGShDevData_dhpdev       Retrieve the device hPDev, the real DHPDEV
 258 * DxEGShDevData_eddg         Retrieve the device pEDDgpl
 259 * DxEGShDevData_dd_nCount    Retrieve the device DxDd_nCount
 260 * DxEGShDevData_dd_flags     Retrieve the device DxDd_Flags
 261 * DxEGShDevData_disable      See if the device pdev is disabled
 262 * DxEGShDevData_metadev      See if the device pdev is a meta device
 263 * DxEGShDevData_display      See if the device is the primary display driver
 264 * DxEGShDevData_Parent       Retrieve the ppdevParent
 265 * DxEGShDevData_OpenRefs     Retrieve the pdevOpenRefs counter
 266 * DxEGShDevData_palette      See if the device RC_PALETTE is set
 267 * DxEGShDevData_ldev         ATM we do not support the Loader Device driver structure
 268 * DxEGShDevData_GDev         Retrieve the device pGraphicsDevice
 269 * DxEGShDevData_clonedev     Retrieve the device PDEV_CLONE_DEVICE flag is set or not
 270 *
 271 * @return
 272 * Returns the data we requested
 273 *
 274 * @remarks.
 275 * ReactOS specific: Implementation is incomplete, I do not save the value into the hdev yet.
 276 *
 277 *--*/
 278 DWORD_PTR
 279 APIENTRY
 280 DxEngGetHdevData(HDEV hDev,
 281                  DXEGSHDEVDATA Type)
 282 {
 283     DWORD_PTR retVal = 0;
 284     PPDEVOBJ PDev = (PPDEVOBJ)hDev;
 285
 286     DPRINT1("ReactX Calling : DxEngGetHdevData DXEGSHDEVDATA : %ld\n", Type);
 287
 288 #if 1
 289     DPRINT1("HDEV hDev %08lx\n", hDev);
 290 #endif
 291
 292     switch ( Type )
 293     {
 294       case DxEGShDevData_Surface:
 295         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Surface\n");
 296         retVal = (DWORD_PTR) PDev->pSurface; // ptr to Surface handle.
 297         break;
 298       case DxEGShDevData_hSpooler:
 299         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_hSpooler\n");
 300         retVal = 0;//(DWORD_PTR) PDev->hSpooler; // If the device is a spooler driver.
 301         break;
 302       case DxEGShDevData_DitherFmt:
 303         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DitherFmt\n");
 304         retVal = (DWORD_PTR) PDev->devinfo.iDitherFormat;
 305         break;
 306       case DxEGShDevData_FxCaps:
 307         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps\n");
 308         retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps;
 309         break;
 310       case DxEGShDevData_FxCaps2:
 311         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps2\n");
 312         retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps2;
 313         break;
 314       case DxEGShDevData_DrvFuncs:
 315         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DrvFuncs\n");
 316         retVal = (DWORD_PTR) &PDev->DriverFunctions;
 317         break;
 318       case DxEGShDevData_dhpdev:
 319         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dhpdev\n");
 320         retVal = (DWORD_PTR) PDev->dhpdev; // DHPDEV
 321         break;
 322       case DxEGShDevData_eddg:
 323         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_eddg\n");
 324         retVal = (DWORD_PTR) PDev->pEDDgpl;
 325         break;
 326       case DxEGShDevData_dd_nCount:
 327         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_nCount\n");
 328         retVal = (DWORD_PTR) PDev->DxDd_nCount;
 329         break;
 330       case DxEGShDevData_dd_flags:
 331         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_flags\n");
 332         retVal = (DWORD_PTR) PDev->DxDd_Flags;
 333         break;
 334       case DxEGShDevData_disable:
 335         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_disable\n");
 336         retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISABLED;
 337         break;
 338       case DxEGShDevData_metadev:
 339         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_metadev\n");
 340         retVal = (DWORD_PTR) PDev->flFlags & PDEV_META_DEVICE;
 341         break;
 342       case DxEGShDevData_display:
 343         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_display\n");
 344         retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISPLAY;
 345         break;
 346       case DxEGShDevData_Parent:
 347         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Parent\n");
 348         retVal = (DWORD_PTR) PDev->ppdevParent;
 349         break;
 350       case DxEGShDevData_OpenRefs:
 351         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_OpenRefs\n");
 352         retVal = (DWORD_PTR) PDev->cPdevOpenRefs != 0;
 353         break;
 354       case DxEGShDevData_palette:
 355         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_palette\n");
 356         retVal = (DWORD_PTR) PDev->gdiinfo.flRaster & RC_PALETTE;
 357         break;
 358       case DxEGShDevData_ldev:
 359           DPRINT1("DxEGShDevData_ldev not supported yet\n");
 360       // ATM we do not support the Loader Device driver structure.
 361 //        retVal = (DWORD) PDev->pldev;
 362         break;
 363       case DxEGShDevData_GDev:
 364         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_GDev\n");
 365         retVal = (DWORD_PTR) PDev->pGraphicsDevice; // P"GRAPHICS_DEVICE"
 366         break;
 367       case DxEGShDevData_clonedev:
 368         DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_clonedev\n");
 369         retVal = (DWORD_PTR) PDev->flFlags & PDEV_CLONE_DEVICE;
 370         break;
 371
 372       default:
 373         break;
 374     }
 375
 376 #if 1
 377     DPRINT1("return value %08lx\n", retVal);
 378 #endif
 379
 380     return retVal;
 381
 382 }
 383
 384 /*++
 385 * @name DxEngSetHdevData
 386 * @implemented
 387 *
 388 * The function DxEngSetHdevData sets a value in hdev
 389
 390 * @param HDEV hPDev
 391 * The hdev
 392 *
 393 * @param DXEGSHDEVDATA Type
 394 * Supports only DxEGShDevData_dd_nCount. It is an internal counter on how many times hdev has been locked and unlocked
 395 *
 396 * @param DWORD Data
 397 * The value to be saved to hdev's internal counter.
 398 *
 399 * @return
 400 * Returns TRUE for success, FALSE for failure
 401 *
 402 * @remarks.
 403 * none
 404 *
 405 *--*/
 406 BOOLEAN
 407 APIENTRY
 408 DxEngSetHdevData(HDEV hDev,
 409                  DXEGSHDEVDATA Type,
 410                  DWORD_PTR Data)
 411 {
 412     BOOLEAN retVal = FALSE; // Default, no set.
 413
 414     DPRINT1("ReactX Calling : DxEngSetHdevData DXEGSHDEVDATA : %ld\n", Type);
 415
 416     if ( Type == DxEGShDevData_dd_nCount )
 417     {
 418         ((PPDEVOBJ)hDev)->DxDd_nCount = Data;
 419         retVal = TRUE; // Set
 420     }
 421     return retVal;
 422 }
 423
 424 /*++
 425 * @name DxEngGetDCState
 426 * @implemented
 427 *
 428 * The function DxEngGetDCState is capable of returning three
 429 * DC states depending on what value is passed in its second parameter:
 430 * 1. If the DC is full screen
 431 * 2. Get Complexity of visible region
 432 * 3. Get Driver hdev, which is ppdev
 433 *
 434 * @param HDC hdc
 435 * The DC handle
 436 *
 437 * @param DWORD type
 438 * value 1 = Is DC fullscreen
 439 * value 2 = Get Complexity of visible region.
 440 * value 3 = Get Driver hdev, which is a ppdev.
 441 *
 442 * @return
 443 * Return one of the type values
 444 *
 445 * @remarks.
 446 * We do not have type 2 implemented yet
 447 *
 448 *--*/
 449 DWORD_PTR
 450 APIENTRY
 451 DxEngGetDCState(HDC hDC,
 452                 DWORD type)
 453 {
 454     PDC pDC = DC_LockDc(hDC);
 455     DWORD_PTR retVal = 0;
 456
 457     DPRINT1("ReactX Calling : DxEngGetDCState type : %ld\n", type);
 458
 459     if (pDC)
 460     {
 461         switch (type)
 462         {
 463             case 1:
 464                 retVal = (DWORD_PTR) pDC->fs & DC_FLAG_FULLSCREEN;
 465                 break;
 466             case 2:
 467                 UNIMPLEMENTED;
 468                 break;
 469             case 3:
 470             {
 471                 /* Return the HDEV of this DC. */
 472                 retVal = (DWORD_PTR) pDC->ppdev;
 473                 break;
 474             }
 475             default:
 476                 /* if a valid type is not found, zero is returned */
 477                 DPRINT1("Warning did not find type %d\n",type);
 478                 break;
 479         }
 480         DC_UnlockDc(pDC);
 481     }
 482
 483     return retVal;
 484 }
 485
 486 /*++
 487 * @name DxEngIncDispUniq
 488 * @implemented
 489 *
 490 * The function DxEngIncDispUniq increments the DisplayUniqVisrgn counter from GDI shared memory.
 491 *
 492 * @return
 493 * This function returns TRUE no matter what.
 494 *
 495 * @remarks.
 496 * none
 497 *
 498 *--*/
 499 BOOLEAN
 500 APIENTRY
 501 DxEngIncDispUniq()
 502 {
 503     DPRINT1("ReactX Calling : DxEngIncDispUniq \n");
 504
 505     InterlockedIncrement((LONG*)&GdiHandleTable->flDeviceUniq);
 506     return TRUE;
 507 }
 508
 509 /*++
 510 * @name DxEngLockHdev
 511 * @implemented
 512 *
 513 * The function DxEngLockHdev lock the internal PDEV
 514 *
 515 * @param HDEV type
 516 * it is a pointer to win32k internal pdev struct known as PPDEVOBJ
 517
 518 * @return
 519 * This function returns TRUE no matter what.
 520 *
 521 * @remarks.
 522 * none
 523 *
 524 *--*/
 525 BOOLEAN
 526 APIENTRY
 527 DxEngLockHdev(HDEV hDev)
 528 {
 529     PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
 530     PERESOURCE Resource;
 531
 532     DPRINT1("ReactX Calling : DxEngLockHdev \n");
 533
 534     DPRINT1("hDev                   : 0x%08lx\n",hDev);
 535
 536     Resource = ppdev->hsemDevLock;
 537
 538     if (Resource)
 539     {
 540         KeEnterCriticalRegion();
 541         ExAcquireResourceExclusiveLite( Resource , TRUE); // Lock monitor.
 542     }
 543     return TRUE;
 544 }
 545
 546 /*++
 547 * @name DxEngUnlockHdev
 548 * @implemented
 549 *
 550 * The function DxEngUnlockHdev unlock the internal PDEV
 551 *
 552 * @param HDEV type
 553 * it is a pointer to win32k internal pdev struct known as PPDEVOBJ
 554
 555 * @return
 556 * This function returns TRUE no matter what.
 557 *
 558 * @remarks.
 559 * none
 560 *
 561 *--*/
 562 BOOLEAN
 563 APIENTRY
 564 DxEngUnlockHdev(HDEV hDev)
 565 {
 566     PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
 567     PERESOURCE Resource = ppdev->hsemDevLock;
 568
 569     DPRINT1("ReactX Calling : DxEngUnlockHdev \n");
 570
 571     if (Resource)
 572     {
 573         ExReleaseResourceLite( Resource );
 574         KeLeaveCriticalRegion();
 575     }
 576     return TRUE;
 577 }
 578
 579
 580 /************************************************************************/
 581 /* DxEngReferenceHdev                                                   */
 582 /************************************************************************/
 583 BOOLEAN
 584 APIENTRY
 585 DxEngReferenceHdev(HDEV hDev)
 586 {
 587     IntGdiReferencePdev((PPDEVOBJ) hDev);
 588     /* ALWAYS return true */
 589     return TRUE;
 590 }
 591
 592 /************************************************************************/
 593 /* DxEngNUIsTermSrv                                                     */
 594 /************************************************************************/
 595
 596 /* Notes : Check see if termal server got a connections or not */
 597 BOOLEAN
 598 APIENTRY
 599 DxEngNUIsTermSrv()
 600 {
 601     /* FIXME ReactOS does not suport terminal server yet, we can not check if we got a connections or not */
 602     UNIMPLEMENTED;
 603     return FALSE;
 604 }
 605
 606 /************************************************************************/
 607 /* DxEngRedrawDesktop                                                   */
 608 /************************************************************************/
 609
 610 /* Notes : it always returns TRUE, and it updates whole screen
 611    (redraws current desktop) */
 612 BOOLEAN
 613 APIENTRY
 614 DxEngRedrawDesktop()
 615 {
 616     UserRedrawDesktop();
 617     return TRUE;
 618 }
 619
 620
 621 ULONG gulVisRgnUniqueness; // Increase count everytime client region is updated.
 622
 623 /************************************************************************/
 624 /* DxEngVisRgnUniq                                                      */
 625 /************************************************************************/
 626 /* Notes :  returns the VisRgnUniq counter for win32k */
 627 ULONG
 628 APIENTRY
 629 DxEngVisRgnUniq()
 630 {
 631     DPRINT1("ReactX Calling : DxEngVisRgnUniq \n");
 632
 633     return gulVisRgnUniqueness;
 634 }
 635
 636 /************************************************************************/
 637 /* DxEngEnumerateHdev                                                   */
 638 /************************************************************************/
 639 /* Enumerate all drivers in win32k */
 640 HDEV *
 641 APIENTRY
 642 DxEngEnumerateHdev(HDEV *hdev)
 643 {
 644     /* FIXME Enumerate all drivers in win32k */
 645     UNIMPLEMENTED;
 646     return FALSE;
 647 }
 648
 649 /************************************************************************/
 650 /* DxEngCreateMemoryDC                                                  */
 651 /************************************************************************/
 652 HDC
 653 APIENTRY
 654 DxEngCreateMemoryDC(HDEV hDev)
 655 {
 656     return IntGdiCreateDisplayDC(hDev, DC_TYPE_MEMORY, FALSE);
 657 }
 658
 659 /************************************************************************/
 660 /* DxEngScreenAccessCheck                                               */
 661 /************************************************************************/
 662 DWORD APIENTRY DxEngScreenAccessCheck()
 663 {
 664     UNIMPLEMENTED;
 665
 666     /* we cheating here and tell dxg.sys it have always premitions to access the screen */
 667     return TRUE;
 668 }
 669
 670 /************************************************************************/
 671 /* DxEngIsHdevLockedByCurrentThread                                     */
 672 /************************************************************************/
 673 BOOLEAN
 674 APIENTRY
 675 DxEngIsHdevLockedByCurrentThread(HDEV hDev)
 676 {   // base on EngIsSemaphoreOwnedByCurrentThread w/o the Ex call.
 677     PERESOURCE pSem = ((PPDEVOBJ)hDev)->hsemDevLock;
 678     return pSem->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread();
 679 }
 680
 681
 682 /************************************************************************/
 683 /* DxEngUnreferenceHdev                                                 */
 684 /************************************************************************/
 685 BOOLEAN
 686 APIENTRY
 687 DxEngUnreferenceHdev(HDEV hDev)
 688 {
 689     IntGdiUnreferencePdev((PPDEVOBJ) hDev, 0);
 690     return TRUE; // Always true.
 691 }
 692
 693 /************************************************************************/
 694 /* DxEngGetDesktopDC                                                    */
 695 /************************************************************************/
 696 HDC
 697 APIENTRY
 698 DxEngGetDesktopDC(ULONG DcType, BOOL EmptyDC, BOOL ValidatehWnd)
 699 {
 700     return UserGetDesktopDC(DcType, EmptyDC, ValidatehWnd);
 701 }
 702
 703 /************************************************************************/
 704 /* DxEngDeleteDC                                                        */
 705 /************************************************************************/
 706 BOOLEAN
 707 APIENTRY
 708 DxEngDeleteDC(HDC hdc, BOOL Force)
 709 {
 710    return IntGdiDeleteDC(hdc, Force);
 711 }
 712
 713 /************************************************************************/
 714 /* DxEngCleanDC                                                         */
 715 /************************************************************************/
 716 BOOLEAN
 717 APIENTRY
 718 DxEngCleanDC(HDC hdc)
 719 {
 720     return IntGdiCleanDC(hdc);
 721 }
 722
 723 /************************************************************************/
 724 /* DxEngSetDCOwner                                                      */
 725 /************************************************************************/
 726 BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
 727 {
 728     DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
 729
 730     return IntGdiSetDCOwnerEx( hObject, OwnerMask, FALSE);
 731 }
 732
 733 /************************************************************************/
 734 /* DxEngSetDCState                                                      */
 735 /************************************************************************/
 736 BOOLEAN
 737 APIENTRY
 738 DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
 739 {
 740    BOOLEAN Ret = FALSE;
 741    PDC pDC = DC_LockDc(hDC);
 742
 743    if (pDC)
 744    {
 745       if (SetType == 1)
 746       {
 747         if ( Set )
 748             pDC->fs |= DC_FLAG_FULLSCREEN;
 749         else
 750             pDC->fs &= ~DC_FLAG_FULLSCREEN;
 751         Ret = TRUE;
 752       }
 753       DC_UnlockDc(pDC);
 754       return Ret; // Everything else returns FALSE.
 755    }
 756    return Ret;
 757 }
 758
 759 /************************************************************************/
 760 /* DxEngSelectBitmap                                                    */
 761 /************************************************************************/
 762 DWORD APIENTRY DxEngSelectBitmap(DWORD x1, DWORD x2)
 763 {
 764     UNIMPLEMENTED;
 765     return FALSE;
 766 }
 767
 768 /************************************************************************/
 769 /* DxEngSetBitmapOwner                                                  */
 770 /************************************************************************/
 771 DWORD APIENTRY DxEngSetBitmapOwner(DWORD x1, DWORD x2)
 772 {
 773     UNIMPLEMENTED;
 774     return FALSE;
 775 }
 776
 777 /************************************************************************/
 778 /* DxEngDeleteSurface                                                   */
 779 /************************************************************************/
 780 DWORD APIENTRY DxEngDeleteSurface(DWORD x1)
 781 {
 782     UNIMPLEMENTED;
 783     return FALSE;
 784 }
 785
 786 /************************************************************************/
 787 /* DxEngGetSurfaceData                                                  */
 788 /************************************************************************/
 789 DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
 790 {
 791     UNIMPLEMENTED;
 792     return FALSE;
 793 }
 794
 795 /************************************************************************/
 796 /* DxEngAltLockSurface                                                  */
 797 /************************************************************************/
 798 DWORD APIENTRY DxEngAltLockSurface(DWORD x1)
 799 {
 800     UNIMPLEMENTED;
 801     return FALSE;
 802 }
 803
 804 /************************************************************************/
 805 /* DxEngUploadPaletteEntryToSurface                                     */
 806 /************************************************************************/
 807 DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
 808 {
 809     UNIMPLEMENTED;
 810     return FALSE;
 811 }
 812
 813 /************************************************************************/
 814 /* DxEngMarkSurfaceAsDirectDraw                                         */
 815 /************************************************************************/
 816 DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
 817 {
 818     UNIMPLEMENTED;
 819     return FALSE;
 820 }
 821
 822 /************************************************************************/
 823 /* DxEngSelectPaletteToSurface                                          */
 824 /************************************************************************/
 825 DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
 826 {
 827     UNIMPLEMENTED;
 828     return FALSE;
 829 }
 830
 831 /************************************************************************/
 832 /* DxEngSyncPaletteTableWithDevice                                      */
 833 /************************************************************************/
 834 DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
 835 {
 836     UNIMPLEMENTED;
 837     return FALSE;
 838 }
 839
 840 /************************************************************************/
 841 /* DxEngSetPaletteState                                                 */
 842 /************************************************************************/
 843 DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
 844 {
 845     UNIMPLEMENTED;
 846     return FALSE;
 847 }
 848
 849 /************************************************************************/
 850 /* DxEngGetRedirectionBitmap                                            */
 851 /************************************************************************/
 852 DWORD
 853 APIENTRY
 854 DxEngGetRedirectionBitmap(DWORD x1)
 855 {
 856     return FALSE; // Normal return.
 857 }
 858
 859 /************************************************************************/
 860 /* DxEngLoadImage                                                       */
 861 /************************************************************************/
 862 DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
 863 {
 864     UNIMPLEMENTED;
 865     return FALSE;
 866 }
 867
 868 /************************************************************************/
 869 /* DxEngSpTearDownSprites                                               */
 870 /************************************************************************/
 871 DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
 872 {
 873     UNIMPLEMENTED;
 874     return FALSE;
 875 }
 876
 877 /************************************************************************/
 878 /* DxEngSpUnTearDownSprites                                             */
 879 /************************************************************************/
 880 DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
 881 {
 882     UNIMPLEMENTED;
 883     return FALSE;
 884 }
 885
 886 /************************************************************************/
 887 /* DxEngSpSpritesVisible                                                */
 888 /************************************************************************/
 889 DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
 890 {
 891     UNIMPLEMENTED;
 892     return FALSE;
 893 }