/******************************Module*Header********************************\ * Module Name: pdevobj.hxx * * * * User object for the PDEV * * * * Copyright (c) 1990-1999 Microsoft Corporation * * * \**************************************************************************/ #define _PDEVOBJ_ #ifndef GDIFLAGS_ONLY // used for gdikdx extern PPDEV gppdevList; extern PPDEV gppdevTrueType; extern PPDEV gppdevATMFD; #endif // GDIFLAGS_ONLY used for gdikdx #define HOOK_BitBlt HOOK_BITBLT #define HOOK_StretchBlt HOOK_STRETCHBLT #define HOOK_PlgBlt HOOK_PLGBLT #define HOOK_TextOut HOOK_TEXTOUT #define HOOK_Paint HOOK_PAINT #define HOOK_StrokePath HOOK_STROKEPATH #define HOOK_FillPath HOOK_FILLPATH #define HOOK_StrokeAndFillPath HOOK_STROKEANDFILLPATH #define HOOK_CopyBits HOOK_COPYBITS #define HOOK_LineTo HOOK_LINETO #define HOOK_StretchBltROP HOOK_STRETCHBLTROP #define HOOK_TransparentBlt HOOK_TRANSPARENTBLT #define HOOK_AlphaBlend HOOK_ALPHABLEND #define HOOK_GradientFill HOOK_GRADIENTFILL /******************************Public*MACRO*******************************\ * PDEV Creation flag * \*************************************************************************/ #define GCH_DEFAULT_DISPLAY 1 #define GCH_DDML 2 #define GCH_PANNING 3 #define GCH_MIRRORING 4 #define GCH_CLONE_DISPLAY 5 #define GCH_GDIPLUS_DISPLAY 6 /******************************Public*MACRO*******************************\ * * This is the acceleration level at which we allow absolutely no driver * accelerations. * \*************************************************************************/ #define DRIVER_ACCELERATIONS_FULL 0 #define DRIVER_ACCELERATIONS_NONE 5 #define DRIVER_ACCELERATIONS_INVALID ((DWORD)(-1)) /******************************Public*MACRO*******************************\ * * This is the capable override defination. The value is set in registry. * It tells us what's the capability of a driver * \*************************************************************************/ #define DRIVER_CAPABLE_ALL 0 #define DRIVER_NOT_CAPABLE_GDI 1 #define DRIVER_NOT_CAPABLE_DDRAW 2 #define DRIVER_NOT_CAPABLE_D3D 4 #define DRIVER_NOT_CAPABLE_OPENGL 8 #define DRIVER_NOT_CAPABLE_ESCAPE 0x10 /******************************Public*MACRO*******************************\ * PFNDRV/PFNGET * * PFNDRV gets the device driver entry point, period. * PFNGET gets the device driver entry point if it is hooked, otherwise gets * the engine entry point. The flag is set by EngAssociate in the surface. * \**************************************************************************/ #ifndef GDIFLAGS_ONLY // used for gdikdx #define PPFNGET(po,name,flag) ((flag & HOOK_##name) ? ((PFN_Drv##name) (po).ppfn(INDEX_Drv##name)) : ((PFN_Drv##name) Eng##name)) #define PPFNDRV(po,name) ((PFN_Drv##name) (po).ppfn(INDEX_Drv##name)) #define PPFNVALID(po,name) (PPFNDRV(po,name) != ((PFN_Drv##name) NULL)) #define PPFNTABLE(apfn,name) ((PFN_Drv##name) apfn[INDEX_Drv##name]) #define PPFNDRVENG(po,name) ((po).ppfn(INDEX_Drv##name) ? (PFN_Drv##name) (po).ppfn(INDEX_Drv##name) : (PFN_Drv##name) Eng##name ) /******************************Public*MACRO*******************************\ * PPFNDIRECT * * PPFNDIRECT retrieves the true device driver entry, bypassing any hooks * by the sprite layer or the like. This should be used only in very * limited circumstances; typically, all drawing should go through the * sprite layer and so one of the above macros should be used. \**************************************************************************/ #define SPRITESTATE(pso) (&((PDEV*) pso->hdev)->SpriteState) #define PPFNDIRECT(pso, Name) \ ((SURFOBJ_TO_SURFACE_NOT_NULL(pso)->flags() & HOOK_##Name) \ ? SPRITESTATE(pso)->pfn##Name \ : Eng##Name) #define PPFNDIRECTENG(pso, Name) \ (SPRITESTATE(pso)->pfn##Name ? SPRITESTATE(pso)->pfn##Name \ : Eng##Name) /**************************************************************************\ * Stuff used for type one fonts. * \**************************************************************************/ typedef struct tagTYPEONEMAP { FONTFILEVIEW fv; ULONG Checksum; } TYPEONEMAP; typedef struct tagTYPEONEINFO { COUNT cRef; COUNT cNumFonts; LARGE_INTEGER LastWriteTime; TYPEONEMAP aTypeOneMap[1]; } TYPEONEINFO, *PTYPEONEINFO; extern LARGE_INTEGER gLastTypeOneWriteTime; extern PTYPEONEINFO gpTypeOneInfo; #endif // GDIFLAGS_ONLY used for gdikdx /*********************************Class************************************\ * class PDEV : public OBJECT * \**************************************************************************/ // Allowed flags for pdev.fl #define PDEV_DISPLAY 0x0001 #define PDEV_HARDWARE_POINTER 0x0002 #define PDEV_SOFTWARE_POINTER 0x0004 #define PDEV_xxx1 0x0008 #define PDEV_xxx2 0x0010 #define PDEV_xxx3 0x0020 #define PDEV_GOTFONTS 0x0040 #define PDEV_PRINTER 0x0080 #define PDEV_ALLOCATEDBRUSHES 0x0100 #define PDEV_HTPAL_IS_DEVPAL 0x0200 #define PDEV_DISABLED 0x0400 #define PDEV_SYNCHRONIZE_ENABLED 0x0800 #define PDEV_xxx4 0x1000 #define PDEV_FONTDRIVER 0x2000 #define PDEV_GAMMARAMP_TABLE 0x4000 #define PDEV_UMPD 0x8000 #define PDEV_SHARED_DEVLOCK 0x00010000 #define PDEV_META_DEVICE 0x00020000 #define PDEV_DRIVER_PUNTED_CALL 0x00040000 #define PDEV_CLONE_DEVICE 0x00080000 #define PDEV_MOUSE_TRAILS 0x00100000 #define PDEV_SYNCHRONOUS_POINTER 0x00200000 #define PDEV_WOW64_HTPATSIZE_USER 0x00400000 // Allowed flags for pdev.flAccelerated #define ACCELERATED_CONSTANT_ALPHA 0x0001 #define ACCELERATED_PIXEL_ALPHA 0x0002 #define ACCELERATED_TRANSPARENT_BLT 0x0004 #ifndef GDIFLAGS_ONLY // used for gdikdx class PDEV : public OBJECT /* pdev */ { public: // // The following three fields may be accessed only when the // ghsemDriverMgmt semaphore is held. // PDEV *ppdevNext; // Next PDEV in the list. ULONG cPdevRefs; // Number of clients. ULONG cPdevOpenRefs; // OpenCount // - Number of references open from // DrvCreateMDEV including Desktop // MDEV and HDCs created from // CreateDC with a specified mode. // // WinBug 306193 2001-02-05 jasonha // CreateDC references are never // subtracted when DC is deleted. public: // // State that is persistent across calls to bDynamicModeChange: // PDEV *ppdevParent; // Parent PDEV. Same as 'this' if not multi-mon. FLONG fl; // PDEV_ flags. FLONG flAccelerated; // Hardware acceleration flags HSEMAPHORE hsemDevLock; // For display locking HSEMAPHORE hsemPointer; // For hardware locking. POINTL ptlPointer; // Where the pointer is. POINTL ptlHotSpot; // Current pointer's hot-spot. SPRITESTATE SpriteState; // Sprite drawing state HLFONT hlfntDefault; // Device default LFONT HLFONT hlfntAnsiVariable; // ANSI variable LFONT HLFONT hlfntAnsiFixed; // ANSI fixed LFONT HSURF ahsurf[HS_DDI_MAX]; // Default patterns. LPWSTR pwszDataFile; // PVOID pDevHTInfo; // Device halftone info. RFONT *prfntActive; // list of active (i.e. 'selected) rfnts RFONT *prfntInactive; // list of inactive rfnts UINT cInactive; // cnt of rfonts on inactive list ULONG_PTR ajbo[(sizeof(EBRUSHOBJ)+sizeof(ULONG_PTR)-1) / sizeof(ULONG_PTR)];// Gray brush used for drag rect ULONG cDirectDrawDisableLocks;// Count of outstanding requests to // disable DirectDraw; when zero, // DirectDraw can be re-enabled. PTYPEONEINFO TypeOneInfo; // Point to Type 1 Info given to this // pdev if PSCRIPT driver. PVOID pvGammaRampTable; // ICM DeviceGammaRamp table (256*3 bytes) PREMOTETYPEONENODE RemoteTypeOne; // Linked list of RemoteType1 fonts SIZEL sizlMeta; // Combined meta device size for multimon // // The following is PDEV data that is swapped along with the device by // 'bDynamicModeChange'. The rest of the PDEV is state that is tied // more to this PDEV than to the device. // PFN_DrvSetPointerShape pfnDrvSetPointerShape; // Accelerator PFN_DrvMovePointer pfnDrvMovePointer; // Accelerator PFN_DrvMovePointer pfnMovePointer; // Accelerator PFN_DrvSynchronize pfnSync; // Accelerator PFN_DrvSynchronizeSurface pfnSyncSurface; // Accelerator PFN_DrvSetPalette pfnSetPalette; PFN_DrvNotify pfnNotify; ULONG ulTag; // For debugging, should be 'Pdev' LDEV *pldev; // Pointer to the LDEV DHPDEV dhpdev; // Device PDEV PPALETTE ppalSurf; // Pointer to Surface palette DEVINFO devinfo; // Caps, fonts, and style steps GDIINFO GdiInfo; // Device parameters SURFACE *pSurface; // Pointer to locked device surface HANDLE hSpooler; // Spooler or miniport handle // in the virtual desktop PVOID pDesktopId; // Id of the desktop this device is // associated with GRAPHICS_DEVICE *pGraphicsDevice; // Pointer to the graphics device structure POINTL ptlOrigin; // Where this device is anchored DEVMODEW *ppdevDevmode; // DEVMODE for this instance PFN_DrvBitBlt pfnUnfilteredBitBlt; // Point to true driver DrvBitBlt routine, // from before vFilterDriverHooks() did its // work DWORD dwDriverCapableOverride; // A flag which indicates if the driver // is capable to GDI/DDRAW/D3D or not DWORD dwDriverAccelerationLevel; // Level that indicates how many // accelerations we allow for this // driver #ifdef DDI_WATCHDOG PVOID pWatchdogContext; // Points to shared watchdog context PWATCHDOG_DATA pWatchdogData; // Points to storage for watchdogs #endif PFN apfn[INDEX_LAST]; // Dispatch table DWORD daDirectDrawContext[1]; // DirectDraw state // !!! SHOULD NOT PUT ANYTHING AFTER daDirectDrawContext[1] !!! }; /*********************************Class************************************\ * class PDEVOBJ * * * * User object for the PDEV class. * * * \**************************************************************************/ class PDEVOBJ { public: PDEV *ppdev; public: VOID vInit(HDEV hdev) {ppdev = (PDEV *) hdev;} PDEVOBJ() {vInit(NULL);} PDEVOBJ(HDEV hdev) {vInit(hdev);} PDEVOBJ(PLDEV pldev, PDEVMODEW pdriv, PWSZ pwszLogAddr, PWSZ pwszDataFile, PWSZ pwszDeviceName, HANDLE hSpooler, PREMOTETYPEONENODE pRemoteTypeOne = NULL, PGDIINFO pMirroredGdiInfo = NULL, PDEVINFO pMirroredDevInfo = NULL, BOOL bUMPD = FALSE, DWORD dwCapableOverride = DRIVER_CAPABLE_ALL, DWORD dwAccelerationLevel = 0); PDEVOBJ(HDEV hdev, FLONG fl); ~PDEVOBJ() {} #if DBG VOID vAssertDevLock(); // On checked builds, assert is in VOID vAssertDynaLock(); // pdevobj.cxx VOID vAssertNoDevLock(); #else VOID vAssertDevLock() {} // On free builds, define to nothing VOID vAssertDynaLock() {} VOID vAssertNoDevLock() {} #endif BOOL bValid() { // Assert if the PDEV is pointing to garbage. We assert in this // case, rather than return failure, as no one should ever pass // us an invalid PDEV, and if they do we want to assert so that // the caller can be fixed. if (ppdev != NULL) { ASSERTGDI(ppdev->ulTag == 'Pdev', "Bad hdev"); } return(ppdev != (PDEV *) NULL); } // 'hdevParent' returns the parent PDEV when the PDEV is a child PDEV in // a multi-monitor system. 'hdevParent' will be the same as 'hdev' when // not multi-monitor. HDEV hdev() {return((HDEV) ppdev);} HDEV hdevParent() {return((HDEV) ppdev->ppdevParent);} LDEV *pldev() {return(ppdev->pldev);} PW32PROCESS pid() {return(ppdev->pldev->pid);} HBITMAP hbmPattern(ULONG ul) {ASSERTGDI(ul < (HS_DDI_MAX), "ul too big"); return((HBITMAP)ppdev->ahsurf[ul]);} ULONG cxDither() {return(ppdev->devinfo.cxDither); } ULONG cyDither() {return(ppdev->devinfo.cyDither); } ////////////////////////////////////////////////////////////////////////////// // Fields that may be asynchronously modified by Dynamic Mode Changes // // The following fields may be changed by display driver dynamic mode // changes, so the appropriate locks must be acquired to access them. BOOL bMetaDriver() {vAssertDynaLock(); return(ppdev->fl & PDEV_META_DEVICE);} BOOL bMetaDriver(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_META_DEVICE);return(b);} BOOL bCloneDriver() {vAssertDynaLock(); return(ppdev->fl & PDEV_CLONE_DEVICE);} BOOL bCloneDriver(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_CLONE_DEVICE);return(b);} ULONG iDitherFormat() {vAssertDynaLock(); return(ppdev->devinfo.iDitherFormat);} ULONG iDitherFormatNotDynamic(){return(ppdev->devinfo.iDitherFormat);} ULONG iParentDitherFormat() { vAssertDynaLock(); return(ppdev->ppdevParent->devinfo.iDitherFormat); } BOOL bIsPalManaged() {vAssertDynaLock(); return(ppdev->GdiInfo.flRaster & RC_PALETTE);} SURFACE *pSurface() {vAssertDynaLock(); return(ppdev->pSurface);} POINTL *pptlOrigin() {vAssertDynaLock(); return(&(ppdev->ptlOrigin)); } HANDLE hScreen() {vAssertDynaLock(); return(ppdev->hSpooler);} SIZEL sizl() { vAssertDynaLock(); if (bMetaDriver()) return(ppdev->sizlMeta); else return(*((SIZEL *)&(ppdev->GdiInfo.ulHorzRes))); } // Dispatch table functions: #if DBG PFN ppfn(ULONG i); // Call out-of-line for some debug code #else PFN ppfn(ULONG i) {return(ppdev->apfn[i]);} #endif PFN* apfn() {vAssertDynaLock(); return(ppdev->apfn);} // The following two methods must be used with care because their values may // change asynchronously, and no locks are asserted: BOOL bAsyncPointerMove() {return((ppdev->devinfo.flGraphicsCaps & GCAPS_ASYNCMOVE) && !bSynchronousPointer());} PVOID pDevHTInfo() {return(ppdev->pDevHTInfo);} // 'dhpdevNotDynamic' and 'ppalSurfNotDynamic' may be used to skip the assert // verifying that a dynamic mode change lock is held, and should be used only // when the dhpdev or ppalSurf is not from a display device that can // dynamically change modes: DHPDEV dhpdev() {vAssertDynaLock(); return(ppdev->dhpdev);} DHPDEV dhpdevNotDynamic() {return(ppdev->dhpdev);} DHPDEV dhpdevParent() { vAssertDynaLock(); ASSERTGDI(ppdev->ppdevParent,"PDEVOBJ::dhpdevParent(): ppdevParent is NULL\n"); return(ppdev->ppdevParent->dhpdev); } PPALETTE ppalSurf() {vAssertDynaLock(); return(ppdev->ppalSurf); } PPALETTE ppalSurfNotDynamic() {return(ppdev->ppalSurf);} VOID ppalSurf(PPALETTE p) {ppdev->ppalSurf = p;} // Dynamic mode changes may cause the contents of the GDIINFO and DEVINFO // data to change at any time (but not the actual GdiInfo() or pdevinfo() // pointers). Consequently, a dynamic mode change lock must be held to // access the fields if you're concerned that the data may change. If you // don't care, use the 'NotDynamic' member function to access the data: FLONG flGraphicsCaps() {vAssertDynaLock(); return(ppdev->devinfo.flGraphicsCaps);} FLONG flGraphicsCapsNotDynamic() {return(ppdev->devinfo.flGraphicsCaps);} FLONG flGraphicsCaps2() {vAssertDynaLock(); return(ppdev->devinfo.flGraphicsCaps2);} FLONG flGraphicsCaps2NotDynamic(){return(ppdev->devinfo.flGraphicsCaps2);} GDIINFO *GdiInfo() {vAssertDynaLock(); return(&ppdev->GdiInfo);} GDIINFO *GdiInfoNotDynamic() {return(&ppdev->GdiInfo);} DEVINFO *pdevinfo() {vAssertDynaLock(); return(&ppdev->devinfo);} DEVINFO *pdevinfoNotDynamic() {return(&ppdev->devinfo);} BOOL bPrimary(SURFACE *pSurface) {return(pSurface == ppdev->pSurface);} // The following GDIINFO fields are currently guaranteed not to change during // dynamic mode changes, because bDynamicModeChange ensures that they don't // change. So call these member functions to access these fields: ULONG ulLogPixelsX() {return(ppdev->GdiInfo.ulLogPixelsX);} ULONG ulLogPixelsY() {return(ppdev->GdiInfo.ulLogPixelsY);} ULONG ulTechnology() {return(ppdev->GdiInfo.ulTechnology);} ULONG flTextCaps() {return(ppdev->GdiInfo.flTextCaps);} LONG xStyleStep() {return(ppdev->GdiInfo.xStyleStep);} LONG yStyleStep() {return(ppdev->GdiInfo.yStyleStep);} LONG denStyleStep() {return(ppdev->GdiInfo.denStyleStep);} ULONG ulGamma() {return(ppdev->GdiInfo.ulPhysicalPixelGamma);} BOOL bCapsHighResText() {return(ppdev->devinfo.flGraphicsCaps & GCAPS_HIGHRESTEXT);} BOOL bCapsForceDither() {return(ppdev->devinfo.flGraphicsCaps & GCAPS_FORCEDITHER);} ////////////////////////////////////////////////////////////////////////////// ULONG cFonts(); ULONG cPdevRefs() {return(ppdev->cPdevRefs);} // bDeleted -- determines whether a PDEV has been marked for deletion. // The PDEV will not be deleted immediately if there are active // references open on it. Note that this field can be accessed // only if ghsemDriverMgmt is held! BOOL bDeleted() {return(ppdev->cPdevOpenRefs == 0);} // fl -- Test the current status word FLONG fl(FLONG fl_ ) {return(ppdev->fl & fl_);} FLONG setfl(BOOL b,FLONG fl_ ) {SETFLAG(b,ppdev->fl,fl_);return(b);} // Flag test and set. BOOL bDisabled() {return(ppdev->fl & PDEV_DISABLED);} BOOL bDisabled(BOOL b); BOOL bFontDriver() {return(ppdev->fl & PDEV_FONTDRIVER);} BOOL bHardwarePointer() {return(ppdev->fl & PDEV_HARDWARE_POINTER);} BOOL bHardwarePointer(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_HARDWARE_POINTER);return(b);} BOOL bSoftwarePointer() {return(ppdev->fl & PDEV_SOFTWARE_POINTER);} BOOL bSoftwarePointer(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_SOFTWARE_POINTER);return(b);} BOOL bSynchronousPointer() {return(ppdev->fl & PDEV_SYNCHRONOUS_POINTER);} BOOL bSynchronousPointer(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_SYNCHRONOUS_POINTER);return(b);} BOOL bMouseTrails() {return(ppdev->fl & PDEV_MOUSE_TRAILS);} BOOL bMouseTrails(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_MOUSE_TRAILS);return(b);} BOOL bDisplayPDEV() {return(ppdev->fl & PDEV_DISPLAY);} BOOL bGotFonts() {return(ppdev->fl & PDEV_GOTFONTS);} BOOL bGotFonts(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_GOTFONTS);return(b);} BOOL bPrinter() {return(ppdev->fl & PDEV_PRINTER);} BOOL bPrinter(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_PRINTER);return(b);} BOOL bHTPalIsDevPal() {return(ppdev->fl & PDEV_HTPAL_IS_DEVPAL);} VOID vHTPalIsDevPal(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_HTPAL_IS_DEVPAL);} BOOL bDriverPuntedCall() {return(ppdev->fl & PDEV_DRIVER_PUNTED_CALL);} VOID vDriverPuntedCall(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_DRIVER_PUNTED_CALL);} BOOL bSynchronizeEnabled() {return(ppdev->fl & PDEV_SYNCHRONIZE_ENABLED);} VOID vSynchronizeEnabled(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_SYNCHRONIZE_ENABLED);} // remote Type1 stuff PREMOTETYPEONENODE RemoteTypeOneGet(VOID){return(ppdev->RemoteTypeOne);} VOID RemoteTypeOneSet(PREMOTETYPEONENODE _RemoteTypeOne) { ppdev->RemoteTypeOne = _RemoteTypeOne; } // ptlPointer -- Where the pointer is. POINTL& ptlPointer() {return(ppdev->ptlPointer);} POINTL& ptlPointer(LONG x,LONG y) { ppdev->ptlPointer.x = x; ppdev->ptlPointer.y = y; return(ppdev->ptlPointer); } // ptlHotSpot - Current pointer's hot-spot. POINTL& ptlHotSpot() {return(ppdev->ptlHotSpot);} POINTL& ptlHotSpot(LONG x,LONG y) { ppdev->ptlHotSpot.x = x; ppdev->ptlHotSpot.y = y; return(ppdev->ptlHotSpot); } // pbo() -- Returns the brush used for drag rects. EBRUSHOBJ *pbo() { return((EBRUSHOBJ *) ppdev->ajbo); } // pfnSync() -- Get the driver synchronization routine. PFN_DrvSynchronize pfnSync() {return(ppdev->pfnSync);} VOID pfnSync( PFN_DrvSynchronize pfn) {ppdev->pfnSync=pfn;} PFN_DrvSynchronizeSurface pfnSyncSurface() {return(ppdev->pfnSyncSurface);} VOID pfnSyncSurface( PFN_DrvSynchronizeSurface pfn) {ppdev->pfnSyncSurface=pfn;} VOID vSync(SURFOBJ* pso, RECTL* prcl, FLONG fl); // pfnSetPalette -- Get the set palette routine. PFN_DrvSetPalette pfnSetPalette() {return(ppdev->pfnSetPalette);} VOID pfnSetPalette( PFN_DrvSetPalette pfn) {ppdev->pfnSetPalette=pfn;} // vUnreferencePdev -- // Decrements the reference count of the PDEV. Deletes the PDEV if // there are no references left. NOTE: The DEVLOCK must not be held // if there's the possibility the PDEV may actually be freed! // vReferencePdev -- // Increments the reference count. VOID vUnreferencePdev(CLEANUPTYPE cutype = CLEANUP_NONE); VOID vReferencePdev(); // hsemDevLock() -- Returns the display semaphore. HSEMAPHORE hsemDevLock() {return(ppdev->hsemDevLock);} // vUseParentDevLock() -- Flip the devlock with parent and save old to Original BOOL bUseParentDevLock() {vAssertDynaLock(); return(ppdev->fl & PDEV_SHARED_DEVLOCK);} BOOL bUseParentDevLock(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_SHARED_DEVLOCK);return(b);} VOID vUseParentDevLock() { // // 1) Parent should be existed. // 2) Parent should NOT be same as me. // 3) Parent DEVLOCK should NOT be NULL. // ASSERTGDI(ppdev->ppdevParent != NULL,"PDEVOBJ.UseParentDevLock():Parent is NULL\n"); ASSERTGDI(ppdev->ppdevParent != ppdev,"PDEVOBJ.UseParentDevLock():Parent is Me\n"); ASSERTGDI(ppdev->ppdevParent->hsemDevLock != NULL,"PDEVOBJ.UseParentDevLock():Parent DevLock is NULL\n"); // // If hsemDevLock points same as parent, we are done. // if (ppdev->hsemDevLock != ppdev->ppdevParent->hsemDevLock) { // // 4) My own DEVLOCK should NOT be locked. // // ASSERTGDI(ppdev->hsemDevLock->ActiveCount == 0,"PDEVOBJ.UseParentDevLock():Locked!\n"); // // If we are switch from Private Lock to Shared Lock, delete old lock and mark it // "shared". If we are already using shared lock, we don't delete it here, owner // (= most of case it's parent) will delete it. // if (!bUseParentDevLock()) { GreDeleteSemaphore(ppdev->hsemDevLock); bUseParentDevLock(TRUE); } // // Exchanges the pointer with parent devlock. // ppdev->hsemDevLock = ppdev->ppdevParent->hsemDevLock; } else { ASSERTGDI(bUseParentDevLock(),"PDEVOBJ.UseParentDevLock():Not mark as shared\n"); } } // hsemPointer() -- Returns the hardware semaphore. HSEMAPHORE hsemPointer() {return(ppdev->hsemPointer);} // bMakeSurface -- Asks the device driver to create a surface for the PDEV. BOOL bMakeSurface(); // vDisableSurface() -- deletes the surface VOID vDisableSurface(CLEANUPTYPE cutype = CLEANUP_NONE); HANDLE hSpooler() { return ppdev->hSpooler; } HANDLE hSpooler(HANDLE hS) { return ppdev->hSpooler = hS; } // pDirectDrawContext() -- Returns a pointer to DirectDraw context for this PDEV PVOID pDirectDrawContext() { return(&(ppdev->daDirectDrawContext[0])); } // cDirectDrawDisableLocks() -- Return a lock count of DirectDraw ULONG cDirectDrawDisableLocks() { return(ppdev->cDirectDrawDisableLocks); } VOID cDirectDrawDisableLocks(ULONG c) { ppdev->cDirectDrawDisableLocks = c; } // pSpriteState() -- Returns a pointer to Sprite context for this PDEV SPRITESTATE *pSpriteState() { return(&ppdev->SpriteState); } // flAccelerated() -- Returns flags that indicated device acceleration FLONG flAccelerated() { return(ppdev->flAccelerated); } VOID vAccelerated(FLONG fl) { ppdev->flAccelerated |= fl; } // hlfntDefault -- Returns the handle to the PDEV's default LFONT. HLFONT hlfntDefault() { return(ppdev->hlfntDefault); } // hlfntAnsiVariable -- Returns the handle to the PDEV's ANSI // variable-pitch LFONT. HLFONT hlfntAnsiVariable() { return(ppdev->hlfntAnsiVariable); } // hlfntAnsiFixed -- Returns the handle to the PDEV's ANSI fixed-pitch LFONT. HLFONT hlfntAnsiFixed() { return(ppdev->hlfntAnsiFixed); } // Creates the default brushes for the display driver. BOOL bCreateDefaultBrushes(); // bEnableHalftone -- Create and initialize the device halftone info. BOOL bEnableHalftone(COLORADJUSTMENT *pca); // bDisableHalftone -- Delete the device halftone info. BOOL bDisableHalftone(); #if defined(_WIN64) // vDeleteWOW64HTPATSIZEUSER VOID vDeleteWOW64HTPATSIZEUSERAllocations() { if (fl(PDEV_WOW64_HTPATSIZE_USER)) { EngFreeUserMem(ppdev->GdiInfo.pHTPatA); EngFreeUserMem(ppdev->GdiInfo.pHTPatB); EngFreeUserMem(ppdev->GdiInfo.pHTPatC); } } #endif // bCreateHalftoneBrushes() -- init the standard brushs if the driver didn't BOOL bCreateHalftoneBrushes(); // prfntActive() -- returns the head of the active list of rfnts RFONT *prfntActive() { return ppdev->prfntActive; } // prfntActive(RFONT *) -- set head of active list of rfnt, return old head RFONT *prfntActive(RFONT *prf) { RFONT *prfntrv = ppdev->prfntActive; ppdev->prfntActive = prf; return prfntrv; } // prfntInactive() -- returns the head of the inactive list of rfnts RFONT *prfntInactive() { return ppdev->prfntInactive; } // prfntInactive(RFONT *) -- set head of inactive list of rfnt, return old head RFONT *prfntInactive(RFONT *prf) { RFONT *prfntrv = ppdev->prfntInactive; ppdev->prfntInactive = prf; return prfntrv; } UINT cInactive() { return ppdev->cInactive; }; UINT cInactive(UINT i) { return ppdev->cInactive = i; }; // lazy load of device fonts BOOL bGetDeviceFonts(); // User-mode-printer-driver flag BOOL bUMPD() {return(ppdev->fl & PDEV_UMPD);} BOOL bUMPD(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_UMPD);return(b);} // ICM stuff BOOL bHasGammaRampTable() {return(ppdev->fl & PDEV_GAMMARAMP_TABLE);} BOOL bHasGammaRampTable(BOOL b) {SETFLAG(b,ppdev->fl,PDEV_GAMMARAMP_TABLE);return(b);} PVOID pvGammaRampTable() {return(ppdev->pvGammaRampTable);} PVOID pvGammaRampTable(PVOID p) {ppdev->pvGammaRampTable = p;return (p);} // returns TRUE if path matches the path of the image of this PDEV's LDEV BOOL MatchingLDEVImage(UNICODE_STRING usDriverName) { return((ppdev->pldev->pGdiDriverInfo != NULL) && RtlEqualUnicodeString(&(ppdev->pldev->pGdiDriverInfo->DriverName), &usDriverName, TRUE)); } // Notify VOID vNotify(ULONG iType, PVOID pvData); // disable driver functionality as appropriate VOID vFilterDriverHooks(); // driver capable override. DWORD dwDriverCapableOverride() {return(ppdev->dwDriverCapableOverride);} // driver acceleration level. DWORD dwDriverAccelerationsLevel() {return(ppdev->dwDriverAccelerationLevel);} VOID vSetDriverAccelerationsLevel(DWORD dwNewLevel) {ppdev->dwDriverAccelerationLevel=dwNewLevel;} // proile the driver VOID vProfileDriver(); DHPDEV EnablePDEV( DEVMODEW *pdm , LPWSTR pwszLogAddress , ULONG cPat , HSURF *phsurfPatterns , ULONG cjCaps , GDIINFO *pGdiInfo , ULONG cjDevInfo , DEVINFO *pdi , HDEV hdev , LPWSTR pwszDeviceName , HANDLE hDriver ); VOID DisablePDEV( DHPDEV dhpdev ); VOID CompletePDEV( DHPDEV dhpdev , HDEV hdev ); IFIMETRICS* QueryFont( DHPDEV dhpdev , ULONG_PTR iFile , ULONG iFace , ULONG_PTR *pid ); PVOID QueryFontTree( DHPDEV dhpdev , ULONG_PTR iFile , ULONG iFace , ULONG iMode , ULONG_PTR *pid ); PFD_GLYPHATTR QueryGlyphAttrs( FONTOBJ *pfo, ULONG iMode ); LONG QueryFontData( DHPDEV dhpdev , FONTOBJ *pfo , ULONG iMode , HGLYPH hg , GLYPHDATA *pgd , PVOID pv , ULONG cjSize ); VOID DestroyFont( FONTOBJ *pfo ); LONG QueryFontCaps( ULONG culCaps , ULONG *pulCaps ); HFF LoadFontFile( ULONG cFiles , ULONG_PTR *piFile , PVOID *ppvView , ULONG *pcjView , DESIGNVECTOR *pdv , ULONG ulLangID , ULONG ulFastCheckSum ); BOOL UnloadFontFile( ULONG_PTR iFile ); LONG QueryFontFile( ULONG_PTR iFile , ULONG ulMode , ULONG cjBuf , ULONG *pulBuf ); BOOL QueryAdvanceWidths( DHPDEV dhpdev , FONTOBJ *pfo , ULONG iMode , HGLYPH *phg , PVOID pvWidths , ULONG cGlyphs ); VOID Free( PVOID pv , ULONG_PTR id ); LONG QueryTrueTypeTable( ULONG_PTR iFile , ULONG ulFont , ULONG ulTag , PTRDIFF dpStart , ULONG cjBuf , BYTE *pjBuf , BYTE **ppjTable , ULONG *pcjTable ); LONG QueryTrueTypeOutline( DHPDEV dhpdev , FONTOBJ *pfo , HGLYPH hglyph , BOOL bMetricsOnly , GLYPHDATA *pgldt , ULONG cjBuf , TTPOLYGONHEADER *ppoly ); PVOID GetTrueTypeFile( ULONG_PTR iFile , ULONG *pcj ); BOOL FontManagement ( SURFOBJ *pso, FONTOBJ *pfo, ULONG iEsc, ULONG cjIn, PVOID pvIn, ULONG cjOut, PVOID pvOut ); ULONG Escape( SURFOBJ *pso , ULONG iEsc , ULONG cjIn , PVOID pvIn , ULONG cjOut , PVOID pvOut ); }; typedef PDEVOBJ *PPDEVOBJ; // Miscellaneous PDEV-related prototypes: VOID vEnableSynchronize(HDEV hdev); VOID vDisableSynchronize(HDEV hdev); HDEV hdevEnumerate(HDEV hdevPrevious); // Support class to disable and enable Watchdog class SUSPENDWATCH { public: PDEV *_ppdev; SUSPENDWATCH() { #ifdef DDI_WATCHDOG _ppdev = NULL; #endif } SUSPENDWATCH(PDEVOBJ& pdo) { Suspend(pdo); } void Suspend(PDEVOBJ& pdo) { #ifdef DDI_WATCHDOG _ppdev = NULL; if (pdo.bValid() && pdo.bDisplayPDEV()) { _ppdev = pdo.ppdev; GreSuspendWatch(_ppdev, WD_DEVLOCK); } #endif } void Resume() { #ifdef DDI_WATCHDOG if (_ppdev) { GreResumeWatch(_ppdev, WD_DEVLOCK); _ppdev = NULL; } #endif } ~SUSPENDWATCH() { Resume(); } }; #endif // GDIFLAGS_ONLY used for gdikdx