?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Add utility function get_visible_clip_region.
[wine/multimedia.git] / dlls / gdiplus / graphics.c
blob297393a72d8b466e29955f0b79b3a73c9937365f
1 /*
2 * Copyright (C) 2007 Google (Evan Stade)
3 *
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.
8 *
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.
13 *
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
17 */
18
19 #include <stdarg.h>
20 #include <math.h>
21 #include <limits.h>
22
23 #include "windef.h"
24 #include "winbase.h"
25 #include "winuser.h"
26 #include "wingdi.h"
27 #include "wine/unicode.h"
28
29 #define COBJMACROS
30 #include "objbase.h"
31 #include "ocidl.h"
32 #include "olectl.h"
33 #include "ole2.h"
34
35 #include "winreg.h"
36 #include "shlwapi.h"
37
38 #include "gdiplus.h"
39 #include "gdiplus_private.h"
40 #include "wine/debug.h"
41 #include "wine/list.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
44
45 /* looks-right constants */
46 #define ANCHOR_WIDTH (2.0)
47 #define MAX_ITERS (50)
48
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)
51 {
52 REAL radAngle, hypotenuse;
53
54 radAngle = deg2rad(angle);
55 hypotenuse = 50.0; /* arbitrary */
56
57 *x = x_0 + cos(radAngle) * hypotenuse;
58 *y = y_0 + sin(radAngle) * hypotenuse;
59 }
60
61 /* Converts from gdiplus path point type to gdi path point type. */
62 static BYTE convert_path_point_type(BYTE type)
63 {
64 BYTE ret;
65
66 switch(type & PathPointTypePathTypeMask){
67 case PathPointTypeBezier:
68 ret = PT_BEZIERTO;
69 break;
70 case PathPointTypeLine:
71 ret = PT_LINETO;
72 break;
73 case PathPointTypeStart:
74 ret = PT_MOVETO;
75 break;
76 default:
77 ERR("Bad point type\n");
78 return 0;
79 }
80
81 if(type & PathPointTypeCloseSubpath)
82 ret |= PT_CLOSEFIGURE;
83
84 return ret;
85 }
86
87 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
88 {
89 HPEN gdipen;
90 REAL width;
91 INT save_state = SaveDC(graphics->hdc), i, numdashes;
92 GpPointF pt[2];
93 DWORD dash_array[MAX_DASHLEN];
94
95 EndPath(graphics->hdc);
96
97 if(pen->unit == UnitPixel){
98 width = pen->width;
99 }
100 else{
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.) */
103 pt[0].X = 0.0;
104 pt[0].Y = 0.0;
105 pt[1].X = 1.0;
106 pt[1].Y = 1.0;
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);
110
111 width *= pen->width * convert_unit(graphics->hdc,
112 pen->unit == UnitWorld ? graphics->unit : pen->unit);
113 }
114
115 if(pen->dash == DashStyleCustom){
116 numdashes = min(pen->numdashes, MAX_DASHLEN);
117
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]);
122 }
123 TRACE("\n and the pen style is %x\n", pen->style);
124
125 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
126 numdashes, dash_array);
127 }
128 else
129 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
130
131 SelectObject(graphics->hdc, gdipen);
132
133 return save_state;
134 }
135
136 static void restore_dc(GpGraphics *graphics, INT state)
137 {
138 DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
139 RestoreDC(graphics->hdc, state);
140 }
141
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
144 * least:
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.
151 */
152 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
153 GpPointF *ptf, INT count)
154 {
155 REAL unitscale;
156 GpMatrix *matrix;
157 int i;
158
159 unitscale = convert_unit(graphics->hdc, graphics->unit);
160
161 /* apply page scale */
162 if(graphics->unit != UnitDisplay)
163 unitscale *= graphics->scale;
164
165 GdipCloneMatrix(graphics->worldtrans, &matrix);
166 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
167 GdipTransformMatrixPoints(matrix, ptf, count);
168 GdipDeleteMatrix(matrix);
169
170 for(i = 0; i < count; i++){
171 pti[i].x = roundr(ptf[i].X);
172 pti[i].y = roundr(ptf[i].Y);
173 }
174 }
175
176 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
177 {
178 ARGB result=0;
179 ARGB i;
180 for (i=0xff; i<=0xff0000; i = i << 8)
181 result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
182 return result;
183 }
184
185 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
186 {
187 REAL blendfac;
188
189 /* clamp to between 0.0 and 1.0, using the wrap mode */
190 if (brush->wrap == WrapModeTile)
191 {
192 position = fmodf(position, 1.0f);
193 if (position < 0.0f) position += 1.0f;
194 }
195 else /* WrapModeFlip* */
196 {
197 position = fmodf(position, 2.0f);
198 if (position < 0.0f) position += 2.0f;
199 if (position > 1.0f) position = 2.0f - position;
200 }
201
202 if (brush->blendcount == 1)
203 blendfac = position;
204 else
205 {
206 int i=1;
207 REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
208 REAL range;
209
210 /* locate the blend positions surrounding this position */
211 while (position > brush->blendpos[i])
212 i++;
213
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;
222 }
223 return blend_colors(brush->startcolor, brush->endcolor, blendfac);
224 }
225
226 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
227 {
228 switch (brush->bt)
229 {
230 case BrushTypeLinearGradient:
231 {
232 GpLineGradient *line = (GpLineGradient*)brush;
233 RECT rc;
234
235 SelectClipPath(graphics->hdc, RGN_AND);
236 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
237 {
238 GpPointF endpointsf[2];
239 POINT endpointsi[2];
240 POINT poly[4];
241
242 SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
243
244 endpointsf[0] = line->startpoint;
245 endpointsf[1] = line->endpoint;
246 transform_and_round_points(graphics, endpointsi, endpointsf, 2);
247
248 if (abs(endpointsi[0].x-endpointsi[1].x) > abs(endpointsi[0].y-endpointsi[1].y))
249 {
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 */
253 int width;
254 COLORREF col;
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 */
257 int x;
258 int tilt; /* horizontal distance covered by a gradient line */
259
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;
265
266 if (startx >= startbottomx)
267 {
268 leftx = rc.left;
269 rightx = rc.right + tilt;
270 }
271 else
272 {
273 leftx = rc.left + tilt;
274 rightx = rc.right;
275 }
276
277 poly[0].y = rc.bottom;
278 poly[1].y = rc.top;
279 poly[2].y = rc.top;
280 poly[3].y = rc.bottom;
281
282 for (x=leftx; x<=rightx; x++)
283 {
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;
289 poly[1].x = x - 1;
290 poly[2].x = x;
291 poly[3].x = x - tilt;
292 Polygon(graphics->hdc, poly, 4);
293 SelectObject(graphics->hdc, hprevbrush);
294 DeleteObject(hbrush);
295 }
296 }
297 else if (endpointsi[0].y != endpointsi[1].y)
298 {
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 */
302 int height;
303 COLORREF col;
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 */
306 int y;
307 int tilt; /* vertical distance covered by a gradient line */
308
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;
314
315 if (starty >= startrighty)
316 {
317 topy = rc.top;
318 bottomy = rc.bottom + tilt;
319 }
320 else
321 {
322 topy = rc.top + tilt;
323 bottomy = rc.bottom;
324 }
325
326 poly[0].x = rc.right;
327 poly[1].x = rc.left;
328 poly[2].x = rc.left;
329 poly[3].x = rc.right;
330
331 for (y=topy; y<=bottomy; y++)
332 {
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;
338 poly[1].y = y - 1;
339 poly[2].y = y;
340 poly[3].y = y - tilt;
341 Polygon(graphics->hdc, poly, 4);
342 SelectObject(graphics->hdc, hprevbrush);
343 DeleteObject(hbrush);
344 }
345 }
346 /* else startpoint == endpoint */
347 }
348 break;
349 }
350 case BrushTypeSolidColor:
351 {
352 GpSolidFill *fill = (GpSolidFill*)brush;
353 if (fill->bmp)
354 {
355 RECT rc;
356 /* partially transparent fill */
357
358 SelectClipPath(graphics->hdc, RGN_AND);
359 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
360 {
361 HDC hdc = CreateCompatibleDC(NULL);
362 HBITMAP oldbmp;
363 BLENDFUNCTION bf;
364
365 if (!hdc) break;
366
367 oldbmp = SelectObject(hdc, fill->bmp);
368
369 bf.BlendOp = AC_SRC_OVER;
370 bf.BlendFlags = 0;
371 bf.SourceConstantAlpha = 255;
372 bf.AlphaFormat = AC_SRC_ALPHA;
373
374 GdiAlphaBlend(graphics->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdc, 0, 0, 1, 1, bf);
375
376 SelectObject(hdc, oldbmp);
377 DeleteDC(hdc);
378 }
379
380 break;
381 }
382 /* else fall through */
383 }
384 default:
385 SelectObject(graphics->hdc, brush->gdibrush);
386 FillPath(graphics->hdc);
387 break;
388 }
389 }
390
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)
394 {
395 GpPointF ptf[4];
396 POINT pti[4];
397
398 ptf[0].X = x;
399 ptf[0].Y = y;
400 ptf[1].X = x + width;
401 ptf[1].Y = y + height;
402
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);
405
406 transform_and_round_points(graphics, pti, ptf, 4);
407
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);
410 }
411
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)
417 {
418 HGDIOBJ oldbrush = NULL, oldpen = NULL;
419 GpMatrix *matrix = NULL;
420 HBRUSH brush = NULL;
421 HPEN pen = NULL;
422 PointF ptf[4], *custptf = NULL;
423 POINT pt[4], *custpt = NULL;
424 BYTE *tp = NULL;
425 REAL theta, dsmall, dbig, dx, dy = 0.0;
426 INT i, count;
427 LOGBRUSH lb;
428 BOOL customstroke;
429
430 if((x1 == x2) && (y1 == y2))
431 return;
432
433 theta = gdiplus_atan2(y2 - y1, x2 - x1);
434
435 customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
436 if(!customstroke){
437 brush = CreateSolidBrush(color);
438 lb.lbStyle = BS_SOLID;
439 lb.lbColor = color;
440 lb.lbHatch = 0;
441 pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
442 PS_JOIN_MITER, 1, &lb, 0,
443 NULL);
444 oldbrush = SelectObject(graphics->hdc, brush);
445 oldpen = SelectObject(graphics->hdc, pen);
446 }
447
448 switch(cap){
449 case LineCapFlat:
450 break;
451 case LineCapSquare:
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;
458 }
459 else{
460 dsmall = cos(theta + M_PI_4) * size;
461 dbig = sin(theta + M_PI_4) * size;
462 }
463
464 ptf[0].X = x2 - dsmall;
465 ptf[1].X = x2 + dbig;
466
467 ptf[0].Y = y2 - dbig;
468 ptf[3].Y = y2 + dsmall;
469
470 ptf[1].Y = y2 - dsmall;
471 ptf[2].Y = y2 + dbig;
472
473 ptf[3].X = x2 - dbig;
474 ptf[2].X = x2 + dsmall;
475
476 transform_and_round_points(graphics, pt, ptf, 4);
477 Polygon(graphics->hdc, pt, 4);
478
479 break;
480 case LineCapArrowAnchor:
481 size = size * 4.0 / sqrt(3.0);
482
483 dx = cos(M_PI / 6.0 + theta) * size;
484 dy = sin(M_PI / 6.0 + theta) * size;
485
486 ptf[0].X = x2 - dx;
487 ptf[0].Y = y2 - dy;
488
489 dx = cos(- M_PI / 6.0 + theta) * size;
490 dy = sin(- M_PI / 6.0 + theta) * size;
491
492 ptf[1].X = x2 - dx;
493 ptf[1].Y = y2 - dy;
494
495 ptf[2].X = x2;
496 ptf[2].Y = y2;
497
498 transform_and_round_points(graphics, pt, ptf, 3);
499 Polygon(graphics->hdc, pt, 3);
500
501 break;
502 case LineCapRoundAnchor:
503 dx = dy = ANCHOR_WIDTH * size / 2.0;
504
505 ptf[0].X = x2 - dx;
506 ptf[0].Y = y2 - dy;
507 ptf[1].X = x2 + dx;
508 ptf[1].Y = y2 + dy;
509
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);
512
513 break;
514 case LineCapTriangle:
515 size = size / 2.0;
516 dx = cos(M_PI_2 + theta) * size;
517 dy = sin(M_PI_2 + theta) * size;
518
519 ptf[0].X = x2 - dx;
520 ptf[0].Y = y2 - dy;
521 ptf[1].X = x2 + dx;
522 ptf[1].Y = y2 + dy;
523
524 dx = cos(theta) * size;
525 dy = sin(theta) * size;
526
527 ptf[2].X = x2 + dx;
528 ptf[2].Y = y2 + dy;
529
530 transform_and_round_points(graphics, pt, ptf, 3);
531 Polygon(graphics->hdc, pt, 3);
532
533 break;
534 case LineCapRound:
535 dx = dy = size / 2.0;
536
537 ptf[0].X = x2 - dx;
538 ptf[0].Y = y2 - dy;
539 ptf[1].X = x2 + dx;
540 ptf[1].Y = y2 + dy;
541
542 dx = -cos(M_PI_2 + theta) * size;
543 dy = -sin(M_PI_2 + theta) * size;
544
545 ptf[2].X = x2 - dx;
546 ptf[2].Y = y2 - dy;
547 ptf[3].X = x2 + dx;
548 ptf[3].Y = y2 + dy;
549
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);
553
554 break;
555 case LineCapCustom:
556 if(!custom)
557 break;
558
559 count = custom->pathdata.Count;
560 custptf = GdipAlloc(count * sizeof(PointF));
561 custpt = GdipAlloc(count * sizeof(POINT));
562 tp = GdipAlloc(count);
563
564 if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
565 goto custend;
566
567 memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
568
569 GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
570 GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
571 MatrixOrderAppend);
572 GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
573 GdipTransformMatrixPoints(matrix, custptf, count);
574
575 transform_and_round_points(graphics, custpt, custptf, count);
576
577 for(i = 0; i < count; i++)
578 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
579
580 if(custom->fill){
581 BeginPath(graphics->hdc);
582 PolyDraw(graphics->hdc, custpt, tp, count);
583 EndPath(graphics->hdc);
584 StrokeAndFillPath(graphics->hdc);
585 }
586 else
587 PolyDraw(graphics->hdc, custpt, tp, count);
588
589 custend:
590 GdipFree(custptf);
591 GdipFree(custpt);
592 GdipFree(tp);
593 GdipDeleteMatrix(matrix);
594 break;
595 default:
596 break;
597 }
598
599 if(!customstroke){
600 SelectObject(graphics->hdc, oldbrush);
601 SelectObject(graphics->hdc, oldpen);
602 DeleteObject(brush);
603 DeleteObject(pen);
604 }
605 }
606
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)
611 {
612 REAL dist, theta, dx, dy;
613
614 if((y1 == *y2) && (x1 == *x2))
615 return;
616
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;
621
622 *x2 = *x2 + dx;
623 *y2 = *y2 + dy;
624 }
625
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)
630 {
631 REAL dx, dy, percent;
632
633 dx = *x2 - x1;
634 dy = *y2 - y1;
635 if(dx == 0 && dy == 0)
636 return;
637
638 percent = amt / sqrt(dx * dx + dy * dy);
639 if(percent >= 1.0){
640 *x2 = x1;
641 *y2 = y1;
642 return;
643 }
644
645 shorten_line_percent(x1, y1, x2, y2, percent);
646 }
647
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)
652 {
653 POINT *pti = NULL;
654 GpPointF *ptcopy = NULL;
655 GpStatus status = GenericError;
656
657 if(!count)
658 return Ok;
659
660 pti = GdipAlloc(count * sizeof(POINT));
661 ptcopy = GdipAlloc(count * sizeof(GpPointF));
662
663 if(!pti || !ptcopy){
664 status = OutOfMemory;
665 goto end;
666 }
667
668 memcpy(ptcopy, pt, count * sizeof(GpPointF));
669
670 if(caps){
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);
678
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);
686
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);
691 }
692
693 transform_and_round_points(graphics, pti, ptcopy, count);
694
695 if(Polyline(graphics->hdc, pti, count))
696 status = Ok;
697
698 end:
699 GdipFree(pti);
700 GdipFree(ptcopy);
701
702 return status;
703 }
704
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)
713 {
714 GpPointF origpt[4];
715 REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
716 INT i, first = 0, second = 1, third = 2, fourth = 3;
717
718 if(rev){
719 first = 3;
720 second = 2;
721 third = 1;
722 fourth = 0;
723 }
724
725 origx = pt[fourth].X;
726 origy = pt[fourth].Y;
727 memcpy(origpt, pt, sizeof(GpPointF) * 4);
728
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);
739
740 dx = pt[fourth].X - origx;
741 dy = pt[fourth].Y - origy;
742
743 diff = sqrt(dx * dx + dy * dy);
744 percent += 0.0005 * amt;
745 }
746 }
747
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)
752 {
753 POINT *pti;
754 GpPointF *ptcopy;
755 GpStatus status = GenericError;
756
757 if(!count)
758 return Ok;
759
760 pti = GdipAlloc(count * sizeof(POINT));
761 ptcopy = GdipAlloc(count * sizeof(GpPointF));
762
763 if(!pti || !ptcopy){
764 status = OutOfMemory;
765 goto end;
766 }
767
768 memcpy(ptcopy, pt, count * sizeof(GpPointF));
769
770 if(caps){
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,
775 FALSE);
776
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);
781
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);
789
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);
793 }
794
795 transform_and_round_points(graphics, pti, ptcopy, count);
796
797 PolyBezier(graphics->hdc, pti, count);
798
799 status = Ok;
800
801 end:
802 GdipFree(pti);
803 GdipFree(ptcopy);
804
805 return status;
806 }
807
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)
811 {
812 POINT *pti = GdipAlloc(count * sizeof(POINT));
813 BYTE *tp = GdipAlloc(count);
814 GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
815 INT i, j;
816 GpStatus status = GenericError;
817
818 if(!count){
819 status = Ok;
820 goto end;
821 }
822 if(!pti || !tp || !ptcopy){
823 status = OutOfMemory;
824 goto end;
825 }
826
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");
832 goto end;
833 }
834 i += 2;
835 }
836 }
837
838 memcpy(ptcopy, pt, count * sizeof(GpPointF));
839
840 /* If we are drawing caps, go through the points and adjust them accordingly,
841 * and draw the caps. */
842 if(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);
850
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);
855
856 break;
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,
861 pen->width);
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);
866
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,
869 pt[count - 1].Y);
870
871 break;
872 default:
873 ERR("Bad path last point\n");
874 goto end;
875 }
876
877 /* Find start of points */
878 for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
879 == PathPointTypeStart); j++);
880
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);
888
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);
893
894 break;
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,
899 pen->width);
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);
904
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,
907 pt[j - 1].Y);
908
909 break;
910 default:
911 ERR("Bad path points\n");
912 goto end;
913 }
914 }
915
916 transform_and_round_points(graphics, pti, ptcopy, count);
917
918 for(i = 0; i < count; i++){
919 tp[i] = convert_path_point_type(types[i]);
920 }
921
922 PolyDraw(graphics->hdc, pti, tp, count);
923
924 status = Ok;
925
926 end:
927 GdipFree(pti);
928 GdipFree(ptcopy);
929 GdipFree(tp);
930
931 return status;
932 }
933
934 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
935 {
936 GpStatus result;
937
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);
942 return result;
943 }
944
945 typedef struct _GraphicsContainerItem {
946 struct list entry;
947 GraphicsContainer contid;
948
949 SmoothingMode smoothing;
950 CompositingQuality compqual;
951 InterpolationMode interpolation;
952 CompositingMode compmode;
953 TextRenderingHint texthint;
954 REAL scale;
955 GpUnit unit;
956 PixelOffsetMode pixeloffset;
957 UINT textcontrast;
958 GpMatrix* worldtrans;
959 GpRegion* clip;
960 } GraphicsContainerItem;
961
962 static GpStatus init_container(GraphicsContainerItem** container,
963 GDIPCONST GpGraphics* graphics){
964 GpStatus sts;
965
966 *container = GdipAlloc(sizeof(GraphicsContainerItem));
967 if(!(*container))
968 return OutOfMemory;
969
970 (*container)->contid = graphics->contid + 1;
971
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;
981
982 sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
983 if(sts != Ok){
984 GdipFree(*container);
985 *container = NULL;
986 return sts;
987 }
988
989 sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
990 if(sts != Ok){
991 GdipDeleteMatrix((*container)->worldtrans);
992 GdipFree(*container);
993 *container = NULL;
994 return sts;
995 }
996
997 return Ok;
998 }
999
1000 static void delete_container(GraphicsContainerItem* container){
1001 GdipDeleteMatrix(container->worldtrans);
1002 GdipDeleteRegion(container->clip);
1003 GdipFree(container);
1004 }
1005
1006 static GpStatus restore_container(GpGraphics* graphics,
1007 GDIPCONST GraphicsContainerItem* container){
1008 GpStatus sts;
1009 GpMatrix *newTrans;
1010 GpRegion *newClip;
1011
1012 sts = GdipCloneMatrix(container->worldtrans, &newTrans);
1013 if(sts != Ok)
1014 return sts;
1015
1016 sts = GdipCloneRegion(container->clip, &newClip);
1017 if(sts != Ok){
1018 GdipDeleteMatrix(newTrans);
1019 return sts;
1020 }
1021
1022 GdipDeleteMatrix(graphics->worldtrans);
1023 graphics->worldtrans = newTrans;
1024
1025 GdipDeleteRegion(graphics->clip);
1026 graphics->clip = newClip;
1027
1028 graphics->contid = container->contid - 1;
1029
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;
1039
1040 return Ok;
1041 }
1042
1043 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
1044 {
1045 RECT wnd_rect;
1046
1047 if(graphics->hwnd) {
1048 if(!GetClientRect(graphics->hwnd, &wnd_rect))
1049 return GenericError;
1050
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;
1055 }else{
1056 rect->X = 0;
1057 rect->Y = 0;
1058 rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
1059 rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
1060 }
1061
1062 return Ok;
1063 }
1064
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)
1068 {
1069 GpStatus stat;
1070 GpRectF rectf;
1071 GpRegion* tmp;
1072
1073 if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
1074 return stat;
1075
1076 if((stat = GdipCreateRegion(&tmp)) != Ok)
1077 return stat;
1078
1079 if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
1080 goto end;
1081
1082 if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
1083 goto end;
1084
1085 stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
1086
1087 end:
1088 GdipDeleteRegion(tmp);
1089 return stat;
1090 }
1091
1092 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
1093 {
1094 TRACE("(%p, %p)\n", hdc, graphics);
1095
1096 return GdipCreateFromHDC2(hdc, NULL, graphics);
1097 }
1098
1099 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
1100 {
1101 GpStatus retval;
1102
1103 TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
1104
1105 if(hDevice != NULL) {
1106 FIXME("Don't know how to handle parameter hDevice\n");
1107 return NotImplemented;
1108 }
1109
1110 if(hdc == NULL)
1111 return OutOfMemory;
1112
1113 if(graphics == NULL)
1114 return InvalidParameter;
1115
1116 *graphics = GdipAlloc(sizeof(GpGraphics));
1117 if(!*graphics) return OutOfMemory;
1118
1119 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1120 GdipFree(*graphics);
1121 return retval;
1122 }
1123
1124 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1125 GdipFree((*graphics)->worldtrans);
1126 GdipFree(*graphics);
1127 return retval;
1128 }
1129
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;
1144
1145 return Ok;
1146 }
1147
1148 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
1149 {
1150 GpStatus ret;
1151 HDC hdc;
1152
1153 TRACE("(%p, %p)\n", hwnd, graphics);
1154
1155 hdc = GetDC(hwnd);
1156
1157 if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
1158 {
1159 ReleaseDC(hwnd, hdc);
1160 return ret;
1161 }
1162
1163 (*graphics)->hwnd = hwnd;
1164 (*graphics)->owndc = TRUE;
1165
1166 return Ok;
1167 }
1168
1169 /* FIXME: no icm handling */
1170 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
1171 {
1172 TRACE("(%p, %p)\n", hwnd, graphics);
1173
1174 return GdipCreateFromHWND(hwnd, graphics);
1175 }
1176
1177 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1178 GpMetafile **metafile)
1179 {
1180 static int calls;
1181
1182 if(!hemf || !metafile)
1183 return InvalidParameter;
1184
1185 if(!(calls++))
1186 FIXME("not implemented\n");
1187
1188 return NotImplemented;
1189 }
1190
1191 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1192 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1193 {
1194 IStream *stream = NULL;
1195 UINT read;
1196 BYTE* copy;
1197 HENHMETAFILE hemf;
1198 GpStatus retval = GenericError;
1199
1200 TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1201
1202 if(!hwmf || !metafile || !placeable)
1203 return InvalidParameter;
1204
1205 *metafile = NULL;
1206 read = GetMetaFileBitsEx(hwmf, 0, NULL);
1207 if(!read)
1208 return GenericError;
1209 copy = GdipAlloc(read);
1210 GetMetaFileBitsEx(hwmf, read, copy);
1211
1212 hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1213 GdipFree(copy);
1214
1215 read = GetEnhMetaFileBits(hemf, 0, NULL);
1216 copy = GdipAlloc(read);
1217 GetEnhMetaFileBits(hemf, read, copy);
1218 DeleteEnhMetaFile(hemf);
1219
1220 if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
1221 ERR("could not make stream\n");
1222 GdipFree(copy);
1223 goto err;
1224 }
1225
1226 *metafile = GdipAlloc(sizeof(GpMetafile));
1227 if(!*metafile){
1228 retval = OutOfMemory;
1229 goto err;
1230 }
1231
1232 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1233 (LPVOID*) &((*metafile)->image.picture)) != S_OK)
1234 goto err;
1235
1236
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;
1245
1246 if(delete)
1247 DeleteMetaFile(hwmf);
1248
1249 return Ok;
1250
1251 err:
1252 GdipFree(*metafile);
1253 IStream_Release(stream);
1254 return retval;
1255 }
1256
1257 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1258 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1259 {
1260 HMETAFILE hmf = GetMetaFileW(file);
1261
1262 TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1263
1264 if(!hmf) return InvalidParameter;
1265
1266 return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1267 }
1268
1269 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1270 GpMetafile **metafile)
1271 {
1272 FIXME("(%p, %p): stub\n", file, metafile);
1273 return NotImplemented;
1274 }
1275
1276 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1277 GpMetafile **metafile)
1278 {
1279 FIXME("(%p, %p): stub\n", stream, metafile);
1280 return NotImplemented;
1281 }
1282
1283 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
1284 UINT access, IStream **stream)
1285 {
1286 DWORD dwMode;
1287 HRESULT ret;
1288
1289 TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
1290
1291 if(!stream || !filename)
1292 return InvalidParameter;
1293
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;
1298 else
1299 return InvalidParameter;
1300
1301 ret = SHCreateStreamOnFileW(filename, dwMode, stream);
1302
1303 return hresult_to_status(ret);
1304 }
1305
1306 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
1307 {
1308 GraphicsContainerItem *cont, *next;
1309 TRACE("(%p)\n", graphics);
1310
1311 if(!graphics) return InvalidParameter;
1312 if(graphics->busy) return ObjectBusy;
1313
1314 if(graphics->owndc)
1315 ReleaseDC(graphics->hwnd, graphics->hdc);
1316
1317 LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
1318 list_remove(&cont->entry);
1319 delete_container(cont);
1320 }
1321
1322 GdipDeleteRegion(graphics->clip);
1323 GdipDeleteMatrix(graphics->worldtrans);
1324 GdipFree(graphics);
1325
1326 return Ok;
1327 }
1328
1329 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
1330 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
1331 {
1332 INT save_state, num_pts;
1333 GpPointF points[MAX_ARC_PTS];
1334 GpStatus retval;
1335
1336 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
1337 width, height, startAngle, sweepAngle);
1338
1339 if(!graphics || !pen || width <= 0 || height <= 0)
1340 return InvalidParameter;
1341
1342 if(graphics->busy)
1343 return ObjectBusy;
1344
1345 num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
1346
1347 save_state = prepare_dc(graphics, pen);
1348
1349 retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
1350
1351 restore_dc(graphics, save_state);
1352
1353 return retval;
1354 }
1355
1356 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
1357 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
1358 {
1359 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
1360 width, height, startAngle, sweepAngle);
1361
1362 return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
1363 }
1364
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)
1367 {
1368 INT save_state;
1369 GpPointF pt[4];
1370 GpStatus retval;
1371
1372 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
1373 x2, y2, x3, y3, x4, y4);
1374
1375 if(!graphics || !pen)
1376 return InvalidParameter;
1377
1378 if(graphics->busy)
1379 return ObjectBusy;
1380
1381 pt[0].X = x1;
1382 pt[0].Y = y1;
1383 pt[1].X = x2;
1384 pt[1].Y = y2;
1385 pt[2].X = x3;
1386 pt[2].Y = y3;
1387 pt[3].X = x4;
1388 pt[3].Y = y4;
1389
1390 save_state = prepare_dc(graphics, pen);
1391
1392 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1393
1394 restore_dc(graphics, save_state);
1395
1396 return retval;
1397 }
1398
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)
1401 {
1402 INT save_state;
1403 GpPointF pt[4];
1404 GpStatus retval;
1405
1406 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
1407 x2, y2, x3, y3, x4, y4);
1408
1409 if(!graphics || !pen)
1410 return InvalidParameter;
1411
1412 if(graphics->busy)
1413 return ObjectBusy;
1414
1415 pt[0].X = x1;
1416 pt[0].Y = y1;
1417 pt[1].X = x2;
1418 pt[1].Y = y2;
1419 pt[2].X = x3;
1420 pt[2].Y = y3;
1421 pt[3].X = x4;
1422 pt[3].Y = y4;
1423
1424 save_state = prepare_dc(graphics, pen);
1425
1426 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
1427
1428 restore_dc(graphics, save_state);
1429
1430 return retval;
1431 }
1432
1433 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
1434 GDIPCONST GpPointF *points, INT count)
1435 {
1436 INT i;
1437 GpStatus ret;
1438
1439 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1440
1441 if(!graphics || !pen || !points || (count <= 0))
1442 return InvalidParameter;
1443
1444 if(graphics->busy)
1445 return ObjectBusy;
1446
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);
1453 if(ret != Ok)
1454 return ret;
1455 }
1456
1457 return Ok;
1458 }
1459
1460 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
1461 GDIPCONST GpPoint *points, INT count)
1462 {
1463 GpPointF *pts;
1464 GpStatus ret;
1465 INT i;
1466
1467 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1468
1469 if(!graphics || !pen || !points || (count <= 0))
1470 return InvalidParameter;
1471
1472 if(graphics->busy)
1473 return ObjectBusy;
1474
1475 pts = GdipAlloc(sizeof(GpPointF) * count);
1476 if(!pts)
1477 return OutOfMemory;
1478
1479 for(i = 0; i < count; i++){
1480 pts[i].X = (REAL)points[i].X;
1481 pts[i].Y = (REAL)points[i].Y;
1482 }
1483
1484 ret = GdipDrawBeziers(graphics,pen,pts,count);
1485
1486 GdipFree(pts);
1487
1488 return ret;
1489 }
1490
1491 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
1492 GDIPCONST GpPointF *points, INT count)
1493 {
1494 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1495
1496 return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
1497 }
1498
1499 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
1500 GDIPCONST GpPoint *points, INT count)
1501 {
1502 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1503
1504 return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
1505 }
1506
1507 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
1508 GDIPCONST GpPointF *points, INT count, REAL tension)
1509 {
1510 GpPath *path;
1511 GpStatus stat;
1512
1513 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1514
1515 if(!graphics || !pen || !points || count <= 0)
1516 return InvalidParameter;
1517
1518 if(graphics->busy)
1519 return ObjectBusy;
1520
1521 if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
1522 return stat;
1523
1524 stat = GdipAddPathClosedCurve2(path, points, count, tension);
1525 if(stat != Ok){
1526 GdipDeletePath(path);
1527 return stat;
1528 }
1529
1530 stat = GdipDrawPath(graphics, pen, path);
1531
1532 GdipDeletePath(path);
1533
1534 return stat;
1535 }
1536
1537 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
1538 GDIPCONST GpPoint *points, INT count, REAL tension)
1539 {
1540 GpPointF *ptf;
1541 GpStatus stat;
1542 INT i;
1543
1544 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1545
1546 if(!points || count <= 0)
1547 return InvalidParameter;
1548
1549 ptf = GdipAlloc(sizeof(GpPointF)*count);
1550 if(!ptf)
1551 return OutOfMemory;
1552
1553 for(i = 0; i < count; i++){
1554 ptf[i].X = (REAL)points[i].X;
1555 ptf[i].Y = (REAL)points[i].Y;
1556 }
1557
1558 stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
1559
1560 GdipFree(ptf);
1561
1562 return stat;
1563 }
1564
1565 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
1566 GDIPCONST GpPointF *points, INT count)
1567 {
1568 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1569
1570 return GdipDrawCurve2(graphics,pen,points,count,1.0);
1571 }
1572
1573 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
1574 GDIPCONST GpPoint *points, INT count)
1575 {
1576 GpPointF *pointsF;
1577 GpStatus ret;
1578 INT i;
1579
1580 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
1581
1582 if(!points)
1583 return InvalidParameter;
1584
1585 pointsF = GdipAlloc(sizeof(GpPointF)*count);
1586 if(!pointsF)
1587 return OutOfMemory;
1588
1589 for(i = 0; i < count; i++){
1590 pointsF[i].X = (REAL)points[i].X;
1591 pointsF[i].Y = (REAL)points[i].Y;
1592 }
1593
1594 ret = GdipDrawCurve(graphics,pen,pointsF,count);
1595 GdipFree(pointsF);
1596
1597 return ret;
1598 }
1599
1600 /* Approximates cardinal spline with Bezier curves. */
1601 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
1602 GDIPCONST GpPointF *points, INT count, REAL tension)
1603 {
1604 /* PolyBezier expects count*3-2 points. */
1605 INT i, len_pt = count*3-2, save_state;
1606 GpPointF *pt;
1607 REAL x1, x2, y1, y2;
1608 GpStatus retval;
1609
1610 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1611
1612 if(!graphics || !pen)
1613 return InvalidParameter;
1614
1615 if(graphics->busy)
1616 return ObjectBusy;
1617
1618 if(count < 2)
1619 return InvalidParameter;
1620
1621 pt = GdipAlloc(len_pt * sizeof(GpPointF));
1622 if(!pt)
1623 return OutOfMemory;
1624
1625 tension = tension * TENSION_CONST;
1626
1627 calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
1628 tension, &x1, &y1);
1629
1630 pt[0].X = points[0].X;
1631 pt[0].Y = points[0].Y;
1632 pt[1].X = x1;
1633 pt[1].Y = y1;
1634
1635 for(i = 0; i < count-2; i++){
1636 calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
1637
1638 pt[3*i+2].X = x1;
1639 pt[3*i+2].Y = y1;
1640 pt[3*i+3].X = points[i+1].X;
1641 pt[3*i+3].Y = points[i+1].Y;
1642 pt[3*i+4].X = x2;
1643 pt[3*i+4].Y = y2;
1644 }
1645
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);
1648
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;
1653
1654 save_state = prepare_dc(graphics, pen);
1655
1656 retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
1657
1658 GdipFree(pt);
1659 restore_dc(graphics, save_state);
1660
1661 return retval;
1662 }
1663
1664 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
1665 GDIPCONST GpPoint *points, INT count, REAL tension)
1666 {
1667 GpPointF *pointsF;
1668 GpStatus ret;
1669 INT i;
1670
1671 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
1672
1673 if(!points)
1674 return InvalidParameter;
1675
1676 pointsF = GdipAlloc(sizeof(GpPointF)*count);
1677 if(!pointsF)
1678 return OutOfMemory;
1679
1680 for(i = 0; i < count; i++){
1681 pointsF[i].X = (REAL)points[i].X;
1682 pointsF[i].Y = (REAL)points[i].Y;
1683 }
1684
1685 ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
1686 GdipFree(pointsF);
1687
1688 return ret;
1689 }
1690
1691 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
1692 GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
1693 REAL tension)
1694 {
1695 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1696
1697 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1698 return InvalidParameter;
1699 }
1700
1701 return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
1702 }
1703
1704 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
1705 GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
1706 REAL tension)
1707 {
1708 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
1709
1710 if(count < 0){
1711 return OutOfMemory;
1712 }
1713
1714 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
1715 return InvalidParameter;
1716 }
1717
1718 return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
1719 }
1720
1721 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
1722 REAL y, REAL width, REAL height)
1723 {
1724 INT save_state;
1725 GpPointF ptf[2];
1726 POINT pti[2];
1727
1728 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
1729
1730 if(!graphics || !pen)
1731 return InvalidParameter;
1732
1733 if(graphics->busy)
1734 return ObjectBusy;
1735
1736 ptf[0].X = x;
1737 ptf[0].Y = y;
1738 ptf[1].X = x + width;
1739 ptf[1].Y = y + height;
1740
1741 save_state = prepare_dc(graphics, pen);
1742 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
1743
1744 transform_and_round_points(graphics, pti, ptf, 2);
1745
1746 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
1747
1748 restore_dc(graphics, save_state);
1749
1750 return Ok;
1751 }
1752
1753 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
1754 INT y, INT width, INT height)
1755 {
1756 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
1757
1758 return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
1759 }
1760
1761
1762 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
1763 {
1764 UINT width, height;
1765 GpPointF points[3];
1766
1767 TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
1768
1769 if(!graphics || !image)
1770 return InvalidParameter;
1771
1772 GdipGetImageWidth(image, &width);
1773 GdipGetImageHeight(image, &height);
1774
1775 /* FIXME: we should use the graphics and image dpi, somehow */
1776
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;
1781
1782 return GdipDrawImagePointsRect(graphics, image, points, 3, 0, 0, width, height,
1783 UnitPixel, NULL, NULL, NULL);
1784 }
1785
1786 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
1787 INT y)
1788 {
1789 TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
1790
1791 return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
1792 }
1793
1794 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
1795 REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
1796 GpUnit srcUnit)
1797 {
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;
1800 }
1801
1802 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
1803 INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
1804 GpUnit srcUnit)
1805 {
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;
1808 }
1809
1810 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
1811 GDIPCONST GpPointF *dstpoints, INT count)
1812 {
1813 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1814 return NotImplemented;
1815 }
1816
1817 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
1818 GDIPCONST GpPoint *dstpoints, INT count)
1819 {
1820 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
1821 return NotImplemented;
1822 }
1823
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)
1829 {
1830 GpPointF ptf[3];
1831 POINT pti[3];
1832 REAL dx, dy;
1833
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,
1836 callbackData);
1837
1838 if(!graphics || !image || !points || count != 3)
1839 return InvalidParameter;
1840
1841 if(srcUnit == UnitInch)
1842 dx = dy = (REAL) INCH_HIMETRIC;
1843 else if(srcUnit == UnitPixel){
1844 dx = ((REAL) INCH_HIMETRIC) /
1845 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
1846 dy = ((REAL) INCH_HIMETRIC) /
1847 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
1848 }
1849 else
1850 return NotImplemented;
1851
1852 memcpy(ptf, points, 3 * sizeof(GpPointF));
1853 transform_and_round_points(graphics, pti, ptf, 3);
1854
1855 /* IPicture renders bitmaps with the y-axis reversed
1856 * FIXME: flipping for unknown image type might not be correct. */
1857 if(image->type != ImageTypeMetafile){
1858 INT temp;
1859 temp = pti[0].y;
1860 pti[0].y = pti[2].y;
1861 pti[2].y = temp;
1862 }
1863
1864 if(IPicture_Render(image->picture, graphics->hdc,
1865 pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
1866 srcx * dx, srcy * dy,
1867 srcwidth * dx, srcheight * dy,
1868 NULL) != S_OK){
1869 if(callback)
1870 callback(callbackData);
1871 return GenericError;
1872 }
1873
1874 return Ok;
1875 }
1876
1877 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
1878 GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
1879 INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
1880 DrawImageAbort callback, VOID * callbackData)
1881 {
1882 GpPointF pointsF[3];
1883 INT i;
1884
1885 TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
1886 srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
1887 callbackData);
1888
1889 if(!points || count!=3)
1890 return InvalidParameter;
1891
1892 for(i = 0; i < count; i++){
1893 pointsF[i].X = (REAL)points[i].X;
1894 pointsF[i].Y = (REAL)points[i].Y;
1895 }
1896
1897 return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
1898 (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
1899 callback, callbackData);
1900 }
1901
1902 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
1903 REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
1904 REAL srcwidth, REAL srcheight, GpUnit srcUnit,
1905 GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
1906 VOID * callbackData)
1907 {
1908 GpPointF points[3];
1909
1910 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
1911 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
1912 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
1913
1914 points[0].X = dstx;
1915 points[0].Y = dsty;
1916 points[1].X = dstx + dstwidth;
1917 points[1].Y = dsty;
1918 points[2].X = dstx;
1919 points[2].Y = dsty + dstheight;
1920
1921 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
1922 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
1923 }
1924
1925 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
1926 INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
1927 INT srcwidth, INT srcheight, GpUnit srcUnit,
1928 GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
1929 VOID * callbackData)
1930 {
1931 GpPointF points[3];
1932
1933 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
1934 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
1935 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
1936
1937 points[0].X = dstx;
1938 points[0].Y = dsty;
1939 points[1].X = dstx + dstwidth;
1940 points[1].Y = dsty;
1941 points[2].X = dstx;
1942 points[2].Y = dsty + dstheight;
1943
1944 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
1945 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
1946 }
1947
1948 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
1949 REAL x, REAL y, REAL width, REAL height)
1950 {
1951 RectF bounds;
1952 GpUnit unit;
1953 GpStatus ret;
1954
1955 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
1956
1957 if(!graphics || !image)
1958 return InvalidParameter;
1959
1960 ret = GdipGetImageBounds(image, &bounds, &unit);
1961 if(ret != Ok)
1962 return ret;
1963
1964 return GdipDrawImageRectRect(graphics, image, x, y, width, height,
1965 bounds.X, bounds.Y, bounds.Width, bounds.Height,
1966 unit, NULL, NULL, NULL);
1967 }
1968
1969 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
1970 INT x, INT y, INT width, INT height)
1971 {
1972 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
1973
1974 return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
1975 }
1976
1977 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
1978 REAL y1, REAL x2, REAL y2)
1979 {
1980 INT save_state;
1981 GpPointF pt[2];
1982 GpStatus retval;
1983
1984 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
1985
1986 if(!pen || !graphics)
1987 return InvalidParameter;
1988
1989 if(graphics->busy)
1990 return ObjectBusy;
1991
1992 pt[0].X = x1;
1993 pt[0].Y = y1;
1994 pt[1].X = x2;
1995 pt[1].Y = y2;
1996
1997 save_state = prepare_dc(graphics, pen);
1998
1999 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2000
2001 restore_dc(graphics, save_state);
2002
2003 return retval;
2004 }
2005
2006 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
2007 INT y1, INT x2, INT y2)
2008 {
2009 INT save_state;
2010 GpPointF pt[2];
2011 GpStatus retval;
2012
2013 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
2014
2015 if(!pen || !graphics)
2016 return InvalidParameter;
2017
2018 if(graphics->busy)
2019 return ObjectBusy;
2020
2021 pt[0].X = (REAL)x1;
2022 pt[0].Y = (REAL)y1;
2023 pt[1].X = (REAL)x2;
2024 pt[1].Y = (REAL)y2;
2025
2026 save_state = prepare_dc(graphics, pen);
2027
2028 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2029
2030 restore_dc(graphics, save_state);
2031
2032 return retval;
2033 }
2034
2035 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
2036 GpPointF *points, INT count)
2037 {
2038 INT save_state;
2039 GpStatus retval;
2040
2041 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2042
2043 if(!pen || !graphics || (count < 2))
2044 return InvalidParameter;
2045
2046 if(graphics->busy)
2047 return ObjectBusy;
2048
2049 save_state = prepare_dc(graphics, pen);
2050
2051 retval = draw_polyline(graphics, pen, points, count, TRUE);
2052
2053 restore_dc(graphics, save_state);
2054
2055 return retval;
2056 }
2057
2058 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
2059 GpPoint *points, INT count)
2060 {
2061 INT save_state;
2062 GpStatus retval;
2063 GpPointF *ptf = NULL;
2064 int i;
2065
2066 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2067
2068 if(!pen || !graphics || (count < 2))
2069 return InvalidParameter;
2070
2071 if(graphics->busy)
2072 return ObjectBusy;
2073
2074 ptf = GdipAlloc(count * sizeof(GpPointF));
2075 if(!ptf) return OutOfMemory;
2076
2077 for(i = 0; i < count; i ++){
2078 ptf[i].X = (REAL) points[i].X;
2079 ptf[i].Y = (REAL) points[i].Y;
2080 }
2081
2082 save_state = prepare_dc(graphics, pen);
2083
2084 retval = draw_polyline(graphics, pen, ptf, count, TRUE);
2085
2086 restore_dc(graphics, save_state);
2087
2088 GdipFree(ptf);
2089 return retval;
2090 }
2091
2092 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
2093 {
2094 INT save_state;
2095 GpStatus retval;
2096
2097 TRACE("(%p, %p, %p)\n", graphics, pen, path);
2098
2099 if(!pen || !graphics)
2100 return InvalidParameter;
2101
2102 if(graphics->busy)
2103 return ObjectBusy;
2104
2105 save_state = prepare_dc(graphics, pen);
2106
2107 retval = draw_poly(graphics, pen, path->pathdata.Points,
2108 path->pathdata.Types, path->pathdata.Count, TRUE);
2109
2110 restore_dc(graphics, save_state);
2111
2112 return retval;
2113 }
2114
2115 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
2116 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2117 {
2118 INT save_state;
2119
2120 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
2121 width, height, startAngle, sweepAngle);
2122
2123 if(!graphics || !pen)
2124 return InvalidParameter;
2125
2126 if(graphics->busy)
2127 return ObjectBusy;
2128
2129 save_state = prepare_dc(graphics, pen);
2130 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2131
2132 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2133
2134 restore_dc(graphics, save_state);
2135
2136 return Ok;
2137 }
2138
2139 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
2140 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2141 {
2142 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2143 width, height, startAngle, sweepAngle);
2144
2145 return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2146 }
2147
2148 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
2149 REAL y, REAL width, REAL height)
2150 {
2151 INT save_state;
2152 GpPointF ptf[4];
2153 POINT pti[4];
2154
2155 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2156
2157 if(!pen || !graphics)
2158 return InvalidParameter;
2159
2160 if(graphics->busy)
2161 return ObjectBusy;
2162
2163 ptf[0].X = x;
2164 ptf[0].Y = y;
2165 ptf[1].X = x + width;
2166 ptf[1].Y = y;
2167 ptf[2].X = x + width;
2168 ptf[2].Y = y + height;
2169 ptf[3].X = x;
2170 ptf[3].Y = y + height;
2171
2172 save_state = prepare_dc(graphics, pen);
2173 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2174
2175 transform_and_round_points(graphics, pti, ptf, 4);
2176 Polygon(graphics->hdc, pti, 4);
2177
2178 restore_dc(graphics, save_state);
2179
2180 return Ok;
2181 }
2182
2183 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
2184 INT y, INT width, INT height)
2185 {
2186 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2187
2188 return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2189 }
2190
2191 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
2192 GDIPCONST GpRectF* rects, INT count)
2193 {
2194 GpPointF *ptf;
2195 POINT *pti;
2196 INT save_state, i;
2197
2198 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2199
2200 if(!graphics || !pen || !rects || count < 1)
2201 return InvalidParameter;
2202
2203 if(graphics->busy)
2204 return ObjectBusy;
2205
2206 ptf = GdipAlloc(4 * count * sizeof(GpPointF));
2207 pti = GdipAlloc(4 * count * sizeof(POINT));
2208
2209 if(!ptf || !pti){
2210 GdipFree(ptf);
2211 GdipFree(pti);
2212 return OutOfMemory;
2213 }
2214
2215 for(i = 0; i < count; i++){
2216 ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
2217 ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
2218 ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
2219 ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
2220 }
2221
2222 save_state = prepare_dc(graphics, pen);
2223 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2224
2225 transform_and_round_points(graphics, pti, ptf, 4 * count);
2226
2227 for(i = 0; i < count; i++)
2228 Polygon(graphics->hdc, &pti[4 * i], 4);
2229
2230 restore_dc(graphics, save_state);
2231
2232 GdipFree(ptf);
2233 GdipFree(pti);
2234
2235 return Ok;
2236 }
2237
2238 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
2239 GDIPCONST GpRect* rects, INT count)
2240 {
2241 GpRectF *rectsF;
2242 GpStatus ret;
2243 INT i;
2244
2245 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
2246
2247 if(!rects || count<=0)
2248 return InvalidParameter;
2249
2250 rectsF = GdipAlloc(sizeof(GpRectF) * count);
2251 if(!rectsF)
2252 return OutOfMemory;
2253
2254 for(i = 0;i < count;i++){
2255 rectsF[i].X = (REAL)rects[i].X;
2256 rectsF[i].Y = (REAL)rects[i].Y;
2257 rectsF[i].Width = (REAL)rects[i].Width;
2258 rectsF[i].Height = (REAL)rects[i].Height;
2259 }
2260
2261 ret = GdipDrawRectangles(graphics, pen, rectsF, count);
2262 GdipFree(rectsF);
2263
2264 return ret;
2265 }
2266
2267 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
2268 INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
2269 GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
2270 {
2271 HRGN rgn = NULL;
2272 HFONT gdifont;
2273 LOGFONTW lfw;
2274 TEXTMETRICW textmet;
2275 GpPointF pt[2], rectcpy[4];
2276 POINT corners[4];
2277 WCHAR* stringdup;
2278 REAL angle, ang_cos, ang_sin, rel_width, rel_height;
2279 INT sum = 0, height = 0, offsety = 0, fit, fitcpy, save_state, i, j, lret, nwidth,
2280 nheight, lineend;
2281 SIZE size;
2282 POINT drawbase;
2283 UINT drawflags;
2284 RECT drawcoord;
2285
2286 TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
2287 length, font, debugstr_rectf(rect), format, brush);
2288
2289 if(!graphics || !string || !font || !brush || !rect)
2290 return InvalidParameter;
2291
2292 if((brush->bt != BrushTypeSolidColor)){
2293 FIXME("not implemented for given parameters\n");
2294 return NotImplemented;
2295 }
2296
2297 if(format){
2298 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
2299
2300 /* Should be no need to explicitly test for StringAlignmentNear as
2301 * that is default behavior if no alignment is passed. */
2302 if(format->vertalign != StringAlignmentNear){
2303 RectF bounds;
2304 GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
2305
2306 if(format->vertalign == StringAlignmentCenter)
2307 offsety = (rect->Height - bounds.Height) / 2;
2308 else if(format->vertalign == StringAlignmentFar)
2309 offsety = (rect->Height - bounds.Height);
2310 }
2311 }
2312
2313 if(length == -1) length = lstrlenW(string);
2314
2315 stringdup = GdipAlloc(length * sizeof(WCHAR));
2316 if(!stringdup) return OutOfMemory;
2317
2318 save_state = SaveDC(graphics->hdc);
2319 SetBkMode(graphics->hdc, TRANSPARENT);
2320 SetTextColor(graphics->hdc, brush->lb.lbColor);
2321
2322 rectcpy[3].X = rectcpy[0].X = rect->X;
2323 rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
2324 rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
2325 rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
2326 transform_and_round_points(graphics, corners, rectcpy, 4);
2327
2328 if (roundr(rect->Width) == 0)
2329 {
2330 rel_width = 1.0;
2331 nwidth = INT_MAX;
2332 }
2333 else
2334 {
2335 rel_width = sqrt((corners[1].x - corners[0].x) * (corners[1].x - corners[0].x) +
2336 (corners[1].y - corners[0].y) * (corners[1].y - corners[0].y))
2337 / rect->Width;
2338 nwidth = roundr(rel_width * rect->Width);
2339 }
2340
2341 if (roundr(rect->Height) == 0)
2342 {
2343 rel_height = 1.0;
2344 nheight = INT_MAX;
2345 }
2346 else
2347 {
2348 rel_height = sqrt((corners[2].x - corners[1].x) * (corners[2].x - corners[1].x) +
2349 (corners[2].y - corners[1].y) * (corners[2].y - corners[1].y))
2350 / rect->Height;
2351 nheight = roundr(rel_height * rect->Height);
2352 }
2353
2354 if (roundr(rect->Width) != 0 && roundr(rect->Height) != 0)
2355 {
2356 /* FIXME: If only the width or only the height is 0, we should probably still clip */
2357 rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
2358 SelectClipRgn(graphics->hdc, rgn);
2359 }
2360
2361 /* Use gdi to find the font, then perform transformations on it (height,
2362 * width, angle). */
2363 SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
2364 GetTextMetricsW(graphics->hdc, &textmet);
2365 lfw = font->lfw;
2366
2367 lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
2368 lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
2369
2370 pt[0].X = 0.0;
2371 pt[0].Y = 0.0;
2372 pt[1].X = 1.0;
2373 pt[1].Y = 0.0;
2374 GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
2375 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
2376 ang_cos = cos(angle);
2377 ang_sin = sin(angle);
2378 lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
2379
2380 gdifont = CreateFontIndirectW(&lfw);
2381 DeleteObject(SelectObject(graphics->hdc, CreateFontIndirectW(&lfw)));
2382
2383 for(i = 0, j = 0; i < length; i++){
2384 if(!isprintW(string[i]) && (string[i] != '\n'))
2385 continue;
2386
2387 stringdup[j] = string[i];
2388 j++;
2389 }
2390
2391 length = j;
2392
2393 if (!format || format->align == StringAlignmentNear)
2394 {
2395 drawbase.x = corners[0].x;
2396 drawbase.y = corners[0].y;
2397 drawflags = DT_NOCLIP | DT_EXPANDTABS;
2398 }
2399 else if (format->align == StringAlignmentCenter)
2400 {
2401 drawbase.x = (corners[0].x + corners[1].x)/2;
2402 drawbase.y = (corners[0].y + corners[1].y)/2;
2403 drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_CENTER;
2404 }
2405 else /* (format->align == StringAlignmentFar) */
2406 {
2407 drawbase.x = corners[1].x;
2408 drawbase.y = corners[1].y;
2409 drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_RIGHT;
2410 }
2411
2412 while(sum < length){
2413 drawcoord.left = drawcoord.right = drawbase.x + roundr(ang_sin * (REAL) height);
2414 drawcoord.top = drawcoord.bottom = drawbase.y + roundr(ang_cos * (REAL) height);
2415
2416 GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
2417 nwidth, &fit, NULL, &size);
2418 fitcpy = fit;
2419
2420 if(fit == 0){
2421 DrawTextW(graphics->hdc, stringdup + sum, 1, &drawcoord, drawflags);
2422 break;
2423 }
2424
2425 for(lret = 0; lret < fit; lret++)
2426 if(*(stringdup + sum + lret) == '\n')
2427 break;
2428
2429 /* Line break code (may look strange, but it imitates windows). */
2430 if(lret < fit)
2431 lineend = fit = lret; /* this is not an off-by-one error */
2432 else if(fit < (length - sum)){
2433 if(*(stringdup + sum + fit) == ' ')
2434 while(*(stringdup + sum + fit) == ' ')
2435 fit++;
2436 else
2437 while(*(stringdup + sum + fit - 1) != ' '){
2438 fit--;
2439
2440 if(*(stringdup + sum + fit) == '\t')
2441 break;
2442
2443 if(fit == 0){
2444 fit = fitcpy;
2445 break;
2446 }
2447 }
2448 lineend = fit;
2449 while(*(stringdup + sum + lineend - 1) == ' ' ||
2450 *(stringdup + sum + lineend - 1) == '\t')
2451 lineend--;
2452 }
2453 else
2454 lineend = fit;
2455 DrawTextW(graphics->hdc, stringdup + sum, min(length - sum, lineend),
2456 &drawcoord, drawflags);
2457
2458 sum += fit + (lret < fitcpy ? 1 : 0);
2459 height += size.cy;
2460
2461 if(height > nheight)
2462 break;
2463
2464 /* Stop if this was a linewrap (but not if it was a linebreak). */
2465 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
2466 break;
2467 }
2468
2469 GdipFree(stringdup);
2470 DeleteObject(rgn);
2471 DeleteObject(gdifont);
2472
2473 RestoreDC(graphics->hdc, save_state);
2474
2475 return Ok;
2476 }
2477
2478 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
2479 GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
2480 {
2481 GpPath *path;
2482 GpStatus stat;
2483
2484 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2485 count, tension, fill);
2486
2487 if(!graphics || !brush || !points)
2488 return InvalidParameter;
2489
2490 if(graphics->busy)
2491 return ObjectBusy;
2492
2493 stat = GdipCreatePath(fill, &path);
2494 if(stat != Ok)
2495 return stat;
2496
2497 stat = GdipAddPathClosedCurve2(path, points, count, tension);
2498 if(stat != Ok){
2499 GdipDeletePath(path);
2500 return stat;
2501 }
2502
2503 stat = GdipFillPath(graphics, brush, path);
2504 if(stat != Ok){
2505 GdipDeletePath(path);
2506 return stat;
2507 }
2508
2509 GdipDeletePath(path);
2510
2511 return Ok;
2512 }
2513
2514 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
2515 GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
2516 {
2517 GpPointF *ptf;
2518 GpStatus stat;
2519 INT i;
2520
2521 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
2522 count, tension, fill);
2523
2524 if(!points || count <= 0)
2525 return InvalidParameter;
2526
2527 ptf = GdipAlloc(sizeof(GpPointF)*count);
2528 if(!ptf)
2529 return OutOfMemory;
2530
2531 for(i = 0;i < count;i++){
2532 ptf[i].X = (REAL)points[i].X;
2533 ptf[i].Y = (REAL)points[i].Y;
2534 }
2535
2536 stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
2537
2538 GdipFree(ptf);
2539
2540 return stat;
2541 }
2542
2543 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
2544 REAL y, REAL width, REAL height)
2545 {
2546 INT save_state;
2547 GpPointF ptf[2];
2548 POINT pti[2];
2549
2550 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
2551
2552 if(!graphics || !brush)
2553 return InvalidParameter;
2554
2555 if(graphics->busy)
2556 return ObjectBusy;
2557
2558 ptf[0].X = x;
2559 ptf[0].Y = y;
2560 ptf[1].X = x + width;
2561 ptf[1].Y = y + height;
2562
2563 save_state = SaveDC(graphics->hdc);
2564 EndPath(graphics->hdc);
2565
2566 transform_and_round_points(graphics, pti, ptf, 2);
2567
2568 BeginPath(graphics->hdc);
2569 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2570 EndPath(graphics->hdc);
2571
2572 brush_fill_path(graphics, brush);
2573
2574 RestoreDC(graphics->hdc, save_state);
2575
2576 return Ok;
2577 }
2578
2579 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
2580 INT y, INT width, INT height)
2581 {
2582 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
2583
2584 return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2585 }
2586
2587 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
2588 {
2589 INT save_state;
2590 GpStatus retval;
2591
2592 TRACE("(%p, %p, %p)\n", graphics, brush, path);
2593
2594 if(!brush || !graphics || !path)
2595 return InvalidParameter;
2596
2597 if(graphics->busy)
2598 return ObjectBusy;
2599
2600 save_state = SaveDC(graphics->hdc);
2601 EndPath(graphics->hdc);
2602 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
2603 : WINDING));
2604
2605 BeginPath(graphics->hdc);
2606 retval = draw_poly(graphics, NULL, path->pathdata.Points,
2607 path->pathdata.Types, path->pathdata.Count, FALSE);
2608
2609 if(retval != Ok)
2610 goto end;
2611
2612 EndPath(graphics->hdc);
2613 brush_fill_path(graphics, brush);
2614
2615 retval = Ok;
2616
2617 end:
2618 RestoreDC(graphics->hdc, save_state);
2619
2620 return retval;
2621 }
2622
2623 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
2624 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2625 {
2626 INT save_state;
2627
2628 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
2629 graphics, brush, x, y, width, height, startAngle, sweepAngle);
2630
2631 if(!graphics || !brush)
2632 return InvalidParameter;
2633
2634 if(graphics->busy)
2635 return ObjectBusy;
2636
2637 save_state = SaveDC(graphics->hdc);
2638 EndPath(graphics->hdc);
2639
2640 BeginPath(graphics->hdc);
2641 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
2642 EndPath(graphics->hdc);
2643
2644 brush_fill_path(graphics, brush);
2645
2646 RestoreDC(graphics->hdc, save_state);
2647
2648 return Ok;
2649 }
2650
2651 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
2652 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2653 {
2654 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
2655 graphics, brush, x, y, width, height, startAngle, sweepAngle);
2656
2657 return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2658 }
2659
2660 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
2661 GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
2662 {
2663 INT save_state;
2664 GpPointF *ptf = NULL;
2665 POINT *pti = NULL;
2666 GpStatus retval = Ok;
2667
2668 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
2669
2670 if(!graphics || !brush || !points || !count)
2671 return InvalidParameter;
2672
2673 if(graphics->busy)
2674 return ObjectBusy;
2675
2676 ptf = GdipAlloc(count * sizeof(GpPointF));
2677 pti = GdipAlloc(count * sizeof(POINT));
2678 if(!ptf || !pti){
2679 retval = OutOfMemory;
2680 goto end;
2681 }
2682
2683 memcpy(ptf, points, count * sizeof(GpPointF));
2684
2685 save_state = SaveDC(graphics->hdc);
2686 EndPath(graphics->hdc);
2687 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
2688 : WINDING));
2689
2690 transform_and_round_points(graphics, pti, ptf, count);
2691
2692 BeginPath(graphics->hdc);
2693 Polygon(graphics->hdc, pti, count);
2694 EndPath(graphics->hdc);
2695
2696 brush_fill_path(graphics, brush);
2697
2698 RestoreDC(graphics->hdc, save_state);
2699
2700 end:
2701 GdipFree(ptf);
2702 GdipFree(pti);
2703
2704 return retval;
2705 }
2706
2707 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
2708 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
2709 {
2710 INT save_state, i;
2711 GpPointF *ptf = NULL;
2712 POINT *pti = NULL;
2713 GpStatus retval = Ok;
2714
2715 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
2716
2717 if(!graphics || !brush || !points || !count)
2718 return InvalidParameter;
2719
2720 if(graphics->busy)
2721 return ObjectBusy;
2722
2723 ptf = GdipAlloc(count * sizeof(GpPointF));
2724 pti = GdipAlloc(count * sizeof(POINT));
2725 if(!ptf || !pti){
2726 retval = OutOfMemory;
2727 goto end;
2728 }
2729
2730 for(i = 0; i < count; i ++){
2731 ptf[i].X = (REAL) points[i].X;
2732 ptf[i].Y = (REAL) points[i].Y;
2733 }
2734
2735 save_state = SaveDC(graphics->hdc);
2736 EndPath(graphics->hdc);
2737 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
2738 : WINDING));
2739
2740 transform_and_round_points(graphics, pti, ptf, count);
2741
2742 BeginPath(graphics->hdc);
2743 Polygon(graphics->hdc, pti, count);
2744 EndPath(graphics->hdc);
2745
2746 brush_fill_path(graphics, brush);
2747
2748 RestoreDC(graphics->hdc, save_state);
2749
2750 end:
2751 GdipFree(ptf);
2752 GdipFree(pti);
2753
2754 return retval;
2755 }
2756
2757 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
2758 GDIPCONST GpPointF *points, INT count)
2759 {
2760 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2761
2762 return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
2763 }
2764
2765 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
2766 GDIPCONST GpPoint *points, INT count)
2767 {
2768 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
2769
2770 return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
2771 }
2772
2773 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
2774 REAL x, REAL y, REAL width, REAL height)
2775 {
2776 INT save_state;
2777 GpPointF ptf[4];
2778 POINT pti[4];
2779
2780 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
2781
2782 if(!graphics || !brush)
2783 return InvalidParameter;
2784
2785 if(graphics->busy)
2786 return ObjectBusy;
2787
2788 ptf[0].X = x;
2789 ptf[0].Y = y;
2790 ptf[1].X = x + width;
2791 ptf[1].Y = y;
2792 ptf[2].X = x + width;
2793 ptf[2].Y = y + height;
2794 ptf[3].X = x;
2795 ptf[3].Y = y + height;
2796
2797 save_state = SaveDC(graphics->hdc);
2798 EndPath(graphics->hdc);
2799
2800 transform_and_round_points(graphics, pti, ptf, 4);
2801
2802 BeginPath(graphics->hdc);
2803 Polygon(graphics->hdc, pti, 4);
2804 EndPath(graphics->hdc);
2805
2806 brush_fill_path(graphics, brush);
2807
2808 RestoreDC(graphics->hdc, save_state);
2809
2810 return Ok;
2811 }
2812
2813 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
2814 INT x, INT y, INT width, INT height)
2815 {
2816 INT save_state;
2817 GpPointF ptf[4];
2818 POINT pti[4];
2819
2820 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
2821
2822 if(!graphics || !brush)
2823 return InvalidParameter;
2824
2825 if(graphics->busy)
2826 return ObjectBusy;
2827
2828 ptf[0].X = x;
2829 ptf[0].Y = y;
2830 ptf[1].X = x + width;
2831 ptf[1].Y = y;
2832 ptf[2].X = x + width;
2833 ptf[2].Y = y + height;
2834 ptf[3].X = x;
2835 ptf[3].Y = y + height;
2836
2837 save_state = SaveDC(graphics->hdc);
2838 EndPath(graphics->hdc);
2839
2840 transform_and_round_points(graphics, pti, ptf, 4);
2841
2842 BeginPath(graphics->hdc);
2843 Polygon(graphics->hdc, pti, 4);
2844 EndPath(graphics->hdc);
2845
2846 brush_fill_path(graphics, brush);
2847
2848 RestoreDC(graphics->hdc, save_state);
2849
2850 return Ok;
2851 }
2852
2853 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
2854 INT count)
2855 {
2856 GpStatus ret;
2857 INT i;
2858
2859 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
2860
2861 if(!rects)
2862 return InvalidParameter;
2863
2864 for(i = 0; i < count; i++){
2865 ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
2866 if(ret != Ok) return ret;
2867 }
2868
2869 return Ok;
2870 }
2871
2872 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
2873 INT count)
2874 {
2875 GpRectF *rectsF;
2876 GpStatus ret;
2877 INT i;
2878
2879 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
2880
2881 if(!rects || count <= 0)
2882 return InvalidParameter;
2883
2884 rectsF = GdipAlloc(sizeof(GpRectF)*count);
2885 if(!rectsF)
2886 return OutOfMemory;
2887
2888 for(i = 0; i < count; i++){
2889 rectsF[i].X = (REAL)rects[i].X;
2890 rectsF[i].Y = (REAL)rects[i].Y;
2891 rectsF[i].X = (REAL)rects[i].Width;
2892 rectsF[i].Height = (REAL)rects[i].Height;
2893 }
2894
2895 ret = GdipFillRectangles(graphics,brush,rectsF,count);
2896 GdipFree(rectsF);
2897
2898 return ret;
2899 }
2900
2901 /*****************************************************************************
2902 * GdipFillRegion [GDIPLUS.@]
2903 */
2904 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
2905 GpRegion* region)
2906 {
2907 INT save_state;
2908 GpStatus status;
2909 HRGN hrgn;
2910 RECT rc;
2911
2912 TRACE("(%p, %p, %p)\n", graphics, brush, region);
2913
2914 if (!(graphics && brush && region))
2915 return InvalidParameter;
2916
2917 if(graphics->busy)
2918 return ObjectBusy;
2919
2920 status = GdipGetRegionHRgn(region, graphics, &hrgn);
2921 if(status != Ok)
2922 return status;
2923
2924 save_state = SaveDC(graphics->hdc);
2925 EndPath(graphics->hdc);
2926
2927 ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
2928
2929 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
2930 {
2931 BeginPath(graphics->hdc);
2932 Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
2933 EndPath(graphics->hdc);
2934
2935 brush_fill_path(graphics, brush);
2936 }
2937
2938 RestoreDC(graphics->hdc, save_state);
2939
2940 DeleteObject(hrgn);
2941
2942 return Ok;
2943 }
2944
2945 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
2946 {
2947 static int calls;
2948
2949 if(!graphics)
2950 return InvalidParameter;
2951
2952 if(graphics->busy)
2953 return ObjectBusy;
2954
2955 if(!(calls++))
2956 FIXME("not implemented\n");
2957
2958 return NotImplemented;
2959 }
2960
2961 /*****************************************************************************
2962 * GdipGetClipBounds [GDIPLUS.@]
2963 */
2964 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
2965 {
2966 TRACE("(%p, %p)\n", graphics, rect);
2967
2968 if(!graphics)
2969 return InvalidParameter;
2970
2971 if(graphics->busy)
2972 return ObjectBusy;
2973
2974 return GdipGetRegionBounds(graphics->clip, graphics, rect);
2975 }
2976
2977 /*****************************************************************************
2978 * GdipGetClipBoundsI [GDIPLUS.@]
2979 */
2980 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
2981 {
2982 TRACE("(%p, %p)\n", graphics, rect);
2983
2984 if(!graphics)
2985 return InvalidParameter;
2986
2987 if(graphics->busy)
2988 return ObjectBusy;
2989
2990 return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
2991 }
2992
2993 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
2994 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
2995 CompositingMode *mode)
2996 {
2997 TRACE("(%p, %p)\n", graphics, mode);
2998
2999 if(!graphics || !mode)
3000 return InvalidParameter;
3001
3002 if(graphics->busy)
3003 return ObjectBusy;
3004
3005 *mode = graphics->compmode;
3006
3007 return Ok;
3008 }
3009
3010 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
3011 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
3012 CompositingQuality *quality)
3013 {
3014 TRACE("(%p, %p)\n", graphics, quality);
3015
3016 if(!graphics || !quality)
3017 return InvalidParameter;
3018
3019 if(graphics->busy)
3020 return ObjectBusy;
3021
3022 *quality = graphics->compqual;
3023
3024 return Ok;
3025 }
3026
3027 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
3028 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
3029 InterpolationMode *mode)
3030 {
3031 TRACE("(%p, %p)\n", graphics, mode);
3032
3033 if(!graphics || !mode)
3034 return InvalidParameter;
3035
3036 if(graphics->busy)
3037 return ObjectBusy;
3038
3039 *mode = graphics->interpolation;
3040
3041 return Ok;
3042 }
3043
3044 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
3045 {
3046 if(!graphics || !argb)
3047 return InvalidParameter;
3048
3049 if(graphics->busy)
3050 return ObjectBusy;
3051
3052 FIXME("(%p, %p): stub\n", graphics, argb);
3053
3054 return NotImplemented;
3055 }
3056
3057 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
3058 {
3059 TRACE("(%p, %p)\n", graphics, scale);
3060
3061 if(!graphics || !scale)
3062 return InvalidParameter;
3063
3064 if(graphics->busy)
3065 return ObjectBusy;
3066
3067 *scale = graphics->scale;
3068
3069 return Ok;
3070 }
3071
3072 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
3073 {
3074 TRACE("(%p, %p)\n", graphics, unit);
3075
3076 if(!graphics || !unit)
3077 return InvalidParameter;
3078
3079 if(graphics->busy)
3080 return ObjectBusy;
3081
3082 *unit = graphics->unit;
3083
3084 return Ok;
3085 }
3086
3087 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
3088 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
3089 *mode)
3090 {
3091 TRACE("(%p, %p)\n", graphics, mode);
3092
3093 if(!graphics || !mode)
3094 return InvalidParameter;
3095
3096 if(graphics->busy)
3097 return ObjectBusy;
3098
3099 *mode = graphics->pixeloffset;
3100
3101 return Ok;
3102 }
3103
3104 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
3105 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
3106 {
3107 TRACE("(%p, %p)\n", graphics, mode);
3108
3109 if(!graphics || !mode)
3110 return InvalidParameter;
3111
3112 if(graphics->busy)
3113 return ObjectBusy;
3114
3115 *mode = graphics->smoothing;
3116
3117 return Ok;
3118 }
3119
3120 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
3121 {
3122 TRACE("(%p, %p)\n", graphics, contrast);
3123
3124 if(!graphics || !contrast)
3125 return InvalidParameter;
3126
3127 *contrast = graphics->textcontrast;
3128
3129 return Ok;
3130 }
3131
3132 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
3133 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
3134 TextRenderingHint *hint)
3135 {
3136 TRACE("(%p, %p)\n", graphics, hint);
3137
3138 if(!graphics || !hint)
3139 return InvalidParameter;
3140
3141 if(graphics->busy)
3142 return ObjectBusy;
3143
3144 *hint = graphics->texthint;
3145
3146 return Ok;
3147 }
3148
3149 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
3150 {
3151 GpRegion *clip_rgn;
3152 GpStatus stat;
3153
3154 TRACE("(%p, %p)\n", graphics, rect);
3155
3156 if(!graphics || !rect)
3157 return InvalidParameter;
3158
3159 if(graphics->busy)
3160 return ObjectBusy;
3161
3162 /* intersect window and graphics clipping regions */
3163 if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
3164 return stat;
3165
3166 if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
3167 goto cleanup;
3168
3169 /* get bounds of the region */
3170 stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
3171
3172 cleanup:
3173 GdipDeleteRegion(clip_rgn);
3174
3175 return stat;
3176 }
3177
3178 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
3179 {
3180 GpRectF rectf;
3181 GpStatus stat;
3182
3183 TRACE("(%p, %p)\n", graphics, rect);
3184
3185 if(!graphics || !rect)
3186 return InvalidParameter;
3187
3188 if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
3189 {
3190 rect->X = roundr(rectf.X);
3191 rect->Y = roundr(rectf.Y);
3192 rect->Width = roundr(rectf.Width);
3193 rect->Height = roundr(rectf.Height);
3194 }
3195
3196 return stat;
3197 }
3198
3199 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
3200 {
3201 TRACE("(%p, %p)\n", graphics, matrix);
3202
3203 if(!graphics || !matrix)
3204 return InvalidParameter;
3205
3206 if(graphics->busy)
3207 return ObjectBusy;
3208
3209 *matrix = *graphics->worldtrans;
3210 return Ok;
3211 }
3212
3213 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
3214 {
3215 GpSolidFill *brush;
3216 GpStatus stat;
3217 GpRectF wnd_rect;
3218
3219 TRACE("(%p, %x)\n", graphics, color);
3220
3221 if(!graphics)
3222 return InvalidParameter;
3223
3224 if(graphics->busy)
3225 return ObjectBusy;
3226
3227 if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
3228 return stat;
3229
3230 if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
3231 GdipDeleteBrush((GpBrush*)brush);
3232 return stat;
3233 }
3234
3235 GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
3236 wnd_rect.Width, wnd_rect.Height);
3237
3238 GdipDeleteBrush((GpBrush*)brush);
3239
3240 return Ok;
3241 }
3242
3243 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
3244 {
3245 TRACE("(%p, %p)\n", graphics, res);
3246
3247 if(!graphics || !res)
3248 return InvalidParameter;
3249
3250 return GdipIsEmptyRegion(graphics->clip, graphics, res);
3251 }
3252
3253 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
3254 {
3255 FIXME("(%p, %.2f, %.2f, %p) stub\n", graphics, x, y, result);
3256
3257 if(!graphics || !result)
3258 return InvalidParameter;
3259
3260 if(graphics->busy)
3261 return ObjectBusy;
3262
3263 return NotImplemented;
3264 }
3265
3266 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
3267 {
3268 FIXME("(%p, %d, %d, %p) stub\n", graphics, x, y, result);
3269
3270 if(!graphics || !result)
3271 return InvalidParameter;
3272
3273 if(graphics->busy)
3274 return ObjectBusy;
3275
3276 return NotImplemented;
3277 }
3278
3279 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
3280 GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
3281 GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
3282 INT regionCount, GpRegion** regions)
3283 {
3284 if (!(graphics && string && font && layoutRect && stringFormat && regions))
3285 return InvalidParameter;
3286
3287 FIXME("stub: %p %s %d %p %p %p %d %p\n", graphics, debugstr_w(string),
3288 length, font, layoutRect, stringFormat, regionCount, regions);
3289
3290 return NotImplemented;
3291 }
3292
3293 /* Find the smallest rectangle that bounds the text when it is printed in rect
3294 * according to the format options listed in format. If rect has 0 width and
3295 * height, then just find the smallest rectangle that bounds the text when it's
3296 * printed at location (rect->X, rect-Y). */
3297 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
3298 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
3299 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
3300 INT *codepointsfitted, INT *linesfilled)
3301 {
3302 HFONT oldfont;
3303 WCHAR* stringdup;
3304 INT sum = 0, height = 0, fit, fitcpy, max_width = 0, i, j, lret, nwidth,
3305 nheight, lineend;
3306 SIZE size;
3307
3308 TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
3309 debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
3310 bounds, codepointsfitted, linesfilled);
3311
3312 if(!graphics || !string || !font || !rect)
3313 return InvalidParameter;
3314
3315 if(linesfilled) *linesfilled = 0;
3316 if(codepointsfitted) *codepointsfitted = 0;
3317
3318 if(format)
3319 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
3320
3321 if(length == -1) length = lstrlenW(string);
3322
3323 stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
3324 if(!stringdup) return OutOfMemory;
3325
3326 oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
3327 nwidth = roundr(rect->Width);
3328 nheight = roundr(rect->Height);
3329
3330 if((nwidth == 0) && (nheight == 0))
3331 nwidth = nheight = INT_MAX;
3332
3333 for(i = 0, j = 0; i < length; i++){
3334 if(!isprintW(string[i]) && (string[i] != '\n'))
3335 continue;
3336
3337 stringdup[j] = string[i];
3338 j++;
3339 }
3340
3341 stringdup[j] = 0;
3342 length = j;
3343
3344 while(sum < length){
3345 GetTextExtentExPointW(graphics->hdc, stringdup + sum, length - sum,
3346 nwidth, &fit, NULL, &size);
3347 fitcpy = fit;
3348
3349 if(fit == 0)
3350 break;
3351
3352 for(lret = 0; lret < fit; lret++)
3353 if(*(stringdup + sum + lret) == '\n')
3354 break;
3355
3356 /* Line break code (may look strange, but it imitates windows). */
3357 if(lret < fit)
3358 lineend = fit = lret; /* this is not an off-by-one error */
3359 else if(fit < (length - sum)){
3360 if(*(stringdup + sum + fit) == ' ')
3361 while(*(stringdup + sum + fit) == ' ')
3362 fit++;
3363 else
3364 while(*(stringdup + sum + fit - 1) != ' '){
3365 fit--;
3366
3367 if(*(stringdup + sum + fit) == '\t')
3368 break;
3369
3370 if(fit == 0){
3371 fit = fitcpy;
3372 break;
3373 }
3374 }
3375 lineend = fit;
3376 while(*(stringdup + sum + lineend - 1) == ' ' ||
3377 *(stringdup + sum + lineend - 1) == '\t')
3378 lineend--;
3379 }
3380 else
3381 lineend = fit;
3382
3383 GetTextExtentExPointW(graphics->hdc, stringdup + sum, lineend,
3384 nwidth, &j, NULL, &size);
3385
3386 sum += fit + (lret < fitcpy ? 1 : 0);
3387 if(codepointsfitted) *codepointsfitted = sum;
3388
3389 height += size.cy;
3390 if(linesfilled) *linesfilled += size.cy;
3391 max_width = max(max_width, size.cx);
3392
3393 if(height > nheight)
3394 break;
3395
3396 /* Stop if this was a linewrap (but not if it was a linebreak). */
3397 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
3398 break;
3399 }
3400
3401 bounds->X = rect->X;
3402 bounds->Y = rect->Y;
3403 bounds->Width = (REAL)max_width;
3404 bounds->Height = (REAL) min(height, nheight);
3405
3406 GdipFree(stringdup);
3407 DeleteObject(SelectObject(graphics->hdc, oldfont));
3408
3409 return Ok;
3410 }
3411
3412 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
3413 {
3414 TRACE("(%p)\n", graphics);
3415
3416 if(!graphics)
3417 return InvalidParameter;
3418
3419 if(graphics->busy)
3420 return ObjectBusy;
3421
3422 return GdipSetInfinite(graphics->clip);
3423 }
3424
3425 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
3426 {
3427 TRACE("(%p)\n", graphics);
3428
3429 if(!graphics)
3430 return InvalidParameter;
3431
3432 if(graphics->busy)
3433 return ObjectBusy;
3434
3435 graphics->worldtrans->matrix[0] = 1.0;
3436 graphics->worldtrans->matrix[1] = 0.0;
3437 graphics->worldtrans->matrix[2] = 0.0;
3438 graphics->worldtrans->matrix[3] = 1.0;
3439 graphics->worldtrans->matrix[4] = 0.0;
3440 graphics->worldtrans->matrix[5] = 0.0;
3441
3442 return Ok;
3443 }
3444
3445 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
3446 {
3447 return GdipEndContainer(graphics, state);
3448 }
3449
3450 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
3451 GpMatrixOrder order)
3452 {
3453 TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
3454
3455 if(!graphics)
3456 return InvalidParameter;
3457
3458 if(graphics->busy)
3459 return ObjectBusy;
3460
3461 return GdipRotateMatrix(graphics->worldtrans, angle, order);
3462 }
3463
3464 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
3465 {
3466 return GdipBeginContainer2(graphics, state);
3467 }
3468
3469 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
3470 GraphicsContainer *state)
3471 {
3472 GraphicsContainerItem *container;
3473 GpStatus sts;
3474
3475 TRACE("(%p, %p)\n", graphics, state);
3476
3477 if(!graphics || !state)
3478 return InvalidParameter;
3479
3480 sts = init_container(&container, graphics);
3481 if(sts != Ok)
3482 return sts;
3483
3484 list_add_head(&graphics->containers, &container->entry);
3485 *state = graphics->contid = container->contid;
3486
3487 return Ok;
3488 }
3489
3490 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
3491 {
3492 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
3493 return NotImplemented;
3494 }
3495
3496 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
3497 {
3498 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
3499 return NotImplemented;
3500 }
3501
3502 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
3503 {
3504 FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
3505 return NotImplemented;
3506 }
3507
3508 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
3509 {
3510 GpStatus sts;
3511 GraphicsContainerItem *container, *container2;
3512
3513 TRACE("(%p, %x)\n", graphics, state);
3514
3515 if(!graphics)
3516 return InvalidParameter;
3517
3518 LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
3519 if(container->contid == state)
3520 break;
3521 }
3522
3523 /* did not find a matching container */
3524 if(&container->entry == &graphics->containers)
3525 return Ok;
3526
3527 sts = restore_container(graphics, container);
3528 if(sts != Ok)
3529 return sts;
3530
3531 /* remove all of the containers on top of the found container */
3532 LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
3533 if(container->contid == state)
3534 break;
3535 list_remove(&container->entry);
3536 delete_container(container);
3537 }
3538
3539 list_remove(&container->entry);
3540 delete_container(container);
3541
3542 return Ok;
3543 }
3544
3545 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
3546 REAL sy, GpMatrixOrder order)
3547 {
3548 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
3549
3550 if(!graphics)
3551 return InvalidParameter;
3552
3553 if(graphics->busy)
3554 return ObjectBusy;
3555
3556 return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
3557 }
3558
3559 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
3560 CombineMode mode)
3561 {
3562 TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
3563
3564 if(!graphics || !srcgraphics)
3565 return InvalidParameter;
3566
3567 return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
3568 }
3569
3570 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
3571 CompositingMode mode)
3572 {
3573 TRACE("(%p, %d)\n", graphics, mode);
3574
3575 if(!graphics)
3576 return InvalidParameter;
3577
3578 if(graphics->busy)
3579 return ObjectBusy;
3580
3581 graphics->compmode = mode;
3582
3583 return Ok;
3584 }
3585
3586 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
3587 CompositingQuality quality)
3588 {
3589 TRACE("(%p, %d)\n", graphics, quality);
3590
3591 if(!graphics)
3592 return InvalidParameter;
3593
3594 if(graphics->busy)
3595 return ObjectBusy;
3596
3597 graphics->compqual = quality;
3598
3599 return Ok;
3600 }
3601
3602 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
3603 InterpolationMode mode)
3604 {
3605 TRACE("(%p, %d)\n", graphics, mode);
3606
3607 if(!graphics)
3608 return InvalidParameter;
3609
3610 if(graphics->busy)
3611 return ObjectBusy;
3612
3613 graphics->interpolation = mode;
3614
3615 return Ok;
3616 }
3617
3618 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
3619 {
3620 TRACE("(%p, %.2f)\n", graphics, scale);
3621
3622 if(!graphics || (scale <= 0.0))
3623 return InvalidParameter;
3624
3625 if(graphics->busy)
3626 return ObjectBusy;
3627
3628 graphics->scale = scale;
3629
3630 return Ok;
3631 }
3632
3633 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
3634 {
3635 TRACE("(%p, %d)\n", graphics, unit);
3636
3637 if(!graphics)
3638 return InvalidParameter;
3639
3640 if(graphics->busy)
3641 return ObjectBusy;
3642
3643 if(unit == UnitWorld)
3644 return InvalidParameter;
3645
3646 graphics->unit = unit;
3647
3648 return Ok;
3649 }
3650
3651 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
3652 mode)
3653 {
3654 TRACE("(%p, %d)\n", graphics, mode);
3655
3656 if(!graphics)
3657 return InvalidParameter;
3658
3659 if(graphics->busy)
3660 return ObjectBusy;
3661
3662 graphics->pixeloffset = mode;
3663
3664 return Ok;
3665 }
3666
3667 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
3668 {
3669 static int calls;
3670
3671 TRACE("(%p,%i,%i)\n", graphics, x, y);
3672
3673 if (!(calls++))
3674 FIXME("not implemented\n");
3675
3676 return NotImplemented;
3677 }
3678
3679 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
3680 {
3681 TRACE("(%p, %d)\n", graphics, mode);
3682
3683 if(!graphics)
3684 return InvalidParameter;
3685
3686 if(graphics->busy)
3687 return ObjectBusy;
3688
3689 graphics->smoothing = mode;
3690
3691 return Ok;
3692 }
3693
3694 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
3695 {
3696 TRACE("(%p, %d)\n", graphics, contrast);
3697
3698 if(!graphics)
3699 return InvalidParameter;
3700
3701 graphics->textcontrast = contrast;
3702
3703 return Ok;
3704 }
3705
3706 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
3707 TextRenderingHint hint)
3708 {
3709 TRACE("(%p, %d)\n", graphics, hint);
3710
3711 if(!graphics)
3712 return InvalidParameter;
3713
3714 if(graphics->busy)
3715 return ObjectBusy;
3716
3717 graphics->texthint = hint;
3718
3719 return Ok;
3720 }
3721
3722 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
3723 {
3724 TRACE("(%p, %p)\n", graphics, matrix);
3725
3726 if(!graphics || !matrix)
3727 return InvalidParameter;
3728
3729 if(graphics->busy)
3730 return ObjectBusy;
3731
3732 GdipDeleteMatrix(graphics->worldtrans);
3733 return GdipCloneMatrix(matrix, &graphics->worldtrans);
3734 }
3735
3736 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
3737 REAL dy, GpMatrixOrder order)
3738 {
3739 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
3740
3741 if(!graphics)
3742 return InvalidParameter;
3743
3744 if(graphics->busy)
3745 return ObjectBusy;
3746
3747 return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
3748 }
3749
3750 /*****************************************************************************
3751 * GdipSetClipHrgn [GDIPLUS.@]
3752 */
3753 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
3754 {
3755 GpRegion *region;
3756 GpStatus status;
3757
3758 TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
3759
3760 if(!graphics)
3761 return InvalidParameter;
3762
3763 status = GdipCreateRegionHrgn(hrgn, &region);
3764 if(status != Ok)
3765 return status;
3766
3767 status = GdipSetClipRegion(graphics, region, mode);
3768
3769 GdipDeleteRegion(region);
3770 return status;
3771 }
3772
3773 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
3774 {
3775 TRACE("(%p, %p, %d)\n", graphics, path, mode);
3776
3777 if(!graphics)
3778 return InvalidParameter;
3779
3780 if(graphics->busy)
3781 return ObjectBusy;
3782
3783 return GdipCombineRegionPath(graphics->clip, path, mode);
3784 }
3785
3786 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
3787 REAL width, REAL height,
3788 CombineMode mode)
3789 {
3790 GpRectF rect;
3791
3792 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
3793
3794 if(!graphics)
3795 return InvalidParameter;
3796
3797 if(graphics->busy)
3798 return ObjectBusy;
3799
3800 rect.X = x;
3801 rect.Y = y;
3802 rect.Width = width;
3803 rect.Height = height;
3804
3805 return GdipCombineRegionRect(graphics->clip, &rect, mode);
3806 }
3807
3808 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
3809 INT width, INT height,
3810 CombineMode mode)
3811 {
3812 TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
3813
3814 if(!graphics)
3815 return InvalidParameter;
3816
3817 if(graphics->busy)
3818 return ObjectBusy;
3819
3820 return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
3821 }
3822
3823 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
3824 CombineMode mode)
3825 {
3826 TRACE("(%p, %p, %d)\n", graphics, region, mode);
3827
3828 if(!graphics || !region)
3829 return InvalidParameter;
3830
3831 if(graphics->busy)
3832 return ObjectBusy;
3833
3834 return GdipCombineRegionRegion(graphics->clip, region, mode);
3835 }
3836
3837 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
3838 UINT limitDpi)
3839 {
3840 static int calls;
3841
3842 if(!(calls++))
3843 FIXME("not implemented\n");
3844
3845 return NotImplemented;
3846 }
3847
3848 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
3849 INT count)
3850 {
3851 INT save_state;
3852 POINT *pti;
3853
3854 TRACE("(%p, %p, %d)\n", graphics, points, count);
3855
3856 if(!graphics || !pen || count<=0)
3857 return InvalidParameter;
3858
3859 if(graphics->busy)
3860 return ObjectBusy;
3861
3862 pti = GdipAlloc(sizeof(POINT) * count);
3863
3864 save_state = prepare_dc(graphics, pen);
3865 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3866
3867 transform_and_round_points(graphics, pti, (GpPointF*)points, count);
3868 Polygon(graphics->hdc, pti, count);
3869
3870 restore_dc(graphics, save_state);
3871 GdipFree(pti);
3872
3873 return Ok;
3874 }
3875
3876 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
3877 INT count)
3878 {
3879 GpStatus ret;
3880 GpPointF *ptf;
3881 INT i;
3882
3883 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3884
3885 if(count<=0) return InvalidParameter;
3886 ptf = GdipAlloc(sizeof(GpPointF) * count);
3887
3888 for(i = 0;i < count; i++){
3889 ptf[i].X = (REAL)points[i].X;
3890 ptf[i].Y = (REAL)points[i].Y;
3891 }
3892
3893 ret = GdipDrawPolygon(graphics,pen,ptf,count);
3894 GdipFree(ptf);
3895
3896 return ret;
3897 }
3898
3899 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
3900 {
3901 TRACE("(%p, %p)\n", graphics, dpi);
3902
3903 if(!graphics || !dpi)
3904 return InvalidParameter;
3905
3906 if(graphics->busy)
3907 return ObjectBusy;
3908
3909 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
3910
3911 return Ok;
3912 }
3913
3914 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
3915 {
3916 TRACE("(%p, %p)\n", graphics, dpi);
3917
3918 if(!graphics || !dpi)
3919 return InvalidParameter;
3920
3921 if(graphics->busy)
3922 return ObjectBusy;
3923
3924 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
3925
3926 return Ok;
3927 }
3928
3929 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
3930 GpMatrixOrder order)
3931 {
3932 GpMatrix m;
3933 GpStatus ret;
3934
3935 TRACE("(%p, %p, %d)\n", graphics, matrix, order);
3936
3937 if(!graphics || !matrix)
3938 return InvalidParameter;
3939
3940 if(graphics->busy)
3941 return ObjectBusy;
3942
3943 m = *(graphics->worldtrans);
3944
3945 ret = GdipMultiplyMatrix(&m, matrix, order);
3946 if(ret == Ok)
3947 *(graphics->worldtrans) = m;
3948
3949 return ret;
3950 }
3951
3952 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
3953 {
3954 TRACE("(%p, %p)\n", graphics, hdc);
3955
3956 if(!graphics || !hdc)
3957 return InvalidParameter;
3958
3959 if(graphics->busy)
3960 return ObjectBusy;
3961
3962 *hdc = graphics->hdc;
3963 graphics->busy = TRUE;
3964
3965 return Ok;
3966 }
3967
3968 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
3969 {
3970 TRACE("(%p, %p)\n", graphics, hdc);
3971
3972 if(!graphics)
3973 return InvalidParameter;
3974
3975 if(graphics->hdc != hdc || !(graphics->busy))
3976 return InvalidParameter;
3977
3978 graphics->busy = FALSE;
3979
3980 return Ok;
3981 }
3982
3983 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
3984 {
3985 GpRegion *clip;
3986 GpStatus status;
3987
3988 TRACE("(%p, %p)\n", graphics, region);
3989
3990 if(!graphics || !region)
3991 return InvalidParameter;
3992
3993 if(graphics->busy)
3994 return ObjectBusy;
3995
3996 if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
3997 return status;
3998
3999 /* free everything except root node and header */
4000 delete_element(&region->node);
4001 memcpy(region, clip, sizeof(GpRegion));
4002
4003 return Ok;
4004 }
4005
4006 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
4007 GpCoordinateSpace src_space, GpPointF *points, INT count)
4008 {
4009 GpMatrix *matrix;
4010 GpStatus stat;
4011 REAL unitscale;
4012
4013 if(!graphics || !points || count <= 0)
4014 return InvalidParameter;
4015
4016 if(graphics->busy)
4017 return ObjectBusy;
4018
4019 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4020
4021 if (src_space == dst_space) return Ok;
4022
4023 stat = GdipCreateMatrix(&matrix);
4024 if (stat == Ok)
4025 {
4026 unitscale = convert_unit(graphics->hdc, graphics->unit);
4027
4028 if(graphics->unit != UnitDisplay)
4029 unitscale *= graphics->scale;
4030
4031 /* transform from src_space to CoordinateSpacePage */
4032 switch (src_space)
4033 {
4034 case CoordinateSpaceWorld:
4035 GdipMultiplyMatrix(matrix, graphics->worldtrans, MatrixOrderAppend);
4036 break;
4037 case CoordinateSpacePage:
4038 break;
4039 case CoordinateSpaceDevice:
4040 GdipScaleMatrix(matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
4041 break;
4042 }
4043
4044 /* transform from CoordinateSpacePage to dst_space */
4045 switch (dst_space)
4046 {
4047 case CoordinateSpaceWorld:
4048 {
4049 GpMatrix *inverted_transform;
4050 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
4051 if (stat == Ok)
4052 {
4053 stat = GdipInvertMatrix(inverted_transform);
4054 if (stat == Ok)
4055 GdipMultiplyMatrix(matrix, inverted_transform, MatrixOrderAppend);
4056 GdipDeleteMatrix(inverted_transform);
4057 }
4058 break;
4059 }
4060 case CoordinateSpacePage:
4061 break;
4062 case CoordinateSpaceDevice:
4063 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
4064 break;
4065 }
4066
4067 if (stat == Ok)
4068 stat = GdipTransformMatrixPoints(matrix, points, count);
4069
4070 GdipDeleteMatrix(matrix);
4071 }
4072
4073 return stat;
4074 }
4075
4076 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
4077 GpCoordinateSpace src_space, GpPoint *points, INT count)
4078 {
4079 GpPointF *pointsF;
4080 GpStatus ret;
4081 INT i;
4082
4083 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
4084
4085 if(count <= 0)
4086 return InvalidParameter;
4087
4088 pointsF = GdipAlloc(sizeof(GpPointF) * count);
4089 if(!pointsF)
4090 return OutOfMemory;
4091
4092 for(i = 0; i < count; i++){
4093 pointsF[i].X = (REAL)points[i].X;
4094 pointsF[i].Y = (REAL)points[i].Y;
4095 }
4096
4097 ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
4098
4099 if(ret == Ok)
4100 for(i = 0; i < count; i++){
4101 points[i].X = roundr(pointsF[i].X);
4102 points[i].Y = roundr(pointsF[i].Y);
4103 }
4104 GdipFree(pointsF);
4105
4106 return ret;
4107 }
4108
4109 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
4110 {
4111 FIXME("\n");
4112
4113 return NULL;
4114 }
4115
4116 /*****************************************************************************
4117 * GdipTranslateClip [GDIPLUS.@]
4118 */
4119 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
4120 {
4121 TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
4122
4123 if(!graphics)
4124 return InvalidParameter;
4125
4126 if(graphics->busy)
4127 return ObjectBusy;
4128
4129 return GdipTranslateRegion(graphics->clip, dx, dy);
4130 }
4131
4132 /*****************************************************************************
4133 * GdipTranslateClipI [GDIPLUS.@]
4134 */
4135 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
4136 {
4137 TRACE("(%p, %d, %d)\n", graphics, dx, dy);
4138
4139 if(!graphics)
4140 return InvalidParameter;
4141
4142 if(graphics->busy)
4143 return ObjectBusy;
4144
4145 return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
4146 }
4147
4148
4149 /*****************************************************************************
4150 * GdipMeasureDriverString [GDIPLUS.@]
4151 */
4152 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4153 GDIPCONST GpFont *font, GDIPCONST PointF *positions,
4154 INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
4155 {
4156 FIXME("(%p %p %d %p %p %d %p %p): stub\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
4157 return NotImplemented;
4158 }
4159
4160 /*****************************************************************************
4161 * GdipDrawDriverString [GDIPLUS.@]
4162 */
4163 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
4164 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
4165 GDIPCONST PointF *positions, INT flags,
4166 GDIPCONST GpMatrix *matrix )
4167 {
4168 FIXME("(%p %p %d %p %p %p %d %p): stub\n", graphics, text, length, font, brush, positions, flags, matrix);
4169 return NotImplemented;
4170 }
4171
4172 /*****************************************************************************
4173 * GdipRecordMetafileI [GDIPLUS.@]
4174 */
4175 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
4176 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
4177 {
4178 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
4179 return NotImplemented;
4180 }
4181
4182 /*****************************************************************************
4183 * GdipIsVisibleRectI [GDIPLUS.@]
4184 */
4185 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4186 {
4187 FIXME("(%p %d %d %d %d %p): stub\n", graphics, x, y, width, height, result);
4188 return NotImplemented;
4189 }
Maarten's multimedia branch