xref: /reactos/win32ss/gdi/ntgdi/cliprgn.c (revision 50cf16b3) 
1 /*
2  * COPYRIGHT:        GNU GPL, See COPYING in the top level directory
3  * PROJECT:          ReactOS Win32k subsystem
4  * PURPOSE:          Clip region functions
5  * FILE:             win32ss/gdi/ntgdi/cliprgn.c
6  * PROGRAMER:        Unknown
7  */
8 
9 #include <win32k.h>
10 
11 #define NDEBUG
12 #include <debug.h>
13 
14 VOID
15 FASTCALL
16 IntGdiReleaseRaoRgn(PDC pDC)
17 {
18     INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
19     PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
20     pDC->fs |= DC_FLAG_DIRTY_RAO;
21     Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
22     RECTL_vSetEmptyRect(&pDC->erclClip);
23     REGION_Delete(pDC->prgnRao);
24     pDC->prgnRao = NULL;
25 }
26 
27 VOID
28 FASTCALL
29 IntGdiReleaseVisRgn(PDC pDC)
30 {
31     INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
32     PGDI_TABLE_ENTRY Entry = &GdiHandleTable->Entries[Index];
33     pDC->fs |= DC_FLAG_DIRTY_RAO;
34     Entry->Flags |= GDI_ENTRY_VALIDATE_VIS;
35     RECTL_vSetEmptyRect(&pDC->erclClip);
36     REGION_Delete(pDC->prgnVis);
37     pDC->prgnVis = prgnDefault;
38 }
39 
40 VOID
41 FASTCALL
42 GdiSelectVisRgn(
43     HDC hdc,
44     PREGION prgn)
45 {
46     DC *dc;
47 
48     if (!(dc = DC_LockDc(hdc)))
49     {
50         EngSetLastError(ERROR_INVALID_HANDLE);
51         return;
52     }
53 
54     dc->fs |= DC_FLAG_DIRTY_RAO;
55 
56     ASSERT(dc->prgnVis != NULL);
57     ASSERT(prgn != NULL);
58 
59     IntGdiCombineRgn(dc->prgnVis, prgn, NULL, RGN_COPY);
60     REGION_bOffsetRgn(dc->prgnVis, -dc->ptlDCOrig.x, -dc->ptlDCOrig.y);
61 
62     DC_UnlockDc(dc);
63 }
64 
65 
66 int
67 FASTCALL
68 IntGdiExtSelectClipRgn(
69     PDC dc,
70     PREGION prgn,
71     int fnMode)
72 {
73     if (fnMode == RGN_COPY)
74     {
75         if (!prgn)
76         {
77             if (dc->dclevel.prgnClip != NULL)
78             {
79                 REGION_Delete(dc->dclevel.prgnClip);
80                 dc->dclevel.prgnClip = NULL;
81                 dc->fs |= DC_FLAG_DIRTY_RAO;
82             }
83             return SIMPLEREGION;
84         }
85 
86         if (!dc->dclevel.prgnClip)
87             dc->dclevel.prgnClip = IntSysCreateRectpRgn(0, 0, 0, 0);
88 
89         dc->fs |= DC_FLAG_DIRTY_RAO;
90 
91         return IntGdiCombineRgn(dc->dclevel.prgnClip, prgn, NULL, RGN_COPY);
92     }
93 
94     ASSERT(prgn != NULL);
95 
96     if (!dc->dclevel.prgnClip)
97     {
98         RECTL rect;
99 
100         REGION_GetRgnBox(dc->prgnVis, &rect);
101         dc->dclevel.prgnClip = IntSysCreateRectpRgnIndirect(&rect);
102     }
103 
104     dc->fs |= DC_FLAG_DIRTY_RAO;
105 
106     return IntGdiCombineRgn(dc->dclevel.prgnClip, dc->dclevel.prgnClip, prgn, fnMode);
107 }
108 
109 
110 int
111 APIENTRY
112 NtGdiExtSelectClipRgn(
113     HDC  hDC,
114     HRGN  hrgn,
115     int  fnMode)
116 {
117     int retval;
118     DC *dc;
119     PREGION prgn;
120 
121     if (!(dc = DC_LockDc(hDC)))
122     {
123         EngSetLastError(ERROR_INVALID_HANDLE);
124         return ERROR;
125     }
126 
127     prgn = REGION_LockRgn(hrgn);
128 
129     if ((prgn == NULL) && (fnMode != RGN_COPY))
130     {
131         EngSetLastError(ERROR_INVALID_HANDLE);
132         retval = ERROR;
133     }
134     else
135     {
136         retval = IntGdiExtSelectClipRgn(dc, prgn, fnMode);
137     }
138 
139     if (prgn)
140         REGION_UnlockRgn(prgn);
141 
142     DC_UnlockDc(dc);
143     return retval;
144 }
145 
146 _Success_(return!=ERROR)
147 INT
148 FASTCALL
149 GdiGetClipBox(
150     _In_ HDC hdc,
151     _Out_ LPRECT prc)
152 {
153     PDC pdc;
154     INT iComplexity;
155 
156     /* Lock the DC */
157     pdc = DC_LockDc(hdc);
158     if (!pdc)
159     {
160         return ERROR;
161     }
162 
163     /* Update RAO region if necessary */
164     if (pdc->fs & DC_FLAG_DIRTY_RAO)
165         CLIPPING_UpdateGCRegion(pdc);
166 
167     /* Check if we have a RAO region (intersection of API and VIS region) */
168     if (pdc->prgnRao)
169     {
170         /* We have a RAO region, use it */
171         iComplexity = REGION_GetRgnBox(pdc->prgnRao, prc);
172     }
173     else
174     {
175         /* No RAO region means no API region, so use the VIS region */
176         ASSERT(pdc->prgnVis);
177         iComplexity = REGION_GetRgnBox(pdc->prgnVis, prc);
178     }
179 
180     /* Unlock the DC */
181     DC_UnlockDc(pdc);
182 
183     /* Convert the rect to logical coordinates */
184     IntDPtoLP(pdc, (LPPOINT)prc, 2);
185 
186     /* Return the complexity */
187     return iComplexity;
188 }
189 
190 _Success_(return!=ERROR)
191 INT
192 APIENTRY
193 NtGdiGetAppClipBox(
194     _In_ HDC hdc,
195     _Out_ LPRECT prc)
196 {
197     RECT rect;
198     INT iComplexity;
199 
200     /* Call the internal function */
201     iComplexity = GdiGetClipBox(hdc, &rect);
202 
203     if (iComplexity != ERROR)
204     {
205         _SEH2_TRY
206         {
207             ProbeForWrite(prc, sizeof(RECT), 1);
208             *prc = rect;
209         }
210         _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
211         {
212             iComplexity = ERROR;
213         }
214         _SEH2_END
215     }
216 
217     /* Return the complexity */
218     return iComplexity;
219 }
220 
221 INT
222 APIENTRY
223 NtGdiExcludeClipRect(
224     _In_ HDC hdc,
225     _In_ INT xLeft,
226     _In_ INT yTop,
227     _In_ INT xRight,
228     _In_ INT yBottom)
229 {
230     INT iComplexity;
231     RECTL rect;
232     PDC pdc;
233 
234     /* Lock the DC */
235     pdc = DC_LockDc(hdc);
236     if (pdc == NULL)
237     {
238         EngSetLastError(ERROR_INVALID_HANDLE);
239         return ERROR;
240     }
241 
242     /* Convert coordinates to device space */
243     rect.left = xLeft;
244     rect.top = yTop;
245     rect.right = xRight;
246     rect.bottom = yBottom;
247     RECTL_vMakeWellOrdered(&rect);
248     IntLPtoDP(pdc, (LPPOINT)&rect, 2);
249 
250     /* Check if we already have a clip region */
251     if (pdc->dclevel.prgnClip != NULL)
252     {
253         /* We have a region, subtract the rect */
254         iComplexity = REGION_SubtractRectFromRgn(pdc->dclevel.prgnClip,
255                                                  pdc->dclevel.prgnClip,
256                                                  &rect);
257     }
258     else
259     {
260         /* We don't have a clip region yet, create an empty region */
261         pdc->dclevel.prgnClip = IntSysCreateRectpRgn(0, 0, 0, 0);
262         if (pdc->dclevel.prgnClip == NULL)
263         {
264             iComplexity = ERROR;
265         }
266         else
267         {
268             /* Subtract the rect from the VIS region */
269             iComplexity = REGION_SubtractRectFromRgn(pdc->dclevel.prgnClip,
270                                                      pdc->prgnVis,
271                                                      &rect);
272         }
273     }
274 
275     /* Emulate Windows behavior */
276     if (iComplexity == SIMPLEREGION)
277         iComplexity = COMPLEXREGION;
278 
279     /* If we succeeded, mark the RAO region as dirty */
280     if (iComplexity != ERROR)
281         pdc->fs |= DC_FLAG_DIRTY_RAO;
282 
283     /* Unlock the DC */
284     DC_UnlockDc(pdc);
285 
286     return iComplexity;
287 }
288 
289 INT
290 APIENTRY
291 NtGdiIntersectClipRect(
292     _In_ HDC hdc,
293     _In_ INT xLeft,
294     _In_ INT yTop,
295     _In_ INT xRight,
296     _In_ INT yBottom)
297 {
298     INT iComplexity;
299     RECTL rect;
300     PREGION prgnNew;
301     PDC pdc;
302 
303     DPRINT("NtGdiIntersectClipRect(%p, %d,%d-%d,%d)\n",
304             hdc, xLeft, yTop, xRight, yBottom);
305 
306     /* Lock the DC */
307     pdc = DC_LockDc(hdc);
308     if (!pdc)
309     {
310         EngSetLastError(ERROR_INVALID_HANDLE);
311         return ERROR;
312     }
313 
314     /* Convert coordinates to device space */
315     rect.left = xLeft;
316     rect.top = yTop;
317     rect.right = xRight;
318     rect.bottom = yBottom;
319     IntLPtoDP(pdc, (LPPOINT)&rect, 2);
320 
321     /* Check if we already have a clip region */
322     if (pdc->dclevel.prgnClip != NULL)
323     {
324         /* We have a region, crop it */
325         iComplexity = REGION_CropRegion(pdc->dclevel.prgnClip,
326                                         pdc->dclevel.prgnClip,
327                                         &rect);
328     }
329     else
330     {
331         /* We don't have a region yet, allocate a new one */
332         prgnNew = IntSysCreateRectpRgnIndirect(&rect);
333         if (prgnNew == NULL)
334         {
335             iComplexity = ERROR;
336         }
337         else
338         {
339             /* Set the new region */
340             pdc->dclevel.prgnClip = prgnNew;
341             iComplexity = SIMPLEREGION;
342         }
343     }
344 
345     /* If we succeeded, mark the RAO region as dirty */
346     if (iComplexity != ERROR)
347         pdc->fs |= DC_FLAG_DIRTY_RAO;
348 
349     /* Unlock the DC */
350     DC_UnlockDc(pdc);
351 
352     return iComplexity;
353 }
354 
355 INT
356 APIENTRY
357 NtGdiOffsetClipRgn(
358     _In_ HDC hdc,
359     _In_ INT xOffset,
360     _In_ INT yOffset)
361 {
362     INT iComplexity;
363     PDC pdc;
364     POINTL apt[2];
365 
366     /* Lock the DC */
367     pdc = DC_LockDc(hdc);
368     if (pdc == NULL)
369     {
370         return ERROR;
371     }
372 
373     /* Check if we have a clip region */
374     if (pdc->dclevel.prgnClip != NULL)
375     {
376         /* Convert coordinates into device space. Note that we need to convert
377            2 coordinates to account for rotation / shear / offset */
378         apt[0].x = 0;
379         apt[0].y = 0;
380         apt[1].x = xOffset;
381         apt[1].y = yOffset;
382         IntLPtoDP(pdc, &apt, 2);
383 
384         /* Offset the clip region */
385         if (!REGION_bOffsetRgn(pdc->dclevel.prgnClip,
386                                apt[1].x - apt[0].x,
387                                apt[1].y - apt[0].y))
388         {
389             iComplexity = ERROR;
390         }
391         else
392         {
393             iComplexity = REGION_Complexity(pdc->dclevel.prgnClip);
394         }
395 
396         /* Mark the RAO region as dirty */
397         pdc->fs |= DC_FLAG_DIRTY_RAO;
398     }
399     else
400     {
401         /* NULL means no clipping, i.e. the "whole" region */
402         iComplexity = SIMPLEREGION;
403     }
404 
405     /* Unlock the DC and return the complexity */
406     DC_UnlockDc(pdc);
407     return iComplexity;
408 }
409 
410 BOOL APIENTRY NtGdiPtVisible(HDC  hDC,
411                     int  X,
412                     int  Y)
413 {
414     BOOL ret = FALSE;
415     PDC dc;
416 
417     if(!(dc = DC_LockDc(hDC)))
418     {
419         EngSetLastError(ERROR_INVALID_HANDLE);
420         return FALSE;
421     }
422 
423     if (dc->prgnRao)
424     {
425         POINT pt = {X, Y};
426         IntLPtoDP(dc, &pt, 1);
427         ret = REGION_PtInRegion(dc->prgnRao, pt.x, pt.y);
428     }
429 
430     DC_UnlockDc(dc);
431 
432     return ret;
433 }
434 
435 BOOL
436 APIENTRY
437 NtGdiRectVisible(
438     HDC hDC,
439     LPRECT UnsafeRect)
440 {
441     NTSTATUS Status = STATUS_SUCCESS;
442     PDC dc = DC_LockDc(hDC);
443     BOOL Result = FALSE;
444     RECTL Rect;
445 
446     if (!dc)
447     {
448         EngSetLastError(ERROR_INVALID_HANDLE);
449         return FALSE;
450     }
451 
452     _SEH2_TRY
453     {
454         ProbeForRead(UnsafeRect,
455                    sizeof(RECT),
456                    1);
457         Rect = *UnsafeRect;
458     }
459     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
460     {
461         Status = _SEH2_GetExceptionCode();
462     }
463     _SEH2_END;
464 
465     if(!NT_SUCCESS(Status))
466     {
467         DC_UnlockDc(dc);
468         SetLastNtError(Status);
469         return FALSE;
470     }
471 
472     if (dc->fs & DC_FLAG_DIRTY_RAO)
473         CLIPPING_UpdateGCRegion(dc);
474 
475     if (dc->prgnRao)
476     {
477          IntLPtoDP(dc, (LPPOINT)&Rect, 2);
478          Result = REGION_RectInRegion(dc->prgnRao, &Rect);
479     }
480     DC_UnlockDc(dc);
481 
482     return Result;
483 }
484 
485 int
486 FASTCALL
487 IntGdiSetMetaRgn(PDC pDC)
488 {
489     INT Ret = ERROR;
490 
491     if ( pDC->dclevel.prgnMeta )
492     {
493         if ( pDC->dclevel.prgnClip )
494         {
495             // preferably REGION_IntersectRegion
496             Ret = IntGdiCombineRgn(pDC->dclevel.prgnMeta, pDC->dclevel.prgnMeta, pDC->dclevel.prgnClip, RGN_AND);
497             if (Ret != ERROR)
498             {
499                 REGION_Delete(pDC->dclevel.prgnClip);
500                 pDC->dclevel.prgnClip = NULL;
501                 IntGdiReleaseRaoRgn(pDC);
502             }
503         }
504         else
505             Ret = REGION_Complexity(pDC->dclevel.prgnMeta);
506     }
507     else
508     {
509         if ( pDC->dclevel.prgnClip )
510         {
511             Ret = REGION_Complexity(pDC->dclevel.prgnClip);
512             pDC->dclevel.prgnMeta = pDC->dclevel.prgnClip;
513             pDC->dclevel.prgnClip = NULL;
514         }
515         else
516             Ret = SIMPLEREGION;
517     }
518 
519     if (Ret != ERROR)
520         pDC->fs |= DC_FLAG_DIRTY_RAO;
521 
522     return Ret;
523 }
524 
525 
526 int APIENTRY NtGdiSetMetaRgn(HDC  hDC)
527 {
528   INT Ret;
529   PDC pDC = DC_LockDc(hDC);
530 
531   if (!pDC)
532   {
533      EngSetLastError(ERROR_INVALID_PARAMETER);
534      return ERROR;
535   }
536   Ret = IntGdiSetMetaRgn(pDC);
537 
538   DC_UnlockDc(pDC);
539   return Ret;
540 }
541 
542 VOID
543 FASTCALL
544 CLIPPING_UpdateGCRegion(PDC pDC)
545 {
546     /* Must have VisRgn set to a valid state! */
547     ASSERT (pDC->prgnVis);
548 
549     if (pDC->prgnAPI)
550     {
551         REGION_Delete(pDC->prgnAPI);
552         pDC->prgnAPI = NULL;
553     }
554 
555     if (pDC->prgnRao)
556         REGION_Delete(pDC->prgnRao);
557 
558     pDC->prgnRao = IntSysCreateRectpRgn(0,0,0,0);
559 
560     ASSERT(pDC->prgnRao);
561 
562     if (pDC->dclevel.prgnMeta || pDC->dclevel.prgnClip)
563     {
564         pDC->prgnAPI = IntSysCreateRectpRgn(0,0,0,0);
565         if (!pDC->dclevel.prgnMeta)
566         {
567             IntGdiCombineRgn(pDC->prgnAPI,
568                              pDC->dclevel.prgnClip,
569                              NULL,
570                              RGN_COPY);
571         }
572         else if (!pDC->dclevel.prgnClip)
573         {
574             IntGdiCombineRgn(pDC->prgnAPI,
575                              pDC->dclevel.prgnMeta,
576                              NULL,
577                              RGN_COPY);
578         }
579         else
580         {
581             IntGdiCombineRgn(pDC->prgnAPI,
582                              pDC->dclevel.prgnClip,
583                              pDC->dclevel.prgnMeta,
584                              RGN_AND);
585         }
586     }
587 
588     if (pDC->prgnAPI)
589     {
590         IntGdiCombineRgn(pDC->prgnRao,
591                          pDC->prgnVis,
592                          pDC->prgnAPI,
593                          RGN_AND);
594     }
595     else
596     {
597         IntGdiCombineRgn(pDC->prgnRao,
598                          pDC->prgnVis,
599                          NULL,
600                          RGN_COPY);
601     }
602 
603 
604     REGION_bOffsetRgn(pDC->prgnRao, pDC->ptlDCOrig.x, pDC->ptlDCOrig.y);
605 
606     RtlCopyMemory(&pDC->erclClip,
607                 &pDC->prgnRao->rdh.rcBound,
608                 sizeof(RECTL));
609 
610     pDC->fs &= ~DC_FLAG_DIRTY_RAO;
611 
612     // pDC->co should be used. Example, CLIPOBJ_cEnumStart uses XCLIPOBJ to build
613     // the rects from region objects rects in pClipRgn->Buffer.
614     // With pDC->co.pClipRgn->Buffer,
615     // pDC->co.pClipRgn = pDC->prgnRao ? pDC->prgnRao : pDC->prgnVis;
616 
617     IntEngUpdateClipRegion(&pDC->co,
618                            pDC->prgnRao->rdh.nCount,
619                            pDC->prgnRao->Buffer,
620                            &pDC->erclClip);
621 
622     REGION_bOffsetRgn(pDC->prgnRao, -pDC->ptlDCOrig.x, -pDC->ptlDCOrig.y);
623 }
624 
625 /* EOF */
626