xref: /reactos/win32ss/reactx/ntddraw/dxeng.c (revision 49bb853b) 
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 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      IntGdiReferencePdev((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, DC_TYPE_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      IntGdiUnreferencePdev((PPDEVOBJ) hDev, 0);
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_FLAG_FULLSCREEN;
752          else
753              pDC->fs &= ~DC_FLAG_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  DWORD APIENTRY DxEngSelectBitmap(DWORD x1, DWORD x2)
766  {
767      UNIMPLEMENTED;
768      return FALSE;
769  }
770  
771  /************************************************************************/
772  /* DxEngSetBitmapOwner                                                  */
773  /************************************************************************/
774  DWORD APIENTRY DxEngSetBitmapOwner(DWORD x1, DWORD x2)
775  {
776      UNIMPLEMENTED;
777      return FALSE;
778  }
779  
780  /************************************************************************/
781  /* DxEngDeleteSurface                                                   */
782  /************************************************************************/
783  DWORD APIENTRY DxEngDeleteSurface(DWORD x1)
784  {
785      UNIMPLEMENTED;
786      return FALSE;
787  }
788  
789  /************************************************************************/
790  /* DxEngGetSurfaceData                                                  */
791  /************************************************************************/
792  DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
793  {
794      UNIMPLEMENTED;
795      return FALSE;
796  }
797  
798  /************************************************************************/
799  /* DxEngAltLockSurface                                                  */
800  /************************************************************************/
801  DWORD APIENTRY DxEngAltLockSurface(DWORD x1)
802  {
803      UNIMPLEMENTED;
804      return FALSE;
805  }
806  
807  /************************************************************************/
808  /* DxEngUploadPaletteEntryToSurface                                     */
809  /************************************************************************/
810  DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
811  {
812      UNIMPLEMENTED;
813      return FALSE;
814  }
815  
816  /************************************************************************/
817  /* DxEngMarkSurfaceAsDirectDraw                                         */
818  /************************************************************************/
819  DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
820  {
821      UNIMPLEMENTED;
822      return FALSE;
823  }
824  
825  /************************************************************************/
826  /* DxEngSelectPaletteToSurface                                          */
827  /************************************************************************/
828  DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
829  {
830      UNIMPLEMENTED;
831      return FALSE;
832  }
833  
834  /************************************************************************/
835  /* DxEngSyncPaletteTableWithDevice                                      */
836  /************************************************************************/
837  DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
838  {
839      UNIMPLEMENTED;
840      return FALSE;
841  }
842  
843  /************************************************************************/
844  /* DxEngSetPaletteState                                                 */
845  /************************************************************************/
846  DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
847  {
848      UNIMPLEMENTED;
849      return FALSE;
850  }
851  
852  /************************************************************************/
853  /* DxEngGetRedirectionBitmap                                            */
854  /************************************************************************/
855  DWORD
856  APIENTRY
857  DxEngGetRedirectionBitmap(DWORD x1)
858  {
859      return FALSE; // Normal return.
860  }
861  
862  /************************************************************************/
863  /* DxEngLoadImage                                                       */
864  /************************************************************************/
865  DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
866  {
867      UNIMPLEMENTED;
868      return FALSE;
869  }
870  
871  /************************************************************************/
872  /* DxEngSpTearDownSprites                                               */
873  /************************************************************************/
874  DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
875  {
876      UNIMPLEMENTED;
877      return FALSE;
878  }
879  
880  /************************************************************************/
881  /* DxEngSpUnTearDownSprites                                             */
882  /************************************************************************/
883  DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
884  {
885      UNIMPLEMENTED;
886      return FALSE;
887  }
888  
889  /************************************************************************/
890  /* DxEngSpSpritesVisible                                                */
891  /************************************************************************/
892  DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
893  {
894      UNIMPLEMENTED;
895      return FALSE;
896  }
897