[YAROTOWS] Reintegrate the branch. For a brighter future.
[reactos.git] / reactos / subsystems / win32 / win32k / objects / fillshap.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 along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19
20 #include <win32k.h>
21
22 #define NDEBUG
23 #include <debug.h>
24
25 #define Rsin(d) ((d) == 0.0 ? 0.0 : ((d) == 90.0 ? 1.0 : sin(d*M_PI/180.0)))
26 #define Rcos(d) ((d) == 0.0 ? 1.0 : ((d) == 90.0 ? 0.0 : cos(d*M_PI/180.0)))
27
28 BOOL FASTCALL IntFillEllipse( PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush);
29 BOOL FASTCALL IntDrawEllipse( PDC dc, INT XLeft, INT YLeft, INT Width, INT Height, PBRUSH pbrush);
30 BOOL FASTCALL IntFillRoundRect( PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrush);
31 BOOL FASTCALL IntDrawRoundRect( PDC dc, INT Left, INT Top, INT Right, INT Bottom, INT Wellipse, INT Hellipse, PBRUSH pbrush);
32
33 BOOL FASTCALL
34 IntGdiPolygon(PDC dc,
35 PPOINT Points,
36 int Count)
37 {
38 SURFACE *psurf;
39 PBRUSH pbrLine, pbrFill;
40 BOOL ret = FALSE; // default to failure
41 RECTL DestRect;
42 int CurrentPoint;
43 PDC_ATTR pdcattr;
44 POINTL BrushOrigin;
45 // int Left;
46 // int Top;
47
48 ASSERT(dc); // caller's responsibility to pass a valid dc
49
50 if (!Points || Count < 2 )
51 {
52 SetLastWin32Error(ERROR_INVALID_PARAMETER);
53 return FALSE;
54 }
55
56 /*
57 //Find start x, y
58 Left = Points[0].x;
59 Top = Points[0].y;
60 for (CurrentPoint = 1; CurrentPoint < Count; ++CurrentPoint) {
61 Left = min(Left, Points[CurrentPoint].x);
62 Top = min(Top, Points[CurrentPoint].y);
63 }
64 */
65
66 pdcattr = dc->pdcattr;
67
68 /* Convert to screen coordinates */
69 IntLPtoDP(dc, Points, Count);
70 for (CurrentPoint = 0; CurrentPoint < Count; CurrentPoint++)
71 {
72 Points[CurrentPoint].x += dc->ptlDCOrig.x;
73 Points[CurrentPoint].y += dc->ptlDCOrig.y;
74 }
75 // No need to have path here.
76 {
77 DestRect.left = Points[0].x;
78 DestRect.right = Points[0].x;
79 DestRect.top = Points[0].y;
80 DestRect.bottom = Points[0].y;
81
82 for (CurrentPoint = 1; CurrentPoint < Count; ++CurrentPoint)
83 {
84 DestRect.left = min(DestRect.left, Points[CurrentPoint].x);
85 DestRect.right = max(DestRect.right, Points[CurrentPoint].x);
86 DestRect.top = min(DestRect.top, Points[CurrentPoint].y);
87 DestRect.bottom = max(DestRect.bottom, Points[CurrentPoint].y);
88 }
89
90 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
91 DC_vUpdateFillBrush(dc);
92
93 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
94 DC_vUpdateLineBrush(dc);
95
96 /* Special locking order to avoid lock-ups */
97 pbrFill = dc->dclevel.pbrFill;
98 pbrLine = dc->dclevel.pbrLine;
99 psurf = dc->dclevel.pSurface;
100 /* FIXME - psurf can be NULL!!!! don't assert but handle this case gracefully! */
101 ASSERT(psurf);
102
103 /* Now fill the polygon with the current fill brush. */
104 if (!(pbrFill->flAttrs & GDIBRUSH_IS_NULL))
105 {
106 BrushOrigin = *((PPOINTL)&pbrFill->ptOrigin);
107 BrushOrigin.x += dc->ptlDCOrig.x;
108 BrushOrigin.y += dc->ptlDCOrig.y;
109 ret = IntFillPolygon (dc,
110 psurf,
111 &dc->eboFill.BrushObject,
112 Points,
113 Count,
114 DestRect,
115 &BrushOrigin);
116 }
117
118 // Draw the Polygon Edges with the current pen ( if not a NULL pen )
119 if (!(pbrLine->flAttrs & GDIBRUSH_IS_NULL))
120 {
121 int i;
122
123 for (i = 0; i < Count-1; i++)
124 {
125
126 // DPRINT1("Polygon Making line from (%d,%d) to (%d,%d)\n",
127 // Points[0].x, Points[0].y,
128 // Points[1].x, Points[1].y );
129
130 ret = IntEngLineTo(&psurf->SurfObj,
131 dc->rosdc.CombinedClip,
132 &dc->eboLine.BrushObject,
133 Points[i].x, /* From */
134 Points[i].y,
135 Points[i+1].x, /* To */
136 Points[i+1].y,
137 &DestRect,
138 ROP2_TO_MIX(pdcattr->jROP2)); /* MIX */
139 if (!ret) break;
140 }
141 /* Close the polygon */
142 if (ret)
143 {
144 ret = IntEngLineTo(&psurf->SurfObj,
145 dc->rosdc.CombinedClip,
146 &dc->eboLine.BrushObject,
147 Points[Count-1].x, /* From */
148 Points[Count-1].y,
149 Points[0].x, /* To */
150 Points[0].y,
151 &DestRect,
152 ROP2_TO_MIX(pdcattr->jROP2)); /* MIX */
153 }
154 }
155 }
156
157 return ret;
158 }
159
160 BOOL FASTCALL
161 IntGdiPolyPolygon(DC *dc,
162 LPPOINT Points,
163 PULONG PolyCounts,
164 int Count)
165 {
166 if (PATH_IsPathOpen(dc->dclevel))
167 return PATH_PolyPolygon ( dc, Points, (PINT)PolyCounts, Count);
168
169 while (--Count >=0)
170 {
171 if (!IntGdiPolygon ( dc, Points, *PolyCounts ))
172 return FALSE;
173 Points+=*PolyCounts++;
174 }
175 return TRUE;
176 }
177
178
179
180 /******************************************************************************/
181
182 /*
183 * NtGdiEllipse
184 *
185 * Author
186 * Filip Navara
187 *
188 * Remarks
189 * This function uses optimized Bresenham's ellipse algorithm. It draws
190 * four lines of the ellipse in one pass.
191 *
192 */
193
194 BOOL APIENTRY
195 NtGdiEllipse(
196 HDC hDC,
197 int Left,
198 int Top,
199 int Right,
200 int Bottom)
201 {
202 PDC dc;
203 PDC_ATTR pdcattr;
204 RECTL RectBounds;
205 PBRUSH pbrush;
206 BOOL ret = TRUE;
207 LONG PenWidth, PenOrigWidth;
208 LONG RadiusX, RadiusY, CenterX, CenterY;
209 PBRUSH pFillBrushObj;
210 BRUSH tmpFillBrushObj;
211
212 if ((Left == Right) || (Top == Bottom)) return TRUE;
213
214 dc = DC_LockDc(hDC);
215 if (dc == NULL)
216 {
217 SetLastWin32Error(ERROR_INVALID_HANDLE);
218 return FALSE;
219 }
220 if (dc->dctype == DC_TYPE_INFO)
221 {
222 DC_UnlockDc(dc);
223 /* Yes, Windows really returns TRUE in this case */
224 return TRUE;
225 }
226
227 if (PATH_IsPathOpen(dc->dclevel))
228 {
229 ret = PATH_Ellipse(dc, Left, Top, Right, Bottom);
230 DC_UnlockDc(dc);
231 return ret;
232 }
233
234 if (Right < Left)
235 {
236 INT tmp = Right; Right = Left; Left = tmp;
237 }
238 if (Bottom < Top)
239 {
240 INT tmp = Bottom; Bottom = Top; Top = tmp;
241 }
242
243 pdcattr = dc->pdcattr;
244
245 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
246 DC_vUpdateFillBrush(dc);
247
248 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
249 DC_vUpdateLineBrush(dc);
250
251 pbrush = PEN_LockPen(pdcattr->hpen);
252 if (!pbrush)
253 {
254 DPRINT1("Ellipse Fail 1\n");
255 DC_UnlockDc(dc);
256 SetLastWin32Error(ERROR_INTERNAL_ERROR);
257 return FALSE;
258 }
259
260 PenOrigWidth = PenWidth = pbrush->ptPenWidth.x;
261 if (pbrush->ulPenStyle == PS_NULL) PenWidth = 0;
262
263 if (pbrush->ulPenStyle == PS_INSIDEFRAME)
264 {
265 if (2*PenWidth > (Right - Left)) PenWidth = (Right -Left + 1)/2;
266 if (2*PenWidth > (Bottom - Top)) PenWidth = (Bottom -Top + 1)/2;
267 Left += PenWidth / 2;
268 Right -= (PenWidth - 1) / 2;
269 Top += PenWidth / 2;
270 Bottom -= (PenWidth - 1) / 2;
271 }
272
273 if (!PenWidth) PenWidth = 1;
274 pbrush->ptPenWidth.x = PenWidth;
275
276 RectBounds.left = Left;
277 RectBounds.right = Right;
278 RectBounds.top = Top;
279 RectBounds.bottom = Bottom;
280
281 IntLPtoDP(dc, (LPPOINT)&RectBounds, 2);
282
283 RectBounds.left += dc->ptlDCOrig.x;
284 RectBounds.right += dc->ptlDCOrig.x;
285 RectBounds.top += dc->ptlDCOrig.y;
286 RectBounds.bottom += dc->ptlDCOrig.y;
287
288 // Setup for dynamic width and height.
289 RadiusX = max((RectBounds.right - RectBounds.left) / 2, 2); // Needs room
290 RadiusY = max((RectBounds.bottom - RectBounds.top) / 2, 2);
291 CenterX = (RectBounds.right + RectBounds.left) / 2;
292 CenterY = (RectBounds.bottom + RectBounds.top) / 2;
293
294 DPRINT("Ellipse 1: Left: %d, Top: %d, Right: %d, Bottom: %d\n",
295 RectBounds.left,RectBounds.top,RectBounds.right,RectBounds.bottom);
296
297 DPRINT("Ellipse 2: XLeft: %d, YLeft: %d, Width: %d, Height: %d\n",
298 CenterX - RadiusX, CenterY + RadiusY, RadiusX*2, RadiusY*2);
299
300 pFillBrushObj = BRUSH_LockBrush(pdcattr->hbrush);
301 if (NULL == pFillBrushObj)
302 {
303 DPRINT1("FillEllipse Fail\n");
304 SetLastWin32Error(ERROR_INTERNAL_ERROR);
305 ret = FALSE;
306 }
307 else
308 {
309 RtlCopyMemory(&tmpFillBrushObj, pFillBrushObj, sizeof(tmpFillBrushObj));
310 // tmpFillBrushObj.ptOrigin.x += RectBounds.left - Left;
311 // tmpFillBrushObj.ptOrigin.y += RectBounds.top - Top;
312 tmpFillBrushObj.ptOrigin.x += dc->ptlDCOrig.x;
313 tmpFillBrushObj.ptOrigin.y += dc->ptlDCOrig.y;
314 ret = IntFillEllipse( dc,
315 CenterX - RadiusX,
316 CenterY - RadiusY,
317 RadiusX*2, // Width
318 RadiusY*2, // Height
319 &tmpFillBrushObj);
320 BRUSH_UnlockBrush(pFillBrushObj);
321 }
322
323 if (ret)
324 ret = IntDrawEllipse( dc,
325 CenterX - RadiusX,
326 CenterY - RadiusY,
327 RadiusX*2, // Width
328 RadiusY*2, // Height
329 pbrush);
330
331 pbrush->ptPenWidth.x = PenOrigWidth;
332 PEN_UnlockPen(pbrush);
333 DC_UnlockDc(dc);
334 DPRINT("Ellipse Exit.\n");
335 return ret;
336 }
337
338 #if 0
339
340 //When the fill mode is ALTERNATE, GDI fills the area between odd-numbered and
341 //even-numbered polygon sides on each scan line. That is, GDI fills the area between the
342 //first and second side, between the third and fourth side, and so on.
343
344 //WINDING Selects winding mode (fills any region with a nonzero winding value).
345 //When the fill mode is WINDING, GDI fills any region that has a nonzero winding value.
346 //This value is defined as the number of times a pen used to draw the polygon would go around the region.
347 //The direction of each edge of the polygon is important.
348
349 extern BOOL FillPolygon(PDC dc,
350 SURFOBJ *SurfObj,
351 PBRUSHOBJ BrushObj,
352 MIX RopMode,
353 CONST PPOINT Points,
354 int Count,
355 RECTL BoundRect);
356
357 #endif
358
359
360 ULONG_PTR
361 APIENTRY
362 NtGdiPolyPolyDraw( IN HDC hDC,
363 IN PPOINT UnsafePoints,
364 IN PULONG UnsafeCounts,
365 IN ULONG Count,
366 IN INT iFunc )
367 {
368 DC *dc;
369 PVOID pTemp;
370 LPPOINT SafePoints;
371 PULONG SafeCounts;
372 NTSTATUS Status = STATUS_SUCCESS;
373 BOOL Ret = TRUE;
374 INT nPoints = 0, nMaxPoints = 0, nInvalid = 0, i;
375
376 if (!UnsafePoints || !UnsafeCounts ||
377 Count == 0 || iFunc == 0 || iFunc > GdiPolyPolyRgn)
378 {
379 /* Windows doesn't set last error */
380 return FALSE;
381 }
382
383 _SEH2_TRY
384 {
385 ProbeForRead(UnsafePoints, Count * sizeof(POINT), 1);
386 ProbeForRead(UnsafeCounts, Count * sizeof(ULONG), 1);
387
388 /* Count points and validate poligons */
389 for (i = 0; i < Count; i++)
390 {
391 if (UnsafeCounts[i] < 2)
392 {
393 nInvalid++;
394 }
395 nPoints += UnsafeCounts[i];
396 nMaxPoints = max(nMaxPoints, UnsafeCounts[i]);
397 }
398 }
399 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
400 {
401 Status = _SEH2_GetExceptionCode();
402 }
403 _SEH2_END;
404
405 if (!NT_SUCCESS(Status))
406 {
407 /* Windows doesn't set last error */
408 return FALSE;
409 }
410
411 if (nPoints == 0 || nPoints < nMaxPoints)
412 {
413 /* If all polygon counts are zero, or we have overflow,
414 return without setting a last error code. */
415 return FALSE;
416 }
417
418 if (nInvalid != 0)
419 {
420 /* If at least one poly count is 0 or 1, fail */
421 SetLastWin32Error(ERROR_INVALID_PARAMETER);
422 return FALSE;
423 }
424
425 /* Allocate one buffer for both counts and points */
426 pTemp = ExAllocatePoolWithTag(PagedPool,
427 Count * sizeof(ULONG) + nPoints * sizeof(POINT),
428 TAG_SHAPE);
429 if (!pTemp)
430 {
431 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
432 return FALSE;
433 }
434
435 SafeCounts = pTemp;
436 SafePoints = (PVOID)(SafeCounts + Count);
437
438 _SEH2_TRY
439 {
440 /* Pointers already probed! */
441 RtlCopyMemory(SafeCounts, UnsafeCounts, Count * sizeof(ULONG));
442 RtlCopyMemory(SafePoints, UnsafePoints, nPoints * sizeof(POINT));
443 }
444 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
445 {
446 Status = _SEH2_GetExceptionCode();
447 }
448 _SEH2_END;
449
450 if (!NT_SUCCESS(Status))
451 {
452 ExFreePoolWithTag(pTemp, TAG_SHAPE);
453 return FALSE;
454 }
455
456 /* Special handling for GdiPolyPolyRgn */
457 if (iFunc == GdiPolyPolyRgn)
458 {
459 HRGN hRgn;
460 hRgn = IntCreatePolyPolygonRgn(SafePoints, SafeCounts, Count, (INT_PTR)hDC);
461 ExFreePoolWithTag(pTemp, TAG_SHAPE);
462 return (ULONG_PTR)hRgn;
463 }
464
465 dc = DC_LockDc(hDC);
466 if (!dc)
467 {
468 SetLastWin32Error(ERROR_INVALID_HANDLE);
469 ExFreePool(pTemp);
470 return FALSE;
471 }
472
473 if (dc->dctype == DC_TYPE_INFO)
474 {
475 DC_UnlockDc(dc);
476 ExFreePool(pTemp);
477 /* Yes, Windows really returns TRUE in this case */
478 return TRUE;
479 }
480
481 DC_vPrepareDCsForBlit(dc, dc->rosdc.CombinedClip->rclBounds,
482 NULL, dc->rosdc.CombinedClip->rclBounds);
483
484 if (dc->pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
485 DC_vUpdateFillBrush(dc);
486
487 if (dc->pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
488 DC_vUpdateLineBrush(dc);
489
490 /* Perform the actual work */
491 switch (iFunc)
492 {
493 case GdiPolyPolygon:
494 Ret = IntGdiPolyPolygon(dc, SafePoints, SafeCounts, Count);
495 break;
496 case GdiPolyPolyLine:
497 Ret = IntGdiPolyPolyline(dc, SafePoints, SafeCounts, Count);
498 break;
499 case GdiPolyBezier:
500 Ret = IntGdiPolyBezier(dc, SafePoints, *SafeCounts);
501 break;
502 case GdiPolyLineTo:
503 Ret = IntGdiPolylineTo(dc, SafePoints, *SafeCounts);
504 break;
505 case GdiPolyBezierTo:
506 Ret = IntGdiPolyBezierTo(dc, SafePoints, *SafeCounts);
507 break;
508 default:
509 SetLastWin32Error(ERROR_INVALID_PARAMETER);
510 Ret = FALSE;
511 }
512
513 /* Cleanup and return */
514 DC_vFinishBlit(dc, NULL);
515 DC_UnlockDc(dc);
516 ExFreePool(pTemp);
517
518 return (ULONG_PTR)Ret;
519 }
520
521
522 BOOL
523 FASTCALL
524 IntRectangle(PDC dc,
525 int LeftRect,
526 int TopRect,
527 int RightRect,
528 int BottomRect)
529 {
530 SURFACE *psurf = NULL;
531 PBRUSH pbrLine, pbrFill;
532 BOOL ret = FALSE; // default to failure
533 RECTL DestRect;
534 MIX Mix;
535 PDC_ATTR pdcattr;
536 POINTL BrushOrigin;
537
538 ASSERT ( dc ); // caller's responsibility to set this up
539
540 pdcattr = dc->pdcattr;
541
542 // Rectangle Path only.
543 if ( PATH_IsPathOpen(dc->dclevel) )
544 {
545 return PATH_Rectangle ( dc, LeftRect, TopRect, RightRect, BottomRect );
546 }
547
548 DestRect.left = LeftRect;
549 DestRect.right = RightRect;
550 DestRect.top = TopRect;
551 DestRect.bottom = BottomRect;
552
553 IntLPtoDP(dc, (LPPOINT)&DestRect, 2);
554
555 DestRect.left += dc->ptlDCOrig.x;
556 DestRect.right += dc->ptlDCOrig.x;
557 DestRect.top += dc->ptlDCOrig.y;
558 DestRect.bottom += dc->ptlDCOrig.y;
559
560 /* In GM_COMPATIBLE, don't include bottom and right edges */
561 if (pdcattr->iGraphicsMode == GM_COMPATIBLE)
562 {
563 DestRect.right--;
564 DestRect.bottom--;
565 }
566
567 DC_vPrepareDCsForBlit(dc, DestRect, NULL, DestRect);
568
569 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
570 DC_vUpdateFillBrush(dc);
571
572 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
573 DC_vUpdateLineBrush(dc);
574
575 pbrFill = dc->dclevel.pbrFill;
576 pbrLine = dc->dclevel.pbrLine;
577 if (!pbrLine)
578 {
579 ret = FALSE;
580 goto cleanup;
581 }
582
583 psurf = dc->dclevel.pSurface;
584 if (!psurf)
585 {
586 ret = FALSE;
587 goto cleanup;
588 }
589
590 if (pbrFill)
591 {
592 if (!(pbrFill->flAttrs & GDIBRUSH_IS_NULL))
593 {
594 BrushOrigin = *((PPOINTL)&pbrFill->ptOrigin);
595 BrushOrigin.x += dc->ptlDCOrig.x;
596 BrushOrigin.y += dc->ptlDCOrig.y;
597 ret = IntEngBitBlt(&psurf->SurfObj,
598 NULL,
599 NULL,
600 dc->rosdc.CombinedClip,
601 NULL,
602 &DestRect,
603 NULL,
604 NULL,
605 &dc->eboFill.BrushObject,
606 &BrushOrigin,
607 ROP3_TO_ROP4(PATCOPY));
608 }
609 }
610
611 // Draw the rectangle with the current pen
612
613 ret = TRUE; // change default to success
614
615 if (!(pbrLine->flAttrs & GDIBRUSH_IS_NULL))
616 {
617 Mix = ROP2_TO_MIX(pdcattr->jROP2);
618 ret = ret && IntEngLineTo(&psurf->SurfObj,
619 dc->rosdc.CombinedClip,
620 &dc->eboLine.BrushObject,
621 DestRect.left, DestRect.top, DestRect.right, DestRect.top,
622 &DestRect, // Bounding rectangle
623 Mix);
624
625 ret = ret && IntEngLineTo(&psurf->SurfObj,
626 dc->rosdc.CombinedClip,
627 &dc->eboLine.BrushObject,
628 DestRect.right, DestRect.top, DestRect.right, DestRect.bottom,
629 &DestRect, // Bounding rectangle
630 Mix);
631
632 ret = ret && IntEngLineTo(&psurf->SurfObj,
633 dc->rosdc.CombinedClip,
634 &dc->eboLine.BrushObject,
635 DestRect.right, DestRect.bottom, DestRect.left, DestRect.bottom,
636 &DestRect, // Bounding rectangle
637 Mix);
638
639 ret = ret && IntEngLineTo(&psurf->SurfObj,
640 dc->rosdc.CombinedClip,
641 &dc->eboLine.BrushObject,
642 DestRect.left, DestRect.bottom, DestRect.left, DestRect.top,
643 &DestRect, // Bounding rectangle
644 Mix);
645 }
646
647 cleanup:
648 DC_vFinishBlit(dc, NULL);
649
650 /* Move current position in DC?
651 MSDN: The current position is neither used nor updated by Rectangle. */
652
653 return ret;
654 }
655
656 BOOL
657 APIENTRY
658 NtGdiRectangle(HDC hDC,
659 int LeftRect,
660 int TopRect,
661 int RightRect,
662 int BottomRect)
663 {
664 DC *dc;
665 BOOL ret; // default to failure
666
667 dc = DC_LockDc(hDC);
668 if (!dc)
669 {
670 SetLastWin32Error(ERROR_INVALID_HANDLE);
671 return FALSE;
672 }
673 if (dc->dctype == DC_TYPE_INFO)
674 {
675 DC_UnlockDc(dc);
676 /* Yes, Windows really returns TRUE in this case */
677 return TRUE;
678 }
679
680 /* Do we rotate or shear? */
681 if (!(dc->dclevel.mxWorldToDevice.flAccel & MX_SCALE))
682 {
683 POINTL DestCoords[4];
684 ULONG PolyCounts = 4;
685
686 DestCoords[0].x = DestCoords[3].x = LeftRect;
687 DestCoords[0].y = DestCoords[1].y = TopRect;
688 DestCoords[1].x = DestCoords[2].x = RightRect;
689 DestCoords[2].y = DestCoords[3].y = BottomRect;
690 // Use IntGdiPolyPolygon so to support PATH.
691 ret = IntGdiPolyPolygon(dc, DestCoords, &PolyCounts, 1);
692 }
693 else
694 {
695 ret = IntRectangle(dc, LeftRect, TopRect, RightRect, BottomRect );
696 }
697
698 DC_UnlockDc(dc);
699
700 return ret;
701 }
702
703
704 BOOL
705 FASTCALL
706 IntRoundRect(
707 PDC dc,
708 int Left,
709 int Top,
710 int Right,
711 int Bottom,
712 int xCurveDiameter,
713 int yCurveDiameter)
714 {
715 PDC_ATTR pdcattr;
716 PBRUSH pbrushLine, pbrushFill;
717 RECTL RectBounds;
718 LONG PenWidth, PenOrigWidth;
719 BOOL ret = TRUE; // default to success
720 BRUSH brushTemp;
721
722 ASSERT ( dc ); // caller's responsibility to set this up
723
724 if ( PATH_IsPathOpen(dc->dclevel) )
725 return PATH_RoundRect ( dc, Left, Top, Right, Bottom,
726 xCurveDiameter, yCurveDiameter );
727
728 if ((Left == Right) || (Top == Bottom)) return TRUE;
729
730 xCurveDiameter = max(abs( xCurveDiameter ), 1);
731 yCurveDiameter = max(abs( yCurveDiameter ), 1);
732
733 if (Right < Left)
734 {
735 INT tmp = Right; Right = Left; Left = tmp;
736 }
737 if (Bottom < Top)
738 {
739 INT tmp = Bottom; Bottom = Top; Top = tmp;
740 }
741
742 pdcattr = dc->pdcattr;
743
744 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
745 DC_vUpdateFillBrush(dc);
746
747 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
748 DC_vUpdateLineBrush(dc);
749
750 pbrushLine = PEN_LockPen(pdcattr->hpen);
751 if (!pbrushLine)
752 {
753 /* Nothing to do, as we don't have a bitmap */
754 SetLastWin32Error(ERROR_INTERNAL_ERROR);
755 return FALSE;
756 }
757
758 PenOrigWidth = PenWidth = pbrushLine->ptPenWidth.x;
759 if (pbrushLine->ulPenStyle == PS_NULL) PenWidth = 0;
760
761 if (pbrushLine->ulPenStyle == PS_INSIDEFRAME)
762 {
763 if (2*PenWidth > (Right - Left)) PenWidth = (Right -Left + 1)/2;
764 if (2*PenWidth > (Bottom - Top)) PenWidth = (Bottom -Top + 1)/2;
765 Left += PenWidth / 2;
766 Right -= (PenWidth - 1) / 2;
767 Top += PenWidth / 2;
768 Bottom -= (PenWidth - 1) / 2;
769 }
770
771 if (!PenWidth) PenWidth = 1;
772 pbrushLine->ptPenWidth.x = PenWidth;
773
774 RectBounds.left = Left;
775 RectBounds.top = Top;
776 RectBounds.right = Right;
777 RectBounds.bottom = Bottom;
778
779 IntLPtoDP(dc, (LPPOINT)&RectBounds, 2);
780
781 RectBounds.left += dc->ptlDCOrig.x;
782 RectBounds.top += dc->ptlDCOrig.y;
783 RectBounds.right += dc->ptlDCOrig.x;
784 RectBounds.bottom += dc->ptlDCOrig.y;
785
786 pbrushFill = BRUSH_LockBrush(pdcattr->hbrush);
787 if (NULL == pbrushFill)
788 {
789 DPRINT1("FillRound Fail\n");
790 SetLastWin32Error(ERROR_INTERNAL_ERROR);
791 ret = FALSE;
792 }
793 else
794 {
795 RtlCopyMemory(&brushTemp, pbrushFill, sizeof(brushTemp));
796 brushTemp.ptOrigin.x += RectBounds.left - Left;
797 brushTemp.ptOrigin.y += RectBounds.top - Top;
798 ret = IntFillRoundRect( dc,
799 RectBounds.left,
800 RectBounds.top,
801 RectBounds.right,
802 RectBounds.bottom,
803 xCurveDiameter,
804 yCurveDiameter,
805 &brushTemp);
806 BRUSH_UnlockBrush(pbrushFill);
807 }
808
809 if (ret)
810 ret = IntDrawRoundRect( dc,
811 RectBounds.left,
812 RectBounds.top,
813 RectBounds.right,
814 RectBounds.bottom,
815 xCurveDiameter,
816 yCurveDiameter,
817 pbrushLine);
818
819 pbrushLine->ptPenWidth.x = PenOrigWidth;
820 PEN_UnlockPen(pbrushLine);
821 return ret;
822 }
823
824 BOOL
825 APIENTRY
826 NtGdiRoundRect(
827 HDC hDC,
828 int LeftRect,
829 int TopRect,
830 int RightRect,
831 int BottomRect,
832 int Width,
833 int Height)
834 {
835 DC *dc = DC_LockDc(hDC);
836 BOOL ret = FALSE; /* default to failure */
837
838 DPRINT("NtGdiRoundRect(0x%x,%i,%i,%i,%i,%i,%i)\n",hDC,LeftRect,TopRect,RightRect,BottomRect,Width,Height);
839 if ( !dc )
840 {
841 DPRINT1("NtGdiRoundRect() - hDC is invalid\n");
842 SetLastWin32Error(ERROR_INVALID_HANDLE);
843 }
844 else if (dc->dctype == DC_TYPE_INFO)
845 {
846 DC_UnlockDc(dc);
847 /* Yes, Windows really returns TRUE in this case */
848 ret = TRUE;
849 }
850 else
851 {
852 ret = IntRoundRect ( dc, LeftRect, TopRect, RightRect, BottomRect, Width, Height );
853 DC_UnlockDc ( dc );
854 }
855
856 return ret;
857 }
858
859 BOOL
860 NTAPI
861 GreGradientFill(
862 HDC hdc,
863 PTRIVERTEX pVertex,
864 ULONG nVertex,
865 PVOID pMesh,
866 ULONG nMesh,
867 ULONG ulMode)
868 {
869 PDC pdc;
870 SURFACE *psurf;
871 EXLATEOBJ exlo;
872 RECTL rclExtent;
873 POINTL ptlDitherOrg;
874 ULONG i;
875 BOOL bRet;
876
877 /* check parameters */
878 if (ulMode & GRADIENT_FILL_TRIANGLE)
879 {
880 PGRADIENT_TRIANGLE pTriangle = (PGRADIENT_TRIANGLE)pMesh;
881
882 for (i = 0; i < nMesh; i++, pTriangle++)
883 {
884 if (pTriangle->Vertex1 >= nVertex ||
885 pTriangle->Vertex2 >= nVertex ||
886 pTriangle->Vertex3 >= nVertex)
887 {
888 SetLastWin32Error(ERROR_INVALID_PARAMETER);
889 return FALSE;
890 }
891 }
892 }
893 else
894 {
895 PGRADIENT_RECT pRect = (PGRADIENT_RECT)pMesh;
896 for (i = 0; i < nMesh; i++, pRect++)
897 {
898 if (pRect->UpperLeft >= nVertex || pRect->LowerRight >= nVertex)
899 {
900 SetLastWin32Error(ERROR_INVALID_PARAMETER);
901 return FALSE;
902 }
903 }
904 }
905
906 /* Lock the output DC */
907 pdc = DC_LockDc(hdc);
908 if(!pdc)
909 {
910 SetLastWin32Error(ERROR_INVALID_HANDLE);
911 return FALSE;
912 }
913
914 if(pdc->dctype == DC_TYPE_INFO)
915 {
916 DC_UnlockDc(pdc);
917 /* Yes, Windows really returns TRUE in this case */
918 return TRUE;
919 }
920
921 psurf = pdc->dclevel.pSurface;
922 if(!psurf)
923 {
924 /* Memory DC with no surface selected */
925 DC_UnlockDc(pdc);
926 return TRUE; //CHECKME
927 }
928
929 /* calculate extent */
930 rclExtent.left = rclExtent.right = pVertex->x;
931 rclExtent.top = rclExtent.bottom = pVertex->y;
932 for (i = 0; i < nVertex; i++)
933 {
934 rclExtent.left = min(rclExtent.left, (pVertex + i)->x);
935 rclExtent.right = max(rclExtent.right, (pVertex + i)->x);
936 rclExtent.top = min(rclExtent.top, (pVertex + i)->y);
937 rclExtent.bottom = max(rclExtent.bottom, (pVertex + i)->y);
938 }
939 IntLPtoDP(pdc, (LPPOINT)&rclExtent, 2);
940
941 rclExtent.left += pdc->ptlDCOrig.x;
942 rclExtent.right += pdc->ptlDCOrig.x;
943 rclExtent.top += pdc->ptlDCOrig.y;
944 rclExtent.bottom += pdc->ptlDCOrig.y;
945
946 ptlDitherOrg.x = ptlDitherOrg.y = 0;
947 IntLPtoDP(pdc, (LPPOINT)&ptlDitherOrg, 1);
948
949 ptlDitherOrg.x += pdc->ptlDCOrig.x;
950 ptlDitherOrg.y += pdc->ptlDCOrig.y;
951
952 EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurf->ppal, 0, 0, 0);
953
954 ASSERT(pdc->rosdc.CombinedClip);
955
956 DC_vPrepareDCsForBlit(pdc, rclExtent, NULL, rclExtent);
957
958 bRet = IntEngGradientFill(&psurf->SurfObj,
959 pdc->rosdc.CombinedClip,
960 &exlo.xlo,
961 pVertex,
962 nVertex,
963 pMesh,
964 nMesh,
965 &rclExtent,
966 &ptlDitherOrg,
967 ulMode);
968
969 EXLATEOBJ_vCleanup(&exlo);
970 DC_vFinishBlit(pdc, NULL);
971 DC_UnlockDc(pdc);
972
973 return bRet;
974 }
975
976 BOOL
977 APIENTRY
978 NtGdiGradientFill(
979 HDC hdc,
980 PTRIVERTEX pVertex,
981 ULONG nVertex,
982 PVOID pMesh,
983 ULONG nMesh,
984 ULONG ulMode)
985 {
986 BOOL bRet;
987 PTRIVERTEX SafeVertex;
988 PVOID SafeMesh;
989 ULONG cbVertex, cbMesh;
990
991 /* Validate parameters */
992 if (!pVertex || !nVertex || !pMesh || !nMesh)
993 {
994 SetLastWin32Error(ERROR_INVALID_PARAMETER);
995 return FALSE;
996 }
997
998 switch (ulMode)
999 {
1000 case GRADIENT_FILL_RECT_H:
1001 case GRADIENT_FILL_RECT_V:
1002 cbMesh = nMesh * sizeof(GRADIENT_RECT);
1003 break;
1004 case GRADIENT_FILL_TRIANGLE:
1005 cbMesh = nMesh * sizeof(GRADIENT_TRIANGLE);
1006 break;
1007 default:
1008 SetLastWin32Error(ERROR_INVALID_PARAMETER);
1009 return FALSE;
1010 }
1011
1012 cbVertex = nVertex * sizeof(TRIVERTEX) ;
1013 if(cbVertex + cbMesh <= cbVertex)
1014 {
1015 /* Overflow */
1016 return FALSE ;
1017 }
1018
1019 /* Allocate a kernel mode buffer */
1020 SafeVertex = ExAllocatePoolWithTag(PagedPool, cbVertex + cbMesh, TAG_SHAPE);
1021 if(!SafeVertex)
1022 {
1023 SetLastWin32Error(ERROR_NOT_ENOUGH_MEMORY);
1024 return FALSE;
1025 }
1026
1027 SafeMesh = (PVOID)((ULONG_PTR)SafeVertex + cbVertex);
1028
1029 /* Copy the parameters to kernel mode */
1030 _SEH2_TRY
1031 {
1032 ProbeForRead(pVertex, cbVertex, 1);
1033 ProbeForRead(pMesh, cbMesh, 1);
1034 RtlCopyMemory(SafeVertex, pVertex, cbVertex);
1035 RtlCopyMemory(SafeMesh, pMesh, cbMesh);
1036 }
1037 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
1038 {
1039 ExFreePoolWithTag(SafeVertex, TAG_SHAPE);
1040 SetLastNtError(_SEH2_GetExceptionCode());
1041 _SEH2_YIELD(return FALSE;)
1042 }
1043 _SEH2_END;
1044
1045 /* Call the internal function */
1046 bRet = GreGradientFill(hdc, SafeVertex, nVertex, SafeMesh, nMesh, ulMode);
1047
1048 /* Cleanup and return result */
1049 ExFreePoolWithTag(SafeVertex, TAG_SHAPE);
1050 return bRet;
1051 }
1052
1053 BOOL APIENTRY
1054 NtGdiExtFloodFill(
1055 HDC hDC,
1056 INT XStart,
1057 INT YStart,
1058 COLORREF Color,
1059 UINT FillType)
1060 {
1061 PDC dc;
1062 PDC_ATTR pdcattr;
1063 SURFACE *psurf = NULL;
1064 EXLATEOBJ exlo;
1065 BOOL Ret = FALSE;
1066 RECTL DestRect;
1067 POINTL Pt;
1068 ULONG ConvColor;
1069
1070 dc = DC_LockDc(hDC);
1071 if (!dc)
1072 {
1073 SetLastWin32Error(ERROR_INVALID_HANDLE);
1074 return FALSE;
1075 }
1076 if (dc->dctype == DC_TYPE_INFO)
1077 {
1078 DC_UnlockDc(dc);
1079 /* Yes, Windows really returns TRUE in this case */
1080 return TRUE;
1081 }
1082
1083 pdcattr = dc->pdcattr;
1084
1085 if (pdcattr->ulDirty_ & (DIRTY_FILL | DC_BRUSH_DIRTY))
1086 DC_vUpdateFillBrush(dc);
1087
1088 if (pdcattr->ulDirty_ & (DIRTY_LINE | DC_PEN_DIRTY))
1089 DC_vUpdateLineBrush(dc);
1090
1091 Pt.x = XStart;
1092 Pt.y = YStart;
1093 IntLPtoDP(dc, (LPPOINT)&Pt, 1);
1094
1095 Ret = NtGdiPtInRegion(dc->rosdc.hGCClipRgn, Pt.x, Pt.y);
1096 if (Ret)
1097 IntGdiGetRgnBox(dc->rosdc.hGCClipRgn,(LPRECT)&DestRect);
1098 else
1099 goto cleanup;
1100
1101 psurf = dc->dclevel.pSurface;
1102 if (!psurf)
1103 {
1104 Ret = FALSE;
1105 goto cleanup;
1106 }
1107
1108 EXLATEOBJ_vInitialize(&exlo, &gpalRGB, psurf->ppal, 0, 0xffffff, 0);
1109
1110 /* Only solid fills supported for now
1111 * How to support pattern brushes and non standard surfaces (not offering dib functions):
1112 * Version a (most likely slow): call DrvPatBlt for every pixel
1113 * Version b: create a flood mask and let MaskBlt blit a masked brush */
1114 ConvColor = XLATEOBJ_iXlate(&exlo.xlo, Color);
1115 Ret = DIB_XXBPP_FloodFillSolid(&psurf->SurfObj, &dc->eboFill.BrushObject, &DestRect, &Pt, ConvColor, FillType);
1116
1117 EXLATEOBJ_vCleanup(&exlo);
1118
1119 cleanup:
1120 DC_UnlockDc(dc);
1121 return Ret;
1122 }
1123
1124 /* EOF */