ReactOS  0.4.13-dev-99-g7e18b6d
cliprgn.c
Go to the documentation of this file.
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
17 {
18  INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
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
30 {
31  INT Index = GDI_HANDLE_GET_INDEX(pDC->BaseObject.hHmgr);
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
43  HDC hdc,
44  PREGION prgn)
45 {
46  DC *dc;
47 
48  if (!(dc = DC_LockDc(hdc)))
49  {
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
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
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  {
124  return ERROR;
125  }
126 
127  prgn = REGION_LockRgn(hrgn);
128 
129  if ((prgn == NULL) && (fnMode != RGN_COPY))
130  {
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)
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  }
211  {
212  iComplexity = ERROR;
213  }
214  _SEH2_END
215  }
216 
217  /* Return the complexity */
218  return iComplexity;
219 }
220 
221 INT
222 APIENTRY
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  {
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;
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
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  {
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 */
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
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 
411  int X,
412  int Y)
413 {
414  BOOL ret = FALSE;
415  PDC dc;
416 
417  if(!(dc = DC_LockDc(hDC)))
418  {
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
438  HDC hDC,
439  LPRECT UnsafeRect)
440 {
442  PDC dc = DC_LockDc(hDC);
443  BOOL Result = FALSE;
444  RECTL Rect;
445 
446  if (!dc)
447  {
449  return FALSE;
450  }
451 
452  _SEH2_TRY
453  {
454  ProbeForRead(UnsafeRect,
455  sizeof(RECT),
456  1);
457  Rect = *UnsafeRect;
458  }
460  {
462  }
463  _SEH2_END;
464 
465  if(!NT_SUCCESS(Status))
466  {
467  DC_UnlockDc(dc);
469  return FALSE;
470  }
471 
472  if (dc->fs & DC_FLAG_DIRTY_RAO)
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
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 
527 {
528  INT Ret;
529  PDC pDC = DC_LockDc(hDC);
530 
531  if (!pDC)
532  {
534  return ERROR;
535  }
536  Ret = IntGdiSetMetaRgn(pDC);
537 
538  DC_UnlockDc(pDC);
539  return Ret;
540 }
541 
542 VOID
543 FASTCALL
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 */
#define ERROR_INVALID_PARAMETER
Definition: compat.h:91
#define GDI_HANDLE_GET_INDEX(h)
Definition: gdi.h:28
#define IntDPtoLP(pdc, ppt, count)
Definition: coord.h:12
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
FORCEINLINE PDC DC_LockDc(HDC hdc)
Definition: dc.h:219
VOID FASTCALL GdiSelectVisRgn(HDC hdc, PREGION prgn)
Definition: cliprgn.c:42
FORCEINLINE VOID RECTL_vSetEmptyRect(_Out_ RECTL *prcl)
Definition: rect.h:20
#define Y(I)
#define pt(x, y)
Definition: drawing.c:79
INT FASTCALL REGION_SubtractRectFromRgn(PREGION prgnDest, PREGION prgnSrc, const RECTL *prcl)
Definition: region.c:1827
#define ERROR(name)
Definition: error_private.h:53
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
LONG NTSTATUS
Definition: precomp.h:26
static HDC
Definition: imagelist.c:92
#define COMPLEXREGION
Definition: wingdi.h:362
VOID FASTCALL IntGdiReleaseVisRgn(PDC pDC)
Definition: cliprgn.c:29
HDC dc
Definition: cylfrac.c:34
int FASTCALL IntGdiExtSelectClipRgn(PDC dc, PREGION prgn, int fnMode)
Definition: cliprgn.c:68
BOOL FASTCALL REGION_bOffsetRgn(_Inout_ PREGION prgn, _In_ INT cx, _In_ INT cy)
Definition: region.c:2730
INT APIENTRY NtGdiOffsetClipRgn(_In_ HDC hdc, _In_ INT xOffset, _In_ INT yOffset)
Definition: cliprgn.c:357
INT APIENTRY NtGdiIntersectClipRect(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: cliprgn.c:291
PREGION FASTCALL REGION_LockRgn(_In_ HRGN hrgn)
Definition: region.c:2380
#define FASTCALL
Definition: nt_native.h:50
int32_t INT
Definition: typedefs.h:56
VOID NTAPI ProbeForWrite(IN PVOID Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:143
& rect
Definition: startmenu.cpp:1413
LONG y
Definition: windef.h:315
_SEH2_TRY
Definition: create.c:4250
#define RGN_AND
Definition: wingdi.h:355
VOID FASTCALL IntGdiReleaseRaoRgn(PDC pDC)
Definition: cliprgn.c:16
PREGION FASTCALL IntSysCreateRectpRgn(INT LeftRect, INT TopRect, INT RightRect, INT BottomRect)
Definition: region.c:2429
unsigned int BOOL
Definition: ntddk_ex.h:94
#define EXCEPTION_EXECUTE_HANDLER
Definition: excpt.h:85
smooth NULL
Definition: ftsmooth.c:416
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
#define _Out_
Definition: no_sal2.h:323
BOOL FASTCALL REGION_RectInRegion(PREGION Rgn, const RECTL *rect)
Definition: region.c:2628
void DPRINT(...)
Definition: polytest.cpp:61
Definition: region.h:7
INT FASTCALL IntGdiCombineRgn(PREGION prgnDest, PREGION prgnSrc1, PREGION prgnSrc2, INT iCombineMode)
Definition: region.c:2509
#define IntSysCreateRectpRgnIndirect(prc)
Definition: region.h:93
#define GdiHandleTable
Definition: win32nt.h:36
Definition: polytest.cpp:40
PREGION prgnDefault
Definition: region.c:130
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
static const UCHAR Index[8]
Definition: usbohci.c:18
#define DC_FLAG_DIRTY_RAO
Definition: ntgdihdl.h:132
int APIENTRY NtGdiSetMetaRgn(HDC hDC)
Definition: cliprgn.c:526
VOID FASTCALL CLIPPING_UpdateGCRegion(PDC pDC)
Definition: cliprgn.c:544
LONG x
Definition: windef.h:314
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
BOOL APIENTRY NtGdiPtVisible(HDC hDC, int X, int Y)
Definition: cliprgn.c:410
#define IntLPtoDP(pdc, ppt, count)
Definition: coord.h:7
int ret
VOID NTAPI ProbeForRead(IN CONST VOID *Address, IN SIZE_T Length, IN ULONG Alignment)
Definition: exintrin.c:102
HDC hdc
Definition: main.c:9
static HRGN hrgn
Definition: win.c:55
INT APIENTRY NtGdiExcludeClipRect(_In_ HDC hdc, _In_ INT xLeft, _In_ INT yTop, _In_ INT xRight, _In_ INT yBottom)
Definition: cliprgn.c:223
VOID FASTCALL SetLastNtError(NTSTATUS Status)
Definition: error.c:36
Status
Definition: gdiplustypes.h:24
#define RGN_COPY
Definition: wingdi.h:356
#define SIMPLEREGION
Definition: wingdi.h:361
BOOL APIENTRY NtGdiRectVisible(HDC hDC, LPRECT UnsafeRect)
Definition: cliprgn.c:437
#define _In_
Definition: no_sal2.h:204
Definition: gdi.h:1
static HDC hDC
Definition: 3dtext.c:33
_SEH2_END
Definition: create.c:4424
FORCEINLINE VOID DC_UnlockDc(PDC pdc)
Definition: dc.h:237
#define GDI_ENTRY_VALIDATE_VIS
Definition: ntgdihdl.h:40
int xOffset
Definition: appswitch.c:59
VOID FASTCALL REGION_UnlockRgn(_In_ PREGION prgn)
Definition: region.c:2395
VOID FASTCALL IntEngUpdateClipRegion(XCLIPOBJ *Clip, ULONG count, const RECTL *pRect, const RECTL *rcBounds)
Definition: clip.c:173
int APIENTRY NtGdiExtSelectClipRgn(HDC hDC, HRGN hrgn, int fnMode)
Definition: cliprgn.c:112
INT FASTCALL REGION_CropRegion(PREGION rgnDst, PREGION rgnSrc, const RECTL *rect)
Definition: region.c:678
#define _SEH2_EXCEPT(...)
Definition: pseh2_64.h:6
int yOffset
Definition: appswitch.c:59
INT FASTCALL REGION_Complexity(PREGION prgn)
Definition: region.c:567
#define _SEH2_GetExceptionCode()
Definition: pseh2_64.h:12
INT FASTCALL REGION_GetRgnBox(PREGION Rgn, PRECTL pRect)
Definition: region.c:2565
return STATUS_SUCCESS
Definition: btrfs.c:2725
_Out_ LPRECT prc
Definition: ntgdi.h:1658
_Success_(return!=ERROR)
Definition: cliprgn.c:146
VOID FASTCALL REGION_Delete(PREGION pRgn)
Definition: region.c:2471
int FASTCALL IntGdiSetMetaRgn(PDC pDC)
Definition: cliprgn.c:487
VOID FASTCALL RECTL_vMakeWellOrdered(_Inout_ RECTL *prcl)
Definition: rect.c:81
ENGAPI VOID APIENTRY EngSetLastError(_In_ ULONG iError)
Definition: error.c:27
base of all file and directory entries
Definition: entries.h:82
#define APIENTRY
Definition: api.h:79
struct Rect Rect
#define X(b, s)
BOOL FASTCALL REGION_PtInRegion(PREGION prgn, INT X, INT Y)
Definition: region.c:2605