f6c80d37b08b3bf1e926e1a1952f8ea3cb1f0cf3
[reactos.git] / reactos / subsys / win32k / objects / gdiobj.c
1 /*
2 * ReactOS W32 Subsystem
3 * Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18 */
19 /*
20 * GDIOBJ.C - GDI object manipulation routines
21 *
22 * $Id: gdiobj.c,v 1.46 2003/10/15 03:09:23 vizzini Exp $
23 *
24 */
25
26 #undef WIN32_LEAN_AND_MEAN
27 #define WIN32_NO_STATUS
28 #include <windows.h>
29 #include <ddk/ntddk.h>
30 #include <include/dce.h>
31 #include <include/object.h>
32 #include <win32k/gdiobj.h>
33 #include <win32k/brush.h>
34 #include <win32k/pen.h>
35 #include <win32k/text.h>
36 #include <win32k/dc.h>
37 #include <win32k/bitmaps.h>
38 #include <win32k/region.h>
39 #include <win32k/cursoricon.h>
40 #include <include/palette.h>
41 #define NDEBUG
42 #include <win32k/debug1.h>
43
44 /*! Size of the GDI handle table
45 * http://www.windevnet.com/documents/s=7290/wdj9902b/9902b.htm
46 * gdi handle table can hold 0x4000 handles
47 */
48 #define GDI_HANDLE_COUNT 0x4000
49
50 #define GDI_GLOBAL_PROCESS ((HANDLE) 0xffffffff)
51
52 #define GDI_HANDLE_INDEX_MASK (GDI_HANDLE_COUNT - 1)
53 #define GDI_HANDLE_TYPE_MASK 0x007f0000
54 #define GDI_HANDLE_STOCK_MASK 0x00800000
55
56 #define GDI_HANDLE_CREATE(i, t) ((HANDLE)(((i) & GDI_HANDLE_INDEX_MASK) | ((t) & GDI_HANDLE_TYPE_MASK)))
57 #define GDI_HANDLE_GET_INDEX(h) (((DWORD)(h)) & GDI_HANDLE_INDEX_MASK)
58 #define GDI_HANDLE_GET_TYPE(h) (((DWORD)(h)) & GDI_HANDLE_TYPE_MASK)
59 #define GDI_HANDLE_IS_TYPE(h, t) ((t) == (((DWORD)(h)) & GDI_HANDLE_TYPE_MASK))
60 #define GDI_HANDLE_IS_STOCKOBJ(h) (0 != (((DWORD)(h)) & GDI_HANDLE_STOCK_MASK))
61 #define GDI_HANDLE_SET_STOCKOBJ(h) ((h) = (HANDLE)(((DWORD)(h)) | GDI_HANDLE_STOCK_MASK))
62
63 #define GDI_TYPE_TO_MAGIC(t) ((WORD) ((t) >> 16))
64 #define GDI_MAGIC_TO_TYPE(m) ((DWORD)(m) << 16)
65
66 #define GDI_VALID_OBJECT(h, obj, t, f) \
67 (NULL != (obj) \
68 && (GDI_MAGIC_TO_TYPE((obj)->Magic) == (t) || GDI_OBJECT_TYPE_DONTCARE == (t)) \
69 && (GDI_HANDLE_GET_TYPE((h)) == GDI_MAGIC_TO_TYPE((obj)->Magic)) \
70 && (((obj)->hProcessId == PsGetCurrentProcessId()) \
71 || (GDI_GLOBAL_PROCESS == (obj)->hProcessId) \
72 || ((f) & GDIOBJFLAG_IGNOREPID)))
73
74 typedef struct _GDI_HANDLE_TABLE
75 {
76 WORD wTableSize;
77 PGDIOBJHDR Handles[1];
78 } GDI_HANDLE_TABLE, *PGDI_HANDLE_TABLE;
79
80 /* GDI stock objects */
81
82 static LOGBRUSH WhiteBrush =
83 { BS_SOLID, RGB(255,255,255), 0 };
84
85 static LOGBRUSH LtGrayBrush =
86 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
87 { BS_SOLID, RGB(192,192,192), 0 };
88
89 static LOGBRUSH GrayBrush =
90 /* FIXME : this should perhaps be BS_HATCHED, at least for 1 bitperpixel */
91 { BS_SOLID, RGB(128,128,128), 0 };
92
93 static LOGBRUSH DkGrayBrush =
94 /* This is BS_HATCHED, for 1 bitperpixel. This makes the spray work in pbrush */
95 /* NB_HATCH_STYLES is an index into HatchBrushes */
96 { BS_HATCHED, RGB(0,0,0), NB_HATCH_STYLES };
97
98 static LOGBRUSH BlackBrush =
99 { BS_SOLID, RGB(0,0,0), 0 };
100
101 static LOGBRUSH NullBrush =
102 { BS_NULL, 0, 0 };
103
104 static LOGPEN WhitePen =
105 { PS_SOLID, { 0, 0 }, RGB(255,255,255) };
106
107 static LOGPEN BlackPen =
108 { PS_SOLID, { 0, 0 }, RGB(0,0,0) };
109
110 static LOGPEN NullPen =
111 { PS_NULL, { 0, 0 }, 0 };
112
113 static LOGFONTW OEMFixedFont =
114 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, OEM_CHARSET,
115 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"" };
116
117 static LOGFONTW AnsiFixedFont =
118 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
119 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"" };
120
121 /*static LOGFONTW AnsiVarFont =
122 *{ 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
123 * 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Sans Serif" }; */
124
125 static LOGFONTW SystemFont =
126 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
127 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"System" };
128
129 static LOGFONTW DeviceDefaultFont =
130 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
131 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"" };
132
133 static LOGFONTW SystemFixedFont =
134 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
135 0, 0, DEFAULT_QUALITY, FIXED_PITCH | FF_MODERN, L"" };
136
137 /* FIXME: Is this correct? */
138 static LOGFONTW DefaultGuiFont =
139 { 14, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, ANSI_CHARSET,
140 0, 0, DEFAULT_QUALITY, VARIABLE_PITCH | FF_SWISS, L"MS Sans Serif" };
141
142 #define NB_STOCK_OBJECTS (DEFAULT_GUI_FONT + 1)
143
144 static HGDIOBJ *StockObjects[NB_STOCK_OBJECTS];
145 static PGDI_HANDLE_TABLE HandleTable = 0;
146 static FAST_MUTEX HandleTableMutex;
147 static FAST_MUTEX RefCountHandling;
148
149 /*!
150 * Allocate GDI object table.
151 * \param Size - number of entries in the object table.
152 */
153 static PGDI_HANDLE_TABLE FASTCALL
154 GDIOBJ_iAllocHandleTable (WORD Size)
155 {
156 PGDI_HANDLE_TABLE handleTable;
157 KIRQL OldIrql;
158 BOOLEAN IrqlRaised = FALSE;
159
160 if(KeGetCurrentIrql() < APC_LEVEL)
161 {
162 KeRaiseIrql(APC_LEVEL, &OldIrql);
163 IrqlRaised = TRUE;
164 }
165
166 ExAcquireFastMutexUnsafe (&HandleTableMutex);
167 handleTable = ExAllocatePool(PagedPool,
168 sizeof(GDI_HANDLE_TABLE) +
169 sizeof(PGDIOBJ) * Size);
170 ASSERT( handleTable );
171 memset (handleTable,
172 0,
173 sizeof(GDI_HANDLE_TABLE) + sizeof(PGDIOBJ) * Size);
174 handleTable->wTableSize = Size;
175 ExReleaseFastMutexUnsafe (&HandleTableMutex);
176
177 if(IrqlRaised)
178 KeLowerIrql(OldIrql);
179
180 return handleTable;
181 }
182
183 /*!
184 * Returns the entry into the handle table by index.
185 */
186 static PGDIOBJHDR FASTCALL
187 GDIOBJ_iGetObjectForIndex(WORD TableIndex)
188 {
189 if (0 == TableIndex || HandleTable->wTableSize < TableIndex)
190 {
191 DPRINT1("Invalid TableIndex %u\n", (unsigned) TableIndex);
192 return NULL;
193 }
194
195 return HandleTable->Handles[TableIndex];
196 }
197
198 /*!
199 * Finds next free entry in the GDI handle table.
200 * \return index into the table is successful, zero otherwise.
201 */
202 static WORD FASTCALL
203 GDIOBJ_iGetNextOpenHandleIndex (void)
204 {
205 WORD tableIndex;
206 BOOLEAN IrqlRaised = FALSE;
207 KIRQL OldIrql;
208
209 if(KeGetCurrentIrql() < APC_LEVEL)
210 {
211 KeRaiseIrql(APC_LEVEL, &OldIrql);
212 IrqlRaised = TRUE;
213 }
214
215 ExAcquireFastMutexUnsafe (&HandleTableMutex);
216 for (tableIndex = 1; tableIndex < HandleTable->wTableSize; tableIndex++)
217 {
218 if (NULL == HandleTable->Handles[tableIndex])
219 {
220 HandleTable->Handles[tableIndex] = (PGDIOBJHDR) -1;
221 break;
222 }
223 }
224 ExReleaseFastMutexUnsafe (&HandleTableMutex);
225
226 if(IrqlRaised)
227 KeLowerIrql(OldIrql);
228
229 return (tableIndex < HandleTable->wTableSize) ? tableIndex : 0;
230 }
231
232 /*!
233 * Allocate memory for GDI object and return handle to it.
234 *
235 * \param Size - size of the GDI object. This shouldn't to include the size of GDIOBJHDR.
236 * The actual amount of allocated memory is sizeof(GDIOBJHDR)+Size
237 * \param ObjectType - type of object \ref GDI object types
238 * \param CleanupProcPtr - Routine to be called on destruction of object
239 *
240 * \return Handle of the allocated object.
241 *
242 * \note Use GDIOBJ_Lock() to obtain pointer to the new object.
243 */
244 HGDIOBJ FASTCALL
245 GDIOBJ_AllocObj(WORD Size, DWORD ObjectType, GDICLEANUPPROC CleanupProc)
246 {
247 PGDIOBJHDR newObject;
248 WORD Index;
249
250 Index = GDIOBJ_iGetNextOpenHandleIndex ();
251 if (0 == Index)
252 {
253 DPRINT1("Out of GDI handles\n");
254 return NULL;
255 }
256
257 DPRINT("GDIOBJ_AllocObj: handle: %d, size: %d, type: 0x%08x\n", Index, Size, ObjectType);
258 newObject = ExAllocatePool(PagedPool, Size + sizeof (GDIOBJHDR));
259 if (newObject == NULL)
260 {
261 DPRINT1("GDIOBJ_AllocObj: failed\n");
262 return NULL;
263 }
264 RtlZeroMemory (newObject, Size + sizeof(GDIOBJHDR));
265
266 newObject->wTableIndex = Index;
267
268 newObject->dwCount = 0;
269 newObject->hProcessId = PsGetCurrentProcessId ();
270 newObject->CleanupProc = CleanupProc;
271 newObject->Magic = GDI_TYPE_TO_MAGIC(ObjectType);
272 newObject->lockfile = NULL;
273 newObject->lockline = 0;
274 HandleTable->Handles[Index] = newObject;
275
276 return GDI_HANDLE_CREATE(Index, ObjectType);
277 }
278
279 /*!
280 * Free memory allocated for the GDI object. For each object type this function calls the
281 * appropriate cleanup routine.
282 *
283 * \param hObj - handle of the object to be deleted.
284 * \param ObjectType - one of the \ref GDI object types
285 * or GDI_OBJECT_TYPE_DONTCARE.
286 * \param Flag - if set to GDIOBJFLAG_IGNOREPID then the routine doesn't check if the process that
287 * tries to delete the object is the same one that created it.
288 *
289 * \return Returns TRUE if succesful.
290 *
291 * \note You should only use GDIOBJFLAG_IGNOREPID if you are cleaning up after the process that terminated.
292 * \note This function deferres object deletion if it is still in use.
293 */
294 BOOL STDCALL
295 GDIOBJ_FreeObj(HGDIOBJ hObj, DWORD ObjectType, DWORD Flag)
296 {
297 PGDIOBJHDR objectHeader;
298 PGDIOBJ Obj;
299 BOOL bRet = TRUE;
300
301 objectHeader = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(hObj));
302 DPRINT("GDIOBJ_FreeObj: hObj: 0x%08x, object: %x\n", hObj, objectHeader);
303
304 if (! GDI_VALID_OBJECT(hObj, objectHeader, ObjectType, Flag)
305 || GDI_GLOBAL_PROCESS == objectHeader->hProcessId)
306
307 {
308 DPRINT1("Can't delete hObj:0x%08x, type:0x%08x, flag:%d\n", hObj, ObjectType, Flag);
309 return FALSE;
310 }
311
312 DPRINT("FreeObj: locks: %x\n", objectHeader->dwCount );
313 if (!(Flag & GDIOBJFLAG_IGNORELOCK))
314 {
315 /* check that the reference count is zero. if not then set flag
316 * and delete object when releaseobj is called */
317 ExAcquireFastMutex(&RefCountHandling);
318 if ((objectHeader->dwCount & ~0x80000000) > 0 )
319 {
320 DPRINT("GDIOBJ_FreeObj: delayed object deletion: count %d\n", objectHeader->dwCount);
321 objectHeader->dwCount |= 0x80000000;
322 ExReleaseFastMutex(&RefCountHandling);
323 return TRUE;
324 }
325 ExReleaseFastMutex(&RefCountHandling);
326 }
327
328 /* allow object to delete internal data */
329 if (NULL != objectHeader->CleanupProc)
330 {
331 Obj = (PGDIOBJ)((PCHAR)objectHeader + sizeof(GDIOBJHDR));
332 bRet = (*(objectHeader->CleanupProc))(Obj);
333 }
334
335 ExFreePool(objectHeader);
336 HandleTable->Handles[GDI_HANDLE_GET_INDEX(hObj)] = NULL;
337
338 return bRet;
339 }
340
341 /*!
342 * Lock multiple objects. Use this function when you need to lock multiple objects and some of them may be
343 * duplicates. You should use this function to avoid trying to lock the same object twice!
344 *
345 * \param pList pointer to the list that contains handles to the objects. You should set hObj and ObjectType fields.
346 * \param nObj number of objects to lock
347 * \return for each entry in pList this function sets pObj field to point to the object.
348 *
349 * \note this function uses an O(n^2) algoritm because we shouldn't need to call it with more than 3 or 4 objects.
350 */
351 BOOL FASTCALL
352 GDIOBJ_LockMultipleObj(PGDIMULTILOCK pList, INT nObj)
353 {
354 INT i, j;
355 ASSERT( pList );
356 /* FIXME - check for "invalid" handles */
357 /* go through the list checking for duplicate objects */
358 for (i = 0; i < nObj; i++)
359 {
360 pList[i].pObj = NULL;
361 for (j = 0; j < i; j++)
362 {
363 if (pList[i].hObj == pList[j].hObj)
364 {
365 /* already locked, so just copy the pointer to the object */
366 pList[i].pObj = pList[j].pObj;
367 break;
368 }
369 }
370
371 if (NULL == pList[i].pObj)
372 {
373 /* object hasn't been locked, so lock it. */
374 if (NULL != pList[i].hObj)
375 {
376 pList[i].pObj = GDIOBJ_LockObj(pList[i].hObj, pList[i].ObjectType);
377 }
378 }
379 }
380
381 return TRUE;
382 }
383
384 /*!
385 * Unlock multiple objects. Use this function when you need to unlock multiple objects and some of them may be
386 * duplicates.
387 *
388 * \param pList pointer to the list that contains handles to the objects. You should set hObj and ObjectType fields.
389 * \param nObj number of objects to lock
390 *
391 * \note this function uses O(n^2) algoritm because we shouldn't need to call it with more than 3 or 4 objects.
392 */
393 BOOL FASTCALL
394 GDIOBJ_UnlockMultipleObj(PGDIMULTILOCK pList, INT nObj)
395 {
396 INT i, j;
397 ASSERT(pList);
398
399 /* go through the list checking for duplicate objects */
400 for (i = 0; i < nObj; i++)
401 {
402 if (NULL != pList[i].pObj)
403 {
404 for (j = i + 1; j < nObj; j++)
405 {
406 if ((pList[i].pObj == pList[j].pObj))
407 {
408 /* set the pointer to zero for all duplicates */
409 pList[j].pObj = NULL;
410 }
411 }
412 GDIOBJ_UnlockObj(pList[i].hObj, pList[i].ObjectType);
413 pList[i].pObj = NULL;
414 }
415 }
416
417 return TRUE;
418 }
419
420 /*!
421 * Marks the object as global. (Creator process ID is set to GDI_GLOBAL_PROCESS). Global objects may be
422 * accessed by any process.
423 * \param ObjectHandle - handle of the object to make global.
424 *
425 * \note Only stock objects should be marked global.
426 */
427 VOID FASTCALL
428 GDIOBJ_MarkObjectGlobal(HGDIOBJ ObjectHandle)
429 {
430 PGDIOBJHDR ObjHdr;
431
432 DPRINT("GDIOBJ_MarkObjectGlobal handle 0x%08x\n", ObjectHandle);
433 ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(ObjectHandle));
434 if (NULL == ObjHdr)
435 {
436 return;
437 }
438
439 ObjHdr->hProcessId = GDI_GLOBAL_PROCESS;
440 }
441
442 /*!
443 * Removes the global mark from the object. Global objects may be
444 * accessed by any process.
445 * \param ObjectHandle - handle of the object to make local.
446 *
447 * \note Only stock objects should be marked global.
448 */
449 VOID FASTCALL
450 GDIOBJ_UnmarkObjectGlobal(HGDIOBJ ObjectHandle)
451 {
452 PGDIOBJHDR ObjHdr;
453
454 DPRINT("GDIOBJ_MarkObjectGlobal handle 0x%08x\n", ObjectHandle);
455 ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(ObjectHandle));
456 if (NULL == ObjHdr || GDI_GLOBAL_PROCESS != ObjHdr->hProcessId)
457 {
458 return;
459 }
460
461 ObjHdr->hProcessId = PsGetCurrentProcessId();
462 }
463
464 /*!
465 * Get the type of the object.
466 * \param ObjectHandle - handle of the object.
467 * \return One of the \ref GDI object types
468 */
469 DWORD FASTCALL
470 GDIOBJ_GetObjectType(HGDIOBJ ObjectHandle)
471 {
472 PGDIOBJHDR ObjHdr;
473
474 ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(ObjectHandle));
475 if (NULL == ObjHdr
476 || ! GDI_VALID_OBJECT(ObjectHandle, ObjHdr, GDI_MAGIC_TO_TYPE(ObjHdr->Magic), 0))
477 {
478 DPRINT1("Invalid ObjectHandle 0x%08x\n", ObjectHandle);
479 return 0;
480 }
481 DPRINT("GDIOBJ_GetObjectType for handle 0x%08x returns 0x%08x\n", ObjectHandle,
482 GDI_MAGIC_TO_TYPE(ObjHdr->Magic));
483
484 return GDI_MAGIC_TO_TYPE(ObjHdr->Magic);
485 }
486
487 /*!
488 * Initialization of the GDI object engine.
489 */
490 VOID FASTCALL
491 InitGdiObjectHandleTable (VOID)
492 {
493 DPRINT("InitGdiObjectHandleTable\n");
494 ExInitializeFastMutex (&HandleTableMutex);
495 ExInitializeFastMutex (&RefCountHandling);
496
497 HandleTable = GDIOBJ_iAllocHandleTable (GDI_HANDLE_COUNT);
498 DPRINT("HandleTable: %x\n", HandleTable );
499
500 InitEngHandleTable();
501 }
502
503 /*!
504 * Creates a bunch of stock objects: brushes, pens, fonts.
505 */
506 VOID FASTCALL
507 CreateStockObjects(void)
508 {
509 unsigned Object;
510
511 DPRINT("Beginning creation of stock objects\n");
512
513 /* Create GDI Stock Objects from the logical structures we've defined */
514
515 StockObjects[WHITE_BRUSH] = NtGdiCreateBrushIndirect(&WhiteBrush);
516 StockObjects[LTGRAY_BRUSH] = NtGdiCreateBrushIndirect(&LtGrayBrush);
517 StockObjects[GRAY_BRUSH] = NtGdiCreateBrushIndirect(&GrayBrush);
518 StockObjects[DKGRAY_BRUSH] = NtGdiCreateBrushIndirect(&DkGrayBrush);
519 StockObjects[BLACK_BRUSH] = NtGdiCreateBrushIndirect(&BlackBrush);
520 StockObjects[NULL_BRUSH] = NtGdiCreateBrushIndirect(&NullBrush);
521
522 StockObjects[WHITE_PEN] = NtGdiCreatePenIndirect(&WhitePen);
523 StockObjects[BLACK_PEN] = NtGdiCreatePenIndirect(&BlackPen);
524 StockObjects[NULL_PEN] = NtGdiCreatePenIndirect(&NullPen);
525
526 (void) TextIntCreateFontIndirect(&OEMFixedFont, (HFONT*)&StockObjects[OEM_FIXED_FONT]);
527 (void) TextIntCreateFontIndirect(&AnsiFixedFont, (HFONT*)&StockObjects[ANSI_FIXED_FONT]);
528 (void) TextIntCreateFontIndirect(&SystemFont, (HFONT*)&StockObjects[SYSTEM_FONT]);
529 (void) TextIntCreateFontIndirect(&DeviceDefaultFont, (HFONT*)&StockObjects[DEVICE_DEFAULT_FONT]);
530 (void) TextIntCreateFontIndirect(&SystemFixedFont, (HFONT*)&StockObjects[SYSTEM_FIXED_FONT]);
531 (void) TextIntCreateFontIndirect(&DefaultGuiFont, (HFONT*)&StockObjects[DEFAULT_GUI_FONT]);
532
533 StockObjects[DEFAULT_PALETTE] = (HGDIOBJ*)PALETTE_Init();
534
535 for (Object = 0; Object < NB_STOCK_OBJECTS; Object++)
536 {
537 if (NULL != StockObjects[Object])
538 {
539 GDIOBJ_MarkObjectGlobal(StockObjects[Object]);
540 /* GDI_HANDLE_SET_STOCKOBJ(StockObjects[Object]);*/
541 }
542 }
543
544 DPRINT("Completed creation of stock objects\n");
545 }
546
547 /*!
548 * Return stock object.
549 * \param Object - stock object id.
550 * \return Handle to the object.
551 */
552 HGDIOBJ STDCALL
553 NtGdiGetStockObject(INT Object)
554 {
555 DPRINT("NtGdiGetStockObject index %d\n", Object);
556
557 return ((Object < 0) || (NB_STOCK_OBJECTS <= Object)) ? NULL : StockObjects[Object];
558 }
559
560 /*!
561 * Delete GDI object
562 * \param hObject object handle
563 * \return if the function fails the returned value is FALSE.
564 */
565 BOOL STDCALL
566 NtGdiDeleteObject(HGDIOBJ hObject)
567 {
568 DPRINT("NtGdiDeleteObject handle 0x%08x\n", hObject);
569
570 return GDIOBJ_FreeObj(hObject, GDI_OBJECT_TYPE_DONTCARE, GDIOBJFLAG_DEFAULT);
571 }
572
573 /*!
574 * Internal function. Called when the process is destroyed to free the remaining GDI handles.
575 * \param Process - PID of the process that will be destroyed.
576 */
577 BOOL FASTCALL
578 CleanupForProcess (struct _EPROCESS *Process, INT Pid)
579 {
580 DWORD i;
581 PGDIOBJHDR objectHeader;
582 PEPROCESS CurrentProcess;
583
584 DPRINT("Starting CleanupForProcess prochandle %x Pid %d\n", Process, Pid);
585 CurrentProcess = PsGetCurrentProcess();
586 if (CurrentProcess != Process)
587 {
588 KeAttachProcess(Process);
589 }
590
591 for(i = 1; i < HandleTable->wTableSize; i++)
592 {
593 objectHeader = GDIOBJ_iGetObjectForIndex(i);
594 if (NULL != objectHeader &&
595 (INT) objectHeader->hProcessId == Pid)
596 {
597 DPRINT("CleanupForProcess: %d, process: %d, locks: %d, magic: 0x%x", i, objectHeader->hProcessId, objectHeader->dwCount, objectHeader->Magic);
598 GDIOBJ_FreeObj(GDI_HANDLE_CREATE(i, GDI_MAGIC_TO_TYPE(objectHeader->Magic)),
599 GDI_MAGIC_TO_TYPE(objectHeader->Magic),
600 GDIOBJFLAG_IGNOREPID | GDIOBJFLAG_IGNORELOCK);
601 }
602 }
603
604 if (CurrentProcess != Process)
605 {
606 KeDetachProcess();
607 }
608
609 DPRINT("Completed cleanup for process %d\n", Pid);
610
611 return TRUE;
612 }
613
614 #define GDIOBJ_TRACKLOCKS
615
616 #ifdef GDIOBJ_LockObj
617 #undef GDIOBJ_LockObj
618 PGDIOBJ FASTCALL
619 GDIOBJ_LockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType)
620 {
621 PGDIOBJ rc;
622 PGDIOBJHDR ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(hObj));
623
624 if (! GDI_VALID_OBJECT(hObj, ObjHdr, ObjectType, GDIOBJFLAG_DEFAULT))
625 {
626 int reason = 0;
627 if (NULL == ObjHdr)
628 {
629 reason = 1;
630 }
631 else if (GDI_MAGIC_TO_TYPE(ObjHdr->Magic) != ObjectType && ObjectType != GDI_OBJECT_TYPE_DONTCARE)
632 {
633 reason = 2;
634 }
635 else if (ObjHdr->hProcessId != GDI_GLOBAL_PROCESS
636 && ObjHdr->hProcessId != PsGetCurrentProcessId())
637 {
638 reason = 3;
639 }
640 else if (GDI_HANDLE_GET_TYPE(hObj) != ObjectType && ObjectType != GDI_OBJECT_TYPE_DONTCARE)
641 {
642 reason = 4;
643 }
644 DPRINT1("GDIOBJ_LockObj failed for 0x%08x, reqtype 0x%08x reason %d\n",
645 hObj, ObjectType, reason );
646 DPRINT1("\tcalled from: %s:%i\n", file, line );
647 return NULL;
648 }
649 if (NULL != ObjHdr->lockfile)
650 {
651 DPRINT1("Caution! GDIOBJ_LockObj trying to lock object (0x%x) second time\n", hObj );
652 DPRINT1("\tcalled from: %s:%i\n", file, line );
653 DPRINT1("\tpreviously locked from: %s:%i\n", ObjHdr->lockfile, ObjHdr->lockline );
654 }
655 DPRINT("(%s:%i) GDIOBJ_LockObj(0x%08x,0x%08x)\n", file, line, hObj, ObjectType);
656 rc = GDIOBJ_LockObj(hObj, ObjectType);
657 if (rc && NULL == ObjHdr->lockfile)
658 {
659 ObjHdr->lockfile = file;
660 ObjHdr->lockline = line;
661 }
662
663 return rc;
664 }
665 #endif//GDIOBJ_LockObj
666
667 #ifdef GDIOBJ_UnlockObj
668 #undef GDIOBJ_UnlockObj
669 BOOL FASTCALL
670 GDIOBJ_UnlockObjDbg (const char* file, int line, HGDIOBJ hObj, DWORD ObjectType)
671 {
672 PGDIOBJHDR ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(hObj));
673
674 if (! GDI_VALID_OBJECT(hObj, ObjHdr, ObjectType, GDIOBJFLAG_DEFAULT))
675 {
676 DPRINT1("GDIBOJ_UnlockObj failed for 0x%08x, reqtype 0x%08x\n",
677 hObj, ObjectType);
678 DPRINT1("\tcalled from: %s:%i\n", file, line);
679 return FALSE;
680 }
681 DPRINT("(%s:%i) GDIOBJ_UnlockObj(0x%08x,0x%08x)\n", file, line, hObj, ObjectType);
682 ObjHdr->lockfile = NULL;
683 ObjHdr->lockline = 0;
684
685 return GDIOBJ_UnlockObj(hObj, ObjectType);
686 }
687 #endif//GDIOBJ_LockObj
688
689 /*!
690 * Return pointer to the object by handle.
691 *
692 * \param hObj Object handle
693 * \param ObjectType one of the object types defined in \ref GDI object types
694 * \return Pointer to the object.
695 *
696 * \note Process can only get pointer to the objects it created or global objects.
697 *
698 * \todo Don't allow to lock the objects twice! Synchronization!
699 */
700 PGDIOBJ FASTCALL
701 GDIOBJ_LockObj(HGDIOBJ hObj, DWORD ObjectType)
702 {
703 PGDIOBJHDR ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(hObj));
704
705 DPRINT("GDIOBJ_LockObj: hObj: 0x%08x, type: 0x%08x, objhdr: %x\n", hObj, ObjectType, ObjHdr);
706 if (! GDI_VALID_OBJECT(hObj, ObjHdr, ObjectType, GDIOBJFLAG_DEFAULT))
707 {
708 DPRINT1("GDIBOJ_LockObj failed for 0x%08x, type 0x%08x\n",
709 hObj, ObjectType);
710 return NULL;
711 }
712
713 if(0 < ObjHdr->dwCount)
714 {
715 DPRINT1("Caution! GDIOBJ_LockObj trying to lock object (0x%x) second time\n", hObj);
716 DPRINT1("\t called from: %x\n", __builtin_return_address(0));
717 }
718
719 ExAcquireFastMutex(&RefCountHandling);
720 ObjHdr->dwCount++;
721 ExReleaseFastMutex(&RefCountHandling);
722 return (PGDIOBJ)((PCHAR)ObjHdr + sizeof(GDIOBJHDR));
723 }
724
725 /*!
726 * Release GDI object. Every object locked by GDIOBJ_LockObj() must be unlocked. You should unlock the object
727 * as soon as you don't need to have access to it's data.
728
729 * \param hObj Object handle
730 * \param ObjectType one of the object types defined in \ref GDI object types
731 *
732 * \note This function performs delayed cleanup. If the object is locked when GDI_FreeObj() is called
733 * then \em this function frees the object when reference count is zero.
734 *
735 * \todo Change synchronization algorithm.
736 */
737 #undef GDIOBJ_UnlockObj
738 BOOL FASTCALL
739 GDIOBJ_UnlockObj(HGDIOBJ hObj, DWORD ObjectType)
740 {
741 PGDIOBJHDR ObjHdr = GDIOBJ_iGetObjectForIndex(GDI_HANDLE_GET_INDEX(hObj));
742
743 DPRINT("GDIOBJ_UnlockObj: hObj: 0x%08x, type: 0x%08x, objhdr: %x\n", hObj, ObjectType, ObjHdr);
744 if (! GDI_VALID_OBJECT(hObj, ObjHdr, ObjectType, GDIOBJFLAG_DEFAULT))
745 {
746 DPRINT1( "GDIOBJ_UnLockObj: failed\n");
747 return FALSE;
748 }
749
750 ExAcquireFastMutex(&RefCountHandling);
751 if (0 == (ObjHdr->dwCount & ~0x80000000))
752 {
753 ExReleaseFastMutex(&RefCountHandling);
754 DPRINT1( "GDIOBJ_UnLockObj: unlock object (0x%x) that is not locked\n", hObj );
755 return FALSE;
756 }
757
758 ObjHdr->dwCount--;
759
760 if (ObjHdr->dwCount == 0x80000000)
761 {
762 //delayed object release
763 ObjHdr->dwCount = 0;
764 ExReleaseFastMutex(&RefCountHandling);
765 DPRINT("GDIOBJ_UnlockObj: delayed delete\n");
766 return GDIOBJ_FreeObj(hObj, ObjectType, GDIOBJFLAG_DEFAULT);
767 }
768 ExReleaseFastMutex(&RefCountHandling);
769
770 return TRUE;
771 }
772
773 /* EOF */