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"
42 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus
);
44 /* looks-right constants */
45 #define TENSION_CONST (0.3)
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 /* GdipDrawPie/GdipFillPie helper function */
177 static void draw_pie(GpGraphics
*graphics
, REAL x
, REAL y
, REAL width
,
178 REAL height
, REAL startAngle
, REAL sweepAngle
)
185 ptf
[1].X
= x
+ width
;
186 ptf
[1].Y
= y
+ height
;
188 deg2xy(startAngle
+sweepAngle
, x
+ width
/ 2.0, y
+ width
/ 2.0, &ptf
[2].X
, &ptf
[2].Y
);
189 deg2xy(startAngle
, x
+ width
/ 2.0, y
+ width
/ 2.0, &ptf
[3].X
, &ptf
[3].Y
);
191 transform_and_round_points(graphics
, pti
, ptf
, 4);
193 Pie(graphics
->hdc
, pti
[0].x
, pti
[0].y
, pti
[1].x
, pti
[1].y
, pti
[2].x
,
194 pti
[2].y
, pti
[3].x
, pti
[3].y
);
197 /* GdipDrawCurve helper function.
198 * Calculates Bezier points from cardinal spline points. */
199 static void calc_curve_bezier(CONST GpPointF
*pts
, REAL tension
, REAL
*x1
,
200 REAL
*y1
, REAL
*x2
, REAL
*y2
)
204 /* calculate tangent */
205 xdiff
= pts
[2].X
- pts
[0].X
;
206 ydiff
= pts
[2].Y
- pts
[0].Y
;
208 /* apply tangent to get control points */
209 *x1
= pts
[1].X
- tension
* xdiff
;
210 *y1
= pts
[1].Y
- tension
* ydiff
;
211 *x2
= pts
[1].X
+ tension
* xdiff
;
212 *y2
= pts
[1].Y
+ tension
* ydiff
;
215 /* GdipDrawCurve helper function.
216 * Calculates Bezier points from cardinal spline endpoints. */
217 static void calc_curve_bezier_endp(REAL xend
, REAL yend
, REAL xadj
, REAL yadj
,
218 REAL tension
, REAL
*x
, REAL
*y
)
220 /* tangent at endpoints is the line from the endpoint to the adjacent point */
221 *x
= roundr(tension
* (xadj
- xend
) + xend
);
222 *y
= roundr(tension
* (yadj
- yend
) + yend
);
225 /* Draws the linecap the specified color and size on the hdc. The linecap is in
226 * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
227 * should not be called on an hdc that has a path you care about. */
228 static void draw_cap(GpGraphics
*graphics
, COLORREF color
, GpLineCap cap
, REAL size
,
229 const GpCustomLineCap
*custom
, REAL x1
, REAL y1
, REAL x2
, REAL y2
)
231 HGDIOBJ oldbrush
= NULL
, oldpen
= NULL
;
232 GpMatrix
*matrix
= NULL
;
235 PointF ptf
[4], *custptf
= NULL
;
236 POINT pt
[4], *custpt
= NULL
;
238 REAL theta
, dsmall
, dbig
, dx
, dy
= 0.0;
243 if((x1
== x2
) && (y1
== y2
))
246 theta
= gdiplus_atan2(y2
- y1
, x2
- x1
);
248 customstroke
= (cap
== LineCapCustom
) && custom
&& (!custom
->fill
);
250 brush
= CreateSolidBrush(color
);
251 lb
.lbStyle
= BS_SOLID
;
254 pen
= ExtCreatePen(PS_GEOMETRIC
| PS_SOLID
| PS_ENDCAP_FLAT
|
255 PS_JOIN_MITER
, 1, &lb
, 0,
257 oldbrush
= SelectObject(graphics
->hdc
, brush
);
258 oldpen
= SelectObject(graphics
->hdc
, pen
);
265 case LineCapSquareAnchor
:
266 case LineCapDiamondAnchor
:
267 size
= size
* (cap
& LineCapNoAnchor
? ANCHOR_WIDTH
: 1.0) / 2.0;
268 if(cap
== LineCapDiamondAnchor
){
269 dsmall
= cos(theta
+ M_PI_2
) * size
;
270 dbig
= sin(theta
+ M_PI_2
) * size
;
273 dsmall
= cos(theta
+ M_PI_4
) * size
;
274 dbig
= sin(theta
+ M_PI_4
) * size
;
277 ptf
[0].X
= x2
- dsmall
;
278 ptf
[1].X
= x2
+ dbig
;
280 ptf
[0].Y
= y2
- dbig
;
281 ptf
[3].Y
= y2
+ dsmall
;
283 ptf
[1].Y
= y2
- dsmall
;
284 ptf
[2].Y
= y2
+ dbig
;
286 ptf
[3].X
= x2
- dbig
;
287 ptf
[2].X
= x2
+ dsmall
;
289 transform_and_round_points(graphics
, pt
, ptf
, 4);
290 Polygon(graphics
->hdc
, pt
, 4);
293 case LineCapArrowAnchor
:
294 size
= size
* 4.0 / sqrt(3.0);
296 dx
= cos(M_PI
/ 6.0 + theta
) * size
;
297 dy
= sin(M_PI
/ 6.0 + theta
) * size
;
302 dx
= cos(- M_PI
/ 6.0 + theta
) * size
;
303 dy
= sin(- M_PI
/ 6.0 + theta
) * size
;
311 transform_and_round_points(graphics
, pt
, ptf
, 3);
312 Polygon(graphics
->hdc
, pt
, 3);
315 case LineCapRoundAnchor
:
316 dx
= dy
= ANCHOR_WIDTH
* size
/ 2.0;
323 transform_and_round_points(graphics
, pt
, ptf
, 2);
324 Ellipse(graphics
->hdc
, pt
[0].x
, pt
[0].y
, pt
[1].x
, pt
[1].y
);
327 case LineCapTriangle
:
329 dx
= cos(M_PI_2
+ theta
) * size
;
330 dy
= sin(M_PI_2
+ theta
) * size
;
337 dx
= cos(theta
) * size
;
338 dy
= sin(theta
) * size
;
343 transform_and_round_points(graphics
, pt
, ptf
, 3);
344 Polygon(graphics
->hdc
, pt
, 3);
348 dx
= dy
= size
/ 2.0;
355 dx
= -cos(M_PI_2
+ theta
) * size
;
356 dy
= -sin(M_PI_2
+ theta
) * size
;
363 transform_and_round_points(graphics
, pt
, ptf
, 4);
364 Pie(graphics
->hdc
, pt
[0].x
, pt
[0].y
, pt
[1].x
, pt
[1].y
, pt
[2].x
,
365 pt
[2].y
, pt
[3].x
, pt
[3].y
);
372 count
= custom
->pathdata
.Count
;
373 custptf
= GdipAlloc(count
* sizeof(PointF
));
374 custpt
= GdipAlloc(count
* sizeof(POINT
));
375 tp
= GdipAlloc(count
);
377 if(!custptf
|| !custpt
|| !tp
|| (GdipCreateMatrix(&matrix
) != Ok
))
380 memcpy(custptf
, custom
->pathdata
.Points
, count
* sizeof(PointF
));
382 GdipScaleMatrix(matrix
, size
, size
, MatrixOrderAppend
);
383 GdipRotateMatrix(matrix
, (180.0 / M_PI
) * (theta
- M_PI_2
),
385 GdipTranslateMatrix(matrix
, x2
, y2
, MatrixOrderAppend
);
386 GdipTransformMatrixPoints(matrix
, custptf
, count
);
388 transform_and_round_points(graphics
, custpt
, custptf
, count
);
390 for(i
= 0; i
< count
; i
++)
391 tp
[i
] = convert_path_point_type(custom
->pathdata
.Types
[i
]);
394 BeginPath(graphics
->hdc
);
395 PolyDraw(graphics
->hdc
, custpt
, tp
, count
);
396 EndPath(graphics
->hdc
);
397 StrokeAndFillPath(graphics
->hdc
);
400 PolyDraw(graphics
->hdc
, custpt
, tp
, count
);
406 GdipDeleteMatrix(matrix
);
413 SelectObject(graphics
->hdc
, oldbrush
);
414 SelectObject(graphics
->hdc
, oldpen
);
420 /* Shortens the line by the given percent by changing x2, y2.
421 * If percent is > 1.0 then the line will change direction.
422 * If percent is negative it can lengthen the line. */
423 static void shorten_line_percent(REAL x1
, REAL y1
, REAL
*x2
, REAL
*y2
, REAL percent
)
425 REAL dist
, theta
, dx
, dy
;
427 if((y1
== *y2
) && (x1
== *x2
))
430 dist
= sqrt((*x2
- x1
) * (*x2
- x1
) + (*y2
- y1
) * (*y2
- y1
)) * -percent
;
431 theta
= gdiplus_atan2((*y2
- y1
), (*x2
- x1
));
432 dx
= cos(theta
) * dist
;
433 dy
= sin(theta
) * dist
;
439 /* Shortens the line by the given amount by changing x2, y2.
440 * If the amount is greater than the distance, the line will become length 0.
441 * If the amount is negative, it can lengthen the line. */
442 static void shorten_line_amt(REAL x1
, REAL y1
, REAL
*x2
, REAL
*y2
, REAL amt
)
444 REAL dx
, dy
, percent
;
448 if(dx
== 0 && dy
== 0)
451 percent
= amt
/ sqrt(dx
* dx
+ dy
* dy
);
458 shorten_line_percent(x1
, y1
, x2
, y2
, percent
);
461 /* Draws lines between the given points, and if caps is true then draws an endcap
462 * at the end of the last line. */
463 static GpStatus
draw_polyline(GpGraphics
*graphics
, GpPen
*pen
,
464 GDIPCONST GpPointF
* pt
, INT count
, BOOL caps
)
467 GpPointF
*ptcopy
= NULL
;
468 GpStatus status
= GenericError
;
473 pti
= GdipAlloc(count
* sizeof(POINT
));
474 ptcopy
= GdipAlloc(count
* sizeof(GpPointF
));
477 status
= OutOfMemory
;
481 memcpy(ptcopy
, pt
, count
* sizeof(GpPointF
));
484 if(pen
->endcap
== LineCapArrowAnchor
)
485 shorten_line_amt(ptcopy
[count
-2].X
, ptcopy
[count
-2].Y
,
486 &ptcopy
[count
-1].X
, &ptcopy
[count
-1].Y
, pen
->width
);
487 else if((pen
->endcap
== LineCapCustom
) && pen
->customend
)
488 shorten_line_amt(ptcopy
[count
-2].X
, ptcopy
[count
-2].Y
,
489 &ptcopy
[count
-1].X
, &ptcopy
[count
-1].Y
,
490 pen
->customend
->inset
* pen
->width
);
492 if(pen
->startcap
== LineCapArrowAnchor
)
493 shorten_line_amt(ptcopy
[1].X
, ptcopy
[1].Y
,
494 &ptcopy
[0].X
, &ptcopy
[0].Y
, pen
->width
);
495 else if((pen
->startcap
== LineCapCustom
) && pen
->customstart
)
496 shorten_line_amt(ptcopy
[1].X
, ptcopy
[1].Y
,
497 &ptcopy
[0].X
, &ptcopy
[0].Y
,
498 pen
->customstart
->inset
* pen
->width
);
500 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->endcap
, pen
->width
, pen
->customend
,
501 pt
[count
- 2].X
, pt
[count
- 2].Y
, pt
[count
- 1].X
, pt
[count
- 1].Y
);
502 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->startcap
, pen
->width
, pen
->customstart
,
503 pt
[1].X
, pt
[1].Y
, pt
[0].X
, pt
[0].Y
);
506 transform_and_round_points(graphics
, pti
, ptcopy
, count
);
508 if(Polyline(graphics
->hdc
, pti
, count
))
518 /* Conducts a linear search to find the bezier points that will back off
519 * the endpoint of the curve by a distance of amt. Linear search works
520 * better than binary in this case because there are multiple solutions,
521 * and binary searches often find a bad one. I don't think this is what
522 * Windows does but short of rendering the bezier without GDI's help it's
523 * the best we can do. If rev then work from the start of the passed points
524 * instead of the end. */
525 static void shorten_bezier_amt(GpPointF
* pt
, REAL amt
, BOOL rev
)
528 REAL percent
= 0.00, dx
, dy
, origx
, origy
, diff
= -1.0;
529 INT i
, first
= 0, second
= 1, third
= 2, fourth
= 3;
538 origx
= pt
[fourth
].X
;
539 origy
= pt
[fourth
].Y
;
540 memcpy(origpt
, pt
, sizeof(GpPointF
) * 4);
542 for(i
= 0; (i
< MAX_ITERS
) && (diff
< amt
); i
++){
543 /* reset bezier points to original values */
544 memcpy(pt
, origpt
, sizeof(GpPointF
) * 4);
545 /* Perform magic on bezier points. Order is important here.*/
546 shorten_line_percent(pt
[third
].X
, pt
[third
].Y
, &pt
[fourth
].X
, &pt
[fourth
].Y
, percent
);
547 shorten_line_percent(pt
[second
].X
, pt
[second
].Y
, &pt
[third
].X
, &pt
[third
].Y
, percent
);
548 shorten_line_percent(pt
[third
].X
, pt
[third
].Y
, &pt
[fourth
].X
, &pt
[fourth
].Y
, percent
);
549 shorten_line_percent(pt
[first
].X
, pt
[first
].Y
, &pt
[second
].X
, &pt
[second
].Y
, percent
);
550 shorten_line_percent(pt
[second
].X
, pt
[second
].Y
, &pt
[third
].X
, &pt
[third
].Y
, percent
);
551 shorten_line_percent(pt
[third
].X
, pt
[third
].Y
, &pt
[fourth
].X
, &pt
[fourth
].Y
, percent
);
553 dx
= pt
[fourth
].X
- origx
;
554 dy
= pt
[fourth
].Y
- origy
;
556 diff
= sqrt(dx
* dx
+ dy
* dy
);
557 percent
+= 0.0005 * amt
;
561 /* Draws bezier curves between given points, and if caps is true then draws an
562 * endcap at the end of the last line. */
563 static GpStatus
draw_polybezier(GpGraphics
*graphics
, GpPen
*pen
,
564 GDIPCONST GpPointF
* pt
, INT count
, BOOL caps
)
568 GpStatus status
= GenericError
;
573 pti
= GdipAlloc(count
* sizeof(POINT
));
574 ptcopy
= GdipAlloc(count
* sizeof(GpPointF
));
577 status
= OutOfMemory
;
581 memcpy(ptcopy
, pt
, count
* sizeof(GpPointF
));
584 if(pen
->endcap
== LineCapArrowAnchor
)
585 shorten_bezier_amt(&ptcopy
[count
-4], pen
->width
, FALSE
);
586 else if((pen
->endcap
== LineCapCustom
) && pen
->customend
)
587 shorten_bezier_amt(&ptcopy
[count
-4], pen
->width
* pen
->customend
->inset
,
590 if(pen
->startcap
== LineCapArrowAnchor
)
591 shorten_bezier_amt(ptcopy
, pen
->width
, TRUE
);
592 else if((pen
->startcap
== LineCapCustom
) && pen
->customstart
)
593 shorten_bezier_amt(ptcopy
, pen
->width
* pen
->customstart
->inset
, TRUE
);
595 /* the direction of the line cap is parallel to the direction at the
596 * end of the bezier (which, if it has been shortened, is not the same
597 * as the direction from pt[count-2] to pt[count-1]) */
598 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->endcap
, pen
->width
, pen
->customend
,
599 pt
[count
- 1].X
- (ptcopy
[count
- 1].X
- ptcopy
[count
- 2].X
),
600 pt
[count
- 1].Y
- (ptcopy
[count
- 1].Y
- ptcopy
[count
- 2].Y
),
601 pt
[count
- 1].X
, pt
[count
- 1].Y
);
603 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->startcap
, pen
->width
, pen
->customstart
,
604 pt
[0].X
- (ptcopy
[0].X
- ptcopy
[1].X
),
605 pt
[0].Y
- (ptcopy
[0].Y
- ptcopy
[1].Y
), pt
[0].X
, pt
[0].Y
);
608 transform_and_round_points(graphics
, pti
, ptcopy
, count
);
610 PolyBezier(graphics
->hdc
, pti
, count
);
621 /* Draws a combination of bezier curves and lines between points. */
622 static GpStatus
draw_poly(GpGraphics
*graphics
, GpPen
*pen
, GDIPCONST GpPointF
* pt
,
623 GDIPCONST BYTE
* types
, INT count
, BOOL caps
)
625 POINT
*pti
= GdipAlloc(count
* sizeof(POINT
));
626 BYTE
*tp
= GdipAlloc(count
);
627 GpPointF
*ptcopy
= GdipAlloc(count
* sizeof(GpPointF
));
629 GpStatus status
= GenericError
;
635 if(!pti
|| !tp
|| !ptcopy
){
636 status
= OutOfMemory
;
640 for(i
= 1; i
< count
; i
++){
641 if((types
[i
] & PathPointTypePathTypeMask
) == PathPointTypeBezier
){
642 if((i
+ 2 >= count
) || !(types
[i
+ 1] & PathPointTypeBezier
)
643 || !(types
[i
+ 1] & PathPointTypeBezier
)){
644 ERR("Bad bezier points\n");
651 memcpy(ptcopy
, pt
, count
* sizeof(GpPointF
));
653 /* If we are drawing caps, go through the points and adjust them accordingly,
654 * and draw the caps. */
656 switch(types
[count
- 1] & PathPointTypePathTypeMask
){
657 case PathPointTypeBezier
:
658 if(pen
->endcap
== LineCapArrowAnchor
)
659 shorten_bezier_amt(&ptcopy
[count
- 4], pen
->width
, FALSE
);
660 else if((pen
->endcap
== LineCapCustom
) && pen
->customend
)
661 shorten_bezier_amt(&ptcopy
[count
- 4],
662 pen
->width
* pen
->customend
->inset
, FALSE
);
664 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->endcap
, pen
->width
, pen
->customend
,
665 pt
[count
- 1].X
- (ptcopy
[count
- 1].X
- ptcopy
[count
- 2].X
),
666 pt
[count
- 1].Y
- (ptcopy
[count
- 1].Y
- ptcopy
[count
- 2].Y
),
667 pt
[count
- 1].X
, pt
[count
- 1].Y
);
670 case PathPointTypeLine
:
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
,
675 else if((pen
->endcap
== LineCapCustom
) && pen
->customend
)
676 shorten_line_amt(ptcopy
[count
- 2].X
, ptcopy
[count
- 2].Y
,
677 &ptcopy
[count
- 1].X
, &ptcopy
[count
- 1].Y
,
678 pen
->customend
->inset
* pen
->width
);
680 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->endcap
, pen
->width
, pen
->customend
,
681 pt
[count
- 2].X
, pt
[count
- 2].Y
, pt
[count
- 1].X
,
686 ERR("Bad path last point\n");
690 /* Find start of points */
691 for(j
= 1; j
< count
&& ((types
[j
] & PathPointTypePathTypeMask
)
692 == PathPointTypeStart
); j
++);
694 switch(types
[j
] & PathPointTypePathTypeMask
){
695 case PathPointTypeBezier
:
696 if(pen
->startcap
== LineCapArrowAnchor
)
697 shorten_bezier_amt(&ptcopy
[j
- 1], pen
->width
, TRUE
);
698 else if((pen
->startcap
== LineCapCustom
) && pen
->customstart
)
699 shorten_bezier_amt(&ptcopy
[j
- 1],
700 pen
->width
* pen
->customstart
->inset
, TRUE
);
702 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->startcap
, pen
->width
, pen
->customstart
,
703 pt
[j
- 1].X
- (ptcopy
[j
- 1].X
- ptcopy
[j
].X
),
704 pt
[j
- 1].Y
- (ptcopy
[j
- 1].Y
- ptcopy
[j
].Y
),
705 pt
[j
- 1].X
, pt
[j
- 1].Y
);
708 case PathPointTypeLine
:
709 if(pen
->startcap
== LineCapArrowAnchor
)
710 shorten_line_amt(ptcopy
[j
].X
, ptcopy
[j
].Y
,
711 &ptcopy
[j
- 1].X
, &ptcopy
[j
- 1].Y
,
713 else if((pen
->startcap
== LineCapCustom
) && pen
->customstart
)
714 shorten_line_amt(ptcopy
[j
].X
, ptcopy
[j
].Y
,
715 &ptcopy
[j
- 1].X
, &ptcopy
[j
- 1].Y
,
716 pen
->customstart
->inset
* pen
->width
);
718 draw_cap(graphics
, pen
->brush
->lb
.lbColor
, pen
->startcap
, pen
->width
, pen
->customstart
,
719 pt
[j
].X
, pt
[j
].Y
, pt
[j
- 1].X
,
724 ERR("Bad path points\n");
729 transform_and_round_points(graphics
, pti
, ptcopy
, count
);
731 for(i
= 0; i
< count
; i
++){
732 tp
[i
] = convert_path_point_type(types
[i
]);
735 PolyDraw(graphics
->hdc
, pti
, tp
, count
);
747 GpStatus WINGDIPAPI
GdipCreateFromHDC(HDC hdc
, GpGraphics
**graphics
)
749 return GdipCreateFromHDC2(hdc
, NULL
, graphics
);
752 GpStatus WINGDIPAPI
GdipCreateFromHDC2(HDC hdc
, HANDLE hDevice
, GpGraphics
**graphics
)
756 if(hDevice
!= NULL
) {
757 FIXME("Don't know how to hadle parameter hDevice\n");
758 return NotImplemented
;
765 return InvalidParameter
;
767 *graphics
= GdipAlloc(sizeof(GpGraphics
));
768 if(!*graphics
) return OutOfMemory
;
770 if((retval
= GdipCreateMatrix(&(*graphics
)->worldtrans
)) != Ok
){
775 (*graphics
)->hdc
= hdc
;
776 (*graphics
)->hwnd
= NULL
;
777 (*graphics
)->smoothing
= SmoothingModeDefault
;
778 (*graphics
)->compqual
= CompositingQualityDefault
;
779 (*graphics
)->interpolation
= InterpolationModeDefault
;
780 (*graphics
)->pixeloffset
= PixelOffsetModeDefault
;
781 (*graphics
)->compmode
= CompositingModeSourceOver
;
782 (*graphics
)->unit
= UnitDisplay
;
783 (*graphics
)->scale
= 1.0;
788 GpStatus WINGDIPAPI
GdipCreateFromHWND(HWND hwnd
, GpGraphics
**graphics
)
792 if((ret
= GdipCreateFromHDC(GetDC(hwnd
), graphics
)) != Ok
)
795 (*graphics
)->hwnd
= hwnd
;
800 /* FIXME: no icm handling */
801 GpStatus WINGDIPAPI
GdipCreateFromHWNDICM(HWND hwnd
, GpGraphics
**graphics
)
803 return GdipCreateFromHWND(hwnd
, graphics
);
806 GpStatus WINGDIPAPI
GdipCreateMetafileFromEmf(HENHMETAFILE hemf
, BOOL
delete,
807 GpMetafile
**metafile
)
811 if(!hemf
|| !metafile
)
812 return InvalidParameter
;
815 FIXME("not implemented\n");
817 return NotImplemented
;
820 GpStatus WINGDIPAPI
GdipCreateMetafileFromWmf(HMETAFILE hwmf
, BOOL
delete,
821 GDIPCONST WmfPlaceableFileHeader
* placeable
, GpMetafile
**metafile
)
823 IStream
*stream
= NULL
;
827 GpStatus retval
= GenericError
;
829 if(!hwmf
|| !metafile
|| !placeable
)
830 return InvalidParameter
;
833 read
= GetMetaFileBitsEx(hwmf
, 0, NULL
);
836 copy
= GdipAlloc(read
);
837 GetMetaFileBitsEx(hwmf
, read
, copy
);
839 hemf
= SetWinMetaFileBits(read
, copy
, NULL
, NULL
);
842 read
= GetEnhMetaFileBits(hemf
, 0, NULL
);
843 copy
= GdipAlloc(read
);
844 GetEnhMetaFileBits(hemf
, read
, copy
);
845 DeleteEnhMetaFile(hemf
);
847 if(CreateStreamOnHGlobal(copy
, TRUE
, &stream
) != S_OK
){
848 ERR("could not make stream\n");
853 *metafile
= GdipAlloc(sizeof(GpMetafile
));
855 retval
= OutOfMemory
;
859 if(OleLoadPicture(stream
, 0, FALSE
, &IID_IPicture
,
860 (LPVOID
*) &((*metafile
)->image
.picture
)) != S_OK
)
864 (*metafile
)->image
.type
= ImageTypeMetafile
;
865 (*metafile
)->bounds
.X
= ((REAL
) placeable
->BoundingBox
.Left
) / ((REAL
) placeable
->Inch
);
866 (*metafile
)->bounds
.Y
= ((REAL
) placeable
->BoundingBox
.Right
) / ((REAL
) placeable
->Inch
);
867 (*metafile
)->bounds
.Width
= ((REAL
) (placeable
->BoundingBox
.Right
868 - placeable
->BoundingBox
.Left
)) / ((REAL
) placeable
->Inch
);
869 (*metafile
)->bounds
.Height
= ((REAL
) (placeable
->BoundingBox
.Bottom
870 - placeable
->BoundingBox
.Top
)) / ((REAL
) placeable
->Inch
);
871 (*metafile
)->unit
= UnitInch
;
874 DeleteMetaFile(hwmf
);
880 IStream_Release(stream
);
884 GpStatus WINGDIPAPI
GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR
*file
,
885 GDIPCONST WmfPlaceableFileHeader
* placeable
, GpMetafile
**metafile
)
887 HMETAFILE hmf
= GetMetaFileW(file
);
889 TRACE("(%s, %p, %p)\n", debugstr_w(file
), placeable
, metafile
);
891 if(!hmf
) return InvalidParameter
;
893 return GdipCreateMetafileFromWmf(hmf
, TRUE
, placeable
, metafile
);
896 GpStatus WINGDIPAPI
GdipCreateStreamOnFile(GDIPCONST WCHAR
* filename
,
897 UINT access
, IStream
**stream
)
902 if(!stream
|| !filename
)
903 return InvalidParameter
;
905 if(access
& GENERIC_WRITE
)
906 dwMode
= STGM_SHARE_DENY_WRITE
| STGM_WRITE
| STGM_CREATE
;
907 else if(access
& GENERIC_READ
)
908 dwMode
= STGM_SHARE_DENY_WRITE
| STGM_READ
| STGM_FAILIFTHERE
;
910 return InvalidParameter
;
912 ret
= SHCreateStreamOnFileW(filename
, dwMode
, stream
);
914 return hresult_to_status(ret
);
917 GpStatus WINGDIPAPI
GdipDeleteGraphics(GpGraphics
*graphics
)
919 if(!graphics
) return InvalidParameter
;
921 ReleaseDC(graphics
->hwnd
, graphics
->hdc
);
923 GdipDeleteMatrix(graphics
->worldtrans
);
924 HeapFree(GetProcessHeap(), 0, graphics
);
929 GpStatus WINGDIPAPI
GdipDrawArc(GpGraphics
*graphics
, GpPen
*pen
, REAL x
,
930 REAL y
, REAL width
, REAL height
, REAL startAngle
, REAL sweepAngle
)
932 INT save_state
, num_pts
;
933 GpPointF points
[MAX_ARC_PTS
];
936 if(!graphics
|| !pen
|| width
<= 0 || height
<= 0)
937 return InvalidParameter
;
939 num_pts
= arc2polybezier(points
, x
, y
, width
, height
, startAngle
, sweepAngle
);
941 save_state
= prepare_dc(graphics
, pen
);
943 retval
= draw_polybezier(graphics
, pen
, points
, num_pts
, TRUE
);
945 restore_dc(graphics
, save_state
);
950 GpStatus WINGDIPAPI
GdipDrawArcI(GpGraphics
*graphics
, GpPen
*pen
, INT x
,
951 INT y
, INT width
, INT height
, REAL startAngle
, REAL sweepAngle
)
953 return GdipDrawArc(graphics
,pen
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
,startAngle
,sweepAngle
);
956 GpStatus WINGDIPAPI
GdipDrawBezier(GpGraphics
*graphics
, GpPen
*pen
, REAL x1
,
957 REAL y1
, REAL x2
, REAL y2
, REAL x3
, REAL y3
, REAL x4
, REAL y4
)
963 if(!graphics
|| !pen
)
964 return InvalidParameter
;
975 save_state
= prepare_dc(graphics
, pen
);
977 retval
= draw_polybezier(graphics
, pen
, pt
, 4, TRUE
);
979 restore_dc(graphics
, save_state
);
984 GpStatus WINGDIPAPI
GdipDrawBezierI(GpGraphics
*graphics
, GpPen
*pen
, INT x1
,
985 INT y1
, INT x2
, INT y2
, INT x3
, INT y3
, INT x4
, INT y4
)
991 if(!graphics
|| !pen
)
992 return InvalidParameter
;
1003 save_state
= prepare_dc(graphics
, pen
);
1005 retval
= draw_polybezier(graphics
, pen
, pt
, 4, TRUE
);
1007 restore_dc(graphics
, save_state
);
1012 GpStatus WINGDIPAPI
GdipDrawBeziers(GpGraphics
*graphics
, GpPen
*pen
,
1013 GDIPCONST GpPointF
*points
, INT count
)
1018 if(!graphics
|| !pen
|| !points
|| (count
<= 0))
1019 return InvalidParameter
;
1021 for(i
= 0; i
< floor(count
/ 4); i
++){
1022 ret
= GdipDrawBezier(graphics
, pen
,
1023 points
[4*i
].X
, points
[4*i
].Y
,
1024 points
[4*i
+ 1].X
, points
[4*i
+ 1].Y
,
1025 points
[4*i
+ 2].X
, points
[4*i
+ 2].Y
,
1026 points
[4*i
+ 3].X
, points
[4*i
+ 3].Y
);
1034 GpStatus WINGDIPAPI
GdipDrawBeziersI(GpGraphics
*graphics
, GpPen
*pen
,
1035 GDIPCONST GpPoint
*points
, INT count
)
1041 if(!graphics
|| !pen
|| !points
|| (count
<= 0))
1042 return InvalidParameter
;
1044 pts
= GdipAlloc(sizeof(GpPointF
) * count
);
1048 for(i
= 0; i
< count
; i
++){
1049 pts
[i
].X
= (REAL
)points
[i
].X
;
1050 pts
[i
].Y
= (REAL
)points
[i
].Y
;
1053 ret
= GdipDrawBeziers(graphics
,pen
,pts
,count
);
1060 GpStatus WINGDIPAPI
GdipDrawClosedCurve(GpGraphics
*graphics
, GpPen
*pen
,
1061 GDIPCONST GpPointF
*points
, INT count
)
1063 return GdipDrawClosedCurve2(graphics
, pen
, points
, count
, 1.0);
1066 GpStatus WINGDIPAPI
GdipDrawClosedCurveI(GpGraphics
*graphics
, GpPen
*pen
,
1067 GDIPCONST GpPoint
*points
, INT count
)
1069 return GdipDrawClosedCurve2I(graphics
, pen
, points
, count
, 1.0);
1072 GpStatus WINGDIPAPI
GdipDrawClosedCurve2(GpGraphics
*graphics
, GpPen
*pen
,
1073 GDIPCONST GpPointF
*points
, INT count
, REAL tension
)
1078 if(!graphics
|| !pen
|| !points
|| count
<= 0)
1079 return InvalidParameter
;
1081 /* make a full points copy.. */
1082 ptf
= GdipAlloc(sizeof(GpPointF
)*(count
+1));
1085 memcpy(ptf
, points
, sizeof(GpPointF
)*count
);
1087 /* ..and add a first point as a last one */
1088 ptf
[count
] = ptf
[0];
1090 stat
= GdipDrawCurve2(graphics
, pen
, ptf
, count
+ 1, tension
);
1097 GpStatus WINGDIPAPI
GdipDrawClosedCurve2I(GpGraphics
*graphics
, GpPen
*pen
,
1098 GDIPCONST GpPoint
*points
, INT count
, REAL tension
)
1104 if(!points
|| count
<= 0)
1105 return InvalidParameter
;
1107 ptf
= GdipAlloc(sizeof(GpPointF
)*count
);
1111 for(i
= 0; i
< count
; i
++){
1112 ptf
[i
].X
= (REAL
)points
[i
].X
;
1113 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
1116 stat
= GdipDrawClosedCurve2(graphics
, pen
, ptf
, count
, tension
);
1123 GpStatus WINGDIPAPI
GdipDrawCurve(GpGraphics
*graphics
, GpPen
*pen
,
1124 GDIPCONST GpPointF
*points
, INT count
)
1126 return GdipDrawCurve2(graphics
,pen
,points
,count
,1.0);
1129 GpStatus WINGDIPAPI
GdipDrawCurveI(GpGraphics
*graphics
, GpPen
*pen
,
1130 GDIPCONST GpPoint
*points
, INT count
)
1136 if(!points
|| count
<= 0)
1137 return InvalidParameter
;
1139 pointsF
= GdipAlloc(sizeof(GpPointF
)*count
);
1143 for(i
= 0; i
< count
; i
++){
1144 pointsF
[i
].X
= (REAL
)points
[i
].X
;
1145 pointsF
[i
].Y
= (REAL
)points
[i
].Y
;
1148 ret
= GdipDrawCurve(graphics
,pen
,pointsF
,count
);
1154 /* Approximates cardinal spline with Bezier curves. */
1155 GpStatus WINGDIPAPI
GdipDrawCurve2(GpGraphics
*graphics
, GpPen
*pen
,
1156 GDIPCONST GpPointF
*points
, INT count
, REAL tension
)
1158 /* PolyBezier expects count*3-2 points. */
1159 INT i
, len_pt
= count
*3-2, save_state
;
1161 REAL x1
, x2
, y1
, y2
;
1164 if(!graphics
|| !pen
)
1165 return InvalidParameter
;
1167 pt
= GdipAlloc(len_pt
* sizeof(GpPointF
));
1168 tension
= tension
* TENSION_CONST
;
1170 calc_curve_bezier_endp(points
[0].X
, points
[0].Y
, points
[1].X
, points
[1].Y
,
1173 pt
[0].X
= points
[0].X
;
1174 pt
[0].Y
= points
[0].Y
;
1178 for(i
= 0; i
< count
-2; i
++){
1179 calc_curve_bezier(&(points
[i
]), tension
, &x1
, &y1
, &x2
, &y2
);
1183 pt
[3*i
+3].X
= points
[i
+1].X
;
1184 pt
[3*i
+3].Y
= points
[i
+1].Y
;
1189 calc_curve_bezier_endp(points
[count
-1].X
, points
[count
-1].Y
,
1190 points
[count
-2].X
, points
[count
-2].Y
, tension
, &x1
, &y1
);
1192 pt
[len_pt
-2].X
= x1
;
1193 pt
[len_pt
-2].Y
= y1
;
1194 pt
[len_pt
-1].X
= points
[count
-1].X
;
1195 pt
[len_pt
-1].Y
= points
[count
-1].Y
;
1197 save_state
= prepare_dc(graphics
, pen
);
1199 retval
= draw_polybezier(graphics
, pen
, pt
, len_pt
, TRUE
);
1202 restore_dc(graphics
, save_state
);
1207 GpStatus WINGDIPAPI
GdipDrawCurve2I(GpGraphics
*graphics
, GpPen
*pen
,
1208 GDIPCONST GpPoint
*points
, INT count
, REAL tension
)
1214 if(!points
|| count
<= 0)
1215 return InvalidParameter
;
1217 pointsF
= GdipAlloc(sizeof(GpPointF
)*count
);
1221 for(i
= 0; i
< count
; i
++){
1222 pointsF
[i
].X
= (REAL
)points
[i
].X
;
1223 pointsF
[i
].Y
= (REAL
)points
[i
].Y
;
1226 ret
= GdipDrawCurve2(graphics
,pen
,pointsF
,count
,tension
);
1232 GpStatus WINGDIPAPI
GdipDrawEllipse(GpGraphics
*graphics
, GpPen
*pen
, REAL x
,
1233 REAL y
, REAL width
, REAL height
)
1239 if(!graphics
|| !pen
)
1240 return InvalidParameter
;
1244 ptf
[1].X
= x
+ width
;
1245 ptf
[1].Y
= y
+ height
;
1247 save_state
= prepare_dc(graphics
, pen
);
1248 SelectObject(graphics
->hdc
, GetStockObject(NULL_BRUSH
));
1250 transform_and_round_points(graphics
, pti
, ptf
, 2);
1252 Ellipse(graphics
->hdc
, pti
[0].x
, pti
[0].y
, pti
[1].x
, pti
[1].y
);
1254 restore_dc(graphics
, save_state
);
1259 GpStatus WINGDIPAPI
GdipDrawEllipseI(GpGraphics
*graphics
, GpPen
*pen
, INT x
,
1260 INT y
, INT width
, INT height
)
1262 return GdipDrawEllipse(graphics
,pen
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
1266 GpStatus WINGDIPAPI
GdipDrawImage(GpGraphics
*graphics
, GpImage
*image
, REAL x
, REAL y
)
1268 /* IPicture::Render uses LONG coords */
1269 return GdipDrawImageI(graphics
,image
,roundr(x
),roundr(y
));
1272 GpStatus WINGDIPAPI
GdipDrawImageI(GpGraphics
*graphics
, GpImage
*image
, INT x
,
1275 UINT width
, height
, srcw
, srch
;
1277 if(!graphics
|| !image
)
1278 return InvalidParameter
;
1280 GdipGetImageWidth(image
, &width
);
1281 GdipGetImageHeight(image
, &height
);
1283 srcw
= width
* (((REAL
) INCH_HIMETRIC
) /
1284 ((REAL
) GetDeviceCaps(graphics
->hdc
, LOGPIXELSX
)));
1285 srch
= height
* (((REAL
) INCH_HIMETRIC
) /
1286 ((REAL
) GetDeviceCaps(graphics
->hdc
, LOGPIXELSY
)));
1288 if(image
->type
!= ImageTypeMetafile
){
1293 IPicture_Render(image
->picture
, graphics
->hdc
, x
, y
, width
, height
,
1294 0, 0, srcw
, srch
, NULL
);
1299 /* FIXME: partially implemented (only works for rectangular parallelograms) */
1300 GpStatus WINGDIPAPI
GdipDrawImagePointsRect(GpGraphics
*graphics
, GpImage
*image
,
1301 GDIPCONST GpPointF
*points
, INT count
, REAL srcx
, REAL srcy
, REAL srcwidth
,
1302 REAL srcheight
, GpUnit srcUnit
, GDIPCONST GpImageAttributes
* imageAttributes
,
1303 DrawImageAbort callback
, VOID
* callbackData
)
1309 TRACE("%p %p %p %d %f %f %f %f %d %p %p %p\n", graphics
, image
, points
, count
,
1310 srcx
, srcy
, srcwidth
, srcheight
, srcUnit
, imageAttributes
, callback
,
1313 if(!graphics
|| !image
|| !points
|| count
!= 3)
1314 return InvalidParameter
;
1316 if(srcUnit
== UnitInch
)
1317 dx
= dy
= (REAL
) INCH_HIMETRIC
;
1318 else if(srcUnit
== UnitPixel
){
1319 dx
= ((REAL
) INCH_HIMETRIC
) /
1320 ((REAL
) GetDeviceCaps(graphics
->hdc
, LOGPIXELSX
));
1321 dy
= ((REAL
) INCH_HIMETRIC
) /
1322 ((REAL
) GetDeviceCaps(graphics
->hdc
, LOGPIXELSY
));
1325 return NotImplemented
;
1327 memcpy(ptf
, points
, 3 * sizeof(GpPointF
));
1328 transform_and_round_points(graphics
, pti
, ptf
, 3);
1330 /* IPicture renders bitmaps with the y-axis reversed
1331 * FIXME: flipping for unknown image type might not be correct. */
1332 if(image
->type
!= ImageTypeMetafile
){
1335 pti
[0].y
= pti
[2].y
;
1339 if(IPicture_Render(image
->picture
, graphics
->hdc
,
1340 pti
[0].x
, pti
[0].y
, pti
[1].x
- pti
[0].x
, pti
[2].y
- pti
[0].y
,
1341 srcx
* dx
, srcy
* dy
,
1342 srcwidth
* dx
, srcheight
* dy
,
1345 callback(callbackData
);
1346 return GenericError
;
1352 GpStatus WINGDIPAPI
GdipDrawImagePointsRectI(GpGraphics
*graphics
, GpImage
*image
,
1353 GDIPCONST GpPoint
*points
, INT count
, INT srcx
, INT srcy
, INT srcwidth
,
1354 INT srcheight
, GpUnit srcUnit
, GDIPCONST GpImageAttributes
* imageAttributes
,
1355 DrawImageAbort callback
, VOID
* callbackData
)
1357 GpPointF pointsF
[3];
1360 if(!points
|| count
!=3)
1361 return InvalidParameter
;
1363 for(i
= 0; i
< count
; i
++){
1364 pointsF
[i
].X
= (REAL
)points
[i
].X
;
1365 pointsF
[i
].Y
= (REAL
)points
[i
].Y
;
1368 return GdipDrawImagePointsRect(graphics
, image
, pointsF
, count
, (REAL
)srcx
, (REAL
)srcy
,
1369 (REAL
)srcwidth
, (REAL
)srcheight
, srcUnit
, imageAttributes
,
1370 callback
, callbackData
);
1373 GpStatus WINGDIPAPI
GdipDrawImageRectRect(GpGraphics
*graphics
, GpImage
*image
,
1374 REAL dstx
, REAL dsty
, REAL dstwidth
, REAL dstheight
, REAL srcx
, REAL srcy
,
1375 REAL srcwidth
, REAL srcheight
, GpUnit srcUnit
,
1376 GDIPCONST GpImageAttributes
* imageattr
, DrawImageAbort callback
,
1377 VOID
* callbackData
)
1383 points
[1].X
= dstx
+ dstwidth
;
1386 points
[2].Y
= dsty
+ dstheight
;
1388 return GdipDrawImagePointsRect(graphics
, image
, points
, 3, srcx
, srcy
,
1389 srcwidth
, srcheight
, srcUnit
, imageattr
, callback
, callbackData
);
1392 GpStatus WINGDIPAPI
GdipDrawImageRectRectI(GpGraphics
*graphics
, GpImage
*image
,
1393 INT dstx
, INT dsty
, INT dstwidth
, INT dstheight
, INT srcx
, INT srcy
,
1394 INT srcwidth
, INT srcheight
, GpUnit srcUnit
,
1395 GDIPCONST GpImageAttributes
* imageAttributes
, DrawImageAbort callback
,
1396 VOID
* callbackData
)
1402 points
[1].X
= dstx
+ dstwidth
;
1405 points
[2].Y
= dsty
+ dstheight
;
1407 return GdipDrawImagePointsRect(graphics
, image
, points
, 3, srcx
, srcy
,
1408 srcwidth
, srcheight
, srcUnit
, imageAttributes
, callback
, callbackData
);
1411 GpStatus WINGDIPAPI
GdipDrawImageRect(GpGraphics
*graphics
, GpImage
*image
,
1412 REAL x
, REAL y
, REAL width
, REAL height
)
1418 if(!graphics
|| !image
)
1419 return InvalidParameter
;
1421 ret
= GdipGetImageBounds(image
, &bounds
, &unit
);
1425 return GdipDrawImageRectRect(graphics
, image
, x
, y
, width
, height
,
1426 bounds
.X
, bounds
.Y
, bounds
.Width
, bounds
.Height
,
1427 unit
, NULL
, NULL
, NULL
);
1430 GpStatus WINGDIPAPI
GdipDrawImageRectI(GpGraphics
*graphics
, GpImage
*image
,
1431 INT x
, INT y
, INT width
, INT height
)
1433 return GdipDrawImageRect(graphics
, image
, (REAL
)x
, (REAL
)y
, (REAL
)width
, (REAL
)height
);
1436 GpStatus WINGDIPAPI
GdipDrawLine(GpGraphics
*graphics
, GpPen
*pen
, REAL x1
,
1437 REAL y1
, REAL x2
, REAL y2
)
1443 if(!pen
|| !graphics
)
1444 return InvalidParameter
;
1451 save_state
= prepare_dc(graphics
, pen
);
1453 retval
= draw_polyline(graphics
, pen
, pt
, 2, TRUE
);
1455 restore_dc(graphics
, save_state
);
1460 GpStatus WINGDIPAPI
GdipDrawLineI(GpGraphics
*graphics
, GpPen
*pen
, INT x1
,
1461 INT y1
, INT x2
, INT y2
)
1467 if(!pen
|| !graphics
)
1468 return InvalidParameter
;
1475 save_state
= prepare_dc(graphics
, pen
);
1477 retval
= draw_polyline(graphics
, pen
, pt
, 2, TRUE
);
1479 restore_dc(graphics
, save_state
);
1484 GpStatus WINGDIPAPI
GdipDrawLines(GpGraphics
*graphics
, GpPen
*pen
, GDIPCONST
1485 GpPointF
*points
, INT count
)
1490 if(!pen
|| !graphics
|| (count
< 2))
1491 return InvalidParameter
;
1493 save_state
= prepare_dc(graphics
, pen
);
1495 retval
= draw_polyline(graphics
, pen
, points
, count
, TRUE
);
1497 restore_dc(graphics
, save_state
);
1502 GpStatus WINGDIPAPI
GdipDrawLinesI(GpGraphics
*graphics
, GpPen
*pen
, GDIPCONST
1503 GpPoint
*points
, INT count
)
1507 GpPointF
*ptf
= NULL
;
1510 if(!pen
|| !graphics
|| (count
< 2))
1511 return InvalidParameter
;
1513 ptf
= GdipAlloc(count
* sizeof(GpPointF
));
1514 if(!ptf
) return OutOfMemory
;
1516 for(i
= 0; i
< count
; i
++){
1517 ptf
[i
].X
= (REAL
) points
[i
].X
;
1518 ptf
[i
].Y
= (REAL
) points
[i
].Y
;
1521 save_state
= prepare_dc(graphics
, pen
);
1523 retval
= draw_polyline(graphics
, pen
, ptf
, count
, TRUE
);
1525 restore_dc(graphics
, save_state
);
1531 GpStatus WINGDIPAPI
GdipDrawPath(GpGraphics
*graphics
, GpPen
*pen
, GpPath
*path
)
1536 if(!pen
|| !graphics
)
1537 return InvalidParameter
;
1539 save_state
= prepare_dc(graphics
, pen
);
1541 retval
= draw_poly(graphics
, pen
, path
->pathdata
.Points
,
1542 path
->pathdata
.Types
, path
->pathdata
.Count
, TRUE
);
1544 restore_dc(graphics
, save_state
);
1549 GpStatus WINGDIPAPI
GdipDrawPie(GpGraphics
*graphics
, GpPen
*pen
, REAL x
,
1550 REAL y
, REAL width
, REAL height
, REAL startAngle
, REAL sweepAngle
)
1554 if(!graphics
|| !pen
)
1555 return InvalidParameter
;
1557 save_state
= prepare_dc(graphics
, pen
);
1558 SelectObject(graphics
->hdc
, GetStockObject(NULL_BRUSH
));
1560 draw_pie(graphics
, x
, y
, width
, height
, startAngle
, sweepAngle
);
1562 restore_dc(graphics
, save_state
);
1567 GpStatus WINGDIPAPI
GdipDrawPieI(GpGraphics
*graphics
, GpPen
*pen
, INT x
,
1568 INT y
, INT width
, INT height
, REAL startAngle
, REAL sweepAngle
)
1570 return GdipDrawPie(graphics
,pen
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
,startAngle
,sweepAngle
);
1573 GpStatus WINGDIPAPI
GdipDrawRectangle(GpGraphics
*graphics
, GpPen
*pen
, REAL x
,
1574 REAL y
, REAL width
, REAL height
)
1580 if(!pen
|| !graphics
)
1581 return InvalidParameter
;
1585 ptf
[1].X
= x
+ width
;
1587 ptf
[2].X
= x
+ width
;
1588 ptf
[2].Y
= y
+ height
;
1590 ptf
[3].Y
= y
+ height
;
1592 save_state
= prepare_dc(graphics
, pen
);
1593 SelectObject(graphics
->hdc
, GetStockObject(NULL_BRUSH
));
1595 transform_and_round_points(graphics
, pti
, ptf
, 4);
1596 Polygon(graphics
->hdc
, pti
, 4);
1598 restore_dc(graphics
, save_state
);
1603 GpStatus WINGDIPAPI
GdipDrawRectangleI(GpGraphics
*graphics
, GpPen
*pen
, INT x
,
1604 INT y
, INT width
, INT height
)
1606 return GdipDrawRectangle(graphics
,pen
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
1609 GpStatus WINGDIPAPI
GdipDrawRectangles(GpGraphics
*graphics
, GpPen
*pen
,
1610 GDIPCONST GpRectF
* rects
, INT count
)
1616 if(!graphics
|| !pen
|| !rects
|| count
< 1)
1617 return InvalidParameter
;
1619 ptf
= GdipAlloc(4 * count
* sizeof(GpPointF
));
1620 pti
= GdipAlloc(4 * count
* sizeof(POINT
));
1628 for(i
= 0; i
< count
; i
++){
1629 ptf
[4 * i
+ 3].X
= ptf
[4 * i
].X
= rects
[i
].X
;
1630 ptf
[4 * i
+ 1].Y
= ptf
[4 * i
].Y
= rects
[i
].Y
;
1631 ptf
[4 * i
+ 2].X
= ptf
[4 * i
+ 1].X
= rects
[i
].X
+ rects
[i
].Width
;
1632 ptf
[4 * i
+ 3].Y
= ptf
[4 * i
+ 2].Y
= rects
[i
].Y
+ rects
[i
].Height
;
1635 save_state
= prepare_dc(graphics
, pen
);
1636 SelectObject(graphics
->hdc
, GetStockObject(NULL_BRUSH
));
1638 transform_and_round_points(graphics
, pti
, ptf
, 4 * count
);
1640 for(i
= 0; i
< count
; i
++)
1641 Polygon(graphics
->hdc
, &pti
[4 * i
], 4);
1643 restore_dc(graphics
, save_state
);
1651 GpStatus WINGDIPAPI
GdipDrawRectanglesI(GpGraphics
*graphics
, GpPen
*pen
,
1652 GDIPCONST GpRect
* rects
, INT count
)
1658 if(!rects
|| count
<=0)
1659 return InvalidParameter
;
1661 rectsF
= GdipAlloc(sizeof(GpRectF
) * count
);
1665 for(i
= 0;i
< count
;i
++){
1666 rectsF
[i
].X
= (REAL
)rects
[i
].X
;
1667 rectsF
[i
].Y
= (REAL
)rects
[i
].Y
;
1668 rectsF
[i
].Width
= (REAL
)rects
[i
].Width
;
1669 rectsF
[i
].Height
= (REAL
)rects
[i
].Height
;
1672 ret
= GdipDrawRectangles(graphics
, pen
, rectsF
, count
);
1678 GpStatus WINGDIPAPI
GdipDrawString(GpGraphics
*graphics
, GDIPCONST WCHAR
*string
,
1679 INT length
, GDIPCONST GpFont
*font
, GDIPCONST RectF
*rect
,
1680 GDIPCONST GpStringFormat
*format
, GDIPCONST GpBrush
*brush
)
1685 TEXTMETRICW textmet
;
1686 GpPointF pt
[2], rectcpy
[4];
1689 REAL angle
, ang_cos
, ang_sin
, rel_width
, rel_height
;
1690 INT sum
= 0, height
= 0, fit
, fitcpy
, save_state
, i
, j
, lret
, nwidth
,
1695 if(!graphics
|| !string
|| !font
|| !brush
|| !rect
)
1696 return InvalidParameter
;
1698 if((brush
->bt
!= BrushTypeSolidColor
)){
1699 FIXME("not implemented for given parameters\n");
1700 return NotImplemented
;
1704 TRACE("may be ignoring some format flags: attr %x\n", format
->attr
);
1706 if(length
== -1) length
= lstrlenW(string
);
1708 stringdup
= GdipAlloc(length
* sizeof(WCHAR
));
1709 if(!stringdup
) return OutOfMemory
;
1711 save_state
= SaveDC(graphics
->hdc
);
1712 SetBkMode(graphics
->hdc
, TRANSPARENT
);
1713 SetTextColor(graphics
->hdc
, brush
->lb
.lbColor
);
1715 rectcpy
[3].X
= rectcpy
[0].X
= rect
->X
;
1716 rectcpy
[1].Y
= rectcpy
[0].Y
= rect
->Y
;
1717 rectcpy
[2].X
= rectcpy
[1].X
= rect
->X
+ rect
->Width
;
1718 rectcpy
[3].Y
= rectcpy
[2].Y
= rect
->Y
+ rect
->Height
;
1719 transform_and_round_points(graphics
, corners
, rectcpy
, 4);
1721 if(roundr(rect
->Width
) == 0 && roundr(rect
->Height
) == 0){
1722 rel_width
= rel_height
= 1.0;
1723 nwidth
= nheight
= INT_MAX
;
1726 rel_width
= sqrt((corners
[1].x
- corners
[0].x
) * (corners
[1].x
- corners
[0].x
) +
1727 (corners
[1].y
- corners
[0].y
) * (corners
[1].y
- corners
[0].y
))
1729 rel_height
= sqrt((corners
[2].x
- corners
[1].x
) * (corners
[2].x
- corners
[1].x
) +
1730 (corners
[2].y
- corners
[1].y
) * (corners
[2].y
- corners
[1].y
))
1733 nwidth
= roundr(rel_width
* rect
->Width
);
1734 nheight
= roundr(rel_height
* rect
->Height
);
1735 rgn
= CreatePolygonRgn(corners
, 4, ALTERNATE
);
1736 SelectClipRgn(graphics
->hdc
, rgn
);
1739 /* Use gdi to find the font, then perform transformations on it (height,
1741 SelectObject(graphics
->hdc
, CreateFontIndirectW(&font
->lfw
));
1742 GetTextMetricsW(graphics
->hdc
, &textmet
);
1745 lfw
.lfHeight
= roundr(((REAL
)lfw
.lfHeight
) * rel_height
);
1746 lfw
.lfWidth
= roundr(textmet
.tmAveCharWidth
* rel_width
);
1752 GdipTransformMatrixPoints(graphics
->worldtrans
, pt
, 2);
1753 angle
= gdiplus_atan2((pt
[1].Y
- pt
[0].Y
), (pt
[1].X
- pt
[0].X
));
1754 ang_cos
= cos(angle
);
1755 ang_sin
= sin(angle
);
1756 lfw
.lfEscapement
= lfw
.lfOrientation
= -roundr((angle
/ M_PI
) * 1800.0);
1758 gdifont
= CreateFontIndirectW(&lfw
);
1759 DeleteObject(SelectObject(graphics
->hdc
, CreateFontIndirectW(&lfw
)));
1761 for(i
= 0, j
= 0; i
< length
; i
++){
1762 if(!isprintW(string
[i
]) && (string
[i
] != '\n'))
1765 stringdup
[j
] = string
[i
];
1772 while(sum
< length
){
1773 drawcoord
.left
= corners
[0].x
+ roundr(ang_sin
* (REAL
) height
);
1774 drawcoord
.top
= corners
[0].y
+ roundr(ang_cos
* (REAL
) height
);
1776 GetTextExtentExPointW(graphics
->hdc
, stringdup
+ sum
, length
- sum
,
1777 nwidth
, &fit
, NULL
, &size
);
1781 DrawTextW(graphics
->hdc
, stringdup
+ sum
, 1, &drawcoord
, DT_NOCLIP
|
1786 for(lret
= 0; lret
< fit
; lret
++)
1787 if(*(stringdup
+ sum
+ lret
) == '\n')
1790 /* Line break code (may look strange, but it imitates windows). */
1792 fit
= lret
; /* this is not an off-by-one error */
1793 else if(fit
< (length
- sum
)){
1794 if(*(stringdup
+ sum
+ fit
) == ' ')
1795 while(*(stringdup
+ sum
+ fit
) == ' ')
1798 while(*(stringdup
+ sum
+ fit
- 1) != ' '){
1801 if(*(stringdup
+ sum
+ fit
) == '\t')
1810 DrawTextW(graphics
->hdc
, stringdup
+ sum
, min(length
- sum
, fit
),
1811 &drawcoord
, DT_NOCLIP
| DT_EXPANDTABS
);
1813 sum
+= fit
+ (lret
< fitcpy
? 1 : 0);
1816 if(height
> nheight
)
1819 /* Stop if this was a linewrap (but not if it was a linebreak). */
1820 if((lret
== fitcpy
) && format
&& (format
->attr
& StringFormatFlagsNoWrap
))
1824 GdipFree(stringdup
);
1826 DeleteObject(gdifont
);
1828 RestoreDC(graphics
->hdc
, save_state
);
1833 GpStatus WINGDIPAPI
GdipFillEllipse(GpGraphics
*graphics
, GpBrush
*brush
, REAL x
,
1834 REAL y
, REAL width
, REAL height
)
1840 if(!graphics
|| !brush
)
1841 return InvalidParameter
;
1845 ptf
[1].X
= x
+ width
;
1846 ptf
[1].Y
= y
+ height
;
1848 save_state
= SaveDC(graphics
->hdc
);
1849 EndPath(graphics
->hdc
);
1850 SelectObject(graphics
->hdc
, brush
->gdibrush
);
1851 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
1853 transform_and_round_points(graphics
, pti
, ptf
, 2);
1855 Ellipse(graphics
->hdc
, pti
[0].x
, pti
[0].y
, pti
[1].x
, pti
[1].y
);
1857 RestoreDC(graphics
->hdc
, save_state
);
1862 GpStatus WINGDIPAPI
GdipFillEllipseI(GpGraphics
*graphics
, GpBrush
*brush
, INT x
,
1863 INT y
, INT width
, INT height
)
1865 return GdipFillEllipse(graphics
,brush
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
);
1868 GpStatus WINGDIPAPI
GdipFillPath(GpGraphics
*graphics
, GpBrush
*brush
, GpPath
*path
)
1873 if(!brush
|| !graphics
|| !path
)
1874 return InvalidParameter
;
1876 save_state
= SaveDC(graphics
->hdc
);
1877 EndPath(graphics
->hdc
);
1878 SelectObject(graphics
->hdc
, brush
->gdibrush
);
1879 SetPolyFillMode(graphics
->hdc
, (path
->fill
== FillModeAlternate
? ALTERNATE
1882 BeginPath(graphics
->hdc
);
1883 retval
= draw_poly(graphics
, NULL
, path
->pathdata
.Points
,
1884 path
->pathdata
.Types
, path
->pathdata
.Count
, FALSE
);
1889 EndPath(graphics
->hdc
);
1890 FillPath(graphics
->hdc
);
1895 RestoreDC(graphics
->hdc
, save_state
);
1900 GpStatus WINGDIPAPI
GdipFillPie(GpGraphics
*graphics
, GpBrush
*brush
, REAL x
,
1901 REAL y
, REAL width
, REAL height
, REAL startAngle
, REAL sweepAngle
)
1905 if(!graphics
|| !brush
)
1906 return InvalidParameter
;
1908 save_state
= SaveDC(graphics
->hdc
);
1909 EndPath(graphics
->hdc
);
1910 SelectObject(graphics
->hdc
, brush
->gdibrush
);
1911 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
1913 draw_pie(graphics
, x
, y
, width
, height
, startAngle
, sweepAngle
);
1915 RestoreDC(graphics
->hdc
, save_state
);
1920 GpStatus WINGDIPAPI
GdipFillPieI(GpGraphics
*graphics
, GpBrush
*brush
, INT x
,
1921 INT y
, INT width
, INT height
, REAL startAngle
, REAL sweepAngle
)
1923 return GdipFillPie(graphics
,brush
,(REAL
)x
,(REAL
)y
,(REAL
)width
,(REAL
)height
,startAngle
,sweepAngle
);
1926 GpStatus WINGDIPAPI
GdipFillPolygon(GpGraphics
*graphics
, GpBrush
*brush
,
1927 GDIPCONST GpPointF
*points
, INT count
, GpFillMode fillMode
)
1930 GpPointF
*ptf
= NULL
;
1932 GpStatus retval
= Ok
;
1934 if(!graphics
|| !brush
|| !points
|| !count
)
1935 return InvalidParameter
;
1937 ptf
= GdipAlloc(count
* sizeof(GpPointF
));
1938 pti
= GdipAlloc(count
* sizeof(POINT
));
1940 retval
= OutOfMemory
;
1944 memcpy(ptf
, points
, count
* sizeof(GpPointF
));
1946 save_state
= SaveDC(graphics
->hdc
);
1947 EndPath(graphics
->hdc
);
1948 SelectObject(graphics
->hdc
, brush
->gdibrush
);
1949 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
1950 SetPolyFillMode(graphics
->hdc
, (fillMode
== FillModeAlternate
? ALTERNATE
1953 transform_and_round_points(graphics
, pti
, ptf
, count
);
1954 Polygon(graphics
->hdc
, pti
, count
);
1956 RestoreDC(graphics
->hdc
, save_state
);
1965 GpStatus WINGDIPAPI
GdipFillPolygonI(GpGraphics
*graphics
, GpBrush
*brush
,
1966 GDIPCONST GpPoint
*points
, INT count
, GpFillMode fillMode
)
1969 GpPointF
*ptf
= NULL
;
1971 GpStatus retval
= Ok
;
1973 if(!graphics
|| !brush
|| !points
|| !count
)
1974 return InvalidParameter
;
1976 ptf
= GdipAlloc(count
* sizeof(GpPointF
));
1977 pti
= GdipAlloc(count
* sizeof(POINT
));
1979 retval
= OutOfMemory
;
1983 for(i
= 0; i
< count
; i
++){
1984 ptf
[i
].X
= (REAL
) points
[i
].X
;
1985 ptf
[i
].Y
= (REAL
) points
[i
].Y
;
1988 save_state
= SaveDC(graphics
->hdc
);
1989 EndPath(graphics
->hdc
);
1990 SelectObject(graphics
->hdc
, brush
->gdibrush
);
1991 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
1992 SetPolyFillMode(graphics
->hdc
, (fillMode
== FillModeAlternate
? ALTERNATE
1995 transform_and_round_points(graphics
, pti
, ptf
, count
);
1996 Polygon(graphics
->hdc
, pti
, count
);
1998 RestoreDC(graphics
->hdc
, save_state
);
2007 GpStatus WINGDIPAPI
GdipFillRectangle(GpGraphics
*graphics
, GpBrush
*brush
,
2008 REAL x
, REAL y
, REAL width
, REAL height
)
2014 if(!graphics
|| !brush
)
2015 return InvalidParameter
;
2019 ptf
[1].X
= x
+ width
;
2021 ptf
[2].X
= x
+ width
;
2022 ptf
[2].Y
= y
+ height
;
2024 ptf
[3].Y
= y
+ height
;
2026 save_state
= SaveDC(graphics
->hdc
);
2027 EndPath(graphics
->hdc
);
2028 SelectObject(graphics
->hdc
, brush
->gdibrush
);
2029 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
2031 transform_and_round_points(graphics
, pti
, ptf
, 4);
2033 Polygon(graphics
->hdc
, pti
, 4);
2035 RestoreDC(graphics
->hdc
, save_state
);
2040 GpStatus WINGDIPAPI
GdipFillRectangleI(GpGraphics
*graphics
, GpBrush
*brush
,
2041 INT x
, INT y
, INT width
, INT height
)
2047 if(!graphics
|| !brush
)
2048 return InvalidParameter
;
2052 ptf
[1].X
= x
+ width
;
2054 ptf
[2].X
= x
+ width
;
2055 ptf
[2].Y
= y
+ height
;
2057 ptf
[3].Y
= y
+ height
;
2059 save_state
= SaveDC(graphics
->hdc
);
2060 EndPath(graphics
->hdc
);
2061 SelectObject(graphics
->hdc
, brush
->gdibrush
);
2062 SelectObject(graphics
->hdc
, GetStockObject(NULL_PEN
));
2064 transform_and_round_points(graphics
, pti
, ptf
, 4);
2066 Polygon(graphics
->hdc
, pti
, 4);
2068 RestoreDC(graphics
->hdc
, save_state
);
2073 GpStatus WINGDIPAPI
GdipFillRectangles(GpGraphics
*graphics
, GpBrush
*brush
, GDIPCONST GpRectF
*rects
,
2080 return InvalidParameter
;
2082 for(i
= 0; i
< count
; i
++){
2083 ret
= GdipFillRectangle(graphics
, brush
, rects
[i
].X
, rects
[i
].Y
, rects
[i
].Width
, rects
[i
].Height
);
2084 if(ret
!= Ok
) return ret
;
2090 GpStatus WINGDIPAPI
GdipFillRectanglesI(GpGraphics
*graphics
, GpBrush
*brush
, GDIPCONST GpRect
*rects
,
2097 if(!rects
|| count
<= 0)
2098 return InvalidParameter
;
2100 rectsF
= GdipAlloc(sizeof(GpRectF
)*count
);
2104 for(i
= 0; i
< count
; i
++){
2105 rectsF
[i
].X
= (REAL
)rects
[i
].X
;
2106 rectsF
[i
].Y
= (REAL
)rects
[i
].Y
;
2107 rectsF
[i
].X
= (REAL
)rects
[i
].Width
;
2108 rectsF
[i
].Height
= (REAL
)rects
[i
].Height
;
2111 ret
= GdipFillRectangles(graphics
,brush
,rectsF
,count
);
2117 GpStatus WINGDIPAPI
GdipFillRegion(GpGraphics
* graphics
, GpBrush
* brush
,
2120 if (!(graphics
&& brush
&& region
))
2121 return InvalidParameter
;
2123 FIXME("(%p, %p, %p): stub\n", graphics
, brush
, region
);
2125 return NotImplemented
;
2128 GpStatus WINGDIPAPI
GdipFlush(GpGraphics
*graphics
, GpFlushIntention intention
)
2133 return InvalidParameter
;
2136 FIXME("not implemented\n");
2138 return NotImplemented
;
2141 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
2142 GpStatus WINGDIPAPI
GdipGetCompositingMode(GpGraphics
*graphics
,
2143 CompositingMode
*mode
)
2145 if(!graphics
|| !mode
)
2146 return InvalidParameter
;
2148 *mode
= graphics
->compmode
;
2153 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
2154 GpStatus WINGDIPAPI
GdipGetCompositingQuality(GpGraphics
*graphics
,
2155 CompositingQuality
*quality
)
2157 if(!graphics
|| !quality
)
2158 return InvalidParameter
;
2160 *quality
= graphics
->compqual
;
2165 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
2166 GpStatus WINGDIPAPI
GdipGetInterpolationMode(GpGraphics
*graphics
,
2167 InterpolationMode
*mode
)
2169 if(!graphics
|| !mode
)
2170 return InvalidParameter
;
2172 *mode
= graphics
->interpolation
;
2177 GpStatus WINGDIPAPI
GdipGetPageScale(GpGraphics
*graphics
, REAL
*scale
)
2179 if(!graphics
|| !scale
)
2180 return InvalidParameter
;
2182 *scale
= graphics
->scale
;
2187 GpStatus WINGDIPAPI
GdipGetPageUnit(GpGraphics
*graphics
, GpUnit
*unit
)
2189 if(!graphics
|| !unit
)
2190 return InvalidParameter
;
2192 *unit
= graphics
->unit
;
2197 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
2198 GpStatus WINGDIPAPI
GdipGetPixelOffsetMode(GpGraphics
*graphics
, PixelOffsetMode
2201 if(!graphics
|| !mode
)
2202 return InvalidParameter
;
2204 *mode
= graphics
->pixeloffset
;
2209 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
2210 GpStatus WINGDIPAPI
GdipGetSmoothingMode(GpGraphics
*graphics
, SmoothingMode
*mode
)
2212 if(!graphics
|| !mode
)
2213 return InvalidParameter
;
2215 *mode
= graphics
->smoothing
;
2220 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
2221 GpStatus WINGDIPAPI
GdipGetTextRenderingHint(GpGraphics
*graphics
,
2222 TextRenderingHint
*hint
)
2224 if(!graphics
|| !hint
)
2225 return InvalidParameter
;
2227 *hint
= graphics
->texthint
;
2232 GpStatus WINGDIPAPI
GdipGetWorldTransform(GpGraphics
*graphics
, GpMatrix
*matrix
)
2234 if(!graphics
|| !matrix
)
2235 return InvalidParameter
;
2237 *matrix
= *graphics
->worldtrans
;
2241 GpStatus WINGDIPAPI
GdipMeasureCharacterRanges(GpGraphics
* graphics
,
2242 GDIPCONST WCHAR
* string
, INT length
, GDIPCONST GpFont
* font
,
2243 GDIPCONST RectF
* layoutRect
, GDIPCONST GpStringFormat
*stringFormat
,
2244 INT regionCount
, GpRegion
** regions
)
2246 if (!(graphics
&& string
&& font
&& layoutRect
&& stringFormat
&& regions
))
2247 return InvalidParameter
;
2249 FIXME("stub: %p %s %d %p %p %p %d %p\n", graphics
, debugstr_w(string
),
2250 length
, font
, layoutRect
, stringFormat
, regionCount
, regions
);
2252 return NotImplemented
;
2255 /* Find the smallest rectangle that bounds the text when it is printed in rect
2256 * according to the format options listed in format. If rect has 0 width and
2257 * height, then just find the smallest rectangle that bounds the text when it's
2258 * printed at location (rect->X, rect-Y). */
2259 GpStatus WINGDIPAPI
GdipMeasureString(GpGraphics
*graphics
,
2260 GDIPCONST WCHAR
*string
, INT length
, GDIPCONST GpFont
*font
,
2261 GDIPCONST RectF
*rect
, GDIPCONST GpStringFormat
*format
, RectF
*bounds
,
2262 INT
*codepointsfitted
, INT
*linesfilled
)
2266 INT sum
= 0, height
= 0, fit
, fitcpy
, max_width
= 0, i
, j
, lret
, nwidth
,
2270 if(!graphics
|| !string
|| !font
|| !rect
)
2271 return InvalidParameter
;
2273 if(codepointsfitted
|| linesfilled
){
2274 FIXME("not implemented for given parameters\n");
2275 return NotImplemented
;
2279 TRACE("may be ignoring some format flags: attr %x\n", format
->attr
);
2281 if(length
== -1) length
= lstrlenW(string
);
2283 stringdup
= GdipAlloc(length
* sizeof(WCHAR
));
2284 if(!stringdup
) return OutOfMemory
;
2286 oldfont
= SelectObject(graphics
->hdc
, CreateFontIndirectW(&font
->lfw
));
2287 nwidth
= roundr(rect
->Width
);
2288 nheight
= roundr(rect
->Height
);
2290 if((nwidth
== 0) && (nheight
== 0))
2291 nwidth
= nheight
= INT_MAX
;
2293 for(i
= 0, j
= 0; i
< length
; i
++){
2294 if(!isprintW(string
[i
]) && (string
[i
] != '\n'))
2297 stringdup
[j
] = string
[i
];
2304 while(sum
< length
){
2305 GetTextExtentExPointW(graphics
->hdc
, stringdup
+ sum
, length
- sum
,
2306 nwidth
, &fit
, NULL
, &size
);
2312 for(lret
= 0; lret
< fit
; lret
++)
2313 if(*(stringdup
+ sum
+ lret
) == '\n')
2316 /* Line break code (may look strange, but it imitates windows). */
2318 fit
= lret
; /* this is not an off-by-one error */
2319 else if(fit
< (length
- sum
)){
2320 if(*(stringdup
+ sum
+ fit
) == ' ')
2321 while(*(stringdup
+ sum
+ fit
) == ' ')
2324 while(*(stringdup
+ sum
+ fit
- 1) != ' '){
2327 if(*(stringdup
+ sum
+ fit
) == '\t')
2337 GetTextExtentExPointW(graphics
->hdc
, stringdup
+ sum
, fit
,
2338 nwidth
, &j
, NULL
, &size
);
2340 sum
+= fit
+ (lret
< fitcpy
? 1 : 0);
2342 max_width
= max(max_width
, size
.cx
);
2344 if(height
> nheight
)
2347 /* Stop if this was a linewrap (but not if it was a linebreak). */
2348 if((lret
== fitcpy
) && format
&& (format
->attr
& StringFormatFlagsNoWrap
))
2352 bounds
->X
= rect
->X
;
2353 bounds
->Y
= rect
->Y
;
2354 bounds
->Width
= (REAL
)max_width
;
2355 bounds
->Height
= (REAL
) min(height
, nheight
);
2357 GdipFree(stringdup
);
2358 DeleteObject(SelectObject(graphics
->hdc
, oldfont
));
2363 GpStatus WINGDIPAPI
GdipRestoreGraphics(GpGraphics
*graphics
, GraphicsState state
)
2368 return InvalidParameter
;
2371 FIXME("graphics state not implemented\n");
2373 return NotImplemented
;
2376 GpStatus WINGDIPAPI
GdipRotateWorldTransform(GpGraphics
*graphics
, REAL angle
,
2377 GpMatrixOrder order
)
2380 return InvalidParameter
;
2382 return GdipRotateMatrix(graphics
->worldtrans
, angle
, order
);
2385 GpStatus WINGDIPAPI
GdipSaveGraphics(GpGraphics
*graphics
, GraphicsState
*state
)
2389 if(!graphics
|| !state
)
2390 return InvalidParameter
;
2393 FIXME("graphics state not implemented\n");
2395 return NotImplemented
;
2398 GpStatus WINGDIPAPI
GdipScaleWorldTransform(GpGraphics
*graphics
, REAL sx
,
2399 REAL sy
, GpMatrixOrder order
)
2402 return InvalidParameter
;
2404 return GdipScaleMatrix(graphics
->worldtrans
, sx
, sy
, order
);
2407 GpStatus WINGDIPAPI
GdipSetCompositingMode(GpGraphics
*graphics
,
2408 CompositingMode mode
)
2411 return InvalidParameter
;
2413 graphics
->compmode
= mode
;
2418 GpStatus WINGDIPAPI
GdipSetCompositingQuality(GpGraphics
*graphics
,
2419 CompositingQuality quality
)
2422 return InvalidParameter
;
2424 graphics
->compqual
= quality
;
2429 GpStatus WINGDIPAPI
GdipSetInterpolationMode(GpGraphics
*graphics
,
2430 InterpolationMode mode
)
2433 return InvalidParameter
;
2435 graphics
->interpolation
= mode
;
2440 GpStatus WINGDIPAPI
GdipSetPageScale(GpGraphics
*graphics
, REAL scale
)
2442 if(!graphics
|| (scale
<= 0.0))
2443 return InvalidParameter
;
2445 graphics
->scale
= scale
;
2450 GpStatus WINGDIPAPI
GdipSetPageUnit(GpGraphics
*graphics
, GpUnit unit
)
2452 if(!graphics
|| (unit
== UnitWorld
))
2453 return InvalidParameter
;
2455 graphics
->unit
= unit
;
2460 GpStatus WINGDIPAPI
GdipSetPixelOffsetMode(GpGraphics
*graphics
, PixelOffsetMode
2464 return InvalidParameter
;
2466 graphics
->pixeloffset
= mode
;
2471 GpStatus WINGDIPAPI
GdipSetSmoothingMode(GpGraphics
*graphics
, SmoothingMode mode
)
2474 return InvalidParameter
;
2476 graphics
->smoothing
= mode
;
2481 GpStatus WINGDIPAPI
GdipSetTextRenderingHint(GpGraphics
*graphics
,
2482 TextRenderingHint hint
)
2485 return InvalidParameter
;
2487 graphics
->texthint
= hint
;
2492 GpStatus WINGDIPAPI
GdipSetWorldTransform(GpGraphics
*graphics
, GpMatrix
*matrix
)
2494 if(!graphics
|| !matrix
)
2495 return InvalidParameter
;
2497 GdipDeleteMatrix(graphics
->worldtrans
);
2498 return GdipCloneMatrix(matrix
, &graphics
->worldtrans
);
2501 GpStatus WINGDIPAPI
GdipTranslateWorldTransform(GpGraphics
*graphics
, REAL dx
,
2502 REAL dy
, GpMatrixOrder order
)
2505 return InvalidParameter
;
2507 return GdipTranslateMatrix(graphics
->worldtrans
, dx
, dy
, order
);
2510 GpStatus WINGDIPAPI
GdipSetClipRectI(GpGraphics
*graphics
, INT x
, INT y
,
2511 INT width
, INT height
,
2512 CombineMode combineMode
)
2517 FIXME("not implemented\n");
2519 return NotImplemented
;
2522 GpStatus WINGDIPAPI
GdipSetClipRegion(GpGraphics
*graphics
, GpRegion
*region
,
2523 CombineMode combineMode
)
2528 FIXME("not implemented\n");
2530 return NotImplemented
;
2533 GpStatus WINGDIPAPI
GdipSetMetafileDownLevelRasterizationLimit(GpGraphics
*graphics
,
2539 FIXME("not implemented\n");
2541 return NotImplemented
;
2544 GpStatus WINGDIPAPI
GdipDrawPolygon(GpGraphics
*graphics
,GpPen
*pen
,GDIPCONST GpPointF
*points
,
2550 if(!graphics
|| !pen
|| count
<=0)
2551 return InvalidParameter
;
2553 pti
= GdipAlloc(sizeof(POINT
) * count
);
2555 save_state
= prepare_dc(graphics
, pen
);
2556 SelectObject(graphics
->hdc
, GetStockObject(NULL_BRUSH
));
2558 transform_and_round_points(graphics
, pti
, (GpPointF
*)points
, count
);
2559 Polygon(graphics
->hdc
, pti
, count
);
2561 restore_dc(graphics
, save_state
);
2567 GpStatus WINGDIPAPI
GdipDrawPolygonI(GpGraphics
*graphics
,GpPen
*pen
,GDIPCONST GpPoint
*points
,
2574 if(count
<=0) return InvalidParameter
;
2575 ptf
= GdipAlloc(sizeof(GpPointF
) * count
);
2577 for(i
= 0;i
< count
; i
++){
2578 ptf
[i
].X
= (REAL
)points
[i
].X
;
2579 ptf
[i
].Y
= (REAL
)points
[i
].Y
;
2582 ret
= GdipDrawPolygon(graphics
,pen
,ptf
,count
);
2588 GpStatus WINGDIPAPI
GdipGetDpiX(GpGraphics
*graphics
, REAL
* dpi
)
2590 if(!graphics
|| !dpi
)
2591 return InvalidParameter
;
2593 *dpi
= (REAL
)GetDeviceCaps(graphics
->hdc
, LOGPIXELSX
);
2598 GpStatus WINGDIPAPI
GdipGetDpiY(GpGraphics
*graphics
, REAL
* dpi
)
2600 if(!graphics
|| !dpi
)
2601 return InvalidParameter
;
2603 *dpi
= (REAL
)GetDeviceCaps(graphics
->hdc
, LOGPIXELSY
);
2608 GpStatus WINGDIPAPI
GdipMultiplyWorldTransform(GpGraphics
*graphics
, GDIPCONST GpMatrix
*matrix
,
2609 GpMatrixOrder order
)
2614 if(!graphics
|| !matrix
)
2615 return InvalidParameter
;
2617 m
= *(graphics
->worldtrans
);
2619 ret
= GdipMultiplyMatrix(&m
, (GpMatrix
*)matrix
, order
);
2621 *(graphics
->worldtrans
) = m
;
2626 GpStatus WINGDIPAPI
GdipGetDC(GpGraphics
*graphics
, HDC
*hdc
)
2628 FIXME("(%p, %p): stub\n", graphics
, hdc
);
2631 return NotImplemented
;
2634 GpStatus WINGDIPAPI
GdipReleaseDC(GpGraphics
*graphics
, HDC hdc
)
2636 FIXME("(%p, %p): stub\n", graphics
, hdc
);
2638 return NotImplemented
;
2641 GpStatus WINGDIPAPI
GdipGetClip(GpGraphics
*graphics
, GpRegion
*region
)
2643 FIXME("(%p, %p): stub\n", graphics
, region
);
2645 return NotImplemented
;
2648 GpStatus WINGDIPAPI
GdipTransformPoints(GpGraphics
*graphics
, GpCoordinateSpace dst_space
,
2649 GpCoordinateSpace src_space
, GpPointF
*points
, INT count
)
2651 FIXME("(%p, %d, %d, %p, %d): stub\n", graphics
, dst_space
, src_space
, points
, count
);
2653 return NotImplemented
;
2656 GpStatus WINGDIPAPI
GdipTransformPointsI(GpGraphics
*graphics
, GpCoordinateSpace dst_space
,
2657 GpCoordinateSpace src_space
, GpPoint
*points
, INT count
)
2659 FIXME("(%p, %d, %d, %p, %d): stub\n", graphics
, dst_space
, src_space
, points
, count
);
2661 return NotImplemented
;