subsystems/win32/win32k/include/gdiobj.h

   1 /*
   2  *  GDI object common header definition
   3  *
   4  */
   5
   6 #pragma once
   7
   8 /* Public GDI Object/Handle definitions */
   9 #include <win32k/ntgdihdl.h>
  10 #include "win32.h"
  11
  12 /* apparently the first 10 entries are never used in windows as they are empty */
  13 #define RESERVE_ENTRIES_COUNT 10
  14
  15 typedef struct _GDI_HANDLE_TABLE
  16 {
  17 /* The table must be located at the beginning of this structure so it can be
  18  * properly mapped!
  19  */
  20 //////////////////////////////////////////////////////////////////////////////
  21   GDI_TABLE_ENTRY Entries[GDI_HANDLE_COUNT];
  22   DEVCAPS         DevCaps;                 // Device Capabilities.
  23   FLONG           flDeviceUniq;            // Device settings uniqueness.
  24   PVOID           pvLangPack;              // Language Pack.
  25   CFONT           cfPublic[GDI_CFONT_MAX]; // Public Fonts.
  26   DWORD           dwCFCount;
  27 //////////////////////////////////////////////////////////////////////////////
  28   PPAGED_LOOKASIDE_LIST LookasideLists;
  29
  30   ULONG           FirstFree;
  31   ULONG           FirstUnused;
  32
  33 } GDI_HANDLE_TABLE, *PGDI_HANDLE_TABLE;
  34
  35 extern PGDI_HANDLE_TABLE GdiHandleTable;
  36
  37 typedef PVOID PGDIOBJ;
  38
  39 typedef BOOL (INTERNAL_CALL *GDICLEANUPPROC)(PVOID ObjectBody);
  40
  41 /* Every GDI Object must have this standard type of header.
  42  * It's for thread locking. */
  43 typedef struct _BASEOBJECT
  44 {
  45   HGDIOBJ     hHmgr;
  46   ULONG       ulShareCount;
  47   USHORT      cExclusiveLock;
  48   USHORT      BaseFlags;
  49   PTHREADINFO Tid;
  50   EX_PUSH_LOCK pushlock;
  51 } BASEOBJECT, *POBJ;
  52
  53 typedef struct _CLIENTOBJ
  54 {
  55   BASEOBJECT BaseObject;
  56 } CLIENTOBJ, *PCLIENTOBJ;
  57
  58 enum BASEFLAGS
  59 {
  60     BASEFLAG_LOOKASIDE = 0x80,
  61
  62     /* ReactOS specific: */
  63     BASEFLAG_READY_TO_DIE = 0x1000
  64 };
  65
  66 BOOL    INTERNAL_CALL GDIOBJ_OwnedByCurrentProcess(HGDIOBJ ObjectHandle);
  67 BOOL    INTERNAL_CALL GDIOBJ_SetOwnership(HGDIOBJ ObjectHandle, PEPROCESS Owner);
  68 BOOL    INTERNAL_CALL GDIOBJ_CopyOwnership(HGDIOBJ CopyFrom, HGDIOBJ CopyTo);
  69 BOOL    INTERNAL_CALL GDIOBJ_ConvertToStockObj(HGDIOBJ *hObj);
  70 //VOID    INTERNAL_CALL GDIOBJ_ShareUnlockObjByPtr(POBJ Object);
  71 BOOL    INTERNAL_CALL GDIOBJ_ValidateHandle(HGDIOBJ hObj, ULONG ObjectType);
  72 POBJ    INTERNAL_CALL GDIOBJ_AllocObj(UCHAR ObjectType);
  73 POBJ    INTERNAL_CALL GDIOBJ_AllocObjWithHandle(ULONG ObjectType);
  74 VOID    INTERNAL_CALL GDIOBJ_FreeObj (POBJ pObj, UCHAR ObjectType);
  75 BOOL    INTERNAL_CALL GDIOBJ_FreeObjByHandle (HGDIOBJ hObj, DWORD ObjectType);
  76 PGDIOBJ INTERNAL_CALL GDIOBJ_LockObj (HGDIOBJ hObj, DWORD ObjectType);
  77 PGDIOBJ INTERNAL_CALL GDIOBJ_ShareLockObj (HGDIOBJ hObj, DWORD ObjectType);
  78 VOID INTERNAL_CALL GDIOBJ_LockMultipleObjs(ULONG ulCount, IN HGDIOBJ* ahObj, OUT PGDIOBJ* apObj);
  79
  80 PVOID   INTERNAL_CALL GDI_MapHandleTable(PEPROCESS Process);
  81
  82 INIT_FUNCTION
  83 NTSTATUS
  84 NTAPI
  85 InitGdiHandleTable(VOID);
  86
  87 #define GDIOBJ_GetObjectType(Handle) \
  88   GDI_HANDLE_GET_TYPE(Handle)
  89
  90 #define GDIOBJFLAG_DEFAULT      (0x0)
  91 #define GDIOBJFLAG_IGNOREPID    (0x1)
  92 #define GDIOBJFLAG_IGNORELOCK   (0x2)
  93
  94 BOOL FASTCALL GreDeleteObject(HGDIOBJ hObject);
  95 BOOL FASTCALL IsObjectDead(HGDIOBJ);
  96 BOOL FASTCALL IntGdiSetDCOwnerEx( HDC, DWORD, BOOL);
  97 BOOL FASTCALL IntGdiSetRegionOwner(HRGN,DWORD);
  98
  99 /*!
 100  * Release GDI object. Every object locked by GDIOBJ_LockObj() must be unlocked.
 101  * You should unlock the object
 102  * as soon as you don't need to have access to it's data.
 103
 104  * \param Object        Object pointer (as returned by GDIOBJ_LockObj).
 105  */
 106 ULONG
 107 FORCEINLINE
 108 GDIOBJ_UnlockObjByPtr(POBJ Object)
 109 {
 110 #if DBG
 111     PTHREADINFO pti = (PTHREADINFO)PsGetCurrentThreadWin32Thread();
 112     if (pti)
 113     {
 114         if (pti->cExclusiveLocks < 1)
 115         {
 116             DbgPrint("cExclusiveLocks = %ld, object: %ld\n",
 117                     pti->cExclusiveLocks, Object->cExclusiveLock);
 118             ASSERT(FALSE);
 119         }
 120         pti->cExclusiveLocks--;
 121     }
 122 #endif
 123     INT cLocks = InterlockedDecrement((PLONG)&Object->cExclusiveLock);
 124     ASSERT(cLocks >= 0);
 125     return cLocks;
 126 }
 127
 128 ULONG
 129 FORCEINLINE
 130 GDIOBJ_ShareUnlockObjByPtr(POBJ Object)
 131 {
 132     HGDIOBJ hobj = Object->hHmgr;
 133     USHORT flags = Object->BaseFlags;
 134     INT cLocks = InterlockedDecrement((PLONG)&Object->ulShareCount);
 135     ASSERT(cLocks >= 0);
 136     if ((flags & BASEFLAG_READY_TO_DIE) && (cLocks == 0))
 137     {
 138         ASSERT(Object->cExclusiveLock == 0);
 139         GDIOBJ_SetOwnership(hobj, PsGetCurrentProcess());
 140         GDIOBJ_FreeObjByHandle(hobj, GDI_OBJECT_TYPE_DONTCARE);
 141     }
 142     return cLocks;
 143 }
 144
 145 #ifdef GDI_DEBUG
 146 ULONG FASTCALL GDIOBJ_IncrementShareCount(POBJ Object);
 147 #else
 148 ULONG
 149 FORCEINLINE
 150 GDIOBJ_IncrementShareCount(POBJ Object)
 151 {
 152     INT cLocks = InterlockedIncrement((PLONG)&Object->ulShareCount);
 153     ASSERT(cLocks >= 1);
 154     return cLocks;
 155 }
 156 #endif
 157
 158 INT FASTCALL GreGetObjectOwner(HGDIOBJ, GDIOBJTYPE);
 159
 160 #define GDIOBJ_GetKernelObj(Handle) \
 161   ((PGDI_TABLE_ENTRY)&GdiHandleTable->Entries[GDI_HANDLE_GET_INDEX(Handle)])->KernelData
 162 #define GDI_ENTRY_TO_INDEX(ht, e)                                              \
 163   (((ULONG_PTR)(e) - (ULONG_PTR)&((ht)->Entries[0])) / sizeof(GDI_TABLE_ENTRY))
 164 #define GDI_HANDLE_GET_ENTRY(HandleTable, h)                                   \
 165   (&(HandleTable)->Entries[GDI_HANDLE_GET_INDEX((h))])