[YAROTOWS] Reintegrate the branch. For a brighter future.
[reactos.git] / reactos / 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 <win32k.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 }