xref: /reactos/win32ss/reactx/ntddraw/dxeng.c (revision 8a978a17) 
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.dubinskij2013@yandex.ua)
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_FLAG_FULLSCREEN;
465                 break;
466             case 2:
467                 /* Return the number of rectangles in the visible region. */
468                 retVal = (DWORD_PTR) pDC->prgnRao ? pDC->prgnRao->rdh.nCount : pDC->prgnVis->rdh.nCount;
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     return retVal;
485 }
486 
487 /*++
488 * @name DxEngIncDispUniq
489 * @implemented
490 *
491 * The function DxEngIncDispUniq increments the DisplayUniqVisrgn counter from GDI shared memory.
492 *
493 * @return
494 * This function returns TRUE no matter what.
495 *
496 * @remarks.
497 * none
498 *
499 *--*/
500 BOOLEAN
501 APIENTRY
502 DxEngIncDispUniq(VOID)
503 {
504     DPRINT1("ReactX Calling : DxEngIncDispUniq \n");
505 
506     InterlockedIncrement((LONG*)&GdiHandleTable->flDeviceUniq);
507     return TRUE;
508 }
509 
510 /*++
511 * @name DxEngLockHdev
512 * @implemented
513 *
514 * The function DxEngLockHdev lock the internal PDEV
515 *
516 * @param HDEV type
517 * it is a pointer to win32k internal pdev struct known as PPDEVOBJ
518 
519 * @return
520 * This function returns TRUE no matter what.
521 *
522 * @remarks.
523 * none
524 *
525 *--*/
526 BOOLEAN
527 APIENTRY
528 DxEngLockHdev(HDEV hDev)
529 {
530     PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
531     PERESOURCE Resource;
532 
533     DPRINT1("ReactX Calling : DxEngLockHdev \n");
534 
535     DPRINT1("hDev                   : 0x%p\n",hDev);
536 
537     Resource = (PERESOURCE)ppdev->hsemDevLock;
538 
539     if (Resource)
540     {
541         KeEnterCriticalRegion();
542         ExAcquireResourceExclusiveLite( Resource , TRUE); // Lock monitor.
543     }
544     return TRUE;
545 }
546 
547 /*++
548 * @name DxEngUnlockHdev
549 * @implemented
550 *
551 * The function DxEngUnlockHdev unlock the internal PDEV
552 *
553 * @param HDEV type
554 * it is a pointer to win32k internal pdev struct known as PPDEVOBJ
555 
556 * @return
557 * This function returns TRUE no matter what.
558 *
559 * @remarks.
560 * none
561 *
562 *--*/
563 BOOLEAN
564 APIENTRY
565 DxEngUnlockHdev(HDEV hDev)
566 {
567     PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
568     PERESOURCE Resource = (PERESOURCE)ppdev->hsemDevLock;
569 
570     DPRINT1("ReactX Calling : DxEngUnlockHdev \n");
571 
572     if (Resource)
573     {
574         ExReleaseResourceLite( Resource );
575         KeLeaveCriticalRegion();
576     }
577     return TRUE;
578 }
579 
580 
581 /************************************************************************/
582 /* DxEngReferenceHdev                                                   */
583 /************************************************************************/
584 BOOLEAN
585 APIENTRY
586 DxEngReferenceHdev(HDEV hDev)
587 {
588     IntGdiReferencePdev((PPDEVOBJ) hDev);
589     /* ALWAYS return true */
590     return TRUE;
591 }
592 
593 /************************************************************************/
594 /* DxEngNUIsTermSrv                                                     */
595 /************************************************************************/
596 
597 /* Notes: Check if terminal server got connections or not */
598 BOOLEAN
599 APIENTRY
600 DxEngNUIsTermSrv(VOID)
601 {
602     /* FIXME: ReactOS does not suport terminal server yet, we can not check if we got connections or not */
603     UNIMPLEMENTED;
604     return FALSE;
605 }
606 
607 /************************************************************************/
608 /* DxEngRedrawDesktop                                                   */
609 /************************************************************************/
610 
611 /* Notes: it always returns TRUE, and it updates whole screen
612    (redraws current desktop) */
613 BOOLEAN
614 APIENTRY
615 DxEngRedrawDesktop(VOID)
616 {
617     UserRedrawDesktop();
618     return TRUE;
619 }
620 
621 
622 ULONG gulVisRgnUniqueness; // Increase count everytime client region is updated.
623 
624 /************************************************************************/
625 /* DxEngVisRgnUniq                                                      */
626 /************************************************************************/
627 /* Notes: returns the VisRgnUniq counter for win32k */
628 ULONG
629 APIENTRY
630 DxEngVisRgnUniq(VOID)
631 {
632     DPRINT1("ReactX Calling : DxEngVisRgnUniq \n");
633 
634     return gulVisRgnUniqueness;
635 }
636 
637 /************************************************************************/
638 /* DxEngEnumerateHdev                                                   */
639 /************************************************************************/
640 /* Enumerate all drivers in win32k */
641 HDEV *
642 APIENTRY
643 DxEngEnumerateHdev(HDEV *hdev)
644 {
645     /* FIXME: Enumerate all drivers in win32k */
646     UNIMPLEMENTED;
647     return FALSE;
648 }
649 
650 /************************************************************************/
651 /* DxEngCreateMemoryDC                                                  */
652 /************************************************************************/
653 HDC
654 APIENTRY
655 DxEngCreateMemoryDC(HDEV hDev)
656 {
657     return IntGdiCreateDisplayDC(hDev, DC_TYPE_MEMORY, FALSE);
658 }
659 
660 /************************************************************************/
661 /* DxEngScreenAccessCheck                                               */
662 /************************************************************************/
663 DWORD APIENTRY DxEngScreenAccessCheck(VOID)
664 {
665     UNIMPLEMENTED;
666 
667     /* We're cheating here and telling dxg.sys it has always had permissions to access the screen */
668     return TRUE;
669 }
670 
671 /************************************************************************/
672 /* DxEngIsHdevLockedByCurrentThread                                     */
673 /************************************************************************/
674 BOOLEAN
675 APIENTRY
676 DxEngIsHdevLockedByCurrentThread(HDEV hDev)
677 {   // Based on EngIsSemaphoreOwnedByCurrentThread w/o the Ex call.
678     PERESOURCE pSem = (PERESOURCE)(((PPDEVOBJ)hDev)->hsemDevLock);
679     return pSem->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread();
680 }
681 
682 
683 /************************************************************************/
684 /* DxEngUnreferenceHdev                                                 */
685 /************************************************************************/
686 BOOLEAN
687 APIENTRY
688 DxEngUnreferenceHdev(HDEV hDev)
689 {
690     IntGdiUnreferencePdev((PPDEVOBJ) hDev, 0);
691     return TRUE; // Always true.
692 }
693 
694 /************************************************************************/
695 /* DxEngGetDesktopDC                                                    */
696 /************************************************************************/
697 HDC
698 APIENTRY
699 DxEngGetDesktopDC(ULONG DcType, BOOL EmptyDC, BOOL ValidatehWnd)
700 {
701     return UserGetDesktopDC(DcType, EmptyDC, ValidatehWnd);
702 }
703 
704 /************************************************************************/
705 /* DxEngDeleteDC                                                        */
706 /************************************************************************/
707 BOOLEAN
708 APIENTRY
709 DxEngDeleteDC(HDC hdc, BOOL Force)
710 {
711    return IntGdiDeleteDC(hdc, Force);
712 }
713 
714 /************************************************************************/
715 /* DxEngCleanDC                                                         */
716 /************************************************************************/
717 BOOLEAN
718 APIENTRY
719 DxEngCleanDC(HDC hdc)
720 {
721     return IntGdiCleanDC(hdc);
722 }
723 
724 /************************************************************************/
725 /* DxEngSetDCOwner                                                      */
726 /************************************************************************/
727 BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
728 {
729     DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
730 
731     return GreSetDCOwner(hObject, OwnerMask);
732 }
733 
734 /************************************************************************/
735 /* DxEngSetDCState                                                      */
736 /************************************************************************/
737 BOOLEAN
738 APIENTRY
739 DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
740 {
741    BOOLEAN Ret = FALSE;
742    PDC pDC = DC_LockDc(hDC);
743 
744    if (pDC)
745    {
746       if (SetType == 1)
747       {
748         if ( Set )
749             pDC->fs |= DC_FLAG_FULLSCREEN;
750         else
751             pDC->fs &= ~DC_FLAG_FULLSCREEN;
752         Ret = TRUE;
753       }
754       DC_UnlockDc(pDC);
755       return Ret; // Everything else returns FALSE.
756    }
757    return Ret;
758 }
759 
760 /************************************************************************/
761 /* DxEngSelectBitmap                                                    */
762 /************************************************************************/
763 DWORD APIENTRY DxEngSelectBitmap(DWORD x1, DWORD x2)
764 {
765     UNIMPLEMENTED;
766     return FALSE;
767 }
768 
769 /************************************************************************/
770 /* DxEngSetBitmapOwner                                                  */
771 /************************************************************************/
772 DWORD APIENTRY DxEngSetBitmapOwner(DWORD x1, DWORD x2)
773 {
774     UNIMPLEMENTED;
775     return FALSE;
776 }
777 
778 /************************************************************************/
779 /* DxEngDeleteSurface                                                   */
780 /************************************************************************/
781 DWORD APIENTRY DxEngDeleteSurface(DWORD x1)
782 {
783     UNIMPLEMENTED;
784     return FALSE;
785 }
786 
787 /************************************************************************/
788 /* DxEngGetSurfaceData                                                  */
789 /************************************************************************/
790 DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
791 {
792     UNIMPLEMENTED;
793     return FALSE;
794 }
795 
796 /************************************************************************/
797 /* DxEngAltLockSurface                                                  */
798 /************************************************************************/
799 DWORD APIENTRY DxEngAltLockSurface(DWORD x1)
800 {
801     UNIMPLEMENTED;
802     return FALSE;
803 }
804 
805 /************************************************************************/
806 /* DxEngUploadPaletteEntryToSurface                                     */
807 /************************************************************************/
808 DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
809 {
810     UNIMPLEMENTED;
811     return FALSE;
812 }
813 
814 /************************************************************************/
815 /* DxEngMarkSurfaceAsDirectDraw                                         */
816 /************************************************************************/
817 DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
818 {
819     UNIMPLEMENTED;
820     return FALSE;
821 }
822 
823 /************************************************************************/
824 /* DxEngSelectPaletteToSurface                                          */
825 /************************************************************************/
826 DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
827 {
828     UNIMPLEMENTED;
829     return FALSE;
830 }
831 
832 /************************************************************************/
833 /* DxEngSyncPaletteTableWithDevice                                      */
834 /************************************************************************/
835 DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
836 {
837     UNIMPLEMENTED;
838     return FALSE;
839 }
840 
841 /************************************************************************/
842 /* DxEngSetPaletteState                                                 */
843 /************************************************************************/
844 DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
845 {
846     UNIMPLEMENTED;
847     return FALSE;
848 }
849 
850 /************************************************************************/
851 /* DxEngGetRedirectionBitmap                                            */
852 /************************************************************************/
853 DWORD
854 APIENTRY
855 DxEngGetRedirectionBitmap(DWORD x1)
856 {
857     return FALSE; // Normal return.
858 }
859 
860 /************************************************************************/
861 /* DxEngLoadImage                                                       */
862 /************************************************************************/
863 DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
864 {
865     UNIMPLEMENTED;
866     return FALSE;
867 }
868 
869 /************************************************************************/
870 /* DxEngSpTearDownSprites                                               */
871 /************************************************************************/
872 DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
873 {
874     UNIMPLEMENTED;
875     return FALSE;
876 }
877 
878 /************************************************************************/
879 /* DxEngSpUnTearDownSprites                                             */
880 /************************************************************************/
881 DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
882 {
883     UNIMPLEMENTED;
884     return FALSE;
885 }
886 
887 /************************************************************************/
888 /* DxEngSpSpritesVisible                                                */
889 /************************************************************************/
890 DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
891 {
892     UNIMPLEMENTED;
893     return FALSE;
894 }
895