sync with trunk r46493
[reactos.git] / subsystems / win32 / win32k / ntuser / windc.c
1 /*
2 * PROJECT: ReactOS Kernel
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: subsystems/win32/win32k/ntuser/windc.c
5 * PURPOSE: Window DC management
6 * COPYRIGHT: Copyright 2007 ReactOS
7 *
8 */
9
10 /* INCLUDES ******************************************************************/
11
12 #include <w32k.h>
13
14 #define NDEBUG
15 #include <debug.h>
16
17 int FASTCALL CLIPPING_UpdateGCRegion(DC* Dc);
18
19 /* GLOBALS *******************************************************************/
20
21 /* NOTE - I think we should store this per window station (including gdi objects) */
22 /* Answer: No, use the DCE pMonitor to compare with! */
23
24 static LIST_ENTRY LEDce;
25 static INT DCECount = 0; // Count of DCE in system.
26
27 #define DCX_CACHECOMPAREMASK (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | \
28 DCX_NORESETATTRS | DCX_LOCKWINDOWUPDATE | \
29 DCX_LAYEREDWIN | DCX_CACHE | DCX_WINDOW | \
30 DCX_PARENTCLIP)
31
32 /* FUNCTIONS *****************************************************************/
33
34 //
35 // This should be moved to dc.c or dcutil.c.
36 //
37 HDC FASTCALL
38 DceCreateDisplayDC(VOID)
39 {
40 HDC hDC;
41 UNICODE_STRING DriverName;
42 RtlInitUnicodeString(&DriverName, L"DISPLAY");
43 hDC = IntGdiCreateDC(&DriverName, NULL, NULL, NULL, FALSE);
44
45 co_IntGraphicsCheck(TRUE);
46
47 //
48 // If NULL, first time through! Build the default window dc!
49 //
50 if (hDC && !defaultDCstate) // Ultra HAX! Dedicated to GvG!
51 { // This is a cheesy way to do this.
52 PDC dc = DC_LockDc ( hDC );
53 defaultDCstate = ExAllocatePoolWithTag(PagedPool, sizeof(DC), TAG_DC);
54 RtlZeroMemory(defaultDCstate, sizeof(DC));
55 defaultDCstate->pdcattr = &defaultDCstate->dcattr;
56 DC_vCopyState(dc, defaultDCstate, TRUE);
57 DC_UnlockDc( dc );
58 InitializeListHead(&LEDce);
59 }
60 return hDC;
61 }
62
63 static
64 HRGN FASTCALL
65 DceGetVisRgn(PWINDOW_OBJECT Window, ULONG Flags, HWND hWndChild, ULONG CFlags)
66 {
67 HRGN VisRgn;
68
69 VisRgn = VIS_ComputeVisibleRegion( Window,
70 0 == (Flags & DCX_WINDOW),
71 0 != (Flags & DCX_CLIPCHILDREN),
72 0 != (Flags & DCX_CLIPSIBLINGS));
73
74 if (VisRgn == NULL)
75 VisRgn = IntSysCreateRectRgn(0, 0, 0, 0);
76
77 return VisRgn;
78 }
79
80 PDCE FASTCALL
81 DceAllocDCE(PWINDOW_OBJECT Window OPTIONAL, DCE_TYPE Type)
82 {
83 PDCE pDce;
84 PWND Wnd = NULL;
85
86 if (Window) Wnd = Window->Wnd;
87
88 pDce = ExAllocatePoolWithTag(PagedPool, sizeof(DCE), TAG_PDCE);
89 if(!pDce)
90 return NULL;
91
92 pDce->hDC = DceCreateDisplayDC();
93 if (!pDce->hDC)
94 {
95 ExFreePoolWithTag(pDce, TAG_PDCE);
96 return NULL;
97 }
98 DCECount++;
99 DPRINT("Alloc DCE's! %d\n",DCECount);
100 pDce->hwndCurrent = (Window ? Window->hSelf : NULL);
101 pDce->pwndOrg = Wnd;
102 pDce->pwndClip = Wnd;
103 pDce->hrgnClip = NULL;
104 pDce->hrgnClipPublic = NULL;
105 pDce->hrgnSavedVis = NULL;
106 pDce->ppiOwner = NULL;
107
108 InsertTailList(&LEDce, &pDce->List);
109
110 DCU_SetDcUndeletable(pDce->hDC);
111
112 if (Type == DCE_WINDOW_DC || Type == DCE_CLASS_DC) //Window DCE have ownership.
113 {
114 pDce->ptiOwner = GetW32ThreadInfo();
115 }
116 else
117 {
118 DPRINT("FREE DCATTR!!!! NOT DCE_WINDOW_DC!!!!! hDC-> %x\n", pDce->hDC);
119 IntGdiSetDCOwnerEx( pDce->hDC, GDI_OBJ_HMGR_NONE, FALSE);
120 pDce->ptiOwner = NULL;
121 }
122
123 if (Type == DCE_CACHE_DC)
124 {
125 pDce->DCXFlags = DCX_CACHE | DCX_DCEEMPTY;
126 }
127 else
128 {
129 pDce->DCXFlags = DCX_DCEBUSY;
130 if (Wnd)
131 {
132 if (Type == DCE_WINDOW_DC)
133 {
134 if (Wnd->style & WS_CLIPCHILDREN) pDce->DCXFlags |= DCX_CLIPCHILDREN;
135 if (Wnd->style & WS_CLIPSIBLINGS) pDce->DCXFlags |= DCX_CLIPSIBLINGS;
136 }
137 }
138 }
139 return(pDce);
140 }
141
142 static VOID APIENTRY
143 DceSetDrawable( PWINDOW_OBJECT Window OPTIONAL,
144 HDC hDC,
145 ULONG Flags,
146 BOOL SetClipOrigin)
147 {
148 PWND Wnd;
149 DC *dc = DC_LockDc(hDC);
150 if(!dc)
151 return;
152
153 if (Window == NULL)
154 {
155 dc->ptlDCOrig.x = 0;
156 dc->ptlDCOrig.y = 0;
157 }
158 else
159 {
160 Wnd = Window->Wnd;
161 if (Flags & DCX_WINDOW)
162 {
163 dc->ptlDCOrig.x = Wnd->rcWindow.left;
164 dc->ptlDCOrig.y = Wnd->rcWindow.top;
165 }
166 else
167 {
168 dc->ptlDCOrig.x = Wnd->rcClient.left;
169 dc->ptlDCOrig.y = Wnd->rcClient.top;
170 }
171 }
172 DC_UnlockDc(dc);
173 }
174
175
176 static VOID FASTCALL
177 DceDeleteClipRgn(DCE* Dce)
178 {
179 Dce->DCXFlags &= ~(DCX_EXCLUDERGN | DCX_INTERSECTRGN);
180
181 if (Dce->DCXFlags & DCX_KEEPCLIPRGN )
182 {
183 Dce->DCXFlags &= ~DCX_KEEPCLIPRGN;
184 }
185 else if (Dce->hrgnClip != NULL)
186 {
187 GDIOBJ_FreeObjByHandle(Dce->hrgnClip, GDI_OBJECT_TYPE_REGION|GDI_OBJECT_TYPE_SILENT);
188 }
189
190 Dce->hrgnClip = NULL;
191
192 /* make it dirty so that the vis rgn gets recomputed next time */
193 Dce->DCXFlags |= DCX_DCEDIRTY;
194 }
195
196 static INT FASTCALL
197 DceReleaseDC(DCE* dce, BOOL EndPaint)
198 {
199 if (DCX_DCEBUSY != (dce->DCXFlags & (DCX_INDESTROY | DCX_DCEEMPTY | DCX_DCEBUSY)))
200 {
201 return 0;
202 }
203
204 /* restore previous visible region */
205 if ((dce->DCXFlags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) &&
206 ((dce->DCXFlags & DCX_CACHE) || EndPaint))
207 {
208 DceDeleteClipRgn(dce);
209 }
210
211 if (dce->DCXFlags & DCX_CACHE)
212 {
213 if (!(dce->DCXFlags & DCX_NORESETATTRS))
214 {
215 /* make the DC clean so that SetDCState doesn't try to update the vis rgn */
216 IntGdiSetHookFlags(dce->hDC, DCHF_VALIDATEVISRGN);
217
218 // Clean the DC
219 if (!IntGdiCleanDC(dce->hDC)) return 0;
220
221 if (dce->DCXFlags & DCX_DCEDIRTY)
222 {
223 /* don't keep around invalidated entries
224 * because SetDCState() disables hVisRgn updates
225 * by removing dirty bit. */
226 dce->hwndCurrent = 0;
227 dce->DCXFlags &= DCX_CACHE;
228 dce->DCXFlags |= DCX_DCEEMPTY;
229 }
230 }
231 dce->DCXFlags &= ~DCX_DCEBUSY;
232 DPRINT("Exit!!!!! DCX_CACHE!!!!!! hDC-> %x \n", dce->hDC);
233 if (!IntGdiSetDCOwnerEx( dce->hDC, GDI_OBJ_HMGR_NONE, FALSE))
234 return 0;
235 dce->ptiOwner = NULL; // Reset ownership.
236 dce->ppiOwner = NULL;
237
238 #if 0 // Need to research and fix before this is a "growing" issue.
239 if (++DCECache > 32)
240 {
241 pLE = LEDce.Flink;
242 pDCE = CONTAINING_RECORD(pLE, DCE, List);
243 do
244 {
245 if (!(pDCE->DCXFlags & DCX_DCEBUSY))
246 { /* Free the unused cache DCEs. */
247 pDCE = DceFreeDCE(pDCE, TRUE);
248 if (!pDCE) break;
249 continue;
250 }
251 }
252 while (pLE != &LEDce );
253 }
254 #endif
255 }
256 return 1; // Released!
257 }
258
259 static VOID FASTCALL
260 DceUpdateVisRgn(DCE *Dce, PWINDOW_OBJECT Window, ULONG Flags)
261 {
262 HANDLE hRgnVisible = NULL;
263 ULONG DcxFlags;
264 PWINDOW_OBJECT DesktopWindow;
265
266 if (Flags & DCX_PARENTCLIP)
267 {
268 PWINDOW_OBJECT Parent;
269 PWND ParentWnd;
270
271 Parent = Window->spwndParent;
272 if(!Parent)
273 {
274 hRgnVisible = NULL;
275 goto noparent;
276 }
277
278 ParentWnd = Parent->Wnd;
279
280 if (ParentWnd->style & WS_CLIPSIBLINGS)
281 {
282 DcxFlags = DCX_CLIPSIBLINGS |
283 (Flags & ~(DCX_CLIPCHILDREN | DCX_WINDOW));
284 }
285 else
286 {
287 DcxFlags = Flags & ~(DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN | DCX_WINDOW);
288 }
289 hRgnVisible = DceGetVisRgn(Parent, DcxFlags, Window->hSelf, Flags);
290 }
291 else if (Window == NULL)
292 {
293 DesktopWindow = UserGetWindowObject(IntGetDesktopWindow());
294 if (NULL != DesktopWindow)
295 {
296 hRgnVisible = IntSysCreateRectRgnIndirect(&DesktopWindow->Wnd->rcWindow);
297 }
298 else
299 {
300 hRgnVisible = NULL;
301 }
302 }
303 else
304 {
305 hRgnVisible = DceGetVisRgn(Window, Flags, 0, 0);
306 }
307
308 noparent:
309 if (Flags & DCX_INTERSECTRGN)
310 {
311 if(Dce->hrgnClip != NULL)
312 {
313 NtGdiCombineRgn(hRgnVisible, hRgnVisible, Dce->hrgnClip, RGN_AND);
314 }
315 else
316 {
317 if(hRgnVisible != NULL)
318 {
319 REGION_FreeRgnByHandle(hRgnVisible);
320 }
321 hRgnVisible = IntSysCreateRectRgn(0, 0, 0, 0);
322 }
323 }
324 else if (Flags & DCX_EXCLUDERGN && Dce->hrgnClip != NULL)
325 {
326 NtGdiCombineRgn(hRgnVisible, hRgnVisible, Dce->hrgnClip, RGN_DIFF);
327 }
328
329 Dce->DCXFlags &= ~DCX_DCEDIRTY;
330 GdiSelectVisRgn(Dce->hDC, hRgnVisible);
331
332 if (Window != NULL)
333 {
334 IntEngWindowChanged(Window, WOC_RGN_CLIENT);
335 }
336
337 if (hRgnVisible != NULL)
338 {
339 REGION_FreeRgnByHandle(hRgnVisible);
340 }
341 }
342
343 HDC FASTCALL
344 UserGetDCEx(PWINDOW_OBJECT Window OPTIONAL, HANDLE ClipRegion, ULONG Flags)
345 {
346 PWINDOW_OBJECT Parent;
347 ULONG DcxFlags;
348 DCE* Dce = NULL;
349 BOOL UpdateClipOrigin = FALSE;
350 PWND Wnd = NULL;
351 HDC hDC = NULL;
352 PPROCESSINFO ppi;
353 PLIST_ENTRY pLE;
354
355 if (NULL == Window)
356 {
357 Flags &= ~DCX_USESTYLE;
358 Flags |= DCX_CACHE;
359 }
360 else
361 Wnd = Window->Wnd;
362
363 if (Flags & (DCX_WINDOW | DCX_PARENTCLIP)) Flags |= DCX_CACHE;
364
365 // When GetDC is called with hWnd nz, DCX_CACHE & _WINDOW are clear w _USESTYLE set.
366 if (Flags & DCX_USESTYLE)
367 {
368 Flags &= ~(DCX_CLIPCHILDREN | DCX_CLIPSIBLINGS | DCX_PARENTCLIP);
369 if (!(Flags & DCX_WINDOW)) // not window rectangle
370 {
371 if (Wnd->pcls->style & CS_PARENTDC)
372 {
373 Flags |= DCX_PARENTCLIP;
374 }
375
376 if (!(Flags & DCX_CACHE) && // Not on the cheap wine list.
377 !(Wnd->pcls->style & CS_OWNDC) )
378 {
379 if (!(Wnd->pcls->style & CS_CLASSDC))
380 // The window is not POWNED or has any CLASS, so we are looking for cheap wine.
381 Flags |= DCX_CACHE;
382 else
383 {
384 if (Wnd->pcls->pdce) hDC = ((PDCE)Wnd->pcls->pdce)->hDC;
385 DPRINT("We have CLASS!!\n");
386 }
387 }
388 /* else // For Testing!
389 {
390 DPRINT1("We have POWNER!!\n");
391 if (Window->Dce) DPRINT1("We have POWNER with DCE!!\n");
392 }
393 */
394 if (Wnd->style & WS_CLIPSIBLINGS)
395 {
396 Flags |= DCX_CLIPSIBLINGS;
397 }
398
399 if (Wnd->style & WS_CLIPCHILDREN &&
400 !(Wnd->style & WS_MINIMIZE))
401 {
402 Flags |= DCX_CLIPCHILDREN;
403 }
404 /* If minized with icon in the set, we are forced to be cheap! */
405 if (Wnd->style & WS_MINIMIZE &&
406 Wnd->pcls->hIcon)
407 {
408 Flags |= DCX_CACHE;
409 }
410 }
411 else
412 {
413 if (Wnd->style & WS_CLIPSIBLINGS) Flags |= DCX_CLIPSIBLINGS;
414 Flags |= DCX_CACHE;
415 }
416 }
417
418 if (Flags & DCX_WINDOW) Flags &= ~DCX_CLIPCHILDREN;
419
420 if (Flags & DCX_NOCLIPCHILDREN)
421 {
422 Flags |= DCX_CACHE;
423 Flags &= ~(DCX_PARENTCLIP | DCX_CLIPCHILDREN);
424 }
425
426 Parent = (Window ? Window->spwndParent : NULL);
427
428 if (NULL == Window || !(Wnd->style & WS_CHILD) || NULL == Parent)
429 {
430 Flags &= ~DCX_PARENTCLIP;
431 Flags |= DCX_CLIPSIBLINGS;
432 }
433
434 /* it seems parent clip is ignored when clipping siblings or children */
435 if (Flags & (DCX_CLIPSIBLINGS | DCX_CLIPCHILDREN)) Flags &= ~DCX_PARENTCLIP;
436
437 if (Flags & DCX_PARENTCLIP)
438 {
439 if ((Wnd->style & WS_VISIBLE) &&
440 (Parent->Wnd->style & WS_VISIBLE))
441 {
442 Flags &= ~DCX_CLIPCHILDREN;
443 if (Parent->Wnd->style & WS_CLIPSIBLINGS)
444 {
445 Flags |= DCX_CLIPSIBLINGS;
446 }
447 }
448 }
449
450 // Window nz, check to see if we still own this or it is just cheap wine tonight.
451 if (!(Flags & DCX_CACHE))
452 {
453 if ( Wnd->head.pti != GetW32ThreadInfo())
454 Flags |= DCX_CACHE; // Ah~ Not Powned! Forced to be cheap~
455 }
456
457 DcxFlags = Flags & DCX_CACHECOMPAREMASK;
458
459 if (Flags & DCX_CACHE)
460 { // Scan the cheap wine list for our match.
461 DCE* DceEmpty = NULL;
462 DCE* DceUnused = NULL;
463 KeEnterCriticalRegion();
464 pLE = LEDce.Flink;
465 Dce = CONTAINING_RECORD(pLE, DCE, List);
466 do
467 {
468 // The reason for this you may ask?
469 // Well, it seems ReactOS calls GetDC with out first creating a desktop DC window!
470 // Need to test for null here. Not sure if this is a bug or a feature.
471 // First time use hax, need to use DceAllocDCE during window display init.
472 if (!Dce) break;
473 //
474 // The way I understand this, you can have more than one DC per window.
475 // Only one Owned if one was requested and saved and one Cached.
476 //
477 if ((Dce->DCXFlags & (DCX_CACHE | DCX_DCEBUSY)) == DCX_CACHE)
478 {
479 DceUnused = Dce;
480 if (Dce->DCXFlags & DCX_DCEEMPTY)
481 {
482 DceEmpty = Dce;
483 }
484 else if (Dce->hwndCurrent == (Window ? Window->hSelf : NULL) &&
485 ((Dce->DCXFlags & DCX_CACHECOMPAREMASK) == DcxFlags))
486 {
487 UpdateClipOrigin = TRUE;
488 break;
489 }
490 }
491 pLE = Dce->List.Flink;
492 Dce = CONTAINING_RECORD(pLE, DCE, List);
493 }
494 while (pLE != &LEDce);
495 KeLeaveCriticalRegion();
496
497 Dce = (DceEmpty == NULL) ? DceUnused : DceEmpty;
498
499 if (Dce == NULL)
500 {
501 Dce = DceAllocDCE(NULL, DCE_CACHE_DC);
502 }
503 if (!Dce) return NULL;
504
505 Dce->hwndCurrent = (Window ? Window->hSelf : NULL);
506 }
507 else // If we are here, we are POWNED or having CLASS.
508 {
509 KeEnterCriticalRegion();
510 pLE = LEDce.Flink;
511 Dce = CONTAINING_RECORD(pLE, DCE, List);
512 do
513 { // Check for Window handle than HDC match for CLASS.
514 if ((Dce->hwndCurrent == Window->hSelf) ||
515 (Dce->hDC == hDC))
516 break;
517 pLE = Dce->List.Flink;
518 Dce = CONTAINING_RECORD(pLE, DCE, List);
519 }
520 while (pLE != &LEDce);
521 KeLeaveCriticalRegion();
522
523 if ( (Flags & (DCX_INTERSECTRGN|DCX_EXCLUDERGN)) &&
524 (Dce->DCXFlags & (DCX_INTERSECTRGN|DCX_EXCLUDERGN)) )
525 {
526 DceDeleteClipRgn(Dce);
527 }
528 }
529 // First time use hax, need to use DceAllocDCE during window display init.
530 if (NULL == Dce)
531 {
532 return(NULL);
533 }
534
535 if (!GDIOBJ_ValidateHandle(Dce->hDC, GDI_OBJECT_TYPE_DC))
536 {
537 DPRINT1("FIXME: Got DCE with invalid hDC! 0x%x\n", Dce->hDC);
538 Dce->hDC = DceCreateDisplayDC();
539 /* FIXME: Handle error */
540 }
541
542 Dce->DCXFlags = Flags | DCX_DCEBUSY;
543
544 /*
545 Bump it up! This prevents the random errors in wine dce tests and with
546 proper bits set in DCX_CACHECOMPAREMASK.
547 Reference:
548 http://www.reactos.org/archives/public/ros-dev/2008-July/010498.html
549 http://www.reactos.org/archives/public/ros-dev/2008-July/010499.html
550 */
551 if (pLE != &LEDce)
552 {
553 RemoveEntryList(&Dce->List);
554 InsertHeadList(&LEDce, &Dce->List);
555 }
556
557 /* Introduced in rev 6691 and modified later. */
558 if ( (Flags & DCX_INTERSECTUPDATE) && !ClipRegion )
559 {
560 Flags |= DCX_INTERSECTRGN | DCX_KEEPCLIPRGN;
561 Dce->DCXFlags |= DCX_INTERSECTRGN | DCX_KEEPCLIPRGN;
562 ClipRegion = Window->hrgnUpdate;
563 }
564
565 if (ClipRegion == (HRGN) 1)
566 {
567 if (!(Flags & DCX_WINDOW))
568 {
569 Dce->hrgnClip = IntSysCreateRectRgnIndirect(&Window->Wnd->rcClient);
570 }
571 else
572 {
573 Dce->hrgnClip = IntSysCreateRectRgnIndirect(&Window->Wnd->rcWindow);
574 }
575 Dce->DCXFlags &= ~DCX_KEEPCLIPRGN;
576 }
577 else if (ClipRegion != NULL)
578 {
579 if (Dce->hrgnClip != NULL)
580 {
581 DPRINT1("Should not be called!!\n");
582 GDIOBJ_FreeObjByHandle(Dce->hrgnClip, GDI_OBJECT_TYPE_REGION|GDI_OBJECT_TYPE_SILENT);
583 Dce->hrgnClip = NULL;
584 }
585 Dce->hrgnClip = ClipRegion;
586 }
587
588 DceSetDrawable(Window, Dce->hDC, Flags, UpdateClipOrigin);
589
590 DceUpdateVisRgn(Dce, Window, Flags);
591
592 if (Dce->DCXFlags & DCX_CACHE)
593 {
594 DPRINT("ENTER!!!!!! DCX_CACHE!!!!!! hDC-> %x\n", Dce->hDC);
595 // Need to set ownership so Sync dcattr will work.
596 IntGdiSetDCOwnerEx( Dce->hDC, GDI_OBJ_HMGR_POWNED, FALSE);
597 Dce->ptiOwner = GetW32ThreadInfo(); // Set the temp owning
598 }
599
600 if ( Wnd &&
601 Wnd->ExStyle & WS_EX_LAYOUTRTL &&
602 !(Flags & DCX_KEEPLAYOUT) )
603 {
604 NtGdiSetLayout(Dce->hDC, -1, LAYOUT_RTL);
605 }
606
607 if (Dce->DCXFlags & DCX_PROCESSOWNED)
608 {
609 ppi = PsGetCurrentProcessWin32Process();
610 ppi->W32PF_flags |= W32PF_OWNDCCLEANUP;
611 Dce->ptiOwner = NULL;
612 Dce->ppiOwner = ppi;
613 }
614
615 return(Dce->hDC);
616 }
617
618 /***********************************************************************
619 * DceFreeDCE
620 */
621 PDCE FASTCALL
622 DceFreeDCE(PDCE pdce, BOOLEAN Force)
623 {
624 DCE *ret;
625 PLIST_ENTRY pLE;
626 BOOL Hit = FALSE;
627
628 if (NULL == pdce) return NULL;
629
630 pLE = pdce->List.Flink;
631 ret = CONTAINING_RECORD(pLE, DCE, List);
632
633 pdce->DCXFlags |= DCX_INDESTROY;
634
635 if (Force && !GDIOBJ_OwnedByCurrentProcess(pdce->hDC))
636 {
637 DPRINT("Change ownership for DCE! -> %x\n" , pdce);
638 // Note: Windows sets W32PF_OWNDCCLEANUP and moves on.
639 if (!IsObjectDead((HGDIOBJ) pdce->hDC))
640 {
641 DC_SetOwnership( pdce->hDC, PsGetCurrentProcess());
642 }
643 else
644 {
645 DPRINT1("Attempted to change ownership of an DCEhDC 0x%x currently being destroyed!!!\n",pdce->hDC);
646 Hit = TRUE;
647 }
648 }
649 else
650 {
651 if (!GreGetObjectOwner(pdce->hDC, GDIObjType_DC_TYPE))
652 DC_SetOwnership( pdce->hDC, PsGetCurrentProcess());
653 }
654
655 if (!Hit) IntGdiDeleteDC(pdce->hDC, TRUE);
656
657 if (pdce->hrgnClip && !(pdce->DCXFlags & DCX_KEEPCLIPRGN))
658 {
659 GDIOBJ_FreeObjByHandle(pdce->hrgnClip, GDI_OBJECT_TYPE_REGION|GDI_OBJECT_TYPE_SILENT);
660 pdce->hrgnClip = NULL;
661 }
662
663 RemoveEntryList(&pdce->List);
664
665 if (IsListEmpty(&pdce->List))
666 {
667 DPRINT1("List is Empty! DCE! -> %x\n" , pdce);
668 return NULL;
669 }
670
671 ExFreePoolWithTag(pdce, TAG_PDCE);
672
673 DCECount--;
674 DPRINT("Freed DCE's! %d \n", DCECount);
675
676 return ret;
677 }
678
679 /***********************************************************************
680 * DceFreeWindowDCE
681 *
682 * Remove owned DCE and reset unreleased cache DCEs.
683 */
684 void FASTCALL
685 DceFreeWindowDCE(PWINDOW_OBJECT Window)
686 {
687 PDCE pDCE;
688 PLIST_ENTRY pLE;
689
690 if (DCECount <= 0)
691 {
692 DPRINT1("FreeWindowDCE No Entry! %d\n",DCECount);
693 return;
694 }
695
696 pLE = LEDce.Flink;
697 pDCE = CONTAINING_RECORD(pLE, DCE, List);
698 do
699 {
700 if (!pDCE)
701 {
702 DPRINT1("FreeWindowDCE No DCE Pointer!\n");
703 break;
704 }
705 if (IsListEmpty(&pDCE->List))
706 {
707 DPRINT1("FreeWindowDCE List is Empty!!!!\n");
708 break;
709 }
710 if ( pDCE->hwndCurrent == Window->hSelf &&
711 !(pDCE->DCXFlags & DCX_DCEEMPTY) )
712 {
713 if (!(pDCE->DCXFlags & DCX_CACHE)) /* owned or Class DCE*/
714 {
715 if (Window->Wnd->pcls->style & CS_CLASSDC) /* Test Class first */
716 {
717 if (pDCE->DCXFlags & (DCX_INTERSECTRGN | DCX_EXCLUDERGN)) /* Class DCE*/
718 DceDeleteClipRgn(pDCE);
719 // Update and reset Vis Rgn and clear the dirty bit.
720 // Should release VisRgn than reset it to default.
721 DceUpdateVisRgn(pDCE, Window, pDCE->DCXFlags);
722 pDCE->DCXFlags = DCX_DCEEMPTY|DCX_CACHE;
723 pDCE->hwndCurrent = 0;
724
725 DPRINT("POWNED DCE going Cheap!! DCX_CACHE!! hDC-> %x \n", pDCE->hDC);
726 if (!IntGdiSetDCOwnerEx( pDCE->hDC, GDI_OBJ_HMGR_NONE, FALSE))
727 {
728 DPRINT1("Fail Owner Switch hDC-> %x \n", pDCE->hDC);
729 break;
730 }
731 /* Do not change owner so thread can clean up! */
732 }
733 else if (Window->Wnd->pcls->style & CS_OWNDC) /* owned DCE*/
734 {
735 pDCE = DceFreeDCE(pDCE, FALSE);
736 if (!pDCE) break;
737 continue;
738 }
739 else
740 {
741 DPRINT1("Not POWNED or CLASSDC hwndCurrent -> %x \n", pDCE->hwndCurrent);
742 ASSERT(FALSE);
743 }
744 }
745 else
746 {
747 if (pDCE->DCXFlags & DCX_DCEBUSY) /* shared cache DCE */
748 {
749 /* FIXME: AFAICS we are doing the right thing here so
750 * this should be a DPRINT. But this is best left as an ERR
751 * because the 'application error' is likely to come from
752 * another part of Wine (i.e. it's our fault after all).
753 * We should change this to DPRINT when ReactOS is more stable
754 * (for 1.0?).
755 */
756 DPRINT1("[%p] GetDC() without ReleaseDC()!\n", Window->hSelf);
757 DceReleaseDC(pDCE, FALSE);
758 }
759 pDCE->DCXFlags |= DCX_DCEEMPTY;
760 pDCE->hwndCurrent = 0;
761 }
762 }
763 pLE = pDCE->List.Flink;
764 pDCE = CONTAINING_RECORD(pLE, DCE, List);
765 }
766 while (pLE != &LEDce);
767 }
768
769 void FASTCALL
770 DceFreeClassDCE(HDC hDC)
771 {
772 PDCE pDCE;
773 PLIST_ENTRY pLE;
774 pLE = LEDce.Flink;
775 pDCE = CONTAINING_RECORD(pLE, DCE, List);
776
777 do
778 {
779 if(!pDCE) break;
780 if (pDCE->hDC == hDC)
781 {
782 pDCE = DceFreeDCE(pDCE, TRUE); // Might have gone cheap!
783 if (!pDCE) break;
784 continue;
785 }
786 pLE = pDCE->List.Flink;
787 pDCE = CONTAINING_RECORD(pLE, DCE, List);
788 }
789 while (pLE != &LEDce);
790 }
791
792 void FASTCALL
793 DceFreeThreadDCE(PTHREADINFO pti)
794 {
795 PDCE pDCE;
796 PLIST_ENTRY pLE;
797 pLE = LEDce.Flink;
798 pDCE = CONTAINING_RECORD(pLE, DCE, List);
799
800 do
801 {
802 if(!pDCE) break;
803 if (pDCE->ptiOwner == pti)
804 {
805 if (pDCE->DCXFlags & DCX_CACHE)
806 {
807 pDCE = DceFreeDCE(pDCE, TRUE);
808 if (!pDCE) break;
809 continue;
810 }
811 }
812 pLE = pDCE->List.Flink;
813 pDCE = CONTAINING_RECORD(pLE, DCE, List);
814 }
815 while (pLE != &LEDce);
816 }
817
818 VOID FASTCALL
819 DceEmptyCache(VOID)
820 {
821 PDCE pDCE;
822 PLIST_ENTRY pLE;
823 pLE = LEDce.Flink;
824 pDCE = CONTAINING_RECORD(pLE, DCE, List);
825
826 do
827 {
828 if(!pDCE) break;
829 pDCE = DceFreeDCE(pDCE, TRUE);
830 if(!pDCE) break;
831 }
832 while (pLE != &LEDce);
833 }
834
835 VOID FASTCALL
836 DceResetActiveDCEs(PWINDOW_OBJECT Window)
837 {
838 DCE *pDCE;
839 PDC dc;
840 PWINDOW_OBJECT CurrentWindow;
841 INT DeltaX;
842 INT DeltaY;
843 PLIST_ENTRY pLE;
844
845 if (NULL == Window)
846 {
847 return;
848 }
849 pLE = LEDce.Flink;
850 pDCE = CONTAINING_RECORD(pLE, DCE, List);
851 if(!pDCE) return; // Another null test!
852 do
853 {
854 if(!pDCE) break;
855 if(pLE == &LEDce) break;
856 if (0 == (pDCE->DCXFlags & (DCX_DCEEMPTY|DCX_INDESTROY)))
857 {
858 if (Window->hSelf == pDCE->hwndCurrent)
859 {
860 CurrentWindow = Window;
861 }
862 else
863 {
864 CurrentWindow = UserGetWindowObject(pDCE->hwndCurrent);
865 if (NULL == CurrentWindow)
866 {
867 pLE = pDCE->List.Flink;
868 pDCE = CONTAINING_RECORD(pLE, DCE, List);
869 continue;
870 }
871 }
872
873 if (!GDIOBJ_ValidateHandle(pDCE->hDC, GDI_OBJECT_TYPE_DC) ||
874 (dc = DC_LockDc(pDCE->hDC)) == NULL)
875 {
876 pLE = pDCE->List.Flink;
877 pDCE = CONTAINING_RECORD(pLE, DCE, List);
878 continue;
879 }
880 if (Window == CurrentWindow || IntIsChildWindow(Window, CurrentWindow))
881 {
882 if (pDCE->DCXFlags & DCX_WINDOW)
883 {
884 DeltaX = CurrentWindow->Wnd->rcWindow.left - dc->ptlDCOrig.x;
885 DeltaY = CurrentWindow->Wnd->rcWindow.top - dc->ptlDCOrig.y;
886 dc->ptlDCOrig.x = CurrentWindow->Wnd->rcWindow.left;
887 dc->ptlDCOrig.y = CurrentWindow->Wnd->rcWindow.top;
888 }
889 else
890 {
891 DeltaX = CurrentWindow->Wnd->rcClient.left - dc->ptlDCOrig.x;
892 DeltaY = CurrentWindow->Wnd->rcClient.top - dc->ptlDCOrig.y;
893 dc->ptlDCOrig.x = CurrentWindow->Wnd->rcClient.left;
894 dc->ptlDCOrig.y = CurrentWindow->Wnd->rcClient.top;
895 }
896 if (NULL != dc->rosdc.hClipRgn)
897 {
898 NtGdiOffsetRgn(dc->rosdc.hClipRgn, DeltaX, DeltaY);
899 CLIPPING_UpdateGCRegion(dc);
900 }
901 if (NULL != pDCE->hrgnClip)
902 {
903 NtGdiOffsetRgn(pDCE->hrgnClip, DeltaX, DeltaY);
904 }
905 }
906 DC_UnlockDc(dc);
907
908 DceUpdateVisRgn(pDCE, CurrentWindow, pDCE->DCXFlags);
909
910 if (Window->hSelf != pDCE->hwndCurrent)
911 {
912 // IntEngWindowChanged(CurrentWindow, WOC_RGN_CLIENT);
913 // UserDerefObject(CurrentWindow);
914 }
915 }
916 pLE = pDCE->List.Flink;
917 pDCE = CONTAINING_RECORD(pLE, DCE, List);
918 }
919 while (pLE != &LEDce);
920 }
921
922 HWND FASTCALL
923 IntWindowFromDC(HDC hDc)
924 {
925 DCE *Dce;
926 PLIST_ENTRY pLE;
927 HWND Ret = NULL;
928
929 pLE = LEDce.Flink;
930 Dce = CONTAINING_RECORD(pLE, DCE, List);
931 do
932 {
933 if (Dce->hDC == hDc)
934 {
935 if (Dce->DCXFlags & DCX_INDESTROY)
936 Ret = NULL;
937 else
938 Ret = Dce->hwndCurrent;
939 break;
940 }
941 pLE = Dce->List.Flink;
942 Dce = CONTAINING_RECORD(pLE, DCE, List);
943 }
944 while (pLE != &LEDce);
945 return Ret;
946 }
947
948 INT FASTCALL
949 UserReleaseDC(PWINDOW_OBJECT Window, HDC hDc, BOOL EndPaint)
950 {
951 PDCE dce;
952 PLIST_ENTRY pLE;
953 INT nRet = 0;
954 BOOL Hit = FALSE;
955
956 DPRINT("%p %p\n", Window, hDc);
957 pLE = LEDce.Flink;
958 dce = CONTAINING_RECORD(pLE, DCE, List);
959 do
960 {
961 if(!dce) break;
962 if (dce->hDC == hDc)
963 {
964 Hit = TRUE;
965 break;
966 }
967 pLE = dce->List.Flink;
968 dce = CONTAINING_RECORD(pLE, DCE, List);
969 }
970 while (pLE != &LEDce );
971
972 if ( Hit && (dce->DCXFlags & DCX_DCEBUSY))
973 {
974 nRet = DceReleaseDC(dce, EndPaint);
975 }
976
977 return nRet;
978 }
979
980 HDC FASTCALL
981 UserGetWindowDC(PWINDOW_OBJECT Wnd)
982 {
983 return UserGetDCEx(Wnd, 0, DCX_USESTYLE | DCX_WINDOW);
984 }
985
986 HWND FASTCALL
987 UserGethWnd( HDC hdc, PWNDOBJ *pwndo)
988 {
989 PWNDGDI pWndgdi;
990 PWINDOW_OBJECT Wnd;
991 HWND hWnd;
992
993 hWnd = IntWindowFromDC(hdc);
994
995 if (hWnd && !(Wnd = UserGetWindowObject(hWnd)))
996 {
997 pWndgdi = (WNDGDI *)IntGetProp(Wnd, AtomWndObj);
998
999 if ( pWndgdi && pWndgdi->Hwnd == hWnd )
1000 {
1001 if (pwndo) *pwndo = (PWNDOBJ)pWndgdi;
1002 }
1003 }
1004 return hWnd;
1005 }
1006
1007 HDC APIENTRY
1008 NtUserGetDCEx(HWND hWnd OPTIONAL, HANDLE ClipRegion, ULONG Flags)
1009 {
1010 PWINDOW_OBJECT Wnd=NULL;
1011 DECLARE_RETURN(HDC);
1012
1013 DPRINT("Enter NtUserGetDCEx\n");
1014 UserEnterExclusive();
1015
1016 if (hWnd && !(Wnd = UserGetWindowObject(hWnd)))
1017 {
1018 RETURN(NULL);
1019 }
1020 RETURN( UserGetDCEx(Wnd, ClipRegion, Flags));
1021
1022 CLEANUP:
1023 DPRINT("Leave NtUserGetDCEx, ret=%i\n",_ret_);
1024 UserLeave();
1025 END_CLEANUP;
1026 }
1027
1028 /*
1029 * NtUserGetWindowDC
1030 *
1031 * The NtUserGetWindowDC function retrieves the device context (DC) for the
1032 * entire window, including title bar, menus, and scroll bars. A window device
1033 * context permits painting anywhere in a window, because the origin of the
1034 * device context is the upper-left corner of the window instead of the client
1035 * area.
1036 *
1037 * Status
1038 * @implemented
1039 */
1040 HDC APIENTRY
1041 NtUserGetWindowDC(HWND hWnd)
1042 {
1043 return NtUserGetDCEx(hWnd, 0, DCX_USESTYLE | DCX_WINDOW);
1044 }
1045
1046 HDC APIENTRY
1047 NtUserGetDC(HWND hWnd)
1048 {
1049 DPRINT("NtUGetDC -> %x:%x\n", hWnd, !hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE );
1050
1051 return NtUserGetDCEx(hWnd, NULL, NULL == hWnd ? DCX_CACHE | DCX_WINDOW : DCX_USESTYLE);
1052 }
1053
1054 /*!
1055 * Select logical palette into device context.
1056 * \param hDC handle to the device context
1057 * \param hpal handle to the palette
1058 * \param ForceBackground If this value is FALSE the logical palette will be copied to the device palette only when the applicatioon
1059 * is in the foreground. If this value is TRUE then map the colors in the logical palette to the device
1060 * palette colors in the best way.
1061 * \return old palette
1062 *
1063 * \todo implement ForceBackground == TRUE
1064 */
1065 HPALETTE
1066 APIENTRY
1067 NtUserSelectPalette(HDC hDC,
1068 HPALETTE hpal,
1069 BOOL ForceBackground)
1070 {
1071 HPALETTE oldPal;
1072 UserEnterExclusive();
1073 // Implement window checks
1074 oldPal = GdiSelectPalette( hDC, hpal, ForceBackground);
1075 UserLeave();
1076 return oldPal;
1077 }
1078
1079
1080 /* EOF */