2 * Copyright (C) 2007 Google (Evan Stade)
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/unicode.h"
39 #include "gdiplus_private.h"
40 #include "wine/debug.h"
41 #include "wine/list.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
45 /* looks-right constants */
46 #define ANCHOR_WIDTH (2.0)
47 #define MAX_ITERS (50)
49 /* Converts angle (in degrees) to x/y coordinates */
50 static void deg2xy(REAL angle, REAL x_0, REAL y_0, REAL *x, REAL *y)
52 REAL radAngle, hypotenuse;
54 radAngle = deg2rad(angle);
55 hypotenuse = 50.0; /* arbitrary */
57 *x = x_0 + cos(radAngle) * hypotenuse;
58 *y = y_0 + sin(radAngle) * hypotenuse;
61 /* Converts from gdiplus path point type to gdi path point type. */
62 static BYTE convert_path_point_type(BYTE type)
66 switch(type & PathPointTypePathTypeMask){
67 case PathPointTypeBezier:
70 case PathPointTypeLine:
73 case PathPointTypeStart:
77 ERR("Bad point type\n");
81 if(type & PathPointTypeCloseSubpath)
82 ret |= PT_CLOSEFIGURE;
87 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
91 INT save_state = SaveDC(graphics->hdc), i, numdashes;
93 DWORD dash_array[MAX_DASHLEN];
95 EndPath(graphics->hdc);
97 if(pen->unit == UnitPixel){
101 /* Get an estimate for the amount the pen width is affected by the world
102 * transform. (This is similar to what some of the wine drivers do.) */
107 GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
108 width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
109 (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
111 width *= pen->width * convert_unit(graphics->hdc,
112 pen->unit == UnitWorld ? graphics->unit : pen->unit);
115 if(pen->dash == DashStyleCustom){
116 numdashes = min(pen->numdashes, MAX_DASHLEN);
118 TRACE("dashes are: ");
119 for(i = 0; i < numdashes; i++){
120 dash_array[i] = roundr(width * pen->dashes[i]);
121 TRACE("%d, ", dash_array[i]);
123 TRACE("\n and the pen style is %x\n", pen->style);
125 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
126 numdashes, dash_array);
129 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
131 SelectObject(graphics->hdc, gdipen);
136 static void restore_dc(GpGraphics *graphics, INT state)
138 DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
139 RestoreDC(graphics->hdc, state);
142 /* This helper applies all the changes that the points listed in ptf need in
143 * order to be drawn on the device context. In the end, this should include at
145 * -scaling by page unit
146 * -applying world transformation
147 * -converting from float to int
148 * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
149 * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
150 * gdi to draw, and these functions would irreparably mess with line widths.
152 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
153 GpPointF *ptf, INT count)
159 unitscale = convert_unit(graphics->hdc, graphics->unit);
161 /* apply page scale */
162 if(graphics->unit != UnitDisplay)
163 unitscale *= graphics->scale;
165 GdipCloneMatrix(graphics->worldtrans, &matrix);
166 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
167 GdipTransformMatrixPoints(matrix, ptf, count);
168 GdipDeleteMatrix(matrix);
170 for(i = 0; i < count; i++){
171 pti[i].x = roundr(ptf[i].X);
172 pti[i].y = roundr(ptf[i].Y);
176 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
180 for (i=0xff; i<=0xff0000; i = i << 8)
181 result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
185 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
189 /* clamp to between 0.0 and 1.0, using the wrap mode */
190 if (brush->wrap == WrapModeTile)
192 position = fmodf(position, 1.0f);
193 if (position < 0.0f) position += 1.0f;
195 else /* WrapModeFlip* */
197 position = fmodf(position, 2.0f);
198 if (position < 0.0f) position += 2.0f;
199 if (position > 1.0f) position = 2.0f - position;
202 if (brush->blendcount == 1)
207 REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
210 /* locate the blend positions surrounding this position */
211 while (position > brush->blendpos[i])
214 /* interpolate between the blend positions */
215 left_blendpos = brush->blendpos[i-1];
216 left_blendfac = brush->blendfac[i-1];
217 right_blendpos = brush->blendpos[i];
218 right_blendfac = brush->blendfac[i];
219 range = right_blendpos - left_blendpos;
220 blendfac = (left_blendfac * (right_blendpos - position) +
221 right_blendfac * (position - left_blendpos)) / range;
223 return blend_colors(brush->startcolor, brush->endcolor, blendfac);
226 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
230 case BrushTypeLinearGradient:
232 GpLineGradient *line = (GpLineGradient*)brush;
235 SelectClipPath(graphics->hdc, RGN_AND);
236 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
238 GpPointF endpointsf[2];
242 SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
244 endpointsf[0] = line->startpoint;
245 endpointsf[1] = line->endpoint;
246 transform_and_round_points(graphics, endpointsi, endpointsf, 2);
248 if (abs(endpointsi[0].x-endpointsi[1].x) > abs(endpointsi[0].y-endpointsi[1].y))
250 /* vertical-ish gradient */
251 int startx, endx; /* x co-ordinates of endpoints shifted to intersect the top of the visible rectangle */
252 int startbottomx; /* x co-ordinate of start point shifted to intersect the bottom of the visible rectangle */
255 HBRUSH hbrush, hprevbrush;
256 int leftx, rightx; /* x co-ordinates where the leftmost and rightmost gradient lines hit the top of the visible rectangle */
258 int tilt; /* horizontal distance covered by a gradient line */
260 startx = roundr((rc.top - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
261 endx = roundr((rc.top - endpointsf[1].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[1].X);
262 width = endx - startx;
263 startbottomx = roundr((rc.bottom - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
264 tilt = startx - startbottomx;
266 if (startx >= startbottomx)
269 rightx = rc.right + tilt;
273 leftx = rc.left + tilt;
277 poly[0].y = rc.bottom;
280 poly[3].y = rc.bottom;
282 for (x=leftx; x<=rightx; x++)
284 ARGB argb = blend_line_gradient(line, (x-startx)/(REAL)width);
285 col = ARGB2COLORREF(argb);
286 hbrush = CreateSolidBrush(col);
287 hprevbrush = SelectObject(graphics->hdc, hbrush);
288 poly[0].x = x - tilt - 1;
291 poly[3].x = x - tilt;
292 Polygon(graphics->hdc, poly, 4);
293 SelectObject(graphics->hdc, hprevbrush);
294 DeleteObject(hbrush);
297 else if (endpointsi[0].y != endpointsi[1].y)
299 /* horizontal-ish gradient */
300 int starty, endy; /* y co-ordinates of endpoints shifted to intersect the left of the visible rectangle */
301 int startrighty; /* y co-ordinate of start point shifted to intersect the right of the visible rectangle */
304 HBRUSH hbrush, hprevbrush;
305 int topy, bottomy; /* y co-ordinates where the topmost and bottommost gradient lines hit the left of the visible rectangle */
307 int tilt; /* vertical distance covered by a gradient line */
309 starty = roundr((rc.left - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
310 endy = roundr((rc.left - endpointsf[1].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[1].Y);
311 height = endy - starty;
312 startrighty = roundr((rc.right - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
313 tilt = starty - startrighty;
315 if (starty >= startrighty)
318 bottomy = rc.bottom + tilt;
322 topy = rc.top + tilt;
326 poly[0].x = rc.right;
329 poly[3].x = rc.right;
331 for (y=topy; y<=bottomy; y++)
333 ARGB argb = blend_line_gradient(line, (y-starty)/(REAL)height);
334 col = ARGB2COLORREF(argb);
335 hbrush = CreateSolidBrush(col);
336 hprevbrush = SelectObject(graphics->hdc, hbrush);
337 poly[0].y = y - tilt - 1;
340 poly[3].y = y - tilt;
341 Polygon(graphics->hdc, poly, 4);
342 SelectObject(graphics->hdc, hprevbrush);
343 DeleteObject(hbrush);
346 /* else startpoint == endpoint */
350 case BrushTypeSolidColor:
352 GpSolidFill *fill = (GpSolidFill*)brush;
356 /* partially transparent fill */
358 SelectClipPath(graphics->hdc, RGN_AND);
359 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
361 HDC hdc = CreateCompatibleDC(NULL);
367 oldbmp = SelectObject(hdc, fill->bmp);
369 bf.BlendOp = AC_SRC_OVER;
371 bf.SourceConstantAlpha = 255;
372 bf.AlphaFormat = AC_SRC_ALPHA;
374 GdiAlphaBlend(graphics->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdc, 0, 0, 1, 1, bf);
376 SelectObject(hdc, oldbmp);
382 /* else fall through */
385 SelectObject(graphics->hdc, brush->gdibrush);
386 FillPath(graphics->hdc);
391 /* GdipDrawPie/GdipFillPie helper function */
392 static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
393 REAL height, REAL startAngle, REAL sweepAngle)
400 ptf[1].X = x + width;
401 ptf[1].Y = y + height;
403 deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
404 deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
406 transform_and_round_points(graphics, pti, ptf, 4);
408 Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
409 pti[2].y, pti[3].x, pti[3].y);
412 /* Draws the linecap the specified color and size on the hdc. The linecap is in
413 * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
414 * should not be called on an hdc that has a path you care about. */
415 static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
416 const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
418 HGDIOBJ oldbrush = NULL, oldpen = NULL;
419 GpMatrix *matrix = NULL;
422 PointF ptf[4], *custptf = NULL;
423 POINT pt[4], *custpt = NULL;
425 REAL theta, dsmall, dbig, dx, dy = 0.0;
430 if((x1 == x2) && (y1 == y2))
433 theta = gdiplus_atan2(y2 - y1, x2 - x1);
435 customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
437 brush = CreateSolidBrush(color);
438 lb.lbStyle = BS_SOLID;
441 pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
442 PS_JOIN_MITER, 1, &lb, 0,
444 oldbrush = SelectObject(graphics->hdc, brush);
445 oldpen = SelectObject(graphics->hdc, pen);
452 case LineCapSquareAnchor:
453 case LineCapDiamondAnchor:
454 size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
455 if(cap == LineCapDiamondAnchor){
456 dsmall = cos(theta + M_PI_2) * size;
457 dbig = sin(theta + M_PI_2) * size;
460 dsmall = cos(theta + M_PI_4) * size;
461 dbig = sin(theta + M_PI_4) * size;
464 ptf[0].X = x2 - dsmall;
465 ptf[1].X = x2 + dbig;
467 ptf[0].Y = y2 - dbig;
468 ptf[3].Y = y2 + dsmall;
470 ptf[1].Y = y2 - dsmall;
471 ptf[2].Y = y2 + dbig;
473 ptf[3].X = x2 - dbig;
474 ptf[2].X = x2 + dsmall;
476 transform_and_round_points(graphics, pt, ptf, 4);
477 Polygon(graphics->hdc, pt, 4);
480 case LineCapArrowAnchor:
481 size = size * 4.0 / sqrt(3.0);
483 dx = cos(M_PI / 6.0 + theta) * size;
484 dy = sin(M_PI / 6.0 + theta) * size;
489 dx = cos(- M_PI / 6.0 + theta) * size;
490 dy = sin(- M_PI / 6.0 + theta) * size;
498 transform_and_round_points(graphics, pt, ptf, 3);
499 Polygon(graphics->hdc, pt, 3);
502 case LineCapRoundAnchor:
503 dx = dy = ANCHOR_WIDTH * size / 2.0;
510 transform_and_round_points(graphics, pt, ptf, 2);
511 Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
514 case LineCapTriangle:
516 dx = cos(M_PI_2 + theta) * size;
517 dy = sin(M_PI_2 + theta) * size;
524 dx = cos(theta) * size;
525 dy = sin(theta) * size;
530 transform_and_round_points(graphics, pt, ptf, 3);
531 Polygon(graphics->hdc, pt, 3);
535 dx = dy = size / 2.0;
542 dx = -cos(M_PI_2 + theta) * size;
543 dy = -sin(M_PI_2 + theta) * size;
550 transform_and_round_points(graphics, pt, ptf, 4);
551 Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
552 pt[2].y, pt[3].x, pt[3].y);
559 count = custom->pathdata.Count;
560 custptf = GdipAlloc(count * sizeof(PointF));
561 custpt = GdipAlloc(count * sizeof(POINT));
562 tp = GdipAlloc(count);
564 if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
567 memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
569 GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
570 GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
572 GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
573 GdipTransformMatrixPoints(matrix, custptf, count);
575 transform_and_round_points(graphics, custpt, custptf, count);
577 for(i = 0; i < count; i++)
578 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
581 BeginPath(graphics->hdc);
582 PolyDraw(graphics->hdc, custpt, tp, count);
583 EndPath(graphics->hdc);
584 StrokeAndFillPath(graphics->hdc);
587 PolyDraw(graphics->hdc, custpt, tp, count);
593 GdipDeleteMatrix(matrix);
600 SelectObject(graphics->hdc, oldbrush);
601 SelectObject(graphics->hdc, oldpen);
607 /* Shortens the line by the given percent by changing x2, y2.
608 * If percent is > 1.0 then the line will change direction.
609 * If percent is negative it can lengthen the line. */
610 static void shorten_line_percent(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL percent)
612 REAL dist, theta, dx, dy;
614 if((y1 == *y2) && (x1 == *x2))
617 dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
618 theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
619 dx = cos(theta) * dist;
620 dy = sin(theta) * dist;
626 /* Shortens the line by the given amount by changing x2, y2.
627 * If the amount is greater than the distance, the line will become length 0.
628 * If the amount is negative, it can lengthen the line. */
629 static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
631 REAL dx, dy, percent;
635 if(dx == 0 && dy == 0)
638 percent = amt / sqrt(dx * dx + dy * dy);
645 shorten_line_percent(x1, y1, x2, y2, percent);
648 /* Draws lines between the given points, and if caps is true then draws an endcap
649 * at the end of the last line. */
650 static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
651 GDIPCONST GpPointF * pt, INT count, BOOL caps)
654 GpPointF *ptcopy = NULL;
655 GpStatus status = GenericError;
660 pti = GdipAlloc(count * sizeof(POINT));
661 ptcopy = GdipAlloc(count * sizeof(GpPointF));
664 status = OutOfMemory;
668 memcpy(ptcopy, pt, count * sizeof(GpPointF));
671 if(pen->endcap == LineCapArrowAnchor)
672 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
673 &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
674 else if((pen->endcap == LineCapCustom) && pen->customend)
675 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
676 &ptcopy[count-1].X, &ptcopy[count-1].Y,
677 pen->customend->inset * pen->width);
679 if(pen->startcap == LineCapArrowAnchor)
680 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
681 &ptcopy[0].X, &ptcopy[0].Y, pen->width);
682 else if((pen->startcap == LineCapCustom) && pen->customstart)
683 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
684 &ptcopy[0].X, &ptcopy[0].Y,
685 pen->customstart->inset * pen->width);
687 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
688 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
689 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
690 pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
693 transform_and_round_points(graphics, pti, ptcopy, count);
695 if(Polyline(graphics->hdc, pti, count))
705 /* Conducts a linear search to find the bezier points that will back off
706 * the endpoint of the curve by a distance of amt. Linear search works
707 * better than binary in this case because there are multiple solutions,
708 * and binary searches often find a bad one. I don't think this is what
709 * Windows does but short of rendering the bezier without GDI's help it's
710 * the best we can do. If rev then work from the start of the passed points
711 * instead of the end. */
712 static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
715 REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
716 INT i, first = 0, second = 1, third = 2, fourth = 3;
725 origx = pt[fourth].X;
726 origy = pt[fourth].Y;
727 memcpy(origpt, pt, sizeof(GpPointF) * 4);
729 for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
730 /* reset bezier points to original values */
731 memcpy(pt, origpt, sizeof(GpPointF) * 4);
732 /* Perform magic on bezier points. Order is important here.*/
733 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
734 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
735 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
736 shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
737 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
738 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
740 dx = pt[fourth].X - origx;
741 dy = pt[fourth].Y - origy;
743 diff = sqrt(dx * dx + dy * dy);
744 percent += 0.0005 * amt;
748 /* Draws bezier curves between given points, and if caps is true then draws an
749 * endcap at the end of the last line. */
750 static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
751 GDIPCONST GpPointF * pt, INT count, BOOL caps)
755 GpStatus status = GenericError;
760 pti = GdipAlloc(count * sizeof(POINT));
761 ptcopy = GdipAlloc(count * sizeof(GpPointF));
764 status = OutOfMemory;
768 memcpy(ptcopy, pt, count * sizeof(GpPointF));
771 if(pen->endcap == LineCapArrowAnchor)
772 shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
773 else if((pen->endcap == LineCapCustom) && pen->customend)
774 shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
777 if(pen->startcap == LineCapArrowAnchor)
778 shorten_bezier_amt(ptcopy, pen->width, TRUE);
779 else if((pen->startcap == LineCapCustom) && pen->customstart)
780 shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
782 /* the direction of the line cap is parallel to the direction at the
783 * end of the bezier (which, if it has been shortened, is not the same
784 * as the direction from pt[count-2] to pt[count-1]) */
785 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
786 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
787 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
788 pt[count - 1].X, pt[count - 1].Y);
790 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
791 pt[0].X - (ptcopy[0].X - ptcopy[1].X),
792 pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
795 transform_and_round_points(graphics, pti, ptcopy, count);
797 PolyBezier(graphics->hdc, pti, count);
808 /* Draws a combination of bezier curves and lines between points. */
809 static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
810 GDIPCONST BYTE * types, INT count, BOOL caps)
812 POINT *pti = GdipAlloc(count * sizeof(POINT));
813 BYTE *tp = GdipAlloc(count);
814 GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
816 GpStatus status = GenericError;
822 if(!pti || !tp || !ptcopy){
823 status = OutOfMemory;
827 for(i = 1; i < count; i++){
828 if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
829 if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
830 || !(types[i + 1] & PathPointTypeBezier)){
831 ERR("Bad bezier points\n");
838 memcpy(ptcopy, pt, count * sizeof(GpPointF));
840 /* If we are drawing caps, go through the points and adjust them accordingly,
841 * and draw the caps. */
843 switch(types[count - 1] & PathPointTypePathTypeMask){
844 case PathPointTypeBezier:
845 if(pen->endcap == LineCapArrowAnchor)
846 shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
847 else if((pen->endcap == LineCapCustom) && pen->customend)
848 shorten_bezier_amt(&ptcopy[count - 4],
849 pen->width * pen->customend->inset, FALSE);
851 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
852 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
853 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
854 pt[count - 1].X, pt[count - 1].Y);
857 case PathPointTypeLine:
858 if(pen->endcap == LineCapArrowAnchor)
859 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
860 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
862 else if((pen->endcap == LineCapCustom) && pen->customend)
863 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
864 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
865 pen->customend->inset * pen->width);
867 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
868 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
873 ERR("Bad path last point\n");
877 /* Find start of points */
878 for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
879 == PathPointTypeStart); j++);
881 switch(types[j] & PathPointTypePathTypeMask){
882 case PathPointTypeBezier:
883 if(pen->startcap == LineCapArrowAnchor)
884 shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
885 else if((pen->startcap == LineCapCustom) && pen->customstart)
886 shorten_bezier_amt(&ptcopy[j - 1],
887 pen->width * pen->customstart->inset, TRUE);
889 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
890 pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
891 pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
892 pt[j - 1].X, pt[j - 1].Y);
895 case PathPointTypeLine:
896 if(pen->startcap == LineCapArrowAnchor)
897 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
898 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
900 else if((pen->startcap == LineCapCustom) && pen->customstart)
901 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
902 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
903 pen->customstart->inset * pen->width);
905 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
906 pt[j].X, pt[j].Y, pt[j - 1].X,
911 ERR("Bad path points\n");
916 transform_and_round_points(graphics, pti, ptcopy, count);
918 for(i = 0; i < count; i++){
919 tp[i] = convert_path_point_type(types[i]);
922 PolyDraw(graphics->hdc, pti, tp, count);
934 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
938 BeginPath(graphics->hdc);
939 result = draw_poly(graphics, NULL, path->pathdata.Points,
940 path->pathdata.Types, path->pathdata.Count, FALSE);
941 EndPath(graphics->hdc);
945 typedef struct _GraphicsContainerItem {
947 GraphicsContainer contid;
949 SmoothingMode smoothing;
950 CompositingQuality compqual;
951 InterpolationMode interpolation;
952 CompositingMode compmode;
953 TextRenderingHint texthint;
956 PixelOffsetMode pixeloffset;
958 GpMatrix* worldtrans;
960 } GraphicsContainerItem;
962 static GpStatus init_container(GraphicsContainerItem** container,
963 GDIPCONST GpGraphics* graphics){
966 *container = GdipAlloc(sizeof(GraphicsContainerItem));
970 (*container)->contid = graphics->contid + 1;
972 (*container)->smoothing = graphics->smoothing;
973 (*container)->compqual = graphics->compqual;
974 (*container)->interpolation = graphics->interpolation;
975 (*container)->compmode = graphics->compmode;
976 (*container)->texthint = graphics->texthint;
977 (*container)->scale = graphics->scale;
978 (*container)->unit = graphics->unit;
979 (*container)->textcontrast = graphics->textcontrast;
980 (*container)->pixeloffset = graphics->pixeloffset;
982 sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
984 GdipFree(*container);
989 sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
991 GdipDeleteMatrix((*container)->worldtrans);
992 GdipFree(*container);
1000 static void delete_container(GraphicsContainerItem* container){
1001 GdipDeleteMatrix(container->worldtrans);
1002 GdipDeleteRegion(container->clip);
1003 GdipFree(container);
1006 static GpStatus restore_container(GpGraphics* graphics,
1007 GDIPCONST GraphicsContainerItem* container){
1012 sts = GdipCloneMatrix(container->worldtrans, &newTrans);
1016 sts = GdipCloneRegion(container->clip, &newClip);
1018 GdipDeleteMatrix(newTrans);
1022 GdipDeleteMatrix(graphics->worldtrans);
1023 graphics->worldtrans = newTrans;
1025 GdipDeleteRegion(graphics->clip);
1026 graphics->clip = newClip;
1028 graphics->contid = container->contid - 1;
1030 graphics->smoothing = container->smoothing;
1031 graphics->compqual = container->compqual;
1032 graphics->interpolation = container->interpolation;
1033 graphics->compmode = container->compmode;
1034 graphics->texthint = container->texthint;
1035 graphics->scale = container->scale;
1036 graphics->unit = container->unit;
1037 graphics->textcontrast = container->textcontrast;
1038 graphics->pixeloffset = container->pixeloffset;
1043 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
1047 if(graphics->hwnd) {
1048 if(!GetClientRect(graphics->hwnd, &wnd_rect))
1049 return GenericError;
1051 rect->X = wnd_rect.left;
1052 rect->Y = wnd_rect.top;
1053 rect->Width = wnd_rect.right - wnd_rect.left;
1054 rect->Height = wnd_rect.bottom - wnd_rect.top;
1058 rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
1059 rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
1065 /* on success, rgn will contain the region of the graphics object which
1066 * is visible after clipping has been applied */
1067 static GpStatus get_visible_clip_region(GpGraphics *graphics, GpRegion *rgn)
1073 if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
1076 if((stat = GdipCreateRegion(&tmp)) != Ok)
1079 if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
1082 if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
1085 stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
1088 GdipDeleteRegion(tmp);
1092 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
1094 TRACE("(%p, %p)\n", hdc, graphics);
1096 return GdipCreateFromHDC2(hdc, NULL, graphics);
1099 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
1103 TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
1105 if(hDevice != NULL) {
1106 FIXME("Don't know how to handle parameter hDevice\n");
1107 return NotImplemented;
1113 if(graphics == NULL)
1114 return InvalidParameter;
1116 *graphics = GdipAlloc(sizeof(GpGraphics));
1117 if(!*graphics) return OutOfMemory;
1119 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1120 GdipFree(*graphics);
1124 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1125 GdipFree((*graphics)->worldtrans);
1126 GdipFree(*graphics);
1130 (*graphics)->hdc = hdc;
1131 (*graphics)->hwnd = WindowFromDC(hdc);
1132 (*graphics)->owndc = FALSE;
1133 (*graphics)->smoothing = SmoothingModeDefault;
1134 (*graphics)->compqual = CompositingQualityDefault;
1135 (*graphics)->interpolation = InterpolationModeDefault;
1136 (*graphics)->pixeloffset = PixelOffsetModeDefault;
1137 (*graphics)->compmode = CompositingModeSourceOver;
1138 (*graphics)->unit = UnitDisplay;
1139 (*graphics)->scale = 1.0;
1140 (*graphics)->busy = FALSE;
1141 (*graphics)->textcontrast = 4;
1142 list_init(&(*graphics)->containers);
1143 (*graphics)->contid = 0;
1148 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
1153 TRACE("(%p, %p)\n", hwnd, graphics);
1157 if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
1159 ReleaseDC(hwnd, hdc);
1163 (*graphics)->hwnd = hwnd;
1164 (*graphics)->owndc = TRUE;
1169 /* FIXME: no icm handling */
1170 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
1172 TRACE("(%p, %p)\n", hwnd, graphics);
1174 return GdipCreateFromHWND(hwnd, graphics);
1177 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1178 GpMetafile **metafile)
1182 if(!hemf || !metafile)
1183 return InvalidParameter;
1186 FIXME("not implemented\n");
1188 return NotImplemented;
1191 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1192 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1194 IStream *stream = NULL;
1198 GpStatus retval = GenericError;
1200 TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1202 if(!hwmf || !metafile || !placeable)
1203 return InvalidParameter;
1206 read = GetMetaFileBitsEx(hwmf, 0, NULL);
1208 return GenericError;
1209 copy = GdipAlloc(read);
1210 GetMetaFileBitsEx(hwmf, read, copy);
1212 hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1215 read = GetEnhMetaFileBits(hemf, 0, NULL);
1216 copy = GdipAlloc(read);
1217 GetEnhMetaFileBits(hemf, read, copy);
1218 DeleteEnhMetaFile(hemf);
1220 if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
1221 ERR("could not make stream\n");
1226 *metafile = GdipAlloc(sizeof(GpMetafile));
1228 retval = OutOfMemory;
1232 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1233 (LPVOID*) &((*metafile)->image.picture)) != S_OK)
1237 (*metafile)->image.type = ImageTypeMetafile;
1238 (*metafile)->bounds.X = ((REAL) placeable->BoundingBox.Left) / ((REAL) placeable->Inch);
1239 (*metafile)->bounds.Y = ((REAL) placeable->BoundingBox.Right) / ((REAL) placeable->Inch);
1240 (*metafile)->bounds.Width = ((REAL) (placeable->BoundingBox.Right
1241 - placeable->BoundingBox.Left)) / ((REAL) placeable->Inch);
1242 (*metafile)->bounds.Height = ((REAL) (placeable->BoundingBox.Bottom
1243 - placeable->BoundingBox.Top)) / ((REAL) placeable->Inch);
1244 (*metafile)->unit = UnitInch;
1247 DeleteMetaFile(hwmf);
1252 GdipFree(*metafile);
1253 IStream_Release(stream);
1257 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1258 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1260 HMETAFILE hmf = GetMetaFileW(file);
1262 TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1264 if(!hmf) return InvalidParameter;
1266 return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1269 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1270 GpMetafile **metafile)
1272 FIXME("(%p, %p): stub\n", file, metafile);
1273 return NotImplemented;
1276 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1277 GpMetafile **metafile)
1279 FIXME("(%p, %p): stub\n", stream, metafile);
1280 return NotImplemented;
1283 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
1284 UINT access, IStream **stream)
1289 TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
1291 if(!stream || !filename)
1292 return InvalidParameter;
1294 if(access & GENERIC_WRITE)
1295 dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
1296 else if(access & GENERIC_READ)
1297 dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
1299 return InvalidParameter;
1301 ret = SHCreateStreamOnFileW(filename, dwMode, stream);
1303 return hresult_to_status(ret);
1306 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
1308 GraphicsContainerItem *cont, *next;
1309 TRACE("(%p)\n", graphics);
1311 if(!graphics) return InvalidParameter;
1312 if(graphics->busy) return ObjectBusy;
1315 ReleaseDC(graphics->hwnd, graphics->hdc);
1317 LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
1318 list_remove(&cont->entry);
1319 delete_container(cont);
1322 GdipDeleteRegion(graphics->clip);
1323 GdipDeleteMatrix(graphics->worldtrans);
1329 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
1330 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
1332 INT save_state, num_pts;
1333 GpPointF points[MAX_ARC_PTS];
1336 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
1337 width, height, startAngle, sweepAngle);
1339 if(!graphics || !pen || width <= 0 || height <= 0)
1340 return InvalidParameter;
1345 num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
1347 save_state = prepare_dc(graphics, pen);
1349 retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
1351 restore_dc(graphics, save_state);
1356 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
1357 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
1359 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
1360 width, height, startAngle, sweepAngle);
1362 return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
1365 GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
1366 REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
1372 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
1373 x2, y2, x3, y3, x4, y4);
1375 if(!graphics || !pen)
1376 return InvalidParameter;
1390 save_state = prepare_dc(graphics, pen);
1392 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1394 restore_dc(graphics, save_state);
1399 GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
1400 INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
1406 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
1407 x2, y2, x3, y3, x4, y4);
1409 if(!graphics || !pen)
1410 return InvalidParameter;
1424 save_state = prepare_dc(graphics, pen);
1426 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1428 restore_dc(graphics, save_state);
1433 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
1434 GDIPCONST GpPointF *points, INT count)
1439 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1441 if(!graphics || !pen || !points || (count <= 0))
1442 return InvalidParameter;
1447 for(i = 0; i < floor(count / 4); i++){
1448 ret = GdipDrawBezier(graphics, pen,
1449 points[4*i].X, points[4*i].Y,
1450 points[4*i + 1].X, points[4*i + 1].Y,
1451 points[4*i + 2].X, points[4*i + 2].Y,
1452 points[4*i + 3].X, points[4*i + 3].Y);
1460 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
1461 GDIPCONST GpPoint *points, INT count)
1467 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1469 if(!graphics || !pen || !points || (count <= 0))
1470 return InvalidParameter;
1475 pts = GdipAlloc(sizeof(GpPointF) * count);
1479 for(i = 0; i < count; i++){
1480 pts[i].X = (REAL)points[i].X;
1481 pts[i].Y = (REAL)points[i].Y;
1484 ret = GdipDrawBeziers(graphics,pen,pts,count);
1491 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
1492 GDIPCONST GpPointF *points, INT count)
1494 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1496 return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
1499 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
1500 GDIPCONST GpPoint *points, INT count)
1502 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1504 return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
1507 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
1508 GDIPCONST GpPointF *points, INT count, REAL tension)
1513 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1515 if(!graphics || !pen || !points || count <= 0)
1516 return InvalidParameter;
1521 if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
1524 stat = GdipAddPathClosedCurve2(path, points, count, tension);
1526 GdipDeletePath(path);
1530 stat = GdipDrawPath(graphics, pen, path);
1532 GdipDeletePath(path);
1537 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
1538 GDIPCONST GpPoint *points, INT count, REAL tension)
1544 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1546 if(!points || count <= 0)
1547 return InvalidParameter;
1549 ptf = GdipAlloc(sizeof(GpPointF)*count);
1553 for(i = 0; i < count; i++){
1554 ptf[i].X = (REAL)points[i].X;
1555 ptf[i].Y = (REAL)points[i].Y;
1558 stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
1565 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
1566 GDIPCONST GpPointF *points, INT count)
1568 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1570 return GdipDrawCurve2(graphics,pen,points,count,1.0);
1573 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
1574 GDIPCONST GpPoint *points, INT count)
1580 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1583 return InvalidParameter;
1585 pointsF = GdipAlloc(sizeof(GpPointF)*count);
1589 for(i = 0; i < count; i++){
1590 pointsF[i].X = (REAL)points[i].X;
1591 pointsF[i].Y = (REAL)points[i].Y;
1594 ret = GdipDrawCurve(graphics,pen,pointsF,count);
1600 /* Approximates cardinal spline with Bezier curves. */
1601 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
1602 GDIPCONST GpPointF *points, INT count, REAL tension)
1604 /* PolyBezier expects count*3-2 points. */
1605 INT i, len_pt = count*3-2, save_state;
1607 REAL x1, x2, y1, y2;
1610 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1612 if(!graphics || !pen)
1613 return InvalidParameter;
1619 return InvalidParameter;
1621 pt = GdipAlloc(len_pt * sizeof(GpPointF));
1625 tension = tension * TENSION_CONST;
1627 calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
1630 pt[0].X = points[0].X;
1631 pt[0].Y = points[0].Y;
1635 for(i = 0; i < count-2; i++){
1636 calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
1640 pt[3*i+3].X = points[i+1].X;
1641 pt[3*i+3].Y = points[i+1].Y;
1646 calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
1647 points[count-2].X, points[count-2].Y, tension, &x1, &y1);
1649 pt[len_pt-2].X = x1;
1650 pt[len_pt-2].Y = y1;
1651 pt[len_pt-1].X = points[count-1].X;
1652 pt[len_pt-1].Y = points[count-1].Y;
1654 save_state = prepare_dc(graphics, pen);
1656 retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
1659 restore_dc(graphics, save_state);
1664 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
1665 GDIPCONST GpPoint *points, INT count, REAL tension)
1671 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1674 return InvalidParameter;
1676 pointsF = GdipAlloc(sizeof(GpPointF)*count);
1680 for(i = 0; i < count; i++){
1681 pointsF[i].X = (REAL)points[i].X;
1682 pointsF[i].Y = (REAL)points[i].Y;
1685 ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
1691 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
1692 GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
1695 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1697 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1698 return InvalidParameter;
1701 return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
1704 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
1705 GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
1708 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1714 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1715 return InvalidParameter;
1718 return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
1721 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
1722 REAL y, REAL width, REAL height)
1728 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
1730 if(!graphics || !pen)
1731 return InvalidParameter;
1738 ptf[1].X = x + width;
1739 ptf[1].Y = y + height;
1741 save_state = prepare_dc(graphics, pen);
1742 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
1744 transform_and_round_points(graphics, pti, ptf, 2);
1746 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
1748 restore_dc(graphics, save_state);
1753 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
1754 INT y, INT width, INT height)
1756 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
1758 return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1762 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
1767 TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
1769 if(!graphics || !image)
1770 return InvalidParameter;
1772 GdipGetImageWidth(image, &width);
1773 GdipGetImageHeight(image, &height);
1775 /* FIXME: we should use the graphics and image dpi, somehow */
1777 points[0].X = points[2].X = x;
1778 points[0].Y = points[1].Y = y;
1779 points[1].X = x + width;
1780 points[2].Y = y + height;
1782 return GdipDrawImagePointsRect(graphics, image, points, 3, 0, 0, width, height,
1783 UnitPixel, NULL, NULL, NULL);
1786 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
1789 TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
1791 return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
1794 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
1795 REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
1798 FIXME("(%p, %p, %f, %f, %f, %f, %f, %f, %d): stub\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
1799 return NotImplemented;
1802 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
1803 INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
1806 FIXME("(%p, %p, %d, %d, %d, %d, %d, %d, %d): stub\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
1807 return NotImplemented;
1810 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
1811 GDIPCONST GpPointF *dstpoints, INT count)
1813 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1814 return NotImplemented;
1817 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
1818 GDIPCONST GpPoint *dstpoints, INT count)
1820 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1821 return NotImplemented;
1824 /* FIXME: partially implemented (only works for rectangular parallelograms) */
1825 GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
1826 GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
1827 REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
1828 DrawImageAbort callback, VOID * callbackData)
1834 TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
1835 count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
1838 if(!graphics || !image || !points || count != 3)
1839 return InvalidParameter;
1841 memcpy(ptf, points, 3 * sizeof(GpPointF));
1842 transform_and_round_points(graphics, pti, ptf, 3);
1846 if(srcUnit == UnitInch)
1847 dx = dy = (REAL) INCH_HIMETRIC;
1848 else if(srcUnit == UnitPixel){
1849 dx = ((REAL) INCH_HIMETRIC) /
1850 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
1851 dy = ((REAL) INCH_HIMETRIC) /
1852 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
1855 return NotImplemented;
1857 /* IPicture renders bitmaps with the y-axis reversed
1858 * FIXME: flipping for unknown image type might not be correct. */
1859 if(image->type != ImageTypeMetafile){
1862 pti[0].y = pti[2].y;
1866 if(IPicture_Render(image->picture, graphics->hdc,
1867 pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
1868 srcx * dx, srcy * dy,
1869 srcwidth * dx, srcheight * dy,
1872 callback(callbackData);
1873 return GenericError;
1876 else if (image->type == ImageTypeBitmap && ((GpBitmap*)image)->hbitmap)
1879 GpBitmap* bitmap = (GpBitmap*)image;
1881 HBITMAP old_hbm=NULL;
1883 if (srcUnit == UnitInch)
1884 dx = dy = 96.0; /* FIXME: use the image resolution */
1885 else if (srcUnit == UnitPixel)
1888 return NotImplemented;
1891 bm_is_selected = (hdc != 0);
1893 if (!bm_is_selected)
1895 hdc = CreateCompatibleDC(0);
1896 old_hbm = SelectObject(hdc, bitmap->hbitmap);
1899 /* FIXME: maybe alpha blend depending on the format */
1900 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
1901 hdc, srcx*dx, srcy*dy, srcwidth*dx, srcheight*dy, SRCCOPY);
1903 if (!bm_is_selected)
1905 SelectObject(hdc, old_hbm);
1911 ERR("GpImage with no IPicture or HBITMAP?!\n");
1912 return NotImplemented;
1918 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
1919 GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
1920 INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
1921 DrawImageAbort callback, VOID * callbackData)
1923 GpPointF pointsF[3];
1926 TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
1927 srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
1930 if(!points || count!=3)
1931 return InvalidParameter;
1933 for(i = 0; i < count; i++){
1934 pointsF[i].X = (REAL)points[i].X;
1935 pointsF[i].Y = (REAL)points[i].Y;
1938 return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
1939 (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
1940 callback, callbackData);
1943 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
1944 REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
1945 REAL srcwidth, REAL srcheight, GpUnit srcUnit,
1946 GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
1947 VOID * callbackData)
1951 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
1952 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
1953 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
1957 points[1].X = dstx + dstwidth;
1960 points[2].Y = dsty + dstheight;
1962 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
1963 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
1966 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
1967 INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
1968 INT srcwidth, INT srcheight, GpUnit srcUnit,
1969 GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
1970 VOID * callbackData)
1974 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
1975 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
1976 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
1980 points[1].X = dstx + dstwidth;
1983 points[2].Y = dsty + dstheight;
1985 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
1986 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
1989 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
1990 REAL x, REAL y, REAL width, REAL height)
1996 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
1998 if(!graphics || !image)
1999 return InvalidParameter;
2001 ret = GdipGetImageBounds(image, &bounds, &unit);
2005 return GdipDrawImageRectRect(graphics, image, x, y, width, height,
2006 bounds.X, bounds.Y, bounds.Width, bounds.Height,
2007 unit, NULL, NULL, NULL);
2010 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
2011 INT x, INT y, INT width, INT height)
2013 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
2015 return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
2018 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
2019 REAL y1, REAL x2, REAL y2)
2025 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
2027 if(!pen || !graphics)
2028 return InvalidParameter;
2038 save_state = prepare_dc(graphics, pen);
2040 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2042 restore_dc(graphics, save_state);
2047 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
2048 INT y1, INT x2, INT y2)
2054 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
2056 if(!pen || !graphics)
2057 return InvalidParameter;
2067 save_state = prepare_dc(graphics, pen);
2069 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2071 restore_dc(graphics, save_state);
2076 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
2077 GpPointF *points, INT count)
2082 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2084 if(!pen || !graphics || (count < 2))
2085 return InvalidParameter;
2090 save_state = prepare_dc(graphics, pen);
2092 retval = draw_polyline(graphics, pen, points, count, TRUE);
2094 restore_dc(graphics, save_state);
2099 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
2100 GpPoint *points, INT count)
2104 GpPointF *ptf = NULL;
2107 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2109 if(!pen || !graphics || (count < 2))
2110 return InvalidParameter;
2115 ptf = GdipAlloc(count * sizeof(GpPointF));
2116 if(!ptf) return OutOfMemory;
2118 for(i = 0; i < count; i ++){
2119 ptf[i].X = (REAL) points[i].X;
2120 ptf[i].Y = (REAL) points[i].Y;
2123 save_state = prepare_dc(graphics, pen);
2125 retval = draw_polyline(graphics, pen, ptf, count, TRUE);
2127 restore_dc(graphics, save_state);
2133 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
2138 TRACE("(%p, %p, %p)\n", graphics, pen, path);
2140 if(!pen || !graphics)
2141 return InvalidParameter;
2146 save_state = prepare_dc(graphics, pen);
2148 retval = draw_poly(graphics, pen, path->pathdata.Points,
2149 path->pathdata.Types, path->pathdata.Count, TRUE);
2151 restore_dc(graphics, save_state);
2156 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
2157 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2161 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
2162 width, height, startAngle, sweepAngle);
2164 if(!graphics || !pen)
2165 return InvalidParameter;
2170 save_state = prepare_dc(graphics, pen);
2171 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2173 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2175 restore_dc(graphics, save_state);
2180 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
2181 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2183 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2184 width, height, startAngle, sweepAngle);
2186 return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2189 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
2190 REAL y, REAL width, REAL height)
2196 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2198 if(!pen || !graphics)
2199 return InvalidParameter;
2206 ptf[1].X = x + width;
2208 ptf[2].X = x + width;
2209 ptf[2].Y = y + height;
2211 ptf[3].Y = y + height;
2213 save_state = prepare_dc(graphics, pen);
2214 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2216 transform_and_round_points(graphics, pti, ptf, 4);
2217 Polygon(graphics->hdc, pti, 4);
2219 restore_dc(graphics, save_state);
2224 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
2225 INT y, INT width, INT height)
2227 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2229 return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2232 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
2233 GDIPCONST GpRectF* rects, INT count)
2239 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2241 if(!graphics || !pen || !rects || count < 1)
2242 return InvalidParameter;
2247 ptf = GdipAlloc(4 * count * sizeof(GpPointF));
2248 pti = GdipAlloc(4 * count * sizeof(POINT));
2256 for(i = 0; i < count; i++){
2257 ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
2258 ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
2259 ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
2260 ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
2263 save_state = prepare_dc(graphics, pen);
2264 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2266 transform_and_round_points(graphics, pti, ptf, 4 * count);
2268 for(i = 0; i < count; i++)
2269 Polygon(graphics->hdc, &pti[4 * i], 4);
2271 restore_dc(graphics, save_state);
2279 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
2280 GDIPCONST GpRect* rects, INT count)
2286 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2288 if(!rects || count<=0)
2289 return InvalidParameter;
2291 rectsF = GdipAlloc(sizeof(GpRectF) * count);
2295 for(i = 0;i < count;i++){
2296 rectsF[i].X = (REAL)rects[i].X;
2297 rectsF[i].Y = (REAL)rects[i].Y;
2298 rectsF[i].Width = (REAL)rects[i].Width;
2299 rectsF[i].Height = (REAL)rects[i].Height;
2302 ret = GdipDrawRectangles(graphics, pen, rectsF, count);
2308 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
2309 INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
2310 GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
2315 TEXTMETRICW textmet;
2316 GpPointF pt[2], rectcpy[4];
2319 REAL angle, ang_cos, ang_sin, rel_width, rel_height;
2320 INT sum = 0, height = 0, offsety = 0, fit, fitcpy, save_state, i, j, lret, nwidth,
2327 TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
2328 length, font, debugstr_rectf(rect), format, brush);
2330 if(!graphics || !string || !font || !brush || !rect)
2331 return InvalidParameter;
2333 if((brush->bt != BrushTypeSolidColor)){
2334 FIXME("not implemented for given parameters\n");
2335 return NotImplemented;
2339 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
2341 /* Should be no need to explicitly test for StringAlignmentNear as
2342 * that is default behavior if no alignment is passed. */
2343 if(format->vertalign != StringAlignmentNear){
2345 GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
2347 if(format->vertalign == StringAlignmentCenter)
2348 offsety = (rect->Height - bounds.Height) / 2;
2349 else if(format->vertalign == StringAlignmentFar)
2350 offsety = (rect->Height - bounds.Height);
2354 if(length == -1) length = lstrlenW(string);
2356 stringdup = GdipAlloc(length * sizeof(WCHAR));
2357 if(!stringdup) return OutOfMemory;
2359 save_state = SaveDC(graphics->hdc);
2360 SetBkMode(graphics->hdc, TRANSPARENT);
2361 SetTextColor(graphics->hdc, brush->lb.lbColor);
2363 rectcpy[3].X = rectcpy[0].X = rect->X;
2364 rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
2365 rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
2366 rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
2367 transform_and_round_points(graphics, corners, rectcpy, 4);
2369 if (roundr(rect->Width) == 0)
2376 rel_width = sqrt((corners[1].x - corners[0].x) * (corners[1].x - corners[0].x) +
2377 (corners[1].y - corners[0].y) * (corners[1].y - corners[0].y))
2379 nwidth = roundr(rel_width * rect->Width);
2382 if (roundr(rect->Height) == 0)
2389 rel_height = sqrt((corners[2].x - corners[1].x) * (corners[2].x - corners[1].x) +
2390 (corners[2].y - corners[1].y) * (corners[2].y - corners[1].y))
2392 nheight = roundr(rel_height * rect->Height);
2395 if (roundr(rect->Width) != 0 && roundr(rect->Height) != 0)
2397 /* FIXME: If only the width or only the height is 0, we should probably still clip */
2398 rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
2399 SelectClipRgn(graphics->hdc, rgn);
2402 /* Use gdi to find the font, then perform transformations on it (height,
2404 SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
2405 GetTextMetricsW(graphics->hdc, &textmet);
2408 lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
2409 lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
2415 GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
2416 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
2417 ang_cos = cos(angle);
2418 ang_sin = sin(angle);
2419 lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
2421 gdifont = CreateFontIndirectW(&lfw);
2422 DeleteObject(SelectObject(graphics->hdc, CreateFontIndirectW(&lfw)));
2424 for(i = 0, j = 0; i < length; i++){
2425 if(!isprintW(string[i]) && (string[i] != '\n'))
2428 stringdup[j] = string[i];
2434 if (!format || format->align == StringAlignmentNear)
2436 drawbase.x = corners[0].x;
2437 drawbase.y = corners[0].y;
2438 drawflags = DT_NOCLIP | DT_EXPANDTABS;
2440 else if (format->align == StringAlignmentCenter)
2442 drawbase.x = (corners[0].x + corners[1].x)/2;
2443 drawbase.y = (corners[0].y + corners[1].y)/2;
2444 drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_CENTER;
2446 else /* (format->align == StringAlignmentFar) */
2448 drawbase.x = corners[1].x;
2449 drawbase.y = corners[1].y;
2450 drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_RIGHT;
2453 while(sum < length){
2454 drawcoord.left = drawcoord.right = drawbase.x + roundr(ang_sin * (REAL) height);
2455 drawcoord.top = drawcoord.bottom = drawbase.y + roundr(ang_cos * (REAL) height);
2457 GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
2458 nwidth, &fit, NULL, &size);
2462 DrawTextW(graphics->hdc, stringdup + sum, 1, &drawcoord, drawflags);
2466 for(lret = 0; lret < fit; lret++)
2467 if(*(stringdup + sum + lret) == '\n')
2470 /* Line break code (may look strange, but it imitates windows). */
2472 lineend = fit = lret; /* this is not an off-by-one error */
2473 else if(fit < (length - sum)){
2474 if(*(stringdup + sum + fit) == ' ')
2475 while(*(stringdup + sum + fit) == ' ')
2478 while(*(stringdup + sum + fit - 1) != ' '){
2481 if(*(stringdup + sum + fit) == '\t')
2490 while(*(stringdup + sum + lineend - 1) == ' ' ||
2491 *(stringdup + sum + lineend - 1) == '\t')
2496 DrawTextW(graphics->hdc, stringdup + sum, min(length - sum, lineend),
2497 &drawcoord, drawflags);
2499 sum += fit + (lret < fitcpy ? 1 : 0);
2502 if(height > nheight)
2505 /* Stop if this was a linewrap (but not if it was a linebreak). */
2506 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
2510 GdipFree(stringdup);
2512 DeleteObject(gdifont);
2514 RestoreDC(graphics->hdc, save_state);
2519 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
2520 GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
2525 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2526 count, tension, fill);
2528 if(!graphics || !brush || !points)
2529 return InvalidParameter;
2534 stat = GdipCreatePath(fill, &path);
2538 stat = GdipAddPathClosedCurve2(path, points, count, tension);
2540 GdipDeletePath(path);
2544 stat = GdipFillPath(graphics, brush, path);
2546 GdipDeletePath(path);
2550 GdipDeletePath(path);
2555 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
2556 GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
2562 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2563 count, tension, fill);
2565 if(!points || count <= 0)
2566 return InvalidParameter;
2568 ptf = GdipAlloc(sizeof(GpPointF)*count);
2572 for(i = 0;i < count;i++){
2573 ptf[i].X = (REAL)points[i].X;
2574 ptf[i].Y = (REAL)points[i].Y;
2577 stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
2584 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
2585 REAL y, REAL width, REAL height)
2591 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
2593 if(!graphics || !brush)
2594 return InvalidParameter;
2601 ptf[1].X = x + width;
2602 ptf[1].Y = y + height;
2604 save_state = SaveDC(graphics->hdc);
2605 EndPath(graphics->hdc);
2607 transform_and_round_points(graphics, pti, ptf, 2);
2609 BeginPath(graphics->hdc);
2610 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2611 EndPath(graphics->hdc);
2613 brush_fill_path(graphics, brush);
2615 RestoreDC(graphics->hdc, save_state);
2620 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
2621 INT y, INT width, INT height)
2623 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
2625 return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2628 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
2633 TRACE("(%p, %p, %p)\n", graphics, brush, path);
2635 if(!brush || !graphics || !path)
2636 return InvalidParameter;
2641 save_state = SaveDC(graphics->hdc);
2642 EndPath(graphics->hdc);
2643 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
2646 BeginPath(graphics->hdc);
2647 retval = draw_poly(graphics, NULL, path->pathdata.Points,
2648 path->pathdata.Types, path->pathdata.Count, FALSE);
2653 EndPath(graphics->hdc);
2654 brush_fill_path(graphics, brush);
2659 RestoreDC(graphics->hdc, save_state);
2664 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
2665 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2669 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
2670 graphics, brush, x, y, width, height, startAngle, sweepAngle);
2672 if(!graphics || !brush)
2673 return InvalidParameter;
2678 save_state = SaveDC(graphics->hdc);
2679 EndPath(graphics->hdc);
2681 BeginPath(graphics->hdc);
2682 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2683 EndPath(graphics->hdc);
2685 brush_fill_path(graphics, brush);
2687 RestoreDC(graphics->hdc, save_state);
2692 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
2693 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2695 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
2696 graphics, brush, x, y, width, height, startAngle, sweepAngle);
2698 return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2701 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
2702 GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
2705 GpPointF *ptf = NULL;
2707 GpStatus retval = Ok;
2709 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
2711 if(!graphics || !brush || !points || !count)
2712 return InvalidParameter;
2717 ptf = GdipAlloc(count * sizeof(GpPointF));
2718 pti = GdipAlloc(count * sizeof(POINT));
2720 retval = OutOfMemory;
2724 memcpy(ptf, points, count * sizeof(GpPointF));
2726 save_state = SaveDC(graphics->hdc);
2727 EndPath(graphics->hdc);
2728 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
2731 transform_and_round_points(graphics, pti, ptf, count);
2733 BeginPath(graphics->hdc);
2734 Polygon(graphics->hdc, pti, count);
2735 EndPath(graphics->hdc);
2737 brush_fill_path(graphics, brush);
2739 RestoreDC(graphics->hdc, save_state);
2748 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
2749 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
2752 GpPointF *ptf = NULL;
2754 GpStatus retval = Ok;
2756 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
2758 if(!graphics || !brush || !points || !count)
2759 return InvalidParameter;
2764 ptf = GdipAlloc(count * sizeof(GpPointF));
2765 pti = GdipAlloc(count * sizeof(POINT));
2767 retval = OutOfMemory;
2771 for(i = 0; i < count; i ++){
2772 ptf[i].X = (REAL) points[i].X;
2773 ptf[i].Y = (REAL) points[i].Y;
2776 save_state = SaveDC(graphics->hdc);
2777 EndPath(graphics->hdc);
2778 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
2781 transform_and_round_points(graphics, pti, ptf, count);
2783 BeginPath(graphics->hdc);
2784 Polygon(graphics->hdc, pti, count);
2785 EndPath(graphics->hdc);
2787 brush_fill_path(graphics, brush);
2789 RestoreDC(graphics->hdc, save_state);
2798 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
2799 GDIPCONST GpPointF *points, INT count)
2801 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2803 return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
2806 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
2807 GDIPCONST GpPoint *points, INT count)
2809 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2811 return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
2814 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
2815 REAL x, REAL y, REAL width, REAL height)
2821 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
2823 if(!graphics || !brush)
2824 return InvalidParameter;
2831 ptf[1].X = x + width;
2833 ptf[2].X = x + width;
2834 ptf[2].Y = y + height;
2836 ptf[3].Y = y + height;
2838 save_state = SaveDC(graphics->hdc);
2839 EndPath(graphics->hdc);
2841 transform_and_round_points(graphics, pti, ptf, 4);
2843 BeginPath(graphics->hdc);
2844 Polygon(graphics->hdc, pti, 4);
2845 EndPath(graphics->hdc);
2847 brush_fill_path(graphics, brush);
2849 RestoreDC(graphics->hdc, save_state);
2854 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
2855 INT x, INT y, INT width, INT height)
2861 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
2863 if(!graphics || !brush)
2864 return InvalidParameter;
2871 ptf[1].X = x + width;
2873 ptf[2].X = x + width;
2874 ptf[2].Y = y + height;
2876 ptf[3].Y = y + height;
2878 save_state = SaveDC(graphics->hdc);
2879 EndPath(graphics->hdc);
2881 transform_and_round_points(graphics, pti, ptf, 4);
2883 BeginPath(graphics->hdc);
2884 Polygon(graphics->hdc, pti, 4);
2885 EndPath(graphics->hdc);
2887 brush_fill_path(graphics, brush);
2889 RestoreDC(graphics->hdc, save_state);
2894 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
2900 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
2903 return InvalidParameter;
2905 for(i = 0; i < count; i++){
2906 ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
2907 if(ret != Ok) return ret;
2913 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
2920 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
2922 if(!rects || count <= 0)
2923 return InvalidParameter;
2925 rectsF = GdipAlloc(sizeof(GpRectF)*count);
2929 for(i = 0; i < count; i++){
2930 rectsF[i].X = (REAL)rects[i].X;
2931 rectsF[i].Y = (REAL)rects[i].Y;
2932 rectsF[i].X = (REAL)rects[i].Width;
2933 rectsF[i].Height = (REAL)rects[i].Height;
2936 ret = GdipFillRectangles(graphics,brush,rectsF,count);
2942 /*****************************************************************************
2943 * GdipFillRegion [GDIPLUS.@]
2945 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
2953 TRACE("(%p, %p, %p)\n", graphics, brush, region);
2955 if (!(graphics && brush && region))
2956 return InvalidParameter;
2961 status = GdipGetRegionHRgn(region, graphics, &hrgn);
2965 save_state = SaveDC(graphics->hdc);
2966 EndPath(graphics->hdc);
2968 ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
2970 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
2972 BeginPath(graphics->hdc);
2973 Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
2974 EndPath(graphics->hdc);
2976 brush_fill_path(graphics, brush);
2979 RestoreDC(graphics->hdc, save_state);
2986 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
2991 return InvalidParameter;
2997 FIXME("not implemented\n");
2999 return NotImplemented;
3002 /*****************************************************************************
3003 * GdipGetClipBounds [GDIPLUS.@]
3005 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
3007 TRACE("(%p, %p)\n", graphics, rect);
3010 return InvalidParameter;
3015 return GdipGetRegionBounds(graphics->clip, graphics, rect);
3018 /*****************************************************************************
3019 * GdipGetClipBoundsI [GDIPLUS.@]
3021 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
3023 TRACE("(%p, %p)\n", graphics, rect);
3026 return InvalidParameter;
3031 return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
3034 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
3035 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
3036 CompositingMode *mode)
3038 TRACE("(%p, %p)\n", graphics, mode);
3040 if(!graphics || !mode)
3041 return InvalidParameter;
3046 *mode = graphics->compmode;
3051 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
3052 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
3053 CompositingQuality *quality)
3055 TRACE("(%p, %p)\n", graphics, quality);
3057 if(!graphics || !quality)
3058 return InvalidParameter;
3063 *quality = graphics->compqual;
3068 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
3069 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
3070 InterpolationMode *mode)
3072 TRACE("(%p, %p)\n", graphics, mode);
3074 if(!graphics || !mode)
3075 return InvalidParameter;
3080 *mode = graphics->interpolation;
3085 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
3087 if(!graphics || !argb)
3088 return InvalidParameter;
3093 FIXME("(%p, %p): stub\n", graphics, argb);
3095 return NotImplemented;
3098 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
3100 TRACE("(%p, %p)\n", graphics, scale);
3102 if(!graphics || !scale)
3103 return InvalidParameter;
3108 *scale = graphics->scale;
3113 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
3115 TRACE("(%p, %p)\n", graphics, unit);
3117 if(!graphics || !unit)
3118 return InvalidParameter;
3123 *unit = graphics->unit;
3128 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
3129 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
3132 TRACE("(%p, %p)\n", graphics, mode);
3134 if(!graphics || !mode)
3135 return InvalidParameter;
3140 *mode = graphics->pixeloffset;
3145 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
3146 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
3148 TRACE("(%p, %p)\n", graphics, mode);
3150 if(!graphics || !mode)
3151 return InvalidParameter;
3156 *mode = graphics->smoothing;
3161 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
3163 TRACE("(%p, %p)\n", graphics, contrast);
3165 if(!graphics || !contrast)
3166 return InvalidParameter;
3168 *contrast = graphics->textcontrast;
3173 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
3174 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
3175 TextRenderingHint *hint)
3177 TRACE("(%p, %p)\n", graphics, hint);
3179 if(!graphics || !hint)
3180 return InvalidParameter;
3185 *hint = graphics->texthint;
3190 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
3195 TRACE("(%p, %p)\n", graphics, rect);
3197 if(!graphics || !rect)
3198 return InvalidParameter;
3203 /* intersect window and graphics clipping regions */
3204 if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
3207 if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
3210 /* get bounds of the region */
3211 stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
3214 GdipDeleteRegion(clip_rgn);
3219 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
3224 TRACE("(%p, %p)\n", graphics, rect);
3226 if(!graphics || !rect)
3227 return InvalidParameter;
3229 if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
3231 rect->X = roundr(rectf.X);
3232 rect->Y = roundr(rectf.Y);
3233 rect->Width = roundr(rectf.Width);
3234 rect->Height = roundr(rectf.Height);
3240 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
3242 TRACE("(%p, %p)\n", graphics, matrix);
3244 if(!graphics || !matrix)
3245 return InvalidParameter;
3250 *matrix = *graphics->worldtrans;
3254 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
3260 TRACE("(%p, %x)\n", graphics, color);
3263 return InvalidParameter;
3268 if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
3271 if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
3272 GdipDeleteBrush((GpBrush*)brush);
3276 GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
3277 wnd_rect.Width, wnd_rect.Height);
3279 GdipDeleteBrush((GpBrush*)brush);
3284 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
3286 TRACE("(%p, %p)\n", graphics, res);
3288 if(!graphics || !res)
3289 return InvalidParameter;
3291 return GdipIsEmptyRegion(graphics->clip, graphics, res);
3294 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
3300 TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
3302 if(!graphics || !result)
3303 return InvalidParameter;
3310 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
3311 CoordinateSpaceWorld, &pt, 1)) != Ok)
3314 if((stat = GdipCreateRegion(&rgn)) != Ok)
3317 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
3320 stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
3323 GdipDeleteRegion(rgn);
3327 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
3329 return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
3332 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
3338 TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
3340 if(!graphics || !result)
3341 return InvalidParameter;
3348 pts[1].X = x + width;
3349 pts[1].Y = y + height;
3351 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
3352 CoordinateSpaceWorld, pts, 2)) != Ok)
3355 pts[1].X -= pts[0].X;
3356 pts[1].Y -= pts[0].Y;
3358 if((stat = GdipCreateRegion(&rgn)) != Ok)
3361 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
3364 stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
3367 GdipDeleteRegion(rgn);
3371 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
3373 return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
3376 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
3377 GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
3378 GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
3379 INT regionCount, GpRegion** regions)
3381 if (!(graphics && string && font && layoutRect && stringFormat && regions))
3382 return InvalidParameter;
3384 FIXME("stub: %p %s %d %p %p %p %d %p\n", graphics, debugstr_w(string),
3385 length, font, layoutRect, stringFormat, regionCount, regions);
3387 return NotImplemented;
3390 /* Find the smallest rectangle that bounds the text when it is printed in rect
3391 * according to the format options listed in format. If rect has 0 width and
3392 * height, then just find the smallest rectangle that bounds the text when it's
3393 * printed at location (rect->X, rect-Y). */
3394 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
3395 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
3396 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
3397 INT *codepointsfitted, INT *linesfilled)
3401 INT sum = 0, height = 0, fit, fitcpy, max_width = 0, i, j, lret, nwidth,
3405 TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
3406 debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
3407 bounds, codepointsfitted, linesfilled);
3409 if(!graphics || !string || !font || !rect)
3410 return InvalidParameter;
3412 if(linesfilled) *linesfilled = 0;
3413 if(codepointsfitted) *codepointsfitted = 0;
3416 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
3418 if(length == -1) length = lstrlenW(string);
3420 stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
3421 if(!stringdup) return OutOfMemory;
3423 oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
3424 nwidth = roundr(rect->Width);
3425 nheight = roundr(rect->Height);
3427 if((nwidth == 0) && (nheight == 0))
3428 nwidth = nheight = INT_MAX;
3430 for(i = 0, j = 0; i < length; i++){
3431 if(!isprintW(string[i]) && (string[i] != '\n'))
3434 stringdup[j] = string[i];
3441 while(sum < length){
3442 GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
3443 nwidth, &fit, NULL, &size);
3449 for(lret = 0; lret < fit; lret++)
3450 if(*(stringdup + sum + lret) == '\n')
3453 /* Line break code (may look strange, but it imitates windows). */
3455 lineend = fit = lret; /* this is not an off-by-one error */
3456 else if(fit < (length - sum)){
3457 if(*(stringdup + sum + fit) == ' ')
3458 while(*(stringdup + sum + fit) == ' ')
3461 while(*(stringdup + sum + fit - 1) != ' '){
3464 if(*(stringdup + sum + fit) == '\t')
3473 while(*(stringdup + sum + lineend - 1) == ' ' ||
3474 *(stringdup + sum + lineend - 1) == '\t')
3480 GetTextExtentExPointW(graphics->hdc, stringdup + sum, lineend,
3481 nwidth, &j, NULL, &size);
3483 sum += fit + (lret < fitcpy ? 1 : 0);
3484 if(codepointsfitted) *codepointsfitted = sum;
3487 if(linesfilled) *linesfilled += size.cy;
3488 max_width = max(max_width, size.cx);
3490 if(height > nheight)
3493 /* Stop if this was a linewrap (but not if it was a linebreak). */
3494 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
3498 bounds->X = rect->X;
3499 bounds->Y = rect->Y;
3500 bounds->Width = (REAL)max_width;
3501 bounds->Height = (REAL) min(height, nheight);
3503 GdipFree(stringdup);
3504 DeleteObject(SelectObject(graphics->hdc, oldfont));
3509 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
3511 TRACE("(%p)\n", graphics);
3514 return InvalidParameter;
3519 return GdipSetInfinite(graphics->clip);
3522 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
3524 TRACE("(%p)\n", graphics);
3527 return InvalidParameter;
3532 graphics->worldtrans->matrix[0] = 1.0;
3533 graphics->worldtrans->matrix[1] = 0.0;
3534 graphics->worldtrans->matrix[2] = 0.0;
3535 graphics->worldtrans->matrix[3] = 1.0;
3536 graphics->worldtrans->matrix[4] = 0.0;
3537 graphics->worldtrans->matrix[5] = 0.0;
3542 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
3544 return GdipEndContainer(graphics, state);
3547 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
3548 GpMatrixOrder order)
3550 TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
3553 return InvalidParameter;
3558 return GdipRotateMatrix(graphics->worldtrans, angle, order);
3561 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
3563 return GdipBeginContainer2(graphics, state);
3566 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
3567 GraphicsContainer *state)
3569 GraphicsContainerItem *container;
3572 TRACE("(%p, %p)\n", graphics, state);
3574 if(!graphics || !state)
3575 return InvalidParameter;
3577 sts = init_container(&container, graphics);
3581 list_add_head(&graphics->containers, &container->entry);
3582 *state = graphics->contid = container->contid;
3587 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
3589 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
3590 return NotImplemented;
3593 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
3595 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
3596 return NotImplemented;
3599 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
3601 FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
3602 return NotImplemented;
3605 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
3608 GraphicsContainerItem *container, *container2;
3610 TRACE("(%p, %x)\n", graphics, state);
3613 return InvalidParameter;
3615 LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
3616 if(container->contid == state)
3620 /* did not find a matching container */
3621 if(&container->entry == &graphics->containers)
3624 sts = restore_container(graphics, container);
3628 /* remove all of the containers on top of the found container */
3629 LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
3630 if(container->contid == state)
3632 list_remove(&container->entry);
3633 delete_container(container);
3636 list_remove(&container->entry);
3637 delete_container(container);
3642 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
3643 REAL sy, GpMatrixOrder order)
3645 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
3648 return InvalidParameter;
3653 return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
3656 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
3659 TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
3661 if(!graphics || !srcgraphics)
3662 return InvalidParameter;
3664 return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
3667 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
3668 CompositingMode mode)
3670 TRACE("(%p, %d)\n", graphics, mode);
3673 return InvalidParameter;
3678 graphics->compmode = mode;
3683 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
3684 CompositingQuality quality)
3686 TRACE("(%p, %d)\n", graphics, quality);
3689 return InvalidParameter;
3694 graphics->compqual = quality;
3699 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
3700 InterpolationMode mode)
3702 TRACE("(%p, %d)\n", graphics, mode);
3705 return InvalidParameter;
3710 graphics->interpolation = mode;
3715 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
3717 TRACE("(%p, %.2f)\n", graphics, scale);
3719 if(!graphics || (scale <= 0.0))
3720 return InvalidParameter;
3725 graphics->scale = scale;
3730 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
3732 TRACE("(%p, %d)\n", graphics, unit);
3735 return InvalidParameter;
3740 if(unit == UnitWorld)
3741 return InvalidParameter;
3743 graphics->unit = unit;
3748 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
3751 TRACE("(%p, %d)\n", graphics, mode);
3754 return InvalidParameter;
3759 graphics->pixeloffset = mode;
3764 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
3768 TRACE("(%p,%i,%i)\n", graphics, x, y);
3771 FIXME("not implemented\n");
3773 return NotImplemented;
3776 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
3778 TRACE("(%p, %d)\n", graphics, mode);
3781 return InvalidParameter;
3786 graphics->smoothing = mode;
3791 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
3793 TRACE("(%p, %d)\n", graphics, contrast);
3796 return InvalidParameter;
3798 graphics->textcontrast = contrast;
3803 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
3804 TextRenderingHint hint)
3806 TRACE("(%p, %d)\n", graphics, hint);
3809 return InvalidParameter;
3814 graphics->texthint = hint;
3819 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
3821 TRACE("(%p, %p)\n", graphics, matrix);
3823 if(!graphics || !matrix)
3824 return InvalidParameter;
3829 GdipDeleteMatrix(graphics->worldtrans);
3830 return GdipCloneMatrix(matrix, &graphics->worldtrans);
3833 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
3834 REAL dy, GpMatrixOrder order)
3836 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
3839 return InvalidParameter;
3844 return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
3847 /*****************************************************************************
3848 * GdipSetClipHrgn [GDIPLUS.@]
3850 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
3855 TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
3858 return InvalidParameter;
3860 status = GdipCreateRegionHrgn(hrgn, ®ion);
3864 status = GdipSetClipRegion(graphics, region, mode);
3866 GdipDeleteRegion(region);
3870 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
3872 TRACE("(%p, %p, %d)\n", graphics, path, mode);
3875 return InvalidParameter;
3880 return GdipCombineRegionPath(graphics->clip, path, mode);
3883 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
3884 REAL width, REAL height,
3889 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
3892 return InvalidParameter;
3900 rect.Height = height;
3902 return GdipCombineRegionRect(graphics->clip, &rect, mode);
3905 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
3906 INT width, INT height,
3909 TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
3912 return InvalidParameter;
3917 return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
3920 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
3923 TRACE("(%p, %p, %d)\n", graphics, region, mode);
3925 if(!graphics || !region)
3926 return InvalidParameter;
3931 return GdipCombineRegionRegion(graphics->clip, region, mode);
3934 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
3940 FIXME("not implemented\n");
3942 return NotImplemented;
3945 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
3951 TRACE("(%p, %p, %d)\n", graphics, points, count);
3953 if(!graphics || !pen || count<=0)
3954 return InvalidParameter;
3959 pti = GdipAlloc(sizeof(POINT) * count);
3961 save_state = prepare_dc(graphics, pen);
3962 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3964 transform_and_round_points(graphics, pti, (GpPointF*)points, count);
3965 Polygon(graphics->hdc, pti, count);
3967 restore_dc(graphics, save_state);
3973 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
3980 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3982 if(count<=0) return InvalidParameter;
3983 ptf = GdipAlloc(sizeof(GpPointF) * count);
3985 for(i = 0;i < count; i++){
3986 ptf[i].X = (REAL)points[i].X;
3987 ptf[i].Y = (REAL)points[i].Y;
3990 ret = GdipDrawPolygon(graphics,pen,ptf,count);
3996 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
3998 TRACE("(%p, %p)\n", graphics, dpi);
4000 if(!graphics || !dpi)
4001 return InvalidParameter;
4006 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
4011 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
4013 TRACE("(%p, %p)\n", graphics, dpi);
4015 if(!graphics || !dpi)
4016 return InvalidParameter;
4021 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
4026 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
4027 GpMatrixOrder order)
4032 TRACE("(%p, %p, %d)\n", graphics, matrix, order);
4034 if(!graphics || !matrix)
4035 return InvalidParameter;
4040 m = *(graphics->worldtrans);
4042 ret = GdipMultiplyMatrix(&m, matrix, order);
4044 *(graphics->worldtrans) = m;
4049 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
4051 TRACE("(%p, %p)\n", graphics, hdc);
4053 if(!graphics || !hdc)
4054 return InvalidParameter;
4059 *hdc = graphics->hdc;
4060 graphics->busy = TRUE;
4065 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
4067 TRACE("(%p, %p)\n", graphics, hdc);
4070 return InvalidParameter;
4072 if(graphics->hdc != hdc || !(graphics->busy))
4073 return InvalidParameter;
4075 graphics->busy = FALSE;
4080 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
4085 TRACE("(%p, %p)\n", graphics, region);
4087 if(!graphics || !region)
4088 return InvalidParameter;
4093 if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
4096 /* free everything except root node and header */
4097 delete_element(®ion->node);
4098 memcpy(region, clip, sizeof(GpRegion));
4103 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
4104 GpCoordinateSpace src_space, GpPointF *points, INT count)
4110 if(!graphics || !points || count <= 0)
4111 return InvalidParameter;
4116 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4118 if (src_space == dst_space) return Ok;
4120 stat = GdipCreateMatrix(&matrix);
4123 unitscale = convert_unit(graphics->hdc, graphics->unit);
4125 if(graphics->unit != UnitDisplay)
4126 unitscale *= graphics->scale;
4128 /* transform from src_space to CoordinateSpacePage */
4131 case CoordinateSpaceWorld:
4132 GdipMultiplyMatrix(matrix, graphics->worldtrans, MatrixOrderAppend);
4134 case CoordinateSpacePage:
4136 case CoordinateSpaceDevice:
4137 GdipScaleMatrix(matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
4141 /* transform from CoordinateSpacePage to dst_space */
4144 case CoordinateSpaceWorld:
4146 GpMatrix *inverted_transform;
4147 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
4150 stat = GdipInvertMatrix(inverted_transform);
4152 GdipMultiplyMatrix(matrix, inverted_transform, MatrixOrderAppend);
4153 GdipDeleteMatrix(inverted_transform);
4157 case CoordinateSpacePage:
4159 case CoordinateSpaceDevice:
4160 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
4165 stat = GdipTransformMatrixPoints(matrix, points, count);
4167 GdipDeleteMatrix(matrix);
4173 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
4174 GpCoordinateSpace src_space, GpPoint *points, INT count)
4180 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4183 return InvalidParameter;
4185 pointsF = GdipAlloc(sizeof(GpPointF) * count);
4189 for(i = 0; i < count; i++){
4190 pointsF[i].X = (REAL)points[i].X;
4191 pointsF[i].Y = (REAL)points[i].Y;
4194 ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
4197 for(i = 0; i < count; i++){
4198 points[i].X = roundr(pointsF[i].X);
4199 points[i].Y = roundr(pointsF[i].Y);
4206 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
4213 /*****************************************************************************
4214 * GdipTranslateClip [GDIPLUS.@]
4216 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
4218 TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
4221 return InvalidParameter;
4226 return GdipTranslateRegion(graphics->clip, dx, dy);
4229 /*****************************************************************************
4230 * GdipTranslateClipI [GDIPLUS.@]
4232 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
4234 TRACE("(%p, %d, %d)\n", graphics, dx, dy);
4237 return InvalidParameter;
4242 return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
4246 /*****************************************************************************
4247 * GdipMeasureDriverString [GDIPLUS.@]
4249 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4250 GDIPCONST GpFont *font, GDIPCONST PointF *positions,
4251 INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
4253 FIXME("(%p %p %d %p %p %d %p %p): stub\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
4254 return NotImplemented;
4257 /*****************************************************************************
4258 * GdipDrawDriverString [GDIPLUS.@]
4260 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4261 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
4262 GDIPCONST PointF *positions, INT flags,
4263 GDIPCONST GpMatrix *matrix )
4265 FIXME("(%p %p %d %p %p %p %d %p): stub\n", graphics, text, length, font, brush, positions, flags, matrix);
4266 return NotImplemented;
4269 /*****************************************************************************
4270 * GdipRecordMetafileI [GDIPLUS.@]
4272 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
4273 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
4275 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
4276 return NotImplemented;