You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1193 lines
36 KiB
1193 lines
36 KiB
/******************************Module*Header*******************************\
|
|
* Module Name: hmgshare.h
|
|
*
|
|
* Define shared dc attributes
|
|
*
|
|
* Created: 13-Apr-1995
|
|
* Author: Mark Enstrom [marke]
|
|
*
|
|
* Copyright (c) 1995-1999 Microsoft Corporation
|
|
\**************************************************************************/
|
|
|
|
/******************************WOW64***NOTE********************************\
|
|
* Note: Win32k Memory shared with User-Mode and Wow64
|
|
*
|
|
* For Wow64 (Win32 apps on Win64) we build a 32-bit version
|
|
* of user32.dll & gdi32.dll which can run against the 64-bit kernel
|
|
* with no changes to the 64-bit kernel code.
|
|
*
|
|
* For the 32 on 64 bit dlls all data structures which are shared with
|
|
* win32k must be 64-bit. These data structures include the shared
|
|
* sections, as well as the GDI TEB Batch.
|
|
* These shared data structures are now declared so that they can be
|
|
* built as 32 bit in a 32 bit dll, 64 bit in a 64 bit dll, and now
|
|
* 64 bit in a 32 bit dll.
|
|
*
|
|
* The following rules should be followed when declaring
|
|
* shared data structures:
|
|
*
|
|
* Pointers in shared data structures use the KPTR_MODIFIER in their
|
|
* declaration.
|
|
*
|
|
* Handles in shared data structures are declared KHxxx.
|
|
*
|
|
* xxx_PTR changes to KERNEL_xxx_PTR.
|
|
*
|
|
* Pointers to basic types are declared as KPxxx;
|
|
*
|
|
* Also on Wow64 every thread has both a 32-bit TEB and a 64-bit TEB.
|
|
* GetCurrentTeb() returns the current 32-bit TEB while the kernel
|
|
* will allways reference the 64-bit TEB.
|
|
*
|
|
* All client side references to shared data in the TEB should use
|
|
* the new GetCurrentTebShared() macro which returns the 64-bit TEB
|
|
* for Wow64 builds and returns GetCurrentTeb() for regular builds.
|
|
* The exception to this rule is LastErrorValue, which should allways
|
|
* be referenced through GetCurrentTeb().
|
|
*
|
|
* Ex:
|
|
*
|
|
* DECLARE_HANDLE(HFOO);
|
|
*
|
|
* typedef struct _MY_STRUCT * KPTR_MODIFIER PMPTR;
|
|
*
|
|
* struct _SHARED_STRUCT
|
|
* {
|
|
* struct _SHARED_STRUCT * pNext;
|
|
* PMPTR pmptr;
|
|
* HFOO hFoo;
|
|
* UINT_PTR cb;
|
|
* PBYTE pb;
|
|
* PVOID pv;
|
|
*
|
|
* DWORD dw;
|
|
* USHORT us;
|
|
* } SHARED_STRUCT;
|
|
*
|
|
*
|
|
* Changes to:
|
|
*
|
|
*
|
|
* DECLARE_HANDLE(HFOO);
|
|
* DECLARE_KHANDLE(HFOO);
|
|
*
|
|
* typedef struct _MY_STRUCT *PMPTR;
|
|
*
|
|
* struct _SHARED_STRUCT
|
|
* {
|
|
* struct _SHARED_STRUCT * KPTR_MODIFIER pNext;
|
|
* PMPTR pmptr;
|
|
* KHFOO hFoo;
|
|
* KERNEL_UINT_PTR cb;
|
|
* KPBYTE pb;
|
|
* KERNEL_PVOID pv;
|
|
*
|
|
* DWORD dw;
|
|
* USHORT us;
|
|
* } SHARED_STRUCT;
|
|
\***************************************************************************/
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#include <w32wow64.h>
|
|
|
|
//Sundown: offsetof generates truncation warnings in 64bit environment
|
|
#undef offsetof
|
|
#define offsetof(c,f) FIELD_OFFSET(c,f)
|
|
|
|
/*********************************Structure********************************\
|
|
*
|
|
* RGNATTR
|
|
*
|
|
* Description:
|
|
*
|
|
* As an accelerator, this rectangular region is kept in the DC and
|
|
* represents either a NULL region, a rectangular region, or hte bounding
|
|
* box of a complex region. This can be used for a trivial reject clip test.
|
|
*
|
|
* Fields:
|
|
*
|
|
* Flags - state flags
|
|
* NULLREGION - drawing is allowed anywhere, no trivial clip
|
|
* SIMPLEREGION - Rect is the clip region
|
|
* COMPLEXREGION - Rect is the bounding box of a complex clip region
|
|
* ERROR - this information may not be used
|
|
*
|
|
* LRFlags - valid and dirty flags
|
|
*
|
|
* Rect - clip rectangle or bounding rectangle when in use
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
#define RREGION_INVALID ERROR
|
|
|
|
//
|
|
// ExtSelectClipRgn iMode extra flag for batching
|
|
//
|
|
|
|
#define REGION_NULL_HRGN 0X8000000
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
typedef struct _RGNATTR
|
|
{
|
|
ULONG AttrFlags;
|
|
ULONG Flags;
|
|
RECTL Rect;
|
|
} RGNATTR,*PRGNATTR;
|
|
|
|
/*******************************STRUCTURE**********************************\
|
|
* BRUSHATTR
|
|
*
|
|
* Fields:
|
|
*
|
|
* lbColor - Color from CreateSolidBrush
|
|
* lflag - Brush operation flags
|
|
*
|
|
* CACHED - Set only when brush is cached on PEB
|
|
* TO_BE_DELETED - Set only after DelteteBrush Called in kernel
|
|
* when reference count of brush > 1, this will
|
|
* cause the brush to be deleted via lazy delete
|
|
* when it is selected out later.
|
|
* NEW_COLOR - Set when color changes (retrieve cached brush)
|
|
* ATTR_CANT_SELECT - Set when user calls DeleteObject(hbrush),
|
|
* brush is marked so can't be seleced in user
|
|
* mode. Not deleted until kernel mode DeleteBrush.
|
|
* This is not currently implemented.
|
|
*
|
|
* History:
|
|
*
|
|
* 6-Feb-1996 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef struct _BRUSHATTR
|
|
{
|
|
ULONG AttrFlags;
|
|
COLORREF lbColor;
|
|
} BRUSHATTR,*PBRUSHATTR;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
//
|
|
// Common flags for dealing with RGN/BRUSH ATTR memory
|
|
//
|
|
|
|
#define ATTR_CACHED 0x00000001
|
|
#define ATTR_TO_BE_DELETED 0x00000002
|
|
#define ATTR_NEW_COLOR 0x00000004
|
|
#define ATTR_CANT_SELECT 0x00000008
|
|
#define ATTR_RGN_VALID 0x00000010
|
|
#define ATTR_RGN_DIRTY 0x00000020
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
//
|
|
// Define a union so these objects can be managed together
|
|
//
|
|
|
|
typedef union _OBJECTATTR
|
|
{
|
|
RGNATTR Rgnattr;
|
|
BRUSHATTR Brushattr;
|
|
}OBJECTATTR,*POBJECTATTR;
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* XFORM related structures and macros
|
|
*
|
|
\**************************************************************************/
|
|
|
|
//
|
|
// These types are used to get things right when C code is passing C++
|
|
// defined transform data around.
|
|
//
|
|
|
|
typedef struct _MATRIX_S
|
|
{
|
|
EFLOAT_S efM11;
|
|
EFLOAT_S efM12;
|
|
EFLOAT_S efM21;
|
|
EFLOAT_S efM22;
|
|
EFLOAT_S efDx;
|
|
EFLOAT_S efDy;
|
|
FIX fxDx;
|
|
FIX fxDy;
|
|
FLONG flAccel;
|
|
} MATRIX_S;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
//
|
|
// status and dirty flags
|
|
//
|
|
|
|
#define DIRTY_FILL 0x00000001
|
|
#define DIRTY_LINE 0x00000002
|
|
#define DIRTY_TEXT 0x00000004
|
|
#define DIRTY_BACKGROUND 0x00000008
|
|
#define DIRTY_CHARSET 0x00000010
|
|
#define SLOW_WIDTHS 0x00000020
|
|
#define DC_CACHED_TM_VALID 0x00000040
|
|
#define DISPLAY_DC 0x00000080
|
|
#define DIRTY_PTLCURRENT 0x00000100
|
|
#define DIRTY_PTFXCURRENT 0x00000200
|
|
#define DIRTY_STYLESTATE 0x00000400
|
|
#define DC_PLAYMETAFILE 0x00000800
|
|
#define DC_BRUSH_DIRTY 0x00001000 // cached brush
|
|
#define DC_PEN_DIRTY 0x00002000
|
|
#define DC_DIBSECTION 0x00004000
|
|
#define DC_LAST_CLIPRGN_VALID 0x00008000
|
|
#define DC_PRIMARY_DISPLAY 0x00010000
|
|
#define DIRTY_COLORTRANSFORM 0x00020000
|
|
#define ICM_BRUSH_TRANSLATED 0x00040000
|
|
#define ICM_PEN_TRANSLATED 0x00080000
|
|
#define DIRTY_COLORSPACE 0x00100000
|
|
#define BATCHED_DRAWING 0x00200000
|
|
#define BATCHED_TEXT 0x00400000
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define CLEAR_CACHED_TEXT(pdcattr) (pdcattr->ulDirty_ &= ~(SLOW_WIDTHS))
|
|
|
|
|
|
#define DIRTY_BRUSHES (DIRTY_FILL+DIRTY_LINE+DIRTY_TEXT+DIRTY_BACKGROUND)
|
|
|
|
|
|
#define USER_XFORM_DIRTY(pdcattr) (pdcattr->flXform & (PAGE_XLATE_CHANGED | PAGE_EXTENTS_CHANGED | WORLD_XFORM_CHANGED))
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
|
|
/**************************************************************************\
|
|
*
|
|
* ICM related structures and macros
|
|
*
|
|
\**************************************************************************/
|
|
|
|
//
|
|
// ICM flags
|
|
//
|
|
// DC_ATTR.lIcmMode
|
|
//
|
|
// 0x0 000 0 0 00
|
|
// | | | | + Current ICM Mode (kernel/user)
|
|
// | | | + Requested ICM Mode (kernel/user)
|
|
// | | + ICM Mode context (user only)
|
|
// | + not used
|
|
// + Destination color type (kernel/user)
|
|
|
|
#define DC_ICM_USERMODE_FLAG 0x0000F000
|
|
|
|
//
|
|
// Current ICM mode flags.
|
|
//
|
|
#define DC_ICM_OFF 0x00000000
|
|
#define DC_ICM_HOST 0x00000001
|
|
#define DC_ICM_DEVICE 0x00000002
|
|
#define DC_ICM_OUTSIDEDC 0x00000004
|
|
#define DC_ICM_METAFILING_ON 0x00000008
|
|
#define DC_ICM_LAZY_CORRECTION 0x00000010 // alt mode (preserved through icm mode change)
|
|
#define DC_ICM_DEVICE_CALIBRATE 0x00000020 // alt mode (preserved through icm mode change)
|
|
#define DC_ICM_MODE_MASK 0x000000FF
|
|
#define DC_ICM_ALT_MODE_MASK 0x000000F0
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define ICM_MODE(x) ((x) & DC_ICM_MODE_MASK)
|
|
#define ICM_ALT_MODE(x) ((x) & DC_ICM_ALT_MODE_MASK)
|
|
|
|
#define IS_ICM_DEVICE(x) ((x) & DC_ICM_DEVICE)
|
|
#define IS_ICM_HOST(x) ((x) & DC_ICM_HOST)
|
|
#define IS_ICM_INSIDEDC(x) ((x) & (DC_ICM_DEVICE|DC_ICM_HOST))
|
|
#define IS_ICM_OUTSIDEDC(x) ((x) & DC_ICM_OUTSIDEDC)
|
|
#define IS_ICM_ON(x) ((x) & (DC_ICM_DEVICE|DC_ICM_HOST|DC_ICM_OUTSIDEDC))
|
|
|
|
#define IS_ICM_METAFILING_ON(x) ((x) & DC_ICM_METAFILING_ON)
|
|
#define IS_ICM_LAZY_CORRECTION(x) ((x) & DC_ICM_LAZY_CORRECTION)
|
|
#define IS_ICM_DEVICE_CALIBRATE(x) ((x) & DC_ICM_DEVICE_CALIBRATE)
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
//
|
|
// Request ICM mode flags
|
|
//
|
|
#define REQ_ICM_OFF 0x00000000
|
|
#define REQ_ICM_HOST 0x00000100
|
|
#define REQ_ICM_DEVICE 0x00000200
|
|
#define REQ_ICM_OUTSIDEDC 0x00000400
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define REQ_ICM_MODE(x) ((x) & 0x00000F00)
|
|
|
|
#define IS_ICM_DEVICE_REQUESTED(x) ((x) & REQ_ICM_DEVICE)
|
|
|
|
//
|
|
// Convert Request mode to current ICM mode flags.
|
|
//
|
|
#define ICM_REQ_TO_MODE(x) ((REQ_ICM_MODE((x))) >> 8)
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
//
|
|
// Context mode for ICM.
|
|
//
|
|
#define CTX_ICM_HOST 0x00001000 // Host ICM
|
|
#define CTX_ICM_DEVICE 0x00002000 // Device ICM
|
|
#define CTX_ICM_METAFILING_OUTSIDEDC 0x00004000 // Metfiling outside DC ICM mode
|
|
#define CTX_ICM_PROOFING 0x00008000 // Proofing mode
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define SET_HOST_ICM_DEVMODE(x) ((x) |= CTX_ICM_HOST)
|
|
#define SET_DEVICE_ICM_DEVMODE(x) ((x) |= CTX_ICM_DEVICE)
|
|
#define SET_ICM_PROOFING(x) ((x) |= CTX_ICM_PROOFING)
|
|
|
|
#define CLEAR_ICM_PROOFING(x) ((x) &= ~CTX_ICM_PROOFING)
|
|
|
|
#define IS_DEVICE_ICM_DEVMODE(x) ((x) & CTX_ICM_DEVICE)
|
|
#define IS_ICM_PROOFING(x) ((x) & CTX_ICM_PROOFING)
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
//
|
|
// Destination Color Type
|
|
//
|
|
#define DC_ICM_CMYK_COLOR 0x10000000
|
|
#define DC_ICM_RGB_COLOR 0x20000000
|
|
#define DC_ICM_COLORTYPE_MASK 0xF0000000
|
|
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define DC_ICM_32BITS_COLOR (DC_ICM_CMYK_COLOR)
|
|
|
|
#define IS_32BITS_COLOR(x) ((x) & DC_ICM_32BITS_COLOR)
|
|
#define IS_CMYK_COLOR(x) ((x) & DC_ICM_CMYK_COLOR)
|
|
|
|
#define GET_COLORTYPE(x) ((x) & DC_ICM_COLORTYPE_MASK)
|
|
#define CLEAR_COLORTYPE(x) ((x) &= ~DC_ICM_COLORTYPE_MASK)
|
|
|
|
/******************************Structure***********************************\
|
|
*
|
|
* DC_ATTR: This structure provides a common DC area visible both by in kernel
|
|
* and user mode. Since elements in the DC_ATTR are visible and modifiable
|
|
* in user-mode, data that must be kept safe must be stored in the kernel
|
|
* private DC structure.
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef struct _DC_ATTR
|
|
{
|
|
//
|
|
// local dc info
|
|
//
|
|
|
|
KERNEL_PVOID pvLDC;
|
|
|
|
//
|
|
// General Purpose Dirty Flags for brushes, fonts, etc.
|
|
//
|
|
|
|
ULONG ulDirty_;
|
|
|
|
//
|
|
// brush handle selected into DCATTR, not neccessarily selected
|
|
// into DC
|
|
//
|
|
|
|
KHANDLE hbrush;
|
|
KHANDLE hpen;
|
|
|
|
//
|
|
// *** Attribute Bundles ***
|
|
//
|
|
// When ICM is enabled,
|
|
// + cr____Clr color is corrected to DC's color space.
|
|
// + ul____Clr keeps original (un-corrected) color.
|
|
//
|
|
|
|
COLORREF crBackgroundClr; // Set/GetBkColor
|
|
ULONG ulBackgroundClr; // Set/GetBkColor client attr
|
|
COLORREF crForegroundClr; // Set/GetTextColor
|
|
ULONG ulForegroundClr; // Set/GetTextColor client attr
|
|
|
|
//
|
|
// *** DC Brush color
|
|
//
|
|
// When ICM is enabled,
|
|
// + cr____Clr color is corrected to DC's color space.
|
|
// + ul____Clr keeps original (un-corrected) color.
|
|
//
|
|
|
|
COLORREF crDCBrushClr; // Set/GetDCBrushColor client attr
|
|
ULONG ulDCBrushClr; // Set/GetDCBrushColor client attr
|
|
COLORREF crDCPenClr; // Set/GetDCPenColor
|
|
ULONG ulDCPenClr; // Set/GetDCPenColor client attr
|
|
|
|
//
|
|
// *** Misc. Attrs.
|
|
//
|
|
|
|
DWORD iCS_CP; // LOWORD: code page HIWORD charset
|
|
int iGraphicsMode; // Set/GetGraphicsMode
|
|
BYTE jROP2; // Set/GetROP2
|
|
BYTE jBkMode; // TRANSPARENT/OPAQUE
|
|
BYTE jFillMode; // ALTERNATE/WINDING
|
|
BYTE jStretchBltMode; // BLACKONWHITE/WHITEONBLACK/
|
|
// COLORONCOLOR/HALFTONE
|
|
POINTL ptlCurrent; // Current position in logical coordinates
|
|
// (invalid if DIRTY_PTLCURRENT set)
|
|
POINTL ptfxCurrent; // Current position in device coordinates
|
|
// (invalid if DIRTY_PTFXCURRENT set)
|
|
|
|
//
|
|
// original values set by app
|
|
//
|
|
|
|
LONG lBkMode;
|
|
LONG lFillMode;
|
|
LONG lStretchBltMode;
|
|
|
|
FLONG flFontMapper; // Font mapper flags
|
|
|
|
//
|
|
// *** ICM attributes
|
|
//
|
|
|
|
LONG lIcmMode; // Currnt ICM mode (DC_ICM_xxxx)
|
|
KHANDLE hcmXform; // Handle of Current Color Transform
|
|
KHCOLORSPACE hColorSpace; // Handle of Source Color Space
|
|
KERNEL_ULONG_PTR dwDIBColorSpace; // Identifier of DIB Color Space Data (when DIB selected)
|
|
// Sundown: dwDIBColorSpace actually takes a pointer in,
|
|
// change from DWORD to ULONG_PTR
|
|
COLORREF IcmBrushColor; // ICM-ed color for the brush selected in this DCATTR (Solid or Hatch)
|
|
COLORREF IcmPenColor; // ICM-ed color for the pen selected in this DCATTR
|
|
KERNEL_PVOID pvICM; // Pointer to client-side ICM information
|
|
|
|
//
|
|
// *** Text attributes
|
|
//
|
|
|
|
FLONG flTextAlign;
|
|
LONG lTextAlign;
|
|
LONG lTextExtra; // Inter-character spacing
|
|
LONG lRelAbs; // Moved over from client side
|
|
LONG lBreakExtra;
|
|
LONG cBreak;
|
|
|
|
KHANDLE hlfntNew; // Log font selected into DC
|
|
|
|
//
|
|
// Transform data.
|
|
//
|
|
|
|
MATRIX_S mxWtoD; // World to Device Transform.
|
|
MATRIX_S mxDtoW; // Device to World.
|
|
MATRIX_S mxWtoP; // World transform
|
|
EFLOAT_S efM11PtoD; // efM11 of the Page transform
|
|
EFLOAT_S efM22PtoD; // efM22 of the Page transform
|
|
EFLOAT_S efDxPtoD; // efDx of the Page transform
|
|
EFLOAT_S efDyPtoD; // efDy of the Page transform
|
|
INT iMapMode; // Map mode
|
|
DWORD dwLayout; // Layout orientation bits.
|
|
LONG lWindowOrgx; // The logical x window origin.
|
|
POINTL ptlWindowOrg; // Window origin.
|
|
SIZEL szlWindowExt; // Window extents.
|
|
POINTL ptlViewportOrg; // Viewport origin.
|
|
SIZEL szlViewportExt; // Viewport extents.
|
|
FLONG flXform; // Flags for transform component.
|
|
SIZEL szlVirtualDevicePixel; // Virtual device size in pels.
|
|
SIZEL szlVirtualDeviceMm; // Virtual device size in mm's.
|
|
SIZEL szlVirtualDevice; // Virtual device size
|
|
|
|
POINTL ptlBrushOrigin; // Alignment origin for brushes
|
|
|
|
//
|
|
// dc regions
|
|
//
|
|
|
|
RGNATTR VisRectRegion;
|
|
|
|
} DC_ATTR,*PDC_ATTR;
|
|
|
|
|
|
//
|
|
// conditional system definitions
|
|
//
|
|
|
|
#if !defined(_NTOSP_) && !defined(_USERKDX_)
|
|
typedef struct _W32THREAD * KPTR_MODIFIER PW32THREAD;
|
|
typedef ULONG W32PID;
|
|
DECLARE_HANDLE(HOBJ);
|
|
DECLARE_KHANDLE(HOBJ);
|
|
#endif
|
|
|
|
/*****************************Struct***************************************\
|
|
*
|
|
* BASEOBJECT
|
|
*
|
|
* Description:
|
|
*
|
|
* Each GDI object has a BASEOBJECT at the beggining of the object. This
|
|
* enables fast references to the handle and back to the entry.
|
|
*
|
|
* Fields:
|
|
*
|
|
* hHmgr - object handle
|
|
* ulShareCount - the shared reference count on the object
|
|
* cExclusiveLock - object exclusive lock count
|
|
* BaseFlags - flags representing state of underlying memory
|
|
* tid - thread id of exclusive lock owner
|
|
*
|
|
* Note:
|
|
*
|
|
* Most of the BASEOBJECT represents state logically associated with the
|
|
* object. When objects are swapped (for example, when doing a realloc
|
|
* to grow the object), the BASEOBJECT is swapped to preserve the handle
|
|
* and locking information.
|
|
*
|
|
* However, the BaseFlags field was added as an optimization to allow
|
|
* allocation from a "lookaside" list of preallocated objects. The
|
|
* BaseFlags field is metadata associated with the memory containing
|
|
* an object; it is not associated with the object itself.
|
|
*
|
|
* Current BASEOBJECT swapping code "unswaps" the BaseFlags so that it
|
|
* always remains associated with the memory, not the object.
|
|
*
|
|
* If flags are added to BaseFlags, they must not represent object state.
|
|
* If it is necessary to add such flags, the BaseFlags field could be
|
|
* reduced to a BYTE field and a new BYTE flags field can be added to
|
|
* represent state that is associated with the object.
|
|
*
|
|
* Currently, BASEOBJECT swapping code is in HmgSwapLockedHandleContents
|
|
* and RGNOBJ::bSwap (hmgrapi.cxx and rgnobj.cxx, respectively).
|
|
*
|
|
\**************************************************************************/
|
|
|
|
// BASEOBJECT FLAGS
|
|
|
|
//
|
|
// Due to the read-modify-write cycle and the fact that the Alpha can
|
|
// load and store a minimum of 32bit values, setting BaseFlags requires
|
|
// an InterlockedCompareExchange loop so that it doesn't interfere with the
|
|
// cExclusiveLock.
|
|
//
|
|
// HMGR_LOOKASIDE_ALLOC_FLAG is a 'static' flag - it doesn't change after
|
|
// it is set on object allocation. If anyone adds a 'dynamic' flag they
|
|
// should probably restructure BASEOBJECT to use a DWORD for the BaseFlags and
|
|
// a DWORD for the cExclusiveLock.
|
|
//
|
|
// If anyone restructures BASEOBJECT they'll have to rewrite all the code
|
|
// that uses cExclusiveLock and BaseFlags.
|
|
// This includes:
|
|
// INC_EXCLUSIVE_REF_CNT and DEC_EXCLUSIVE_REF_CNT
|
|
// RGNOBJ::bSwap
|
|
//
|
|
// Also if anyone adds fields to BASEOBJECT they need to go and fix RGNOBJ::bSwap
|
|
// to also copy those fields.
|
|
//
|
|
//
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
#define HMGR_LOOKASIDE_ALLOC_FLAG 0x8000
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
typedef struct _BASEOBJECT
|
|
{
|
|
KHANDLE hHmgr;
|
|
ULONG ulShareCount;
|
|
USHORT cExclusiveLock;
|
|
USHORT BaseFlags;
|
|
PW32THREAD Tid;
|
|
} BASEOBJECT, * KPTR_MODIFIER POBJ;
|
|
|
|
/*****************************Struct***************************************\
|
|
*
|
|
* OBJECTOWNER
|
|
*
|
|
* Description:
|
|
*
|
|
* This object is used for shared and exclusive object ownership
|
|
*
|
|
* Fields for shared Object:
|
|
*
|
|
* Pid : 31
|
|
* Lock : 1
|
|
*
|
|
\**************************************************************************/
|
|
|
|
//
|
|
// The lock and the Pid share the same DWORD.
|
|
//
|
|
// It seems that this is safe from the word tearing problem on the Alpha architecture
|
|
// due to the fact that we always use the InterlockedCompareExchange loop for
|
|
// the Lock and we require that the lock is set when setting the Pid.
|
|
//
|
|
|
|
typedef struct _OBJECTOWNER_S
|
|
{
|
|
ULONG Lock:1;
|
|
W32PID Pid_Shifted:31; // The lowest two bits of the PID are
|
|
// reserved for application use. However,
|
|
// the second bit is used by the
|
|
// OBJECT_OWNER_xxxx constants and so we
|
|
// use 31 bits for the Pid_Shifted field.
|
|
// WARNING: do not access this field directly,
|
|
// but rather via the macros below.
|
|
}OBJECTOWNER_S,*POBJECTOWNER_S;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
// Note: when accessing the Pid_Shifted field the compiler will shift the
|
|
// value by one bit to account for the field being only in the upper 31
|
|
// bits of the OBJECTOWNER_S structure. For example, if the OBJECTOWNER_S
|
|
// is 8, the Pid_Shifted would be only 4. However, since we are really
|
|
// interested in the upper 31 bits of the PID, this shifting is not
|
|
// appropriate (we need masking instead). I'm not aware of any compiler
|
|
// primitives that will accomplish this and will use the macros below
|
|
// instead.
|
|
|
|
#define LOCK_MASK 0x00000001
|
|
#define PID_MASK 0xfffffffe
|
|
|
|
#define PID_BITS 0xfffffffc // The actual bits used by the PID
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define OBJECTOWNER_PID(ObjectOwner) \
|
|
((W32PID) ((ObjectOwner).ulObj & PID_MASK))
|
|
|
|
#define SET_OBJECTOWNER_PID(ObjectOwner, Pid) \
|
|
((ObjectOwner).ulObj) = ((ObjectOwner).ulObj & LOCK_MASK) | ((Pid) & PID_MASK);
|
|
|
|
typedef union _OBJECTOWNER
|
|
{
|
|
OBJECTOWNER_S Share;
|
|
ULONG ulObj;
|
|
}OBJECTOWNER,*POBJECTOWNER;
|
|
|
|
typedef UCHAR OBJTYPE;
|
|
|
|
typedef union _EINFO
|
|
{
|
|
POBJ pobj; // Pointer to object
|
|
HOBJ hFree; // Next entry in free list
|
|
} EINFO;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
/*****************************Struct***************************************\
|
|
*
|
|
* ENTRY
|
|
*
|
|
* Description:
|
|
*
|
|
* This object is allocated for each entry in the handle manager and
|
|
* keeps track of object owners, reference counts, pointers, and handle
|
|
* objt and iuniq
|
|
*
|
|
* Fields:
|
|
*
|
|
* einfo - pointer to object or next free handle
|
|
* ObjectOwner - lock object
|
|
* ObjectInfo - Object Type, Unique and flags
|
|
* pUser - Pointer to user-mode data
|
|
*
|
|
\**************************************************************************/
|
|
|
|
// entry.Flags flags
|
|
|
|
#define HMGR_ENTRY_UNDELETABLE 0x0001
|
|
#define HMGR_ENTRY_LAZY_DEL 0x0002
|
|
#define HMGR_ENTRY_INVALID_VIS 0x0004
|
|
#define HMGR_ENTRY_LOOKASIDE_ALLOC 0x0010
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
typedef struct _ENTRY
|
|
{
|
|
EINFO einfo;
|
|
OBJECTOWNER ObjectOwner;
|
|
USHORT FullUnique;
|
|
OBJTYPE Objt;
|
|
UCHAR Flags;
|
|
KERNEL_PVOID pUser;
|
|
} ENTRY, *PENTRY;
|
|
|
|
typedef union _PENTOBJ
|
|
{
|
|
PENTRY pent;
|
|
POBJ pobj;
|
|
} PENTOBJ;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
//
|
|
// status flags used by metafile in user and kernel
|
|
//
|
|
|
|
#define MRI_ERROR 0
|
|
#define MRI_NULLBOX 1
|
|
#define MRI_OK 2
|
|
|
|
/*******************************STRUCTURE**********************************\
|
|
* GDIHANDLECACHE
|
|
*
|
|
* Cache common handle types, when a handle with user mode attributes is
|
|
* deleted, an attempt is made to cache the handle on memory accessable
|
|
* in user mode.
|
|
*
|
|
* Fields:
|
|
*
|
|
* Lock - CompareExchange used to gain ownership
|
|
* pCacheEntr[] - array of offsets to types
|
|
* ulBuffer - buffer for storage of all handle cache entries
|
|
*
|
|
*
|
|
* History:
|
|
*
|
|
* 30-Jan-1996 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
|
|
//
|
|
// defined cached handle types
|
|
//
|
|
|
|
#define GDI_CACHED_HADNLE_TYPES 4
|
|
|
|
#define CACHE_BRUSH_ENTRIES 10
|
|
#define CACHE_PEN_ENTRIES 8
|
|
#define CACHE_REGION_ENTRIES 8
|
|
#define CACHE_LFONT_ENTRIES 1
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
typedef enum _HANDLECACHETYPE
|
|
{
|
|
BrushHandle,
|
|
PenHandle,
|
|
RegionHandle,
|
|
LFontHandle
|
|
}HANDLECACHETYPE,*PHANDLECACHETYPE;
|
|
|
|
|
|
|
|
typedef struct _GDIHANDLECACHE
|
|
{
|
|
KERNEL_PVOID Lock;
|
|
ULONG ulNumHandles[GDI_CACHED_HADNLE_TYPES];
|
|
KHANDLE Handle[CACHE_BRUSH_ENTRIES +
|
|
CACHE_PEN_ENTRIES +
|
|
CACHE_REGION_ENTRIES +
|
|
CACHE_LFONT_ENTRIES];
|
|
}GDIHANDLECACHE,*PGDIHANDLECACHE;
|
|
|
|
|
|
/*********************************MACRO************************************\
|
|
* Lock handle cache by placing -1 into lock variable using cmp-exchange
|
|
*
|
|
* Arguments:
|
|
*
|
|
* p - handle cache pointer
|
|
* uLock - Thread specific lock ID (TEB or THREAD)
|
|
* bStatus - Lock status
|
|
*
|
|
* History:
|
|
*
|
|
* 22-Feb-1996 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#if defined(BUILD_WOW6432)
|
|
KERNEL_PVOID
|
|
InterlockedCompareExchangeKernelPointer(
|
|
KERNEL_PVOID *Destination,
|
|
KERNEL_PVOID Exchange,
|
|
KERNEL_PVOID Compare
|
|
);
|
|
#else
|
|
#define InterlockedCompareExchangeKernelPointer InterlockedCompareExchangePointer
|
|
#endif
|
|
|
|
#define LOCK_HANDLE_CACHE(p,uLock,bStatus) \
|
|
{ \
|
|
KERNEL_PVOID OldLock = p->Lock; \
|
|
bStatus = FALSE; \
|
|
\
|
|
if (OldLock == NULL) \
|
|
{ \
|
|
if (InterlockedCompareExchangeKernelPointer( \
|
|
&p->Lock, \
|
|
uLock, \
|
|
OldLock) == OldLock) \
|
|
{ \
|
|
bStatus = TRUE; \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
|
|
/*********************************MACRO************************************\
|
|
* unlock locked structure by writing null back to lock variable
|
|
*
|
|
* Arguments:
|
|
*
|
|
* p - pointer to handle cache
|
|
*
|
|
* Return Value:
|
|
*
|
|
* none
|
|
*
|
|
* History:
|
|
*
|
|
* 22-Feb-1996 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#if defined(BUILD_WOW6432) && defined(_X86_)
|
|
|
|
/* It is assumed that p->Lock will be updated atomically. This is true for alpha,
|
|
but it is not true for the 32bit x86 dll on wow64 since Lock is a 64bit quantity
|
|
which requires 2 mov instructions. So call InterlockedCompareExchangeKernelPointer
|
|
to set it.
|
|
*/
|
|
|
|
#define UNLOCK_HANDLE_CACHE(p) \
|
|
InterlockedCompareExchangeKernelPointer(&p->Lock, NULL, p->Lock);
|
|
|
|
#else
|
|
|
|
#define UNLOCK_HANDLE_CACHE(p) \
|
|
{ \
|
|
p->Lock = NULL; \
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
/******************************Struct**************************************\
|
|
* CFONT
|
|
*
|
|
* Client side realized font. Contains widths of all ANSI characters.
|
|
*
|
|
* We keep a free list of CFONT structures for fast allocation. The
|
|
* reference count counts pointers to this structure from all LDC and
|
|
* LOCALFONT structures. When this count hits zero, the CFONT is freed.
|
|
*
|
|
* The only "inactive" CFONTs that we keep around are those referenced by
|
|
* the LOCALFONT.
|
|
*
|
|
* (In the future we could expand this to contain UNICODE info as well.)
|
|
*
|
|
* Mon 11-Jun-1995 00:36:14 -by- Gerrit van Wingerden [gerritv]
|
|
* Addapted for kernel mode
|
|
* Sun 10-Jan-1993 00:36:14 -by- Charles Whitmer [chuckwh]
|
|
* Wrote it.
|
|
\**************************************************************************/
|
|
|
|
#define CFONT_COMPLETE 0x0001
|
|
#define CFONT_EMPTY 0x0002
|
|
#define CFONT_DBCS 0x0004
|
|
#define CFONT_CACHED_METRICS 0x0008 // we have cached the metrics
|
|
#define CFONT_CACHED_AVE 0x0010 // we have cached the average width
|
|
#define CFONT_CACHED_WIDTHS 0x0020 // if off, no widths have been computed
|
|
#define CFONT_PUBLIC 0x0040 // if public font in public cache
|
|
#define CFONT_CACHED_RI 0x0080 // if off, RealizationInfo (RI) has not been cached
|
|
|
|
#ifndef GDIFLAGS_ONLY // used for gdikdx
|
|
|
|
#define DEC_CFONT_REF(pcf) {if (!((pcf)->fl & CFONT_PUBLIC)) --(pcf)->cRef;}
|
|
#define INC_CFONT_REF(pcf) {ASSERTGDI(!((pcf)->fl & CFONT_PUBLIC),"pcfLocate - public font error\n");++(pcf)->cRef;}
|
|
|
|
typedef struct _CFONT * KPTR_MODIFIER PCFONT;
|
|
typedef struct _CFONT
|
|
{
|
|
PCFONT pcfNext;
|
|
KHFONT hf;
|
|
ULONG cRef; // Count of all pointers to this CFONT.
|
|
FLONG fl;
|
|
LONG lHeight; // Precomputed logical height.
|
|
|
|
// The following are keys to match when looking for a mapping.
|
|
|
|
KHDC hdc; // HDC of realization. 0 for display.
|
|
EFLOAT_S efM11; // efM11 of WtoD of DC of realization
|
|
EFLOAT_S efM22; // efM22 of WtoD of DC of realization
|
|
|
|
EFLOAT_S efDtoWBaseline; // Precomputed back transform. (FXtoL)
|
|
EFLOAT_S efDtoWAscent; // Precomputed back transform. (FXtoL)
|
|
|
|
// various extra width info
|
|
|
|
WIDTHDATA wd;
|
|
|
|
// Font info flags.
|
|
|
|
FLONG flInfo;
|
|
|
|
// The width table.
|
|
|
|
USHORT sWidth[256]; // Widths in pels.
|
|
|
|
// other usefull cached info
|
|
|
|
ULONG ulAveWidth; // bogus average used by USER
|
|
TMW_INTERNAL tmw; // cached metrics
|
|
|
|
#ifdef LANGPACK
|
|
// RealizationInfo for this font
|
|
REALIZATION_INFO ri ;
|
|
#endif
|
|
|
|
LONG timeStamp; // to check if cached realization info is updated
|
|
|
|
} CFONT;
|
|
|
|
/*******************************STRUCTURE**********************************\
|
|
*
|
|
* This structure controls the address for allocating and mapping the
|
|
* global shared handle table and device caps (primary display) that
|
|
* is mapped read-only into all user mode processes
|
|
*
|
|
* Fields:
|
|
*
|
|
* aentryHmgr - Handle table
|
|
* DevCaps - Cached primary display device caps
|
|
*
|
|
\**************************************************************************/
|
|
|
|
#define MAX_PUBLIC_CFONT 16
|
|
|
|
typedef struct _GDI_SHARED_MEMORY
|
|
{
|
|
ENTRY aentryHmgr[MAX_HANDLE_COUNT];
|
|
DEVCAPS DevCaps;
|
|
ULONG iDisplaySettingsUniqueness;
|
|
#ifdef LANGPACK
|
|
DWORD dwLpkShapingDLLs;
|
|
#endif
|
|
CFONT acfPublic[MAX_PUBLIC_CFONT];
|
|
LONG timeStamp;
|
|
|
|
} GDI_SHARED_MEMORY, *PGDI_SHARED_MEMORY;
|
|
|
|
/***********************************Structure******************************\
|
|
*
|
|
* GDI TEB Batching
|
|
*
|
|
* Contains the data structures and constants used for the batching of
|
|
* GDI calls to avoid kernel mode transition costs.
|
|
*
|
|
* History:
|
|
* 20-Oct-1995 -by- Mark Enstrom [marke]
|
|
*
|
|
\**************************************************************************/
|
|
|
|
typedef enum _BATCH_TYPE
|
|
{
|
|
BatchTypePatBlt,
|
|
BatchTypePolyPatBlt,
|
|
BatchTypeTextOut,
|
|
BatchTypeTextOutRect,
|
|
BatchTypeSetBrushOrg,
|
|
BatchTypeSelectClip,
|
|
BatchTypeSelectFont,
|
|
BatchTypeDeleteBrush,
|
|
BatchTypeDeleteRegion
|
|
} BATCH_TYPE,*PBATCH_TYPE;
|
|
|
|
typedef struct _BATCHCOMMAND
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
}BATCHCOMMAND,*PBATCHCOMMAND;
|
|
|
|
typedef struct _BATCHDELETEBRUSH
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
KHBRUSH hbrush;
|
|
}BATCHDELETEBRUSH,*PBATCHDELETEBRUSH;
|
|
|
|
typedef struct _BATCHDELETEREGION
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
KHRGN hregion;
|
|
}BATCHDELETEREGION,*PBATCHDELETEREGION;
|
|
|
|
typedef struct _BATCHSETBRUSHORG
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
int x;
|
|
int y;
|
|
}BATCHSETBRUSHORG,*PBATCHSETBRUSHORG;
|
|
|
|
typedef struct _BATCHPATBLT
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
LONG x;
|
|
LONG y;
|
|
LONG cx;
|
|
LONG cy;
|
|
KHBRUSH hbr;
|
|
ULONG rop4;
|
|
ULONG TextColor;
|
|
ULONG BackColor;
|
|
COLORREF DCBrushColor;
|
|
COLORREF IcmBrushColor;
|
|
POINTL ptlViewportOrg;
|
|
ULONG ulTextColor;
|
|
ULONG ulBackColor;
|
|
ULONG ulDCBrushColor;
|
|
}BATCHPATBLT,*PBATCHPATBLT;
|
|
|
|
|
|
typedef struct _BATCHPOLYPATBLT
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
ULONG rop4;
|
|
ULONG Mode;
|
|
ULONG Count;
|
|
ULONG TextColor;
|
|
ULONG BackColor;
|
|
COLORREF DCBrushColor;
|
|
ULONG ulTextColor;
|
|
ULONG ulBackColor;
|
|
ULONG ulDCBrushColor;
|
|
POINTL ptlViewportOrg;
|
|
//
|
|
// Variable length buffer for POLYPATBLT struct. Must be naturally
|
|
// aligned.
|
|
//
|
|
KERNEL_PVOID ulBuffer[1];
|
|
}BATCHPOLYPATBLT,*PBATCHPOLYPATBLT;
|
|
|
|
typedef struct _BATCHTEXTOUT
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
ULONG TextColor;
|
|
ULONG BackColor;
|
|
ULONG BackMode;
|
|
ULONG ulTextColor;
|
|
ULONG ulBackColor;
|
|
LONG x;
|
|
LONG y;
|
|
ULONG fl;
|
|
RECTL rcl;
|
|
DWORD dwCodePage;
|
|
ULONG cChar;
|
|
ULONG PdxOffset;
|
|
KHANDLE hlfntNew;
|
|
UINT flTextAlign;
|
|
POINTL ptlViewportOrg;
|
|
|
|
//
|
|
// variable length buffer for WCHAR and pdx data
|
|
//
|
|
|
|
ULONG ulBuffer[1];
|
|
}BATCHTEXTOUT,*PBATCHTEXTOUT;
|
|
|
|
typedef struct _BATCHTEXTOUTRECT
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
ULONG BackColor;
|
|
ULONG fl;
|
|
RECTL rcl;
|
|
POINTL ptlViewportOrg;
|
|
ULONG ulBackColor;
|
|
}BATCHTEXTOUTRECT,*PBATCHTEXTOUTRECT;
|
|
|
|
typedef struct _BATCHSELECTCLIP
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
int iMode;
|
|
RECTL rclClip;
|
|
}BATCHSELECTCLIP,*PBATCHSELECTCLIP;
|
|
|
|
typedef struct _BATCHSELECTFONT
|
|
{
|
|
USHORT Length;
|
|
USHORT Type;
|
|
KHANDLE hFont;
|
|
}BATCHSELECTFONT,*PBATCHSELECTFONT;
|
|
|
|
|
|
|
|
//
|
|
// GDI_BATCH_BUFFER_SIZE is space (IN BYTES) in TEB allocated
|
|
// for GDI batching
|
|
//
|
|
|
|
#if defined(_GDIPLUS_)
|
|
|
|
#define GDI_BATCH_SIZE 0
|
|
|
|
#else
|
|
|
|
#define GDI_BATCH_SIZE 4 * GDI_BATCH_BUFFER_SIZE
|
|
|
|
#endif
|
|
|
|
//
|
|
// Image32 data
|
|
//
|
|
|
|
typedef enum _IMAGE_TYPE
|
|
{
|
|
Image_Alpha,
|
|
Image_AlphaDIB,
|
|
Image_Transparent,
|
|
Image_TransparentDIB,
|
|
Image_Stretch,
|
|
Image_StretchDIB
|
|
}IMAGE_TYPE,*PIMAGE_TYPE;
|
|
|
|
#endif // GDIFLAGS_ONLY used for gdikdx
|
|
|
|
// these strings are included in both gre\mapfile.c and client\output.c
|
|
// so we put them here so that we can manage the changes from
|
|
// the unified place.
|
|
|
|
//
|
|
// This rubbish comment is in win95 sources. I leave it here for reference
|
|
// [bodind]
|
|
//
|
|
|
|
//
|
|
// this static data goes away as soon as we get the correct functionality in
|
|
// NLS. (its in build 162, use it in buid 163)
|
|
//
|
|
|
|
#define NCHARSETS 16
|
|
#define CHARSET_ARRAYS \
|
|
UINT nCharsets = NCHARSETS; \
|
|
UINT charsets[] = { \
|
|
ANSI_CHARSET, SHIFTJIS_CHARSET, HANGEUL_CHARSET, JOHAB_CHARSET, \
|
|
GB2312_CHARSET, CHINESEBIG5_CHARSET, HEBREW_CHARSET, \
|
|
ARABIC_CHARSET, GREEK_CHARSET, TURKISH_CHARSET, \
|
|
BALTIC_CHARSET, EASTEUROPE_CHARSET, RUSSIAN_CHARSET, THAI_CHARSET, \
|
|
VIETNAMESE_CHARSET, SYMBOL_CHARSET}; \
|
|
UINT codepages[] ={ 1252, 932, 949, 1361, \
|
|
936, 950, 1255, 1256, \
|
|
1253, 1254, 1257, 1250, \
|
|
1251, 874 , 1258, 42}; \
|
|
DWORD fs[] = { FS_LATIN1, FS_JISJAPAN, FS_WANSUNG, FS_JOHAB, \
|
|
FS_CHINESESIMP, FS_CHINESETRAD, FS_HEBREW, FS_ARABIC, \
|
|
FS_GREEK, FS_TURKISH, FS_BALTIC, FS_LATIN2, \
|
|
FS_CYRILLIC, FS_THAI, FS_VIETNAMESE, FS_SYMBOL };
|