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