Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-06-28 17:01:28 +00:00
Code Issues Packages Projects Releases Wiki Activity
reactos/win32ss/reactx/ntddraw/dxeng.c
Oleg Dubinskiy 31139c253f
[WIN32SS][NTDDRAW][NTGDI] Implement some DxEng* callbacks (#3638) 
Implement the following DxEng* functions:
- DxEngAltLockSurface
- DxEngDeleteSurface
- DxEngReferenceHdev
- DxEngSelectBitmap
- DxEngSetBitmapOwner
- DxEngUnreferenceHdev

Update their prototypes and call the appropriate win32k functions
inside them, since they are already implemented. Also get rid of
now unused IntGdi(Un)ReferencePdev, whose were called only by dxeng,
and whose are not used anymore. In Windows, DxEng(Un)ReferenceHdev calls
PDEVOBJ_vReferencePDEV and PDEVOBJ_vDeferencePDEV directly (those
correspond to our PDEVOBJ_vReference and PDEVOBJ_vRelease accordingly).

Required by MS DirectDraw stack (ddraw.dll & dxg.sys). CORE-17561
2022-06-01 00:58:35 +03:00

901 lines
26 KiB
C
Raw Blame History

/*
* PROJECT: ReactOS Win32 Subsystem
* LICENSE: GPL - See COPYING in the top level directory
* FILE: win32ss/reactx/ntddraw/dxeng.c
* PURPOSE: Implementation of DxEng functions
* PROGRAMMERS: Magnus Olsen (magnus@greatlord.com)
* Oleg Dubinskiy (oleg.dubinskij30@gmail.com)
*/
#include <win32k.h>
#include <debug.h>
HSEMAPHORE ghsemShareDevLock = NULL;
ULONG gcEngFuncs = DXENG_INDEX_DxEngLoadImage + 1;
DRVFN gaEngFuncs[] =
{
{0, (PFN) NULL},
{DXENG_INDEX_DxEngNUIsTermSrv, (PFN)DxEngNUIsTermSrv},
{DXENG_INDEX_DxEngScreenAccessCheck, (PFN)DxEngScreenAccessCheck},
{DXENG_INDEX_DxEngRedrawDesktop, (PFN)DxEngRedrawDesktop},
{DXENG_INDEX_DxEngDispUniq, (PFN)DxEngDispUniq},
{DXENG_INDEX_DxEngIncDispUniq, (PFN)DxEngIncDispUniq},
{DXENG_INDEX_DxEngVisRgnUniq, (PFN)DxEngVisRgnUniq},
{DXENG_INDEX_DxEngLockShareSem, (PFN)DxEngLockShareSem},
{DXENG_INDEX_DxEngUnlockShareSem, (PFN)DxEngUnlockShareSem},
{DXENG_INDEX_DxEngEnumerateHdev, (PFN)DxEngEnumerateHdev},
{DXENG_INDEX_DxEngLockHdev, (PFN)DxEngLockHdev},
{DXENG_INDEX_DxEngUnlockHdev, (PFN)DxEngUnlockHdev},
{DXENG_INDEX_DxEngIsHdevLockedByCurrentThread, (PFN)DxEngIsHdevLockedByCurrentThread},
{DXENG_INDEX_DxEngReferenceHdev, (PFN)DxEngReferenceHdev},
{DXENG_INDEX_DxEngUnreferenceHdev, (PFN)DxEngUnreferenceHdev},
{DXENG_INDEX_DxEngGetDeviceGammaRamp, (PFN)DxEngGetDeviceGammaRamp},
{DXENG_INDEX_DxEngSetDeviceGammaRamp, (PFN)DxEngSetDeviceGammaRamp},
{DXENG_INDEX_DxEngSpTearDownSprites, (PFN)DxEngSpTearDownSprites},
{DXENG_INDEX_DxEngSpUnTearDownSprites, (PFN)DxEngSpUnTearDownSprites},
{DXENG_INDEX_DxEngSpSpritesVisible, (PFN)DxEngSpSpritesVisible},
{DXENG_INDEX_DxEngGetHdevData, (PFN)DxEngGetHdevData},
{DXENG_INDEX_DxEngSetHdevData, (PFN)DxEngSetHdevData},
{DXENG_INDEX_DxEngCreateMemoryDC, (PFN)DxEngCreateMemoryDC},
{DXENG_INDEX_DxEngGetDesktopDC, (PFN)DxEngGetDesktopDC},
{DXENG_INDEX_DxEngDeleteDC, (PFN)DxEngDeleteDC},
{DXENG_INDEX_DxEngCleanDC, (PFN)DxEngCleanDC},
{DXENG_INDEX_DxEngSetDCOwner, (PFN)DxEngSetDCOwner},
{DXENG_INDEX_DxEngLockDC, (PFN)DxEngLockDC},
{DXENG_INDEX_DxEngUnlockDC, (PFN)DxEngUnlockDC},
{DXENG_INDEX_DxEngSetDCState, (PFN)DxEngSetDCState},
{DXENG_INDEX_DxEngGetDCState, (PFN)DxEngGetDCState},
{DXENG_INDEX_DxEngSelectBitmap, (PFN)DxEngSelectBitmap},
{DXENG_INDEX_DxEngSetBitmapOwner, (PFN)DxEngSetBitmapOwner},
{DXENG_INDEX_DxEngDeleteSurface, (PFN)DxEngDeleteSurface},
{DXENG_INDEX_DxEngGetSurfaceData, (PFN)DxEngGetSurfaceData},
{DXENG_INDEX_DxEngAltLockSurface, (PFN)DxEngAltLockSurface},
{DXENG_INDEX_DxEngUploadPaletteEntryToSurface, (PFN)DxEngUploadPaletteEntryToSurface},
{DXENG_INDEX_DxEngMarkSurfaceAsDirectDraw, (PFN)DxEngMarkSurfaceAsDirectDraw},
{DXENG_INDEX_DxEngSelectPaletteToSurface, (PFN)DxEngSelectPaletteToSurface},
{DXENG_INDEX_DxEngSyncPaletteTableWithDevice, (PFN)DxEngSyncPaletteTableWithDevice},
{DXENG_INDEX_DxEngSetPaletteState, (PFN)DxEngSetPaletteState},
{DXENG_INDEX_DxEngGetRedirectionBitmap, (PFN)DxEngGetRedirectionBitmap},
{DXENG_INDEX_DxEngLoadImage, (PFN)DxEngLoadImage}
};
/*++
* @name DxEngDispUniq
* @implemented
*
* The function DxEngDispUniq returns the DisplayUniqVisrgn counter value from GDI shared memory
*
* @return
* Returns the DisplayUniqVisrgn counter value from GDI shared memory
*
* @remarks.
* none
*
*--*/
ULONG
APIENTRY
DxEngDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngDispUniq\n");
return GdiHandleTable->flDeviceUniq;
}
/*++
* @name DxEngGetDeviceGammaRamp
* @implemented
*
* The function DxEngGetDeviceGammaRamp gets the gamma ramp to dxg.sys.
* @param HDEV hPDev
* The hdev.
*
* @param PGAMMARAMP Ramp
* Pointer to store the gamma ramp value in.
*
* @return
*Returns TRUE for success, FALSE for failure
*
* @remarks.
* None
*
*--*/
BOOL
APIENTRY
DxEngGetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp)
{
DPRINT1("ReactX Calling : DxEngGetDeviceGammaRamp\n");
return IntGetDeviceGammaRamp(hPDev, Ramp);
}
/*++
* @name DxEngLockDC
* @implemented
*
* The function DxEngLockDC locks a hdc from dxg.sys
*
* @param HDC hDC
* The handle we want to lock
*
* @return
* Returns PDC if lock succeeded or NULL if it failed.
*
* @remarks.
* none
*
*--*/
PDC
APIENTRY
DxEngLockDC(HDC hDC)
{
DPRINT1("ReactX Calling : DxEngLockDC\n");
return DC_LockDc(hDC);
}
/*++
* @name DxEngUnlockDC
* @implemented
*
* The function DxEngUnlockDC unlocks a pDC (hdc) from dxg.sys.
* @param PDC pDC
* The handle we want to unlock.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockDC(PDC pDC)
{
DPRINT1("ReactX Calling : DxEngUnlockDC\n");
DC_UnlockDc(pDC);
return TRUE;
}
/*++
* @name DxEngLockShareSem
* @implemented
*
* The function DxEngLockShareSem locks a struct of type ghsemShareDevLock that can be shared.
*
* @return
* This function returns TRUE for success and FALSE for failure.
* FALSE must mean the struct has already been locked.
*
* @remarks.
* It is being used in various ntuser* functions and ntgdi*
* ReactOS specific: It is not in use yet?
*SystemResourcesList
*--*/
BOOLEAN
APIENTRY
DxEngLockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngLockShareSem\n");
if(!ghsemShareDevLock) ghsemShareDevLock = EngCreateSemaphore(); // Hax, should be in dllmain.c
EngAcquireSemaphore(ghsemShareDevLock);
return TRUE;
}
/*++
* @name DxEngUnlockShareSem
* @implemented
*
* The function DxEngUnlockShareSem unlocks the struct of type ghsemShareDevLock.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* ReactOS specific: It is not in use yet?
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockShareSem(VOID)
{
DPRINT1("ReactX Calling : DxEngUnlockShareSem\n");
EngReleaseSemaphore(ghsemShareDevLock);
return TRUE;
}
/*++
* @name DxEngSetDeviceGammaRamp
* @implemented
*
* The function DxEngSetDeviceGammaRamp sets gamma ramp from dxg.sys
* @param HDEV hPDev
* The hdev
*
* @param PGAMMARAMP Ramp
* Value to change gamma ramp to.
*
* @param BOOL Test
* Whether gamma should be tested. TRUE to test, FALSE to not test.
*
* @return
*Returns TRUE for success, FALSE for failure.
*
* @remarks.
* None
*
*--*/
BOOLEAN
APIENTRY
DxEngSetDeviceGammaRamp(HDEV hPDev, PGAMMARAMP Ramp, BOOL Test)
{
DPRINT1("ReactX Calling : DxEngSetDeviceGammaRamp\n");
return IntSetDeviceGammaRamp(hPDev, Ramp, Test);
}
/*++
* @name DxEngGetHdevData
* @implemented
*
* The function DxEngGetHdevData retrieves a value from the HDEV
* @param HDEV hPDev
* The HDEV
*
* @param DXEGSHDEVDATA Type
* The following typs are supported
* Type Purpose
* DxEGShDevData_Surface Retrieve pointer to Surface handle.
* DxEGShDevData_hSpooler Device object of graphics driver.
* DxEGShDevData_DitherFmt Retrieve the device iDitherFormat
* DxEGShDevData_FxCaps Retrieve the device flGraphicsCaps
* DxEGShDevData_FxCaps2 Retrieve the device flGraphicsCaps2
* DxEGShDevData_DrvFuncs Retrieve the device DriverFunctions function table
* DxEGShDevData_dhpdev Retrieve the device hPDev, the real DHPDEV
* DxEGShDevData_eddg Retrieve the device pEDDgpl
* DxEGShDevData_dd_nCount Retrieve the device DxDd_nCount
* DxEGShDevData_dd_flags Retrieve the device DxDd_Flags
* DxEGShDevData_disable See if the device pdev is disabled
* DxEGShDevData_metadev See if the device pdev is a meta device
* DxEGShDevData_display See if the device is the primary display driver
* DxEGShDevData_Parent Retrieve the ppdevParent
* DxEGShDevData_OpenRefs Retrieve the pdevOpenRefs counter
* DxEGShDevData_palette See if the device RC_PALETTE is set
* DxEGShDevData_ldev ATM we do not support the Loader Device driver structure
* DxEGShDevData_GDev Retrieve the device pGraphicsDevice
* DxEGShDevData_clonedev Retrieve the device PDEV_CLONE_DEVICE flag is set or not
*
* @return
* Returns the data we requested
*
* @remarks.
* ReactOS specific: Implementation is incomplete, I do not save the value into the hdev yet.
*
*--*/
DWORD_PTR
APIENTRY
DxEngGetHdevData(HDEV hDev,
DXEGSHDEVDATA Type)
{
DWORD_PTR retVal = 0;
PPDEVOBJ PDev = (PPDEVOBJ)hDev;
DPRINT1("ReactX Calling : DxEngGetHdevData DXEGSHDEVDATA : %ld\n", Type);
#if 1
DPRINT1("HDEV hDev %p\n", hDev);
#endif
switch ( Type )
{
case DxEGShDevData_Surface:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Surface\n");
retVal = (DWORD_PTR) PDev->pSurface; // ptr to Surface handle.
break;
case DxEGShDevData_hSpooler:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_hSpooler\n");
retVal = (DWORD_PTR) PDev->hSpooler;
break;
case DxEGShDevData_DitherFmt:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DitherFmt\n");
retVal = (DWORD_PTR) PDev->devinfo.iDitherFormat;
break;
case DxEGShDevData_FxCaps:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps;
break;
case DxEGShDevData_FxCaps2:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_FxCaps2\n");
retVal = (DWORD_PTR) PDev->devinfo.flGraphicsCaps2;
break;
case DxEGShDevData_DrvFuncs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_DrvFuncs\n");
retVal = (DWORD_PTR) &PDev->DriverFunctions;
break;
case DxEGShDevData_dhpdev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dhpdev\n");
retVal = (DWORD_PTR) PDev->dhpdev; // DHPDEV
break;
case DxEGShDevData_eddg:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_eddg\n");
retVal = (DWORD_PTR) PDev->pEDDgpl;
break;
case DxEGShDevData_dd_nCount:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_nCount\n");
retVal = (DWORD_PTR) PDev->DxDd_nCount;
break;
case DxEGShDevData_dd_flags:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_dd_flags\n");
retVal = (DWORD_PTR) PDev->DxDd_Flags;
break;
case DxEGShDevData_disable:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_disable\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISABLED;
break;
case DxEGShDevData_metadev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_metadev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_META_DEVICE;
break;
case DxEGShDevData_display:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_display\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_DISPLAY;
break;
case DxEGShDevData_Parent:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_Parent\n");
retVal = (DWORD_PTR) PDev->ppdevParent;
break;
case DxEGShDevData_OpenRefs:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_OpenRefs\n");
retVal = (DWORD_PTR) PDev->cPdevOpenRefs != 0;
break;
case DxEGShDevData_palette:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_palette\n");
retVal = (DWORD_PTR) PDev->gdiinfo.flRaster & RC_PALETTE;
break;
case DxEGShDevData_ldev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_ldev\n");
retVal = (DWORD_PTR) PDev->pldev;
break;
case DxEGShDevData_GDev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_GDev\n");
retVal = (DWORD_PTR) PDev->pGraphicsDevice; // P"GRAPHICS_DEVICE"
break;
case DxEGShDevData_clonedev:
DPRINT1("requested DXEGSHDEVDATA DxEGShDevData_clonedev\n");
retVal = (DWORD_PTR) PDev->flFlags & PDEV_CLONE_DEVICE;
break;
default:
break;
}
#if 1
DPRINT1("return value %08lx\n", retVal);
#endif
return retVal;
}
/*++
* @name DxEngSetHdevData
* @implemented
*
* The function DxEngSetHdevData sets a value in hdev
* @param HDEV hPDev
* The hdev
*
* @param DXEGSHDEVDATA Type
* Supports only DxEGShDevData_dd_nCount. It is an internal counter on how many times hdev has been locked and unlocked
*
* @param DWORD Data
* The value to be saved to hdev's internal counter.
*
* @return
* Returns TRUE for success, FALSE for failure
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngSetHdevData(HDEV hDev,
DXEGSHDEVDATA Type,
DWORD_PTR Data)
{
BOOLEAN retVal = FALSE; // Default, no set.
DPRINT1("ReactX Calling : DxEngSetHdevData DXEGSHDEVDATA : %ld\n", Type);
if ( Type == DxEGShDevData_dd_nCount )
{
((PPDEVOBJ)hDev)->DxDd_nCount = Data;
retVal = TRUE; // Set
}
return retVal;
}
/*++
* @name DxEngGetDCState
* @implemented
*
* The function DxEngGetDCState is capable of returning three
* DC states depending on what value is passed in its second parameter:
* 1. If the DC is full screen
* 2. Get Complexity of visible region
* 3. Get Driver hdev, which is ppdev
*
* @param HDC hdc
* The DC handle
*
* @param DWORD type
* value 1 = Is DC fullscreen
* value 2 = Get Complexity of visible region.
* value 3 = Get Driver hdev, which is a ppdev.
*
* @return
* Return one of the type values
*
* @remarks.
* none
*
*--*/
DWORD_PTR
APIENTRY
DxEngGetDCState(HDC hDC,
DWORD type)
{
PDC pDC = DC_LockDc(hDC);
DWORD_PTR retVal = 0;
DPRINT1("ReactX Calling : DxEngGetDCState type : %lu\n", type);
if (pDC)
{
switch (type)
{
case 1:
retVal = (DWORD_PTR) pDC->fs & DC_FULLSCREEN;
break;
case 2:
/* Return the complexity of the visible region. */
retVal = (DWORD_PTR) REGION_Complexity(pDC->prgnVis);
break;
case 3:
{
/* Return the HDEV of this DC. */
retVal = (DWORD_PTR) pDC->ppdev;
break;
}
default:
/* If a valid type is not found, zero is returned */
DPRINT1("Warning: did not find type %lu\n", type);
break;
}
DC_UnlockDc(pDC);
}
DPRINT1("Return value %08lx\n", retVal);
return retVal;
}
/*++
* @name DxEngIncDispUniq
* @implemented
*
* The function DxEngIncDispUniq increments the DisplayUniqVisrgn counter from GDI shared memory.
*
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngIncDispUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngIncDispUniq \n");
InterlockedIncrement((LONG*)&GdiHandleTable->flDeviceUniq);
return TRUE;
}
/*++
* @name DxEngLockHdev
* @implemented
*
* The function DxEngLockHdev lock the internal PDEV
*
* @param HDEV type
* it is a pointer to win32k internal pdev struct known as PPDEVOBJ
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngLockHdev(HDEV hDev)
{
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource;
DPRINT1("ReactX Calling : DxEngLockHdev \n");
DPRINT1("hDev : 0x%p\n",hDev);
Resource = (PERESOURCE)ppdev->hsemDevLock;
if (Resource)
{
KeEnterCriticalRegion();
ExAcquireResourceExclusiveLite( Resource , TRUE); // Lock monitor.
}
return TRUE;
}
/*++
* @name DxEngUnlockHdev
* @implemented
*
* The function DxEngUnlockHdev unlock the internal PDEV
*
* @param HDEV type
* it is a pointer to win32k internal pdev struct known as PPDEVOBJ
* @return
* This function returns TRUE no matter what.
*
* @remarks.
* none
*
*--*/
BOOLEAN
APIENTRY
DxEngUnlockHdev(HDEV hDev)
{
PPDEVOBJ ppdev = (PPDEVOBJ)hDev;
PERESOURCE Resource = (PERESOURCE)ppdev->hsemDevLock;
DPRINT1("ReactX Calling : DxEngUnlockHdev \n");
if (Resource)
{
ExReleaseResourceLite( Resource );
KeLeaveCriticalRegion();
}
return TRUE;
}
/************************************************************************/
/* DxEngReferenceHdev */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngReferenceHdev(HDEV hDev)
{
PDEVOBJ_vReference((PPDEVOBJ)hDev);
/* ALWAYS return true */
return TRUE;
}
/************************************************************************/
/* DxEngNUIsTermSrv */
/************************************************************************/
/* Notes: Check if terminal server got connections or not */
BOOLEAN
APIENTRY
DxEngNUIsTermSrv(VOID)
{
/* FIXME: ReactOS does not suport terminal server yet, we can not check if we got connections or not */
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngRedrawDesktop */
/************************************************************************/
/* Notes: it always returns TRUE, and it updates whole screen
(redraws current desktop) */
BOOLEAN
APIENTRY
DxEngRedrawDesktop(VOID)
{
UserRedrawDesktop();
return TRUE;
}
ULONG gulVisRgnUniqueness; // Increase count everytime client region is updated.
/************************************************************************/
/* DxEngVisRgnUniq */
/************************************************************************/
/* Notes: returns the VisRgnUniq counter for win32k */
ULONG
APIENTRY
DxEngVisRgnUniq(VOID)
{
DPRINT1("ReactX Calling : DxEngVisRgnUniq \n");
return gulVisRgnUniqueness;
}
/************************************************************************/
/* DxEngEnumerateHdev */
/************************************************************************/
/* Enumerate all drivers in win32k */
HDEV *
APIENTRY
DxEngEnumerateHdev(HDEV *hdev)
{
/* FIXME: Enumerate all drivers in win32k */
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngCreateMemoryDC */
/************************************************************************/
HDC
APIENTRY
DxEngCreateMemoryDC(HDEV hDev)
{
return IntGdiCreateDisplayDC(hDev, DCTYPE_MEMORY, FALSE);
}
/************************************************************************/
/* DxEngScreenAccessCheck */
/************************************************************************/
DWORD APIENTRY DxEngScreenAccessCheck(VOID)
{
UNIMPLEMENTED;
/* We're cheating here and telling dxg.sys it has always had permissions to access the screen */
return TRUE;
}
/************************************************************************/
/* DxEngIsHdevLockedByCurrentThread */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngIsHdevLockedByCurrentThread(HDEV hDev)
{ // Based on EngIsSemaphoreOwnedByCurrentThread w/o the Ex call.
PERESOURCE pSem = (PERESOURCE)(((PPDEVOBJ)hDev)->hsemDevLock);
return pSem->OwnerEntry.OwnerThread == (ERESOURCE_THREAD)PsGetCurrentThread();
}
/************************************************************************/
/* DxEngUnreferenceHdev */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngUnreferenceHdev(HDEV hDev)
{
PDEVOBJ_vRelease((PPDEVOBJ)hDev);
return TRUE; // Always true.
}
/************************************************************************/
/* DxEngGetDesktopDC */
/************************************************************************/
HDC
APIENTRY
DxEngGetDesktopDC(ULONG DcType, BOOL EmptyDC, BOOL ValidatehWnd)
{
return UserGetDesktopDC(DcType, EmptyDC, ValidatehWnd);
}
/************************************************************************/
/* DxEngDeleteDC */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngDeleteDC(HDC hdc, BOOL Force)
{
return IntGdiDeleteDC(hdc, Force);
}
/************************************************************************/
/* DxEngCleanDC */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngCleanDC(HDC hdc)
{
return IntGdiCleanDC(hdc);
}
/************************************************************************/
/* DxEngSetDCOwner */
/************************************************************************/
BOOL APIENTRY DxEngSetDCOwner(HGDIOBJ hObject, DWORD OwnerMask)
{
DPRINT1("ReactX Calling : DxEngSetDCOwner \n");
return GreSetDCOwner(hObject, OwnerMask);
}
/************************************************************************/
/* DxEngSetDCState */
/************************************************************************/
BOOLEAN
APIENTRY
DxEngSetDCState(HDC hDC, DWORD SetType, DWORD Set)
{
BOOLEAN Ret = FALSE;
PDC pDC = DC_LockDc(hDC);
if (pDC)
{
if (SetType == 1)
{
if ( Set )
pDC->fs |= DC_FULLSCREEN;
else
pDC->fs &= ~DC_FULLSCREEN;
Ret = TRUE;
}
DC_UnlockDc(pDC);
return Ret; // Everything else returns FALSE.
}
return Ret;
}
/************************************************************************/
/* DxEngSelectBitmap */
/************************************************************************/
HBITMAP APIENTRY DxEngSelectBitmap(HDC hdc, HBITMAP hbmp)
{
DPRINT1("ReactX Calling : DxEngSelectBitmap \n");
return NtGdiSelectBitmap(hdc, hbmp);
}
/************************************************************************/
/* DxEngSetBitmapOwner */
/************************************************************************/
BOOLEAN APIENTRY DxEngSetBitmapOwner(HBITMAP hbmp, ULONG ulOwner)
{
DPRINT1("ReactX Calling : DxEngSetBitmapOwner \n");
return GreSetBitmapOwner(hbmp, ulOwner);
}
/************************************************************************/
/* DxEngDeleteSurface */
/************************************************************************/
BOOLEAN APIENTRY DxEngDeleteSurface(HSURF hsurf)
{
DPRINT1("ReactX Calling : DxEngDeleteSurface \n");
return EngDeleteSurface(hsurf);
}
/************************************************************************/
/* DxEngGetSurfaceData */
/************************************************************************/
DWORD APIENTRY DxEngGetSurfaceData(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngAltLockSurface */
/************************************************************************/
SURFOBJ * APIENTRY DxEngAltLockSurface(HSURF hsurf)
{
DPRINT1("ReactX Calling : DxEngAltLockSurface \n");
return EngLockSurface(hsurf);
}
/************************************************************************/
/* DxEngUploadPaletteEntryToSurface */
/************************************************************************/
DWORD APIENTRY DxEngUploadPaletteEntryToSurface(DWORD x1, DWORD x2,DWORD x3, DWORD x4)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngMarkSurfaceAsDirectDraw */
/************************************************************************/
DWORD APIENTRY DxEngMarkSurfaceAsDirectDraw(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSelectPaletteToSurface */
/************************************************************************/
DWORD APIENTRY DxEngSelectPaletteToSurface(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSyncPaletteTableWithDevice */
/************************************************************************/
DWORD APIENTRY DxEngSyncPaletteTableWithDevice(DWORD x1, DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSetPaletteState */
/************************************************************************/
DWORD APIENTRY DxEngSetPaletteState(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngGetRedirectionBitmap */
/************************************************************************/
DWORD
APIENTRY
DxEngGetRedirectionBitmap(DWORD x1)
{
return FALSE; // Normal return.
}
/************************************************************************/
/* DxEngLoadImage */
/************************************************************************/
DWORD APIENTRY DxEngLoadImage(DWORD x1,DWORD x2)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpTearDownSprites */
/************************************************************************/
DWORD APIENTRY DxEngSpTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpUnTearDownSprites */
/************************************************************************/
DWORD APIENTRY DxEngSpUnTearDownSprites(DWORD x1, DWORD x2, DWORD x3)
{
UNIMPLEMENTED;
return FALSE;
}
/************************************************************************/
/* DxEngSpSpritesVisible */
/************************************************************************/
DWORD APIENTRY DxEngSpSpritesVisible(DWORD x1)
{
UNIMPLEMENTED;
return FALSE;
}
Reference in a new issue View git blame Copy permalink