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