?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Use GdipFillPath to implement GdipFillPie.
[wine/testsucceed.git] / dlls / gdiplus / graphics.c
blob262828bd42681a5acbdf293f0d442d233e62560e
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 REAL graphics_res(GpGraphics *graphics)
88 {
89 if (graphics->image) return graphics->image->xres;
90 else return (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
91 }
92
93 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
94 {
95 HPEN gdipen;
96 REAL width;
97 INT save_state, i, numdashes;
98 GpPointF pt[2];
99 DWORD dash_array[MAX_DASHLEN];
100
101 save_state = SaveDC(graphics->hdc);
102
103 EndPath(graphics->hdc);
104
105 if(pen->unit == UnitPixel){
106 width = pen->width;
107 }
108 else{
109 /* Get an estimate for the amount the pen width is affected by the world
110 * transform. (This is similar to what some of the wine drivers do.) */
111 pt[0].X = 0.0;
112 pt[0].Y = 0.0;
113 pt[1].X = 1.0;
114 pt[1].Y = 1.0;
115 GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
116 width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
117 (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
118
119 width *= pen->width * convert_unit(graphics_res(graphics),
120 pen->unit == UnitWorld ? graphics->unit : pen->unit);
121 }
122
123 if(pen->dash == DashStyleCustom){
124 numdashes = min(pen->numdashes, MAX_DASHLEN);
125
126 TRACE("dashes are: ");
127 for(i = 0; i < numdashes; i++){
128 dash_array[i] = roundr(width * pen->dashes[i]);
129 TRACE("%d, ", dash_array[i]);
130 }
131 TRACE("\n and the pen style is %x\n", pen->style);
132
133 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
134 numdashes, dash_array);
135 }
136 else
137 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
138
139 SelectObject(graphics->hdc, gdipen);
140
141 return save_state;
142 }
143
144 static void restore_dc(GpGraphics *graphics, INT state)
145 {
146 DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
147 RestoreDC(graphics->hdc, state);
148 }
149
150 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
151 GpCoordinateSpace src_space, GpMatrix **matrix);
152
153 /* This helper applies all the changes that the points listed in ptf need in
154 * order to be drawn on the device context. In the end, this should include at
155 * least:
156 * -scaling by page unit
157 * -applying world transformation
158 * -converting from float to int
159 * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
160 * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
161 * gdi to draw, and these functions would irreparably mess with line widths.
162 */
163 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
164 GpPointF *ptf, INT count)
165 {
166 REAL unitscale;
167 GpMatrix *matrix;
168 int i;
169
170 unitscale = convert_unit(graphics_res(graphics), graphics->unit);
171
172 /* apply page scale */
173 if(graphics->unit != UnitDisplay)
174 unitscale *= graphics->scale;
175
176 GdipCloneMatrix(graphics->worldtrans, &matrix);
177 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
178 GdipTransformMatrixPoints(matrix, ptf, count);
179 GdipDeleteMatrix(matrix);
180
181 for(i = 0; i < count; i++){
182 pti[i].x = roundr(ptf[i].X);
183 pti[i].y = roundr(ptf[i].Y);
184 }
185 }
186
187 /* Draw non-premultiplied ARGB data to the given graphics object */
188 static GpStatus alpha_blend_pixels(GpGraphics *graphics, INT dst_x, INT dst_y,
189 const BYTE *src, INT src_width, INT src_height, INT src_stride)
190 {
191 if (graphics->image && graphics->image->type == ImageTypeBitmap)
192 {
193 GpBitmap *dst_bitmap = (GpBitmap*)graphics->image;
194 INT x, y;
195
196 for (x=0; x<src_width; x++)
197 {
198 for (y=0; y<src_height; y++)
199 {
200 ARGB dst_color, src_color;
201 GdipBitmapGetPixel(dst_bitmap, x+dst_x, y+dst_y, &dst_color);
202 src_color = ((ARGB*)(src + src_stride * y))[x];
203 GdipBitmapSetPixel(dst_bitmap, x+dst_x, y+dst_y, color_over(dst_color, src_color));
204 }
205 }
206
207 return Ok;
208 }
209 else
210 {
211 HDC hdc;
212 HBITMAP hbitmap, old_hbm=NULL;
213 BITMAPINFOHEADER bih;
214 BYTE *temp_bits;
215 BLENDFUNCTION bf;
216
217 hdc = CreateCompatibleDC(0);
218
219 bih.biSize = sizeof(BITMAPINFOHEADER);
220 bih.biWidth = src_width;
221 bih.biHeight = -src_height;
222 bih.biPlanes = 1;
223 bih.biBitCount = 32;
224 bih.biCompression = BI_RGB;
225 bih.biSizeImage = 0;
226 bih.biXPelsPerMeter = 0;
227 bih.biYPelsPerMeter = 0;
228 bih.biClrUsed = 0;
229 bih.biClrImportant = 0;
230
231 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
232 (void**)&temp_bits, NULL, 0);
233
234 convert_32bppARGB_to_32bppPARGB(src_width, src_height, temp_bits,
235 4 * src_width, src, src_stride);
236
237 old_hbm = SelectObject(hdc, hbitmap);
238
239 bf.BlendOp = AC_SRC_OVER;
240 bf.BlendFlags = 0;
241 bf.SourceConstantAlpha = 255;
242 bf.AlphaFormat = AC_SRC_ALPHA;
243
244 GdiAlphaBlend(graphics->hdc, dst_x, dst_y, src_width, src_height,
245 hdc, 0, 0, src_width, src_height, bf);
246
247 SelectObject(hdc, old_hbm);
248 DeleteDC(hdc);
249 DeleteObject(hbitmap);
250
251 return Ok;
252 }
253 }
254
255 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
256 {
257 ARGB result=0;
258 ARGB i;
259 INT a1, a2, a3;
260
261 a1 = (start >> 24) & 0xff;
262 a2 = (end >> 24) & 0xff;
263
264 a3 = (int)(a1*(1.0f - position)+a2*(position));
265
266 result |= a3 << 24;
267
268 for (i=0xff; i<=0xff0000; i = i << 8)
269 result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
270 return result;
271 }
272
273 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
274 {
275 REAL blendfac;
276
277 /* clamp to between 0.0 and 1.0, using the wrap mode */
278 if (brush->wrap == WrapModeTile)
279 {
280 position = fmodf(position, 1.0f);
281 if (position < 0.0f) position += 1.0f;
282 }
283 else /* WrapModeFlip* */
284 {
285 position = fmodf(position, 2.0f);
286 if (position < 0.0f) position += 2.0f;
287 if (position > 1.0f) position = 2.0f - position;
288 }
289
290 if (brush->blendcount == 1)
291 blendfac = position;
292 else
293 {
294 int i=1;
295 REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
296 REAL range;
297
298 /* locate the blend positions surrounding this position */
299 while (position > brush->blendpos[i])
300 i++;
301
302 /* interpolate between the blend positions */
303 left_blendpos = brush->blendpos[i-1];
304 left_blendfac = brush->blendfac[i-1];
305 right_blendpos = brush->blendpos[i];
306 right_blendfac = brush->blendfac[i];
307 range = right_blendpos - left_blendpos;
308 blendfac = (left_blendfac * (right_blendpos - position) +
309 right_blendfac * (position - left_blendpos)) / range;
310 }
311
312 if (brush->pblendcount == 0)
313 return blend_colors(brush->startcolor, brush->endcolor, blendfac);
314 else
315 {
316 int i=1;
317 ARGB left_blendcolor, right_blendcolor;
318 REAL left_blendpos, right_blendpos;
319
320 /* locate the blend colors surrounding this position */
321 while (blendfac > brush->pblendpos[i])
322 i++;
323
324 /* interpolate between the blend colors */
325 left_blendpos = brush->pblendpos[i-1];
326 left_blendcolor = brush->pblendcolor[i-1];
327 right_blendpos = brush->pblendpos[i];
328 right_blendcolor = brush->pblendcolor[i];
329 blendfac = (blendfac - left_blendpos) / (right_blendpos - left_blendpos);
330 return blend_colors(left_blendcolor, right_blendcolor, blendfac);
331 }
332 }
333
334 static void apply_image_attributes(const GpImageAttributes *attributes, LPBYTE data,
335 UINT width, UINT height, INT stride, ColorAdjustType type)
336 {
337 UINT x, y, i;
338
339 if (attributes->colorkeys[type].enabled ||
340 attributes->colorkeys[ColorAdjustTypeDefault].enabled)
341 {
342 const struct color_key *key;
343 BYTE min_blue, min_green, min_red;
344 BYTE max_blue, max_green, max_red;
345
346 if (attributes->colorkeys[type].enabled)
347 key = &attributes->colorkeys[type];
348 else
349 key = &attributes->colorkeys[ColorAdjustTypeDefault];
350
351 min_blue = key->low&0xff;
352 min_green = (key->low>>8)&0xff;
353 min_red = (key->low>>16)&0xff;
354
355 max_blue = key->high&0xff;
356 max_green = (key->high>>8)&0xff;
357 max_red = (key->high>>16)&0xff;
358
359 for (x=0; x<width; x++)
360 for (y=0; y<height; y++)
361 {
362 ARGB *src_color;
363 BYTE blue, green, red;
364 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
365 blue = *src_color&0xff;
366 green = (*src_color>>8)&0xff;
367 red = (*src_color>>16)&0xff;
368 if (blue >= min_blue && green >= min_green && red >= min_red &&
369 blue <= max_blue && green <= max_green && red <= max_red)
370 *src_color = 0x00000000;
371 }
372 }
373
374 if (attributes->colorremaptables[type].enabled ||
375 attributes->colorremaptables[ColorAdjustTypeDefault].enabled)
376 {
377 const struct color_remap_table *table;
378
379 if (attributes->colorremaptables[type].enabled)
380 table = &attributes->colorremaptables[type];
381 else
382 table = &attributes->colorremaptables[ColorAdjustTypeDefault];
383
384 for (x=0; x<width; x++)
385 for (y=0; y<height; y++)
386 {
387 ARGB *src_color;
388 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
389 for (i=0; i<table->mapsize; i++)
390 {
391 if (*src_color == table->colormap[i].oldColor.Argb)
392 {
393 *src_color = table->colormap[i].newColor.Argb;
394 break;
395 }
396 }
397 }
398 }
399
400 if (attributes->colormatrices[type].enabled ||
401 attributes->colormatrices[ColorAdjustTypeDefault].enabled)
402 {
403 static int fixme;
404 if (!fixme++)
405 FIXME("Color transforms not implemented\n");
406 }
407
408 if (attributes->gamma_enabled[type] ||
409 attributes->gamma_enabled[ColorAdjustTypeDefault])
410 {
411 static int fixme;
412 if (!fixme++)
413 FIXME("Gamma adjustment not implemented\n");
414 }
415 }
416
417 /* Given a bitmap and its source rectangle, find the smallest rectangle in the
418 * bitmap that contains all the pixels we may need to draw it. */
419 static void get_bitmap_sample_size(InterpolationMode interpolation, WrapMode wrap,
420 GpBitmap* bitmap, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
421 GpRect *rect)
422 {
423 INT left, top, right, bottom;
424
425 switch (interpolation)
426 {
427 case InterpolationModeHighQualityBilinear:
428 case InterpolationModeHighQualityBicubic:
429 /* FIXME: Include a greater range for the prefilter? */
430 case InterpolationModeBicubic:
431 case InterpolationModeBilinear:
432 left = (INT)(floorf(srcx));
433 top = (INT)(floorf(srcy));
434 right = (INT)(ceilf(srcx+srcwidth));
435 bottom = (INT)(ceilf(srcy+srcheight));
436 break;
437 case InterpolationModeNearestNeighbor:
438 default:
439 left = roundr(srcx);
440 top = roundr(srcy);
441 right = roundr(srcx+srcwidth);
442 bottom = roundr(srcy+srcheight);
443 break;
444 }
445
446 if (wrap == WrapModeClamp)
447 {
448 if (left < 0)
449 left = 0;
450 if (top < 0)
451 top = 0;
452 if (right >= bitmap->width)
453 right = bitmap->width-1;
454 if (bottom >= bitmap->height)
455 bottom = bitmap->height-1;
456 }
457 else
458 {
459 /* In some cases we can make the rectangle smaller here, but the logic
460 * is hard to get right, and tiling suggests we're likely to use the
461 * entire source image. */
462 if (left < 0 || right >= bitmap->width)
463 {
464 left = 0;
465 right = bitmap->width-1;
466 }
467
468 if (top < 0 || bottom >= bitmap->height)
469 {
470 top = 0;
471 bottom = bitmap->height-1;
472 }
473 }
474
475 rect->X = left;
476 rect->Y = top;
477 rect->Width = right - left + 1;
478 rect->Height = bottom - top + 1;
479 }
480
481 static ARGB sample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
482 UINT height, INT x, INT y, GDIPCONST GpImageAttributes *attributes)
483 {
484 if (attributes->wrap == WrapModeClamp)
485 {
486 if (x < 0 || y < 0 || x >= width || y >= height)
487 return attributes->outside_color;
488 }
489 else
490 {
491 /* Tiling. Make sure co-ordinates are positive as it simplifies the math. */
492 if (x < 0)
493 x = width*2 + x % (width * 2);
494 if (y < 0)
495 y = height*2 + y % (height * 2);
496
497 if ((attributes->wrap & 1) == 1)
498 {
499 /* Flip X */
500 if ((x / width) % 2 == 0)
501 x = x % width;
502 else
503 x = width - 1 - x % width;
504 }
505 else
506 x = x % width;
507
508 if ((attributes->wrap & 2) == 2)
509 {
510 /* Flip Y */
511 if ((y / height) % 2 == 0)
512 y = y % height;
513 else
514 y = height - 1 - y % height;
515 }
516 else
517 y = y % height;
518 }
519
520 if (x < src_rect->X || y < src_rect->Y || x >= src_rect->X + src_rect->Width || y >= src_rect->Y + src_rect->Height)
521 {
522 ERR("out of range pixel requested\n");
523 return 0xffcd0084;
524 }
525
526 return ((DWORD*)(bits))[(x - src_rect->X) + (y - src_rect->Y) * src_rect->Width];
527 }
528
529 static ARGB resample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
530 UINT height, GpPointF *point, GDIPCONST GpImageAttributes *attributes,
531 InterpolationMode interpolation)
532 {
533 static int fixme;
534
535 switch (interpolation)
536 {
537 default:
538 if (!fixme++)
539 FIXME("Unimplemented interpolation %i\n", interpolation);
540 /* fall-through */
541 case InterpolationModeBilinear:
542 {
543 REAL leftxf, topyf;
544 INT leftx, rightx, topy, bottomy;
545 ARGB topleft, topright, bottomleft, bottomright;
546 ARGB top, bottom;
547 float x_offset;
548
549 leftxf = floorf(point->X);
550 leftx = (INT)leftxf;
551 rightx = (INT)ceilf(point->X);
552 topyf = floorf(point->Y);
553 topy = (INT)topyf;
554 bottomy = (INT)ceilf(point->Y);
555
556 if (leftx == rightx && topy == bottomy)
557 return sample_bitmap_pixel(src_rect, bits, width, height,
558 leftx, topy, attributes);
559
560 topleft = sample_bitmap_pixel(src_rect, bits, width, height,
561 leftx, topy, attributes);
562 topright = sample_bitmap_pixel(src_rect, bits, width, height,
563 rightx, topy, attributes);
564 bottomleft = sample_bitmap_pixel(src_rect, bits, width, height,
565 leftx, bottomy, attributes);
566 bottomright = sample_bitmap_pixel(src_rect, bits, width, height,
567 rightx, bottomy, attributes);
568
569 x_offset = point->X - leftxf;
570 top = blend_colors(topleft, topright, x_offset);
571 bottom = blend_colors(bottomleft, bottomright, x_offset);
572
573 return blend_colors(top, bottom, point->Y - topyf);
574 }
575 case InterpolationModeNearestNeighbor:
576 return sample_bitmap_pixel(src_rect, bits, width, height,
577 roundr(point->X), roundr(point->Y), attributes);
578 }
579 }
580
581 static INT brush_can_fill_path(GpBrush *brush)
582 {
583 switch (brush->bt)
584 {
585 case BrushTypeSolidColor:
586 case BrushTypeHatchFill:
587 return 1;
588 case BrushTypeLinearGradient:
589 case BrushTypeTextureFill:
590 /* Gdi32 isn't much help with these, so we should use brush_fill_pixels instead. */
591 default:
592 return 0;
593 }
594 }
595
596 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
597 {
598 switch (brush->bt)
599 {
600 case BrushTypeLinearGradient:
601 {
602 GpLineGradient *line = (GpLineGradient*)brush;
603 RECT rc;
604
605 SelectClipPath(graphics->hdc, RGN_AND);
606 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
607 {
608 GpPointF endpointsf[2];
609 POINT endpointsi[2];
610 POINT poly[4];
611
612 SelectObject(graphics->hdc, GetStockObject(NULL_PEN));
613
614 endpointsf[0] = line->startpoint;
615 endpointsf[1] = line->endpoint;
616 transform_and_round_points(graphics, endpointsi, endpointsf, 2);
617
618 if (abs(endpointsi[0].x-endpointsi[1].x) > abs(endpointsi[0].y-endpointsi[1].y))
619 {
620 /* vertical-ish gradient */
621 int startx, endx; /* x co-ordinates of endpoints shifted to intersect the top of the visible rectangle */
622 int startbottomx; /* x co-ordinate of start point shifted to intersect the bottom of the visible rectangle */
623 int width;
624 COLORREF col;
625 HBRUSH hbrush, hprevbrush;
626 int leftx, rightx; /* x co-ordinates where the leftmost and rightmost gradient lines hit the top of the visible rectangle */
627 int x;
628 int tilt; /* horizontal distance covered by a gradient line */
629
630 startx = roundr((rc.top - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
631 endx = roundr((rc.top - endpointsf[1].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[1].X);
632 width = endx - startx;
633 startbottomx = roundr((rc.bottom - endpointsf[0].Y) * (endpointsf[1].Y - endpointsf[0].Y) / (endpointsf[0].X - endpointsf[1].X) + endpointsf[0].X);
634 tilt = startx - startbottomx;
635
636 if (startx >= startbottomx)
637 {
638 leftx = rc.left;
639 rightx = rc.right + tilt;
640 }
641 else
642 {
643 leftx = rc.left + tilt;
644 rightx = rc.right;
645 }
646
647 poly[0].y = rc.bottom;
648 poly[1].y = rc.top;
649 poly[2].y = rc.top;
650 poly[3].y = rc.bottom;
651
652 for (x=leftx; x<=rightx; x++)
653 {
654 ARGB argb = blend_line_gradient(line, (x-startx)/(REAL)width);
655 col = ARGB2COLORREF(argb);
656 hbrush = CreateSolidBrush(col);
657 hprevbrush = SelectObject(graphics->hdc, hbrush);
658 poly[0].x = x - tilt - 1;
659 poly[1].x = x - 1;
660 poly[2].x = x;
661 poly[3].x = x - tilt;
662 Polygon(graphics->hdc, poly, 4);
663 SelectObject(graphics->hdc, hprevbrush);
664 DeleteObject(hbrush);
665 }
666 }
667 else if (endpointsi[0].y != endpointsi[1].y)
668 {
669 /* horizontal-ish gradient */
670 int starty, endy; /* y co-ordinates of endpoints shifted to intersect the left of the visible rectangle */
671 int startrighty; /* y co-ordinate of start point shifted to intersect the right of the visible rectangle */
672 int height;
673 COLORREF col;
674 HBRUSH hbrush, hprevbrush;
675 int topy, bottomy; /* y co-ordinates where the topmost and bottommost gradient lines hit the left of the visible rectangle */
676 int y;
677 int tilt; /* vertical distance covered by a gradient line */
678
679 starty = roundr((rc.left - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
680 endy = roundr((rc.left - endpointsf[1].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[1].Y);
681 height = endy - starty;
682 startrighty = roundr((rc.right - endpointsf[0].X) * (endpointsf[0].X - endpointsf[1].X) / (endpointsf[1].Y - endpointsf[0].Y) + endpointsf[0].Y);
683 tilt = starty - startrighty;
684
685 if (starty >= startrighty)
686 {
687 topy = rc.top;
688 bottomy = rc.bottom + tilt;
689 }
690 else
691 {
692 topy = rc.top + tilt;
693 bottomy = rc.bottom;
694 }
695
696 poly[0].x = rc.right;
697 poly[1].x = rc.left;
698 poly[2].x = rc.left;
699 poly[3].x = rc.right;
700
701 for (y=topy; y<=bottomy; y++)
702 {
703 ARGB argb = blend_line_gradient(line, (y-starty)/(REAL)height);
704 col = ARGB2COLORREF(argb);
705 hbrush = CreateSolidBrush(col);
706 hprevbrush = SelectObject(graphics->hdc, hbrush);
707 poly[0].y = y - tilt - 1;
708 poly[1].y = y - 1;
709 poly[2].y = y;
710 poly[3].y = y - tilt;
711 Polygon(graphics->hdc, poly, 4);
712 SelectObject(graphics->hdc, hprevbrush);
713 DeleteObject(hbrush);
714 }
715 }
716 /* else startpoint == endpoint */
717 }
718 break;
719 }
720 case BrushTypeSolidColor:
721 {
722 GpSolidFill *fill = (GpSolidFill*)brush;
723 if (fill->bmp)
724 {
725 RECT rc;
726 /* partially transparent fill */
727
728 SelectClipPath(graphics->hdc, RGN_AND);
729 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
730 {
731 HDC hdc = CreateCompatibleDC(NULL);
732 HBITMAP oldbmp;
733 BLENDFUNCTION bf;
734
735 if (!hdc) break;
736
737 oldbmp = SelectObject(hdc, fill->bmp);
738
739 bf.BlendOp = AC_SRC_OVER;
740 bf.BlendFlags = 0;
741 bf.SourceConstantAlpha = 255;
742 bf.AlphaFormat = AC_SRC_ALPHA;
743
744 GdiAlphaBlend(graphics->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdc, 0, 0, 1, 1, bf);
745
746 SelectObject(hdc, oldbmp);
747 DeleteDC(hdc);
748 }
749
750 break;
751 }
752 /* else fall through */
753 }
754 default:
755 SelectObject(graphics->hdc, brush->gdibrush);
756 FillPath(graphics->hdc);
757 break;
758 }
759 }
760
761 static INT brush_can_fill_pixels(GpBrush *brush)
762 {
763 switch (brush->bt)
764 {
765 case BrushTypeSolidColor:
766 case BrushTypeHatchFill:
767 case BrushTypeLinearGradient:
768 case BrushTypeTextureFill:
769 return 1;
770 default:
771 return 0;
772 }
773 }
774
775 static GpStatus brush_fill_pixels(GpGraphics *graphics, GpBrush *brush,
776 DWORD *argb_pixels, GpRect *fill_area, UINT cdwStride)
777 {
778 switch (brush->bt)
779 {
780 case BrushTypeSolidColor:
781 {
782 int x, y;
783 GpSolidFill *fill = (GpSolidFill*)brush;
784 for (x=0; x<fill_area->Width; x++)
785 for (y=0; y<fill_area->Height; y++)
786 argb_pixels[x + y*cdwStride] = fill->color;
787 return Ok;
788 }
789 case BrushTypeHatchFill:
790 {
791 int x, y;
792 GpHatch *fill = (GpHatch*)brush;
793 const char *hatch_data;
794
795 if (get_hatch_data(fill->hatchstyle, &hatch_data) != Ok)
796 return NotImplemented;
797
798 for (x=0; x<fill_area->Width; x++)
799 for (y=0; y<fill_area->Height; y++)
800 {
801 int hx, hy;
802
803 /* FIXME: Account for the rendering origin */
804 hx = (x + fill_area->X) % 8;
805 hy = (y + fill_area->Y) % 8;
806
807 if ((hatch_data[7-hy] & (0x80 >> hx)) != 0)
808 argb_pixels[x + y*cdwStride] = fill->forecol;
809 else
810 argb_pixels[x + y*cdwStride] = fill->backcol;
811 }
812
813 return Ok;
814 }
815 case BrushTypeLinearGradient:
816 {
817 GpLineGradient *fill = (GpLineGradient*)brush;
818 GpPointF draw_points[3], line_points[3];
819 GpStatus stat;
820 static const GpRectF box_1 = { 0.0, 0.0, 1.0, 1.0 };
821 GpMatrix *world_to_gradient; /* FIXME: Store this in the brush? */
822 int x, y;
823
824 draw_points[0].X = fill_area->X;
825 draw_points[0].Y = fill_area->Y;
826 draw_points[1].X = fill_area->X+1;
827 draw_points[1].Y = fill_area->Y;
828 draw_points[2].X = fill_area->X;
829 draw_points[2].Y = fill_area->Y+1;
830
831 /* Transform the points to a co-ordinate space where X is the point's
832 * position in the gradient, 0.0 being the start point and 1.0 the
833 * end point. */
834 stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
835 CoordinateSpaceDevice, draw_points, 3);
836
837 if (stat == Ok)
838 {
839 line_points[0] = fill->startpoint;
840 line_points[1] = fill->endpoint;
841 line_points[2].X = fill->startpoint.X + (fill->startpoint.Y - fill->endpoint.Y);
842 line_points[2].Y = fill->startpoint.Y + (fill->endpoint.X - fill->startpoint.X);
843
844 stat = GdipCreateMatrix3(&box_1, line_points, &world_to_gradient);
845 }
846
847 if (stat == Ok)
848 {
849 stat = GdipInvertMatrix(world_to_gradient);
850
851 if (stat == Ok)
852 stat = GdipTransformMatrixPoints(world_to_gradient, draw_points, 3);
853
854 GdipDeleteMatrix(world_to_gradient);
855 }
856
857 if (stat == Ok)
858 {
859 REAL x_delta = draw_points[1].X - draw_points[0].X;
860 REAL y_delta = draw_points[2].X - draw_points[0].X;
861
862 for (y=0; y<fill_area->Height; y++)
863 {
864 for (x=0; x<fill_area->Width; x++)
865 {
866 REAL pos = draw_points[0].X + x * x_delta + y * y_delta;
867
868 argb_pixels[x + y*cdwStride] = blend_line_gradient(fill, pos);
869 }
870 }
871 }
872
873 return stat;
874 }
875 case BrushTypeTextureFill:
876 {
877 GpTexture *fill = (GpTexture*)brush;
878 GpPointF draw_points[3];
879 GpStatus stat;
880 GpMatrix *world_to_texture;
881 int x, y;
882 GpBitmap *bitmap;
883 int src_stride;
884 GpRect src_area;
885
886 if (fill->image->type != ImageTypeBitmap)
887 {
888 FIXME("metafile texture brushes not implemented\n");
889 return NotImplemented;
890 }
891
892 bitmap = (GpBitmap*)fill->image;
893 src_stride = sizeof(ARGB) * bitmap->width;
894
895 src_area.X = src_area.Y = 0;
896 src_area.Width = bitmap->width;
897 src_area.Height = bitmap->height;
898
899 draw_points[0].X = fill_area->X;
900 draw_points[0].Y = fill_area->Y;
901 draw_points[1].X = fill_area->X+1;
902 draw_points[1].Y = fill_area->Y;
903 draw_points[2].X = fill_area->X;
904 draw_points[2].Y = fill_area->Y+1;
905
906 /* Transform the points to the co-ordinate space of the bitmap. */
907 stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
908 CoordinateSpaceDevice, draw_points, 3);
909
910 if (stat == Ok)
911 {
912 stat = GdipCloneMatrix(fill->transform, &world_to_texture);
913 }
914
915 if (stat == Ok)
916 {
917 stat = GdipInvertMatrix(world_to_texture);
918
919 if (stat == Ok)
920 stat = GdipTransformMatrixPoints(world_to_texture, draw_points, 3);
921
922 GdipDeleteMatrix(world_to_texture);
923 }
924
925 if (stat == Ok && !fill->bitmap_bits)
926 {
927 BitmapData lockeddata;
928
929 fill->bitmap_bits = GdipAlloc(sizeof(ARGB) * bitmap->width * bitmap->height);
930 if (!fill->bitmap_bits)
931 stat = OutOfMemory;
932
933 if (stat == Ok)
934 {
935 lockeddata.Width = bitmap->width;
936 lockeddata.Height = bitmap->height;
937 lockeddata.Stride = src_stride;
938 lockeddata.PixelFormat = PixelFormat32bppARGB;
939 lockeddata.Scan0 = fill->bitmap_bits;
940
941 stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
942 PixelFormat32bppARGB, &lockeddata);
943 }
944
945 if (stat == Ok)
946 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
947
948 if (stat == Ok)
949 apply_image_attributes(fill->imageattributes, fill->bitmap_bits,
950 bitmap->width, bitmap->height,
951 src_stride, ColorAdjustTypeBitmap);
952
953 if (stat != Ok)
954 {
955 GdipFree(fill->bitmap_bits);
956 fill->bitmap_bits = NULL;
957 }
958 }
959
960 if (stat == Ok)
961 {
962 REAL x_dx = draw_points[1].X - draw_points[0].X;
963 REAL x_dy = draw_points[1].Y - draw_points[0].Y;
964 REAL y_dx = draw_points[2].X - draw_points[0].X;
965 REAL y_dy = draw_points[2].Y - draw_points[0].Y;
966
967 for (y=0; y<fill_area->Height; y++)
968 {
969 for (x=0; x<fill_area->Width; x++)
970 {
971 GpPointF point;
972 point.X = draw_points[0].X + x * x_dx + y * y_dx;
973 point.Y = draw_points[0].Y + y * x_dy + y * y_dy;
974
975 argb_pixels[x + y*cdwStride] = resample_bitmap_pixel(
976 &src_area, fill->bitmap_bits, bitmap->width, bitmap->height,
977 &point, fill->imageattributes, graphics->interpolation);
978 }
979 }
980 }
981
982 return stat;
983 }
984 default:
985 return NotImplemented;
986 }
987 }
988
989 /* GdipDrawPie/GdipFillPie helper function */
990 static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
991 REAL height, REAL startAngle, REAL sweepAngle)
992 {
993 GpPointF ptf[4];
994 POINT pti[4];
995
996 ptf[0].X = x;
997 ptf[0].Y = y;
998 ptf[1].X = x + width;
999 ptf[1].Y = y + height;
1000
1001 deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
1002 deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
1003
1004 transform_and_round_points(graphics, pti, ptf, 4);
1005
1006 Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
1007 pti[2].y, pti[3].x, pti[3].y);
1008 }
1009
1010 /* Draws the linecap the specified color and size on the hdc. The linecap is in
1011 * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
1012 * should not be called on an hdc that has a path you care about. */
1013 static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
1014 const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
1015 {
1016 HGDIOBJ oldbrush = NULL, oldpen = NULL;
1017 GpMatrix *matrix = NULL;
1018 HBRUSH brush = NULL;
1019 HPEN pen = NULL;
1020 PointF ptf[4], *custptf = NULL;
1021 POINT pt[4], *custpt = NULL;
1022 BYTE *tp = NULL;
1023 REAL theta, dsmall, dbig, dx, dy = 0.0;
1024 INT i, count;
1025 LOGBRUSH lb;
1026 BOOL customstroke;
1027
1028 if((x1 == x2) && (y1 == y2))
1029 return;
1030
1031 theta = gdiplus_atan2(y2 - y1, x2 - x1);
1032
1033 customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
1034 if(!customstroke){
1035 brush = CreateSolidBrush(color);
1036 lb.lbStyle = BS_SOLID;
1037 lb.lbColor = color;
1038 lb.lbHatch = 0;
1039 pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
1040 PS_JOIN_MITER, 1, &lb, 0,
1041 NULL);
1042 oldbrush = SelectObject(graphics->hdc, brush);
1043 oldpen = SelectObject(graphics->hdc, pen);
1044 }
1045
1046 switch(cap){
1047 case LineCapFlat:
1048 break;
1049 case LineCapSquare:
1050 case LineCapSquareAnchor:
1051 case LineCapDiamondAnchor:
1052 size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
1053 if(cap == LineCapDiamondAnchor){
1054 dsmall = cos(theta + M_PI_2) * size;
1055 dbig = sin(theta + M_PI_2) * size;
1056 }
1057 else{
1058 dsmall = cos(theta + M_PI_4) * size;
1059 dbig = sin(theta + M_PI_4) * size;
1060 }
1061
1062 ptf[0].X = x2 - dsmall;
1063 ptf[1].X = x2 + dbig;
1064
1065 ptf[0].Y = y2 - dbig;
1066 ptf[3].Y = y2 + dsmall;
1067
1068 ptf[1].Y = y2 - dsmall;
1069 ptf[2].Y = y2 + dbig;
1070
1071 ptf[3].X = x2 - dbig;
1072 ptf[2].X = x2 + dsmall;
1073
1074 transform_and_round_points(graphics, pt, ptf, 4);
1075 Polygon(graphics->hdc, pt, 4);
1076
1077 break;
1078 case LineCapArrowAnchor:
1079 size = size * 4.0 / sqrt(3.0);
1080
1081 dx = cos(M_PI / 6.0 + theta) * size;
1082 dy = sin(M_PI / 6.0 + theta) * size;
1083
1084 ptf[0].X = x2 - dx;
1085 ptf[0].Y = y2 - dy;
1086
1087 dx = cos(- M_PI / 6.0 + theta) * size;
1088 dy = sin(- M_PI / 6.0 + theta) * size;
1089
1090 ptf[1].X = x2 - dx;
1091 ptf[1].Y = y2 - dy;
1092
1093 ptf[2].X = x2;
1094 ptf[2].Y = y2;
1095
1096 transform_and_round_points(graphics, pt, ptf, 3);
1097 Polygon(graphics->hdc, pt, 3);
1098
1099 break;
1100 case LineCapRoundAnchor:
1101 dx = dy = ANCHOR_WIDTH * size / 2.0;
1102
1103 ptf[0].X = x2 - dx;
1104 ptf[0].Y = y2 - dy;
1105 ptf[1].X = x2 + dx;
1106 ptf[1].Y = y2 + dy;
1107
1108 transform_and_round_points(graphics, pt, ptf, 2);
1109 Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
1110
1111 break;
1112 case LineCapTriangle:
1113 size = size / 2.0;
1114 dx = cos(M_PI_2 + theta) * size;
1115 dy = sin(M_PI_2 + theta) * size;
1116
1117 ptf[0].X = x2 - dx;
1118 ptf[0].Y = y2 - dy;
1119 ptf[1].X = x2 + dx;
1120 ptf[1].Y = y2 + dy;
1121
1122 dx = cos(theta) * size;
1123 dy = sin(theta) * size;
1124
1125 ptf[2].X = x2 + dx;
1126 ptf[2].Y = y2 + dy;
1127
1128 transform_and_round_points(graphics, pt, ptf, 3);
1129 Polygon(graphics->hdc, pt, 3);
1130
1131 break;
1132 case LineCapRound:
1133 dx = dy = size / 2.0;
1134
1135 ptf[0].X = x2 - dx;
1136 ptf[0].Y = y2 - dy;
1137 ptf[1].X = x2 + dx;
1138 ptf[1].Y = y2 + dy;
1139
1140 dx = -cos(M_PI_2 + theta) * size;
1141 dy = -sin(M_PI_2 + theta) * size;
1142
1143 ptf[2].X = x2 - dx;
1144 ptf[2].Y = y2 - dy;
1145 ptf[3].X = x2 + dx;
1146 ptf[3].Y = y2 + dy;
1147
1148 transform_and_round_points(graphics, pt, ptf, 4);
1149 Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
1150 pt[2].y, pt[3].x, pt[3].y);
1151
1152 break;
1153 case LineCapCustom:
1154 if(!custom)
1155 break;
1156
1157 count = custom->pathdata.Count;
1158 custptf = GdipAlloc(count * sizeof(PointF));
1159 custpt = GdipAlloc(count * sizeof(POINT));
1160 tp = GdipAlloc(count);
1161
1162 if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
1163 goto custend;
1164
1165 memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
1166
1167 GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
1168 GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
1169 MatrixOrderAppend);
1170 GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
1171 GdipTransformMatrixPoints(matrix, custptf, count);
1172
1173 transform_and_round_points(graphics, custpt, custptf, count);
1174
1175 for(i = 0; i < count; i++)
1176 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
1177
1178 if(custom->fill){
1179 BeginPath(graphics->hdc);
1180 PolyDraw(graphics->hdc, custpt, tp, count);
1181 EndPath(graphics->hdc);
1182 StrokeAndFillPath(graphics->hdc);
1183 }
1184 else
1185 PolyDraw(graphics->hdc, custpt, tp, count);
1186
1187 custend:
1188 GdipFree(custptf);
1189 GdipFree(custpt);
1190 GdipFree(tp);
1191 GdipDeleteMatrix(matrix);
1192 break;
1193 default:
1194 break;
1195 }
1196
1197 if(!customstroke){
1198 SelectObject(graphics->hdc, oldbrush);
1199 SelectObject(graphics->hdc, oldpen);
1200 DeleteObject(brush);
1201 DeleteObject(pen);
1202 }
1203 }
1204
1205 /* Shortens the line by the given percent by changing x2, y2.
1206 * If percent is > 1.0 then the line will change direction.
1207 * If percent is negative it can lengthen the line. */
1208 static void shorten_line_percent(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL percent)
1209 {
1210 REAL dist, theta, dx, dy;
1211
1212 if((y1 == *y2) && (x1 == *x2))
1213 return;
1214
1215 dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
1216 theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
1217 dx = cos(theta) * dist;
1218 dy = sin(theta) * dist;
1219
1220 *x2 = *x2 + dx;
1221 *y2 = *y2 + dy;
1222 }
1223
1224 /* Shortens the line by the given amount by changing x2, y2.
1225 * If the amount is greater than the distance, the line will become length 0.
1226 * If the amount is negative, it can lengthen the line. */
1227 static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
1228 {
1229 REAL dx, dy, percent;
1230
1231 dx = *x2 - x1;
1232 dy = *y2 - y1;
1233 if(dx == 0 && dy == 0)
1234 return;
1235
1236 percent = amt / sqrt(dx * dx + dy * dy);
1237 if(percent >= 1.0){
1238 *x2 = x1;
1239 *y2 = y1;
1240 return;
1241 }
1242
1243 shorten_line_percent(x1, y1, x2, y2, percent);
1244 }
1245
1246 /* Draws lines between the given points, and if caps is true then draws an endcap
1247 * at the end of the last line. */
1248 static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
1249 GDIPCONST GpPointF * pt, INT count, BOOL caps)
1250 {
1251 POINT *pti = NULL;
1252 GpPointF *ptcopy = NULL;
1253 GpStatus status = GenericError;
1254
1255 if(!count)
1256 return Ok;
1257
1258 pti = GdipAlloc(count * sizeof(POINT));
1259 ptcopy = GdipAlloc(count * sizeof(GpPointF));
1260
1261 if(!pti || !ptcopy){
1262 status = OutOfMemory;
1263 goto end;
1264 }
1265
1266 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1267
1268 if(caps){
1269 if(pen->endcap == LineCapArrowAnchor)
1270 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1271 &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
1272 else if((pen->endcap == LineCapCustom) && pen->customend)
1273 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1274 &ptcopy[count-1].X, &ptcopy[count-1].Y,
1275 pen->customend->inset * pen->width);
1276
1277 if(pen->startcap == LineCapArrowAnchor)
1278 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1279 &ptcopy[0].X, &ptcopy[0].Y, pen->width);
1280 else if((pen->startcap == LineCapCustom) && pen->customstart)
1281 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1282 &ptcopy[0].X, &ptcopy[0].Y,
1283 pen->customstart->inset * pen->width);
1284
1285 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1286 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
1287 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1288 pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
1289 }
1290
1291 transform_and_round_points(graphics, pti, ptcopy, count);
1292
1293 if(Polyline(graphics->hdc, pti, count))
1294 status = Ok;
1295
1296 end:
1297 GdipFree(pti);
1298 GdipFree(ptcopy);
1299
1300 return status;
1301 }
1302
1303 /* Conducts a linear search to find the bezier points that will back off
1304 * the endpoint of the curve by a distance of amt. Linear search works
1305 * better than binary in this case because there are multiple solutions,
1306 * and binary searches often find a bad one. I don't think this is what
1307 * Windows does but short of rendering the bezier without GDI's help it's
1308 * the best we can do. If rev then work from the start of the passed points
1309 * instead of the end. */
1310 static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
1311 {
1312 GpPointF origpt[4];
1313 REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
1314 INT i, first = 0, second = 1, third = 2, fourth = 3;
1315
1316 if(rev){
1317 first = 3;
1318 second = 2;
1319 third = 1;
1320 fourth = 0;
1321 }
1322
1323 origx = pt[fourth].X;
1324 origy = pt[fourth].Y;
1325 memcpy(origpt, pt, sizeof(GpPointF) * 4);
1326
1327 for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
1328 /* reset bezier points to original values */
1329 memcpy(pt, origpt, sizeof(GpPointF) * 4);
1330 /* Perform magic on bezier points. Order is important here.*/
1331 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1332 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1333 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1334 shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
1335 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1336 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1337
1338 dx = pt[fourth].X - origx;
1339 dy = pt[fourth].Y - origy;
1340
1341 diff = sqrt(dx * dx + dy * dy);
1342 percent += 0.0005 * amt;
1343 }
1344 }
1345
1346 /* Draws bezier curves between given points, and if caps is true then draws an
1347 * endcap at the end of the last line. */
1348 static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
1349 GDIPCONST GpPointF * pt, INT count, BOOL caps)
1350 {
1351 POINT *pti;
1352 GpPointF *ptcopy;
1353 GpStatus status = GenericError;
1354
1355 if(!count)
1356 return Ok;
1357
1358 pti = GdipAlloc(count * sizeof(POINT));
1359 ptcopy = GdipAlloc(count * sizeof(GpPointF));
1360
1361 if(!pti || !ptcopy){
1362 status = OutOfMemory;
1363 goto end;
1364 }
1365
1366 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1367
1368 if(caps){
1369 if(pen->endcap == LineCapArrowAnchor)
1370 shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
1371 else if((pen->endcap == LineCapCustom) && pen->customend)
1372 shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
1373 FALSE);
1374
1375 if(pen->startcap == LineCapArrowAnchor)
1376 shorten_bezier_amt(ptcopy, pen->width, TRUE);
1377 else if((pen->startcap == LineCapCustom) && pen->customstart)
1378 shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
1379
1380 /* the direction of the line cap is parallel to the direction at the
1381 * end of the bezier (which, if it has been shortened, is not the same
1382 * as the direction from pt[count-2] to pt[count-1]) */
1383 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1384 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1385 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1386 pt[count - 1].X, pt[count - 1].Y);
1387
1388 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1389 pt[0].X - (ptcopy[0].X - ptcopy[1].X),
1390 pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
1391 }
1392
1393 transform_and_round_points(graphics, pti, ptcopy, count);
1394
1395 PolyBezier(graphics->hdc, pti, count);
1396
1397 status = Ok;
1398
1399 end:
1400 GdipFree(pti);
1401 GdipFree(ptcopy);
1402
1403 return status;
1404 }
1405
1406 /* Draws a combination of bezier curves and lines between points. */
1407 static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
1408 GDIPCONST BYTE * types, INT count, BOOL caps)
1409 {
1410 POINT *pti = GdipAlloc(count * sizeof(POINT));
1411 BYTE *tp = GdipAlloc(count);
1412 GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
1413 INT i, j;
1414 GpStatus status = GenericError;
1415
1416 if(!count){
1417 status = Ok;
1418 goto end;
1419 }
1420 if(!pti || !tp || !ptcopy){
1421 status = OutOfMemory;
1422 goto end;
1423 }
1424
1425 for(i = 1; i < count; i++){
1426 if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
1427 if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
1428 || !(types[i + 1] & PathPointTypeBezier)){
1429 ERR("Bad bezier points\n");
1430 goto end;
1431 }
1432 i += 2;
1433 }
1434 }
1435
1436 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1437
1438 /* If we are drawing caps, go through the points and adjust them accordingly,
1439 * and draw the caps. */
1440 if(caps){
1441 switch(types[count - 1] & PathPointTypePathTypeMask){
1442 case PathPointTypeBezier:
1443 if(pen->endcap == LineCapArrowAnchor)
1444 shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
1445 else if((pen->endcap == LineCapCustom) && pen->customend)
1446 shorten_bezier_amt(&ptcopy[count - 4],
1447 pen->width * pen->customend->inset, FALSE);
1448
1449 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1450 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1451 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1452 pt[count - 1].X, pt[count - 1].Y);
1453
1454 break;
1455 case PathPointTypeLine:
1456 if(pen->endcap == LineCapArrowAnchor)
1457 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1458 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1459 pen->width);
1460 else if((pen->endcap == LineCapCustom) && pen->customend)
1461 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1462 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1463 pen->customend->inset * pen->width);
1464
1465 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1466 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
1467 pt[count - 1].Y);
1468
1469 break;
1470 default:
1471 ERR("Bad path last point\n");
1472 goto end;
1473 }
1474
1475 /* Find start of points */
1476 for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
1477 == PathPointTypeStart); j++);
1478
1479 switch(types[j] & PathPointTypePathTypeMask){
1480 case PathPointTypeBezier:
1481 if(pen->startcap == LineCapArrowAnchor)
1482 shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
1483 else if((pen->startcap == LineCapCustom) && pen->customstart)
1484 shorten_bezier_amt(&ptcopy[j - 1],
1485 pen->width * pen->customstart->inset, TRUE);
1486
1487 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1488 pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
1489 pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
1490 pt[j - 1].X, pt[j - 1].Y);
1491
1492 break;
1493 case PathPointTypeLine:
1494 if(pen->startcap == LineCapArrowAnchor)
1495 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1496 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1497 pen->width);
1498 else if((pen->startcap == LineCapCustom) && pen->customstart)
1499 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1500 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1501 pen->customstart->inset * pen->width);
1502
1503 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1504 pt[j].X, pt[j].Y, pt[j - 1].X,
1505 pt[j - 1].Y);
1506
1507 break;
1508 default:
1509 ERR("Bad path points\n");
1510 goto end;
1511 }
1512 }
1513
1514 transform_and_round_points(graphics, pti, ptcopy, count);
1515
1516 for(i = 0; i < count; i++){
1517 tp[i] = convert_path_point_type(types[i]);
1518 }
1519
1520 PolyDraw(graphics->hdc, pti, tp, count);
1521
1522 status = Ok;
1523
1524 end:
1525 GdipFree(pti);
1526 GdipFree(ptcopy);
1527 GdipFree(tp);
1528
1529 return status;
1530 }
1531
1532 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
1533 {
1534 GpStatus result;
1535
1536 BeginPath(graphics->hdc);
1537 result = draw_poly(graphics, NULL, path->pathdata.Points,
1538 path->pathdata.Types, path->pathdata.Count, FALSE);
1539 EndPath(graphics->hdc);
1540 return result;
1541 }
1542
1543 typedef struct _GraphicsContainerItem {
1544 struct list entry;
1545 GraphicsContainer contid;
1546
1547 SmoothingMode smoothing;
1548 CompositingQuality compqual;
1549 InterpolationMode interpolation;
1550 CompositingMode compmode;
1551 TextRenderingHint texthint;
1552 REAL scale;
1553 GpUnit unit;
1554 PixelOffsetMode pixeloffset;
1555 UINT textcontrast;
1556 GpMatrix* worldtrans;
1557 GpRegion* clip;
1558 } GraphicsContainerItem;
1559
1560 static GpStatus init_container(GraphicsContainerItem** container,
1561 GDIPCONST GpGraphics* graphics){
1562 GpStatus sts;
1563
1564 *container = GdipAlloc(sizeof(GraphicsContainerItem));
1565 if(!(*container))
1566 return OutOfMemory;
1567
1568 (*container)->contid = graphics->contid + 1;
1569
1570 (*container)->smoothing = graphics->smoothing;
1571 (*container)->compqual = graphics->compqual;
1572 (*container)->interpolation = graphics->interpolation;
1573 (*container)->compmode = graphics->compmode;
1574 (*container)->texthint = graphics->texthint;
1575 (*container)->scale = graphics->scale;
1576 (*container)->unit = graphics->unit;
1577 (*container)->textcontrast = graphics->textcontrast;
1578 (*container)->pixeloffset = graphics->pixeloffset;
1579
1580 sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
1581 if(sts != Ok){
1582 GdipFree(*container);
1583 *container = NULL;
1584 return sts;
1585 }
1586
1587 sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
1588 if(sts != Ok){
1589 GdipDeleteMatrix((*container)->worldtrans);
1590 GdipFree(*container);
1591 *container = NULL;
1592 return sts;
1593 }
1594
1595 return Ok;
1596 }
1597
1598 static void delete_container(GraphicsContainerItem* container){
1599 GdipDeleteMatrix(container->worldtrans);
1600 GdipDeleteRegion(container->clip);
1601 GdipFree(container);
1602 }
1603
1604 static GpStatus restore_container(GpGraphics* graphics,
1605 GDIPCONST GraphicsContainerItem* container){
1606 GpStatus sts;
1607 GpMatrix *newTrans;
1608 GpRegion *newClip;
1609
1610 sts = GdipCloneMatrix(container->worldtrans, &newTrans);
1611 if(sts != Ok)
1612 return sts;
1613
1614 sts = GdipCloneRegion(container->clip, &newClip);
1615 if(sts != Ok){
1616 GdipDeleteMatrix(newTrans);
1617 return sts;
1618 }
1619
1620 GdipDeleteMatrix(graphics->worldtrans);
1621 graphics->worldtrans = newTrans;
1622
1623 GdipDeleteRegion(graphics->clip);
1624 graphics->clip = newClip;
1625
1626 graphics->contid = container->contid - 1;
1627
1628 graphics->smoothing = container->smoothing;
1629 graphics->compqual = container->compqual;
1630 graphics->interpolation = container->interpolation;
1631 graphics->compmode = container->compmode;
1632 graphics->texthint = container->texthint;
1633 graphics->scale = container->scale;
1634 graphics->unit = container->unit;
1635 graphics->textcontrast = container->textcontrast;
1636 graphics->pixeloffset = container->pixeloffset;
1637
1638 return Ok;
1639 }
1640
1641 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
1642 {
1643 RECT wnd_rect;
1644 GpStatus stat=Ok;
1645 GpUnit unit;
1646
1647 if(graphics->hwnd) {
1648 if(!GetClientRect(graphics->hwnd, &wnd_rect))
1649 return GenericError;
1650
1651 rect->X = wnd_rect.left;
1652 rect->Y = wnd_rect.top;
1653 rect->Width = wnd_rect.right - wnd_rect.left;
1654 rect->Height = wnd_rect.bottom - wnd_rect.top;
1655 }else if (graphics->image){
1656 stat = GdipGetImageBounds(graphics->image, rect, &unit);
1657 if (stat == Ok && unit != UnitPixel)
1658 FIXME("need to convert from unit %i\n", unit);
1659 }else{
1660 rect->X = 0;
1661 rect->Y = 0;
1662 rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
1663 rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
1664 }
1665
1666 return stat;
1667 }
1668
1669 /* on success, rgn will contain the region of the graphics object which
1670 * is visible after clipping has been applied */
1671 static GpStatus get_visible_clip_region(GpGraphics *graphics, GpRegion *rgn)
1672 {
1673 GpStatus stat;
1674 GpRectF rectf;
1675 GpRegion* tmp;
1676
1677 if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
1678 return stat;
1679
1680 if((stat = GdipCreateRegion(&tmp)) != Ok)
1681 return stat;
1682
1683 if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
1684 goto end;
1685
1686 if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
1687 goto end;
1688
1689 stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
1690
1691 end:
1692 GdipDeleteRegion(tmp);
1693 return stat;
1694 }
1695
1696 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
1697 {
1698 TRACE("(%p, %p)\n", hdc, graphics);
1699
1700 return GdipCreateFromHDC2(hdc, NULL, graphics);
1701 }
1702
1703 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
1704 {
1705 GpStatus retval;
1706
1707 TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
1708
1709 if(hDevice != NULL) {
1710 FIXME("Don't know how to handle parameter hDevice\n");
1711 return NotImplemented;
1712 }
1713
1714 if(hdc == NULL)
1715 return OutOfMemory;
1716
1717 if(graphics == NULL)
1718 return InvalidParameter;
1719
1720 *graphics = GdipAlloc(sizeof(GpGraphics));
1721 if(!*graphics) return OutOfMemory;
1722
1723 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1724 GdipFree(*graphics);
1725 return retval;
1726 }
1727
1728 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1729 GdipFree((*graphics)->worldtrans);
1730 GdipFree(*graphics);
1731 return retval;
1732 }
1733
1734 (*graphics)->hdc = hdc;
1735 (*graphics)->hwnd = WindowFromDC(hdc);
1736 (*graphics)->owndc = FALSE;
1737 (*graphics)->smoothing = SmoothingModeDefault;
1738 (*graphics)->compqual = CompositingQualityDefault;
1739 (*graphics)->interpolation = InterpolationModeBilinear;
1740 (*graphics)->pixeloffset = PixelOffsetModeDefault;
1741 (*graphics)->compmode = CompositingModeSourceOver;
1742 (*graphics)->unit = UnitDisplay;
1743 (*graphics)->scale = 1.0;
1744 (*graphics)->busy = FALSE;
1745 (*graphics)->textcontrast = 4;
1746 list_init(&(*graphics)->containers);
1747 (*graphics)->contid = 0;
1748
1749 TRACE("<-- %p\n", *graphics);
1750
1751 return Ok;
1752 }
1753
1754 GpStatus graphics_from_image(GpImage *image, GpGraphics **graphics)
1755 {
1756 GpStatus retval;
1757
1758 *graphics = GdipAlloc(sizeof(GpGraphics));
1759 if(!*graphics) return OutOfMemory;
1760
1761 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1762 GdipFree(*graphics);
1763 return retval;
1764 }
1765
1766 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1767 GdipFree((*graphics)->worldtrans);
1768 GdipFree(*graphics);
1769 return retval;
1770 }
1771
1772 (*graphics)->hdc = NULL;
1773 (*graphics)->hwnd = NULL;
1774 (*graphics)->owndc = FALSE;
1775 (*graphics)->image = image;
1776 (*graphics)->smoothing = SmoothingModeDefault;
1777 (*graphics)->compqual = CompositingQualityDefault;
1778 (*graphics)->interpolation = InterpolationModeBilinear;
1779 (*graphics)->pixeloffset = PixelOffsetModeDefault;
1780 (*graphics)->compmode = CompositingModeSourceOver;
1781 (*graphics)->unit = UnitDisplay;
1782 (*graphics)->scale = 1.0;
1783 (*graphics)->busy = FALSE;
1784 (*graphics)->textcontrast = 4;
1785 list_init(&(*graphics)->containers);
1786 (*graphics)->contid = 0;
1787
1788 TRACE("<-- %p\n", *graphics);
1789
1790 return Ok;
1791 }
1792
1793 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
1794 {
1795 GpStatus ret;
1796 HDC hdc;
1797
1798 TRACE("(%p, %p)\n", hwnd, graphics);
1799
1800 hdc = GetDC(hwnd);
1801
1802 if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
1803 {
1804 ReleaseDC(hwnd, hdc);
1805 return ret;
1806 }
1807
1808 (*graphics)->hwnd = hwnd;
1809 (*graphics)->owndc = TRUE;
1810
1811 return Ok;
1812 }
1813
1814 /* FIXME: no icm handling */
1815 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
1816 {
1817 TRACE("(%p, %p)\n", hwnd, graphics);
1818
1819 return GdipCreateFromHWND(hwnd, graphics);
1820 }
1821
1822 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1823 GpMetafile **metafile)
1824 {
1825 static int calls;
1826
1827 TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
1828
1829 if(!hemf || !metafile)
1830 return InvalidParameter;
1831
1832 if(!(calls++))
1833 FIXME("not implemented\n");
1834
1835 return NotImplemented;
1836 }
1837
1838 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1839 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1840 {
1841 IStream *stream = NULL;
1842 UINT read;
1843 BYTE* copy;
1844 HENHMETAFILE hemf;
1845 GpStatus retval = Ok;
1846
1847 TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1848
1849 if(!hwmf || !metafile || !placeable)
1850 return InvalidParameter;
1851
1852 *metafile = NULL;
1853 read = GetMetaFileBitsEx(hwmf, 0, NULL);
1854 if(!read)
1855 return GenericError;
1856 copy = GdipAlloc(read);
1857 GetMetaFileBitsEx(hwmf, read, copy);
1858
1859 hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1860 GdipFree(copy);
1861
1862 read = GetEnhMetaFileBits(hemf, 0, NULL);
1863 copy = GdipAlloc(read);
1864 GetEnhMetaFileBits(hemf, read, copy);
1865 DeleteEnhMetaFile(hemf);
1866
1867 if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
1868 ERR("could not make stream\n");
1869 GdipFree(copy);
1870 retval = GenericError;
1871 goto err;
1872 }
1873
1874 *metafile = GdipAlloc(sizeof(GpMetafile));
1875 if(!*metafile){
1876 retval = OutOfMemory;
1877 goto err;
1878 }
1879
1880 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1881 (LPVOID*) &((*metafile)->image.picture)) != S_OK)
1882 {
1883 retval = GenericError;
1884 goto err;
1885 }
1886
1887
1888 (*metafile)->image.type = ImageTypeMetafile;
1889 memcpy(&(*metafile)->image.format, &ImageFormatWMF, sizeof(GUID));
1890 (*metafile)->image.palette_flags = 0;
1891 (*metafile)->image.palette_count = 0;
1892 (*metafile)->image.palette_size = 0;
1893 (*metafile)->image.palette_entries = NULL;
1894 (*metafile)->image.xres = (REAL)placeable->Inch;
1895 (*metafile)->image.yres = (REAL)placeable->Inch;
1896 (*metafile)->bounds.X = ((REAL) placeable->BoundingBox.Left) / ((REAL) placeable->Inch);
1897 (*metafile)->bounds.Y = ((REAL) placeable->BoundingBox.Top) / ((REAL) placeable->Inch);
1898 (*metafile)->bounds.Width = ((REAL) (placeable->BoundingBox.Right
1899 - placeable->BoundingBox.Left));
1900 (*metafile)->bounds.Height = ((REAL) (placeable->BoundingBox.Bottom
1901 - placeable->BoundingBox.Top));
1902 (*metafile)->unit = UnitPixel;
1903
1904 if(delete)
1905 DeleteMetaFile(hwmf);
1906
1907 TRACE("<-- %p\n", *metafile);
1908
1909 err:
1910 if (retval != Ok)
1911 GdipFree(*metafile);
1912 IStream_Release(stream);
1913 return retval;
1914 }
1915
1916 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1917 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1918 {
1919 HMETAFILE hmf = GetMetaFileW(file);
1920
1921 TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1922
1923 if(!hmf) return InvalidParameter;
1924
1925 return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1926 }
1927
1928 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1929 GpMetafile **metafile)
1930 {
1931 FIXME("(%p, %p): stub\n", file, metafile);
1932 return NotImplemented;
1933 }
1934
1935 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1936 GpMetafile **metafile)
1937 {
1938 FIXME("(%p, %p): stub\n", stream, metafile);
1939 return NotImplemented;
1940 }
1941
1942 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
1943 UINT access, IStream **stream)
1944 {
1945 DWORD dwMode;
1946 HRESULT ret;
1947
1948 TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
1949
1950 if(!stream || !filename)
1951 return InvalidParameter;
1952
1953 if(access & GENERIC_WRITE)
1954 dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
1955 else if(access & GENERIC_READ)
1956 dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
1957 else
1958 return InvalidParameter;
1959
1960 ret = SHCreateStreamOnFileW(filename, dwMode, stream);
1961
1962 return hresult_to_status(ret);
1963 }
1964
1965 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
1966 {
1967 GraphicsContainerItem *cont, *next;
1968 TRACE("(%p)\n", graphics);
1969
1970 if(!graphics) return InvalidParameter;
1971 if(graphics->busy) return ObjectBusy;
1972
1973 if(graphics->owndc)
1974 ReleaseDC(graphics->hwnd, graphics->hdc);
1975
1976 LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
1977 list_remove(&cont->entry);
1978 delete_container(cont);
1979 }
1980
1981 GdipDeleteRegion(graphics->clip);
1982 GdipDeleteMatrix(graphics->worldtrans);
1983 GdipFree(graphics);
1984
1985 return Ok;
1986 }
1987
1988 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
1989 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
1990 {
1991 INT save_state, num_pts;
1992 GpPointF points[MAX_ARC_PTS];
1993 GpStatus retval;
1994
1995 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
1996 width, height, startAngle, sweepAngle);
1997
1998 if(!graphics || !pen || width <= 0 || height <= 0)
1999 return InvalidParameter;
2000
2001 if(graphics->busy)
2002 return ObjectBusy;
2003
2004 if (!graphics->hdc)
2005 {
2006 FIXME("graphics object has no HDC\n");
2007 return Ok;
2008 }
2009
2010 num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
2011
2012 save_state = prepare_dc(graphics, pen);
2013
2014 retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
2015
2016 restore_dc(graphics, save_state);
2017
2018 return retval;
2019 }
2020
2021 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
2022 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2023 {
2024 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2025 width, height, startAngle, sweepAngle);
2026
2027 return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2028 }
2029
2030 GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
2031 REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
2032 {
2033 INT save_state;
2034 GpPointF pt[4];
2035 GpStatus retval;
2036
2037 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
2038 x2, y2, x3, y3, x4, y4);
2039
2040 if(!graphics || !pen)
2041 return InvalidParameter;
2042
2043 if(graphics->busy)
2044 return ObjectBusy;
2045
2046 if (!graphics->hdc)
2047 {
2048 FIXME("graphics object has no HDC\n");
2049 return Ok;
2050 }
2051
2052 pt[0].X = x1;
2053 pt[0].Y = y1;
2054 pt[1].X = x2;
2055 pt[1].Y = y2;
2056 pt[2].X = x3;
2057 pt[2].Y = y3;
2058 pt[3].X = x4;
2059 pt[3].Y = y4;
2060
2061 save_state = prepare_dc(graphics, pen);
2062
2063 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2064
2065 restore_dc(graphics, save_state);
2066
2067 return retval;
2068 }
2069
2070 GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
2071 INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
2072 {
2073 INT save_state;
2074 GpPointF pt[4];
2075 GpStatus retval;
2076
2077 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
2078 x2, y2, x3, y3, x4, y4);
2079
2080 if(!graphics || !pen)
2081 return InvalidParameter;
2082
2083 if(graphics->busy)
2084 return ObjectBusy;
2085
2086 if (!graphics->hdc)
2087 {
2088 FIXME("graphics object has no HDC\n");
2089 return Ok;
2090 }
2091
2092 pt[0].X = x1;
2093 pt[0].Y = y1;
2094 pt[1].X = x2;
2095 pt[1].Y = y2;
2096 pt[2].X = x3;
2097 pt[2].Y = y3;
2098 pt[3].X = x4;
2099 pt[3].Y = y4;
2100
2101 save_state = prepare_dc(graphics, pen);
2102
2103 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2104
2105 restore_dc(graphics, save_state);
2106
2107 return retval;
2108 }
2109
2110 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
2111 GDIPCONST GpPointF *points, INT count)
2112 {
2113 INT i;
2114 GpStatus ret;
2115
2116 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2117
2118 if(!graphics || !pen || !points || (count <= 0))
2119 return InvalidParameter;
2120
2121 if(graphics->busy)
2122 return ObjectBusy;
2123
2124 for(i = 0; i < floor(count / 4); i++){
2125 ret = GdipDrawBezier(graphics, pen,
2126 points[4*i].X, points[4*i].Y,
2127 points[4*i + 1].X, points[4*i + 1].Y,
2128 points[4*i + 2].X, points[4*i + 2].Y,
2129 points[4*i + 3].X, points[4*i + 3].Y);
2130 if(ret != Ok)
2131 return ret;
2132 }
2133
2134 return Ok;
2135 }
2136
2137 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
2138 GDIPCONST GpPoint *points, INT count)
2139 {
2140 GpPointF *pts;
2141 GpStatus ret;
2142 INT i;
2143
2144 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2145
2146 if(!graphics || !pen || !points || (count <= 0))
2147 return InvalidParameter;
2148
2149 if(graphics->busy)
2150 return ObjectBusy;
2151
2152 pts = GdipAlloc(sizeof(GpPointF) * count);
2153 if(!pts)
2154 return OutOfMemory;
2155
2156 for(i = 0; i < count; i++){
2157 pts[i].X = (REAL)points[i].X;
2158 pts[i].Y = (REAL)points[i].Y;
2159 }
2160
2161 ret = GdipDrawBeziers(graphics,pen,pts,count);
2162
2163 GdipFree(pts);
2164
2165 return ret;
2166 }
2167
2168 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
2169 GDIPCONST GpPointF *points, INT count)
2170 {
2171 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2172
2173 return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
2174 }
2175
2176 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
2177 GDIPCONST GpPoint *points, INT count)
2178 {
2179 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2180
2181 return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
2182 }
2183
2184 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
2185 GDIPCONST GpPointF *points, INT count, REAL tension)
2186 {
2187 GpPath *path;
2188 GpStatus stat;
2189
2190 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2191
2192 if(!graphics || !pen || !points || count <= 0)
2193 return InvalidParameter;
2194
2195 if(graphics->busy)
2196 return ObjectBusy;
2197
2198 if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
2199 return stat;
2200
2201 stat = GdipAddPathClosedCurve2(path, points, count, tension);
2202 if(stat != Ok){
2203 GdipDeletePath(path);
2204 return stat;
2205 }
2206
2207 stat = GdipDrawPath(graphics, pen, path);
2208
2209 GdipDeletePath(path);
2210
2211 return stat;
2212 }
2213
2214 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
2215 GDIPCONST GpPoint *points, INT count, REAL tension)
2216 {
2217 GpPointF *ptf;
2218 GpStatus stat;
2219 INT i;
2220
2221 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2222
2223 if(!points || count <= 0)
2224 return InvalidParameter;
2225
2226 ptf = GdipAlloc(sizeof(GpPointF)*count);
2227 if(!ptf)
2228 return OutOfMemory;
2229
2230 for(i = 0; i < count; i++){
2231 ptf[i].X = (REAL)points[i].X;
2232 ptf[i].Y = (REAL)points[i].Y;
2233 }
2234
2235 stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
2236
2237 GdipFree(ptf);
2238
2239 return stat;
2240 }
2241
2242 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
2243 GDIPCONST GpPointF *points, INT count)
2244 {
2245 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2246
2247 return GdipDrawCurve2(graphics,pen,points,count,1.0);
2248 }
2249
2250 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
2251 GDIPCONST GpPoint *points, INT count)
2252 {
2253 GpPointF *pointsF;
2254 GpStatus ret;
2255 INT i;
2256
2257 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2258
2259 if(!points)
2260 return InvalidParameter;
2261
2262 pointsF = GdipAlloc(sizeof(GpPointF)*count);
2263 if(!pointsF)
2264 return OutOfMemory;
2265
2266 for(i = 0; i < count; i++){
2267 pointsF[i].X = (REAL)points[i].X;
2268 pointsF[i].Y = (REAL)points[i].Y;
2269 }
2270
2271 ret = GdipDrawCurve(graphics,pen,pointsF,count);
2272 GdipFree(pointsF);
2273
2274 return ret;
2275 }
2276
2277 /* Approximates cardinal spline with Bezier curves. */
2278 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
2279 GDIPCONST GpPointF *points, INT count, REAL tension)
2280 {
2281 /* PolyBezier expects count*3-2 points. */
2282 INT i, len_pt = count*3-2, save_state;
2283 GpPointF *pt;
2284 REAL x1, x2, y1, y2;
2285 GpStatus retval;
2286
2287 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2288
2289 if(!graphics || !pen)
2290 return InvalidParameter;
2291
2292 if(graphics->busy)
2293 return ObjectBusy;
2294
2295 if(count < 2)
2296 return InvalidParameter;
2297
2298 if (!graphics->hdc)
2299 {
2300 FIXME("graphics object has no HDC\n");
2301 return Ok;
2302 }
2303
2304 pt = GdipAlloc(len_pt * sizeof(GpPointF));
2305 if(!pt)
2306 return OutOfMemory;
2307
2308 tension = tension * TENSION_CONST;
2309
2310 calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
2311 tension, &x1, &y1);
2312
2313 pt[0].X = points[0].X;
2314 pt[0].Y = points[0].Y;
2315 pt[1].X = x1;
2316 pt[1].Y = y1;
2317
2318 for(i = 0; i < count-2; i++){
2319 calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
2320
2321 pt[3*i+2].X = x1;
2322 pt[3*i+2].Y = y1;
2323 pt[3*i+3].X = points[i+1].X;
2324 pt[3*i+3].Y = points[i+1].Y;
2325 pt[3*i+4].X = x2;
2326 pt[3*i+4].Y = y2;
2327 }
2328
2329 calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
2330 points[count-2].X, points[count-2].Y, tension, &x1, &y1);
2331
2332 pt[len_pt-2].X = x1;
2333 pt[len_pt-2].Y = y1;
2334 pt[len_pt-1].X = points[count-1].X;
2335 pt[len_pt-1].Y = points[count-1].Y;
2336
2337 save_state = prepare_dc(graphics, pen);
2338
2339 retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
2340
2341 GdipFree(pt);
2342 restore_dc(graphics, save_state);
2343
2344 return retval;
2345 }
2346
2347 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
2348 GDIPCONST GpPoint *points, INT count, REAL tension)
2349 {
2350 GpPointF *pointsF;
2351 GpStatus ret;
2352 INT i;
2353
2354 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2355
2356 if(!points)
2357 return InvalidParameter;
2358
2359 pointsF = GdipAlloc(sizeof(GpPointF)*count);
2360 if(!pointsF)
2361 return OutOfMemory;
2362
2363 for(i = 0; i < count; i++){
2364 pointsF[i].X = (REAL)points[i].X;
2365 pointsF[i].Y = (REAL)points[i].Y;
2366 }
2367
2368 ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
2369 GdipFree(pointsF);
2370
2371 return ret;
2372 }
2373
2374 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
2375 GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
2376 REAL tension)
2377 {
2378 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2379
2380 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2381 return InvalidParameter;
2382 }
2383
2384 return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
2385 }
2386
2387 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
2388 GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
2389 REAL tension)
2390 {
2391 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2392
2393 if(count < 0){
2394 return OutOfMemory;
2395 }
2396
2397 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2398 return InvalidParameter;
2399 }
2400
2401 return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
2402 }
2403
2404 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
2405 REAL y, REAL width, REAL height)
2406 {
2407 INT save_state;
2408 GpPointF ptf[2];
2409 POINT pti[2];
2410
2411 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2412
2413 if(!graphics || !pen)
2414 return InvalidParameter;
2415
2416 if(graphics->busy)
2417 return ObjectBusy;
2418
2419 if (!graphics->hdc)
2420 {
2421 FIXME("graphics object has no HDC\n");
2422 return Ok;
2423 }
2424
2425 ptf[0].X = x;
2426 ptf[0].Y = y;
2427 ptf[1].X = x + width;
2428 ptf[1].Y = y + height;
2429
2430 save_state = prepare_dc(graphics, pen);
2431 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2432
2433 transform_and_round_points(graphics, pti, ptf, 2);
2434
2435 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2436
2437 restore_dc(graphics, save_state);
2438
2439 return Ok;
2440 }
2441
2442 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
2443 INT y, INT width, INT height)
2444 {
2445 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2446
2447 return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2448 }
2449
2450
2451 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
2452 {
2453 UINT width, height;
2454 GpPointF points[3];
2455
2456 TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
2457
2458 if(!graphics || !image)
2459 return InvalidParameter;
2460
2461 GdipGetImageWidth(image, &width);
2462 GdipGetImageHeight(image, &height);
2463
2464 /* FIXME: we should use the graphics and image dpi, somehow */
2465
2466 points[0].X = points[2].X = x;
2467 points[0].Y = points[1].Y = y;
2468 points[1].X = x + width;
2469 points[2].Y = y + height;
2470
2471 return GdipDrawImagePointsRect(graphics, image, points, 3, 0, 0, width, height,
2472 UnitPixel, NULL, NULL, NULL);
2473 }
2474
2475 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
2476 INT y)
2477 {
2478 TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
2479
2480 return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
2481 }
2482
2483 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
2484 REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
2485 GpUnit srcUnit)
2486 {
2487 GpPointF points[3];
2488 TRACE("(%p, %p, %f, %f, %f, %f, %f, %f, %d)\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2489
2490 points[0].X = points[2].X = x;
2491 points[0].Y = points[1].Y = y;
2492
2493 /* FIXME: convert image coordinates to Graphics coordinates? */
2494 points[1].X = x + srcwidth;
2495 points[2].Y = y + srcheight;
2496
2497 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2498 srcwidth, srcheight, srcUnit, NULL, NULL, NULL);
2499 }
2500
2501 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
2502 INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
2503 GpUnit srcUnit)
2504 {
2505 return GdipDrawImagePointRect(graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2506 }
2507
2508 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
2509 GDIPCONST GpPointF *dstpoints, INT count)
2510 {
2511 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
2512 return NotImplemented;
2513 }
2514
2515 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
2516 GDIPCONST GpPoint *dstpoints, INT count)
2517 {
2518 FIXME("(%p, %p, %p, %d): stub\n", graphics, image, dstpoints, count);
2519 return NotImplemented;
2520 }
2521
2522 GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
2523 GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
2524 REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2525 DrawImageAbort callback, VOID * callbackData)
2526 {
2527 GpPointF ptf[4];
2528 POINT pti[4];
2529 REAL dx, dy;
2530 GpStatus stat;
2531
2532 TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
2533 count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2534 callbackData);
2535
2536 if (count > 3)
2537 return NotImplemented;
2538
2539 if(!graphics || !image || !points || count != 3)
2540 return InvalidParameter;
2541
2542 TRACE("%s %s %s\n", debugstr_pointf(&points[0]), debugstr_pointf(&points[1]),
2543 debugstr_pointf(&points[2]));
2544
2545 memcpy(ptf, points, 3 * sizeof(GpPointF));
2546 ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
2547 ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
2548 if (!srcwidth || !srcheight || ptf[3].X == ptf[0].X || ptf[3].Y == ptf[0].Y)
2549 return Ok;
2550 transform_and_round_points(graphics, pti, ptf, 4);
2551
2552 if (image->picture)
2553 {
2554 if (!graphics->hdc)
2555 {
2556 FIXME("graphics object has no HDC\n");
2557 }
2558
2559 /* FIXME: partially implemented (only works for rectangular parallelograms) */
2560 if(srcUnit == UnitInch)
2561 dx = dy = (REAL) INCH_HIMETRIC;
2562 else if(srcUnit == UnitPixel){
2563 dx = ((REAL) INCH_HIMETRIC) /
2564 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
2565 dy = ((REAL) INCH_HIMETRIC) /
2566 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
2567 }
2568 else
2569 return NotImplemented;
2570
2571 if(IPicture_Render(image->picture, graphics->hdc,
2572 pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
2573 srcx * dx, srcy * dy,
2574 srcwidth * dx, srcheight * dy,
2575 NULL) != S_OK){
2576 if(callback)
2577 callback(callbackData);
2578 return GenericError;
2579 }
2580 }
2581 else if (image->type == ImageTypeBitmap)
2582 {
2583 GpBitmap* bitmap = (GpBitmap*)image;
2584 int use_software=0;
2585
2586 if (srcUnit == UnitInch)
2587 dx = dy = 96.0; /* FIXME: use the image resolution */
2588 else if (srcUnit == UnitPixel)
2589 dx = dy = 1.0;
2590 else
2591 return NotImplemented;
2592
2593 srcx = srcx * dx;
2594 srcy = srcy * dy;
2595 srcwidth = srcwidth * dx;
2596 srcheight = srcheight * dy;
2597
2598 if (imageAttributes ||
2599 (graphics->image && graphics->image->type == ImageTypeBitmap) ||
2600 !((GpBitmap*)image)->hbitmap ||
2601 ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X ||
2602 ptf[1].X - ptf[0].X != srcwidth || ptf[2].Y - ptf[0].Y != srcheight ||
2603 srcx < 0 || srcy < 0 ||
2604 srcx + srcwidth > bitmap->width || srcy + srcheight > bitmap->height)
2605 use_software = 1;
2606
2607 if (use_software)
2608 {
2609 RECT dst_area;
2610 GpRect src_area;
2611 int i, x, y, src_stride, dst_stride;
2612 GpMatrix *dst_to_src;
2613 REAL m11, m12, m21, m22, mdx, mdy;
2614 LPBYTE src_data, dst_data;
2615 BitmapData lockeddata;
2616 InterpolationMode interpolation = graphics->interpolation;
2617 GpPointF dst_to_src_points[3] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}};
2618 REAL x_dx, x_dy, y_dx, y_dy;
2619 static const GpImageAttributes defaultImageAttributes = {WrapModeClamp, 0, FALSE};
2620
2621 if (!imageAttributes)
2622 imageAttributes = &defaultImageAttributes;
2623
2624 dst_area.left = dst_area.right = pti[0].x;
2625 dst_area.top = dst_area.bottom = pti[0].y;
2626 for (i=1; i<4; i++)
2627 {
2628 if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
2629 if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
2630 if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
2631 if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
2632 }
2633
2634 m11 = (ptf[1].X - ptf[0].X) / srcwidth;
2635 m21 = (ptf[2].X - ptf[0].X) / srcheight;
2636 mdx = ptf[0].X - m11 * srcx - m21 * srcy;
2637 m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
2638 m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
2639 mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
2640
2641 stat = GdipCreateMatrix2(m11, m12, m21, m22, mdx, mdy, &dst_to_src);
2642 if (stat != Ok) return stat;
2643
2644 stat = GdipInvertMatrix(dst_to_src);
2645 if (stat != Ok)
2646 {
2647 GdipDeleteMatrix(dst_to_src);
2648 return stat;
2649 }
2650
2651 dst_data = GdipAlloc(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
2652 if (!dst_data)
2653 {
2654 GdipDeleteMatrix(dst_to_src);
2655 return OutOfMemory;
2656 }
2657
2658 dst_stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
2659
2660 get_bitmap_sample_size(interpolation, imageAttributes->wrap,
2661 bitmap, srcx, srcy, srcwidth, srcheight, &src_area);
2662
2663 src_data = GdipAlloc(sizeof(ARGB) * src_area.Width * src_area.Height);
2664 if (!src_data)
2665 {
2666 GdipFree(dst_data);
2667 GdipDeleteMatrix(dst_to_src);
2668 return OutOfMemory;
2669 }
2670 src_stride = sizeof(ARGB) * src_area.Width;
2671
2672 /* Read the bits we need from the source bitmap into an ARGB buffer. */
2673 lockeddata.Width = src_area.Width;
2674 lockeddata.Height = src_area.Height;
2675 lockeddata.Stride = src_stride;
2676 lockeddata.PixelFormat = PixelFormat32bppARGB;
2677 lockeddata.Scan0 = src_data;
2678
2679 stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
2680 PixelFormat32bppARGB, &lockeddata);
2681
2682 if (stat == Ok)
2683 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
2684
2685 if (stat != Ok)
2686 {
2687 if (src_data != dst_data)
2688 GdipFree(src_data);
2689 GdipFree(dst_data);
2690 GdipDeleteMatrix(dst_to_src);
2691 return OutOfMemory;
2692 }
2693
2694 apply_image_attributes(imageAttributes, src_data,
2695 src_area.Width, src_area.Height,
2696 src_stride, ColorAdjustTypeBitmap);
2697
2698 /* Transform the bits as needed to the destination. */
2699 GdipTransformMatrixPoints(dst_to_src, dst_to_src_points, 3);
2700
2701 x_dx = dst_to_src_points[1].X - dst_to_src_points[0].X;
2702 x_dy = dst_to_src_points[1].Y - dst_to_src_points[0].Y;
2703 y_dx = dst_to_src_points[2].X - dst_to_src_points[0].X;
2704 y_dy = dst_to_src_points[2].Y - dst_to_src_points[0].Y;
2705
2706 for (x=dst_area.left; x<dst_area.right; x++)
2707 {
2708 for (y=dst_area.top; y<dst_area.bottom; y++)
2709 {
2710 GpPointF src_pointf;
2711 ARGB *dst_color;
2712
2713 src_pointf.X = dst_to_src_points[0].X + x * x_dx + y * y_dx;
2714 src_pointf.Y = dst_to_src_points[0].Y + x * x_dy + y * y_dy;
2715
2716 dst_color = (ARGB*)(dst_data + dst_stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2717
2718 if (src_pointf.X >= srcx && src_pointf.X < srcx + srcwidth && src_pointf.Y >= srcy && src_pointf.Y < srcy+srcheight)
2719 *dst_color = resample_bitmap_pixel(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf, imageAttributes, interpolation);
2720 else
2721 *dst_color = 0;
2722 }
2723 }
2724
2725 GdipDeleteMatrix(dst_to_src);
2726
2727 GdipFree(src_data);
2728
2729 stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
2730 dst_data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, dst_stride);
2731
2732 GdipFree(dst_data);
2733
2734 return stat;
2735 }
2736 else
2737 {
2738 HDC hdc;
2739 int temp_hdc=0, temp_bitmap=0;
2740 HBITMAP hbitmap, old_hbm=NULL;
2741
2742 if (!(bitmap->format == PixelFormat16bppRGB555 ||
2743 bitmap->format == PixelFormat24bppRGB ||
2744 bitmap->format == PixelFormat32bppRGB ||
2745 bitmap->format == PixelFormat32bppPARGB))
2746 {
2747 BITMAPINFOHEADER bih;
2748 BYTE *temp_bits;
2749 PixelFormat dst_format;
2750
2751 /* we can't draw a bitmap of this format directly */
2752 hdc = CreateCompatibleDC(0);
2753 temp_hdc = 1;
2754 temp_bitmap = 1;
2755
2756 bih.biSize = sizeof(BITMAPINFOHEADER);
2757 bih.biWidth = bitmap->width;
2758 bih.biHeight = -bitmap->height;
2759 bih.biPlanes = 1;
2760 bih.biBitCount = 32;
2761 bih.biCompression = BI_RGB;
2762 bih.biSizeImage = 0;
2763 bih.biXPelsPerMeter = 0;
2764 bih.biYPelsPerMeter = 0;
2765 bih.biClrUsed = 0;
2766 bih.biClrImportant = 0;
2767
2768 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
2769 (void**)&temp_bits, NULL, 0);
2770
2771 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2772 dst_format = PixelFormat32bppPARGB;
2773 else
2774 dst_format = PixelFormat32bppRGB;
2775
2776 convert_pixels(bitmap->width, bitmap->height,
2777 bitmap->width*4, temp_bits, dst_format,
2778 bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette_entries);
2779 }
2780 else
2781 {
2782 hbitmap = bitmap->hbitmap;
2783 hdc = bitmap->hdc;
2784 temp_hdc = (hdc == 0);
2785 }
2786
2787 if (temp_hdc)
2788 {
2789 if (!hdc) hdc = CreateCompatibleDC(0);
2790 old_hbm = SelectObject(hdc, hbitmap);
2791 }
2792
2793 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2794 {
2795 BLENDFUNCTION bf;
2796
2797 bf.BlendOp = AC_SRC_OVER;
2798 bf.BlendFlags = 0;
2799 bf.SourceConstantAlpha = 255;
2800 bf.AlphaFormat = AC_SRC_ALPHA;
2801
2802 GdiAlphaBlend(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2803 hdc, srcx, srcy, srcwidth, srcheight, bf);
2804 }
2805 else
2806 {
2807 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2808 hdc, srcx, srcy, srcwidth, srcheight, SRCCOPY);
2809 }
2810
2811 if (temp_hdc)
2812 {
2813 SelectObject(hdc, old_hbm);
2814 DeleteDC(hdc);
2815 }
2816
2817 if (temp_bitmap)
2818 DeleteObject(hbitmap);
2819 }
2820 }
2821 else
2822 {
2823 ERR("GpImage with no IPicture or HBITMAP?!\n");
2824 return NotImplemented;
2825 }
2826
2827 return Ok;
2828 }
2829
2830 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
2831 GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
2832 INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2833 DrawImageAbort callback, VOID * callbackData)
2834 {
2835 GpPointF pointsF[3];
2836 INT i;
2837
2838 TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
2839 srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2840 callbackData);
2841
2842 if(!points || count!=3)
2843 return InvalidParameter;
2844
2845 for(i = 0; i < count; i++){
2846 pointsF[i].X = (REAL)points[i].X;
2847 pointsF[i].Y = (REAL)points[i].Y;
2848 }
2849
2850 return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
2851 (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
2852 callback, callbackData);
2853 }
2854
2855 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
2856 REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
2857 REAL srcwidth, REAL srcheight, GpUnit srcUnit,
2858 GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
2859 VOID * callbackData)
2860 {
2861 GpPointF points[3];
2862
2863 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
2864 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2865 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2866
2867 points[0].X = dstx;
2868 points[0].Y = dsty;
2869 points[1].X = dstx + dstwidth;
2870 points[1].Y = dsty;
2871 points[2].X = dstx;
2872 points[2].Y = dsty + dstheight;
2873
2874 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2875 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2876 }
2877
2878 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
2879 INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
2880 INT srcwidth, INT srcheight, GpUnit srcUnit,
2881 GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
2882 VOID * callbackData)
2883 {
2884 GpPointF points[3];
2885
2886 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
2887 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2888 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2889
2890 points[0].X = dstx;
2891 points[0].Y = dsty;
2892 points[1].X = dstx + dstwidth;
2893 points[1].Y = dsty;
2894 points[2].X = dstx;
2895 points[2].Y = dsty + dstheight;
2896
2897 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2898 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2899 }
2900
2901 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
2902 REAL x, REAL y, REAL width, REAL height)
2903 {
2904 RectF bounds;
2905 GpUnit unit;
2906 GpStatus ret;
2907
2908 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
2909
2910 if(!graphics || !image)
2911 return InvalidParameter;
2912
2913 ret = GdipGetImageBounds(image, &bounds, &unit);
2914 if(ret != Ok)
2915 return ret;
2916
2917 return GdipDrawImageRectRect(graphics, image, x, y, width, height,
2918 bounds.X, bounds.Y, bounds.Width, bounds.Height,
2919 unit, NULL, NULL, NULL);
2920 }
2921
2922 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
2923 INT x, INT y, INT width, INT height)
2924 {
2925 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
2926
2927 return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
2928 }
2929
2930 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
2931 REAL y1, REAL x2, REAL y2)
2932 {
2933 INT save_state;
2934 GpPointF pt[2];
2935 GpStatus retval;
2936
2937 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
2938
2939 if(!pen || !graphics)
2940 return InvalidParameter;
2941
2942 if(graphics->busy)
2943 return ObjectBusy;
2944
2945 if (!graphics->hdc)
2946 {
2947 FIXME("graphics object has no HDC\n");
2948 return Ok;
2949 }
2950
2951 pt[0].X = x1;
2952 pt[0].Y = y1;
2953 pt[1].X = x2;
2954 pt[1].Y = y2;
2955
2956 save_state = prepare_dc(graphics, pen);
2957
2958 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2959
2960 restore_dc(graphics, save_state);
2961
2962 return retval;
2963 }
2964
2965 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
2966 INT y1, INT x2, INT y2)
2967 {
2968 INT save_state;
2969 GpPointF pt[2];
2970 GpStatus retval;
2971
2972 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
2973
2974 if(!pen || !graphics)
2975 return InvalidParameter;
2976
2977 if(graphics->busy)
2978 return ObjectBusy;
2979
2980 if (!graphics->hdc)
2981 {
2982 FIXME("graphics object has no HDC\n");
2983 return Ok;
2984 }
2985
2986 pt[0].X = (REAL)x1;
2987 pt[0].Y = (REAL)y1;
2988 pt[1].X = (REAL)x2;
2989 pt[1].Y = (REAL)y2;
2990
2991 save_state = prepare_dc(graphics, pen);
2992
2993 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
2994
2995 restore_dc(graphics, save_state);
2996
2997 return retval;
2998 }
2999
3000 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
3001 GpPointF *points, INT count)
3002 {
3003 INT save_state;
3004 GpStatus retval;
3005
3006 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3007
3008 if(!pen || !graphics || (count < 2))
3009 return InvalidParameter;
3010
3011 if(graphics->busy)
3012 return ObjectBusy;
3013
3014 if (!graphics->hdc)
3015 {
3016 FIXME("graphics object has no HDC\n");
3017 return Ok;
3018 }
3019
3020 save_state = prepare_dc(graphics, pen);
3021
3022 retval = draw_polyline(graphics, pen, points, count, TRUE);
3023
3024 restore_dc(graphics, save_state);
3025
3026 return retval;
3027 }
3028
3029 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
3030 GpPoint *points, INT count)
3031 {
3032 INT save_state;
3033 GpStatus retval;
3034 GpPointF *ptf = NULL;
3035 int i;
3036
3037 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3038
3039 if(!pen || !graphics || (count < 2))
3040 return InvalidParameter;
3041
3042 if(graphics->busy)
3043 return ObjectBusy;
3044
3045 if (!graphics->hdc)
3046 {
3047 FIXME("graphics object has no HDC\n");
3048 return Ok;
3049 }
3050
3051 ptf = GdipAlloc(count * sizeof(GpPointF));
3052 if(!ptf) return OutOfMemory;
3053
3054 for(i = 0; i < count; i ++){
3055 ptf[i].X = (REAL) points[i].X;
3056 ptf[i].Y = (REAL) points[i].Y;
3057 }
3058
3059 save_state = prepare_dc(graphics, pen);
3060
3061 retval = draw_polyline(graphics, pen, ptf, count, TRUE);
3062
3063 restore_dc(graphics, save_state);
3064
3065 GdipFree(ptf);
3066 return retval;
3067 }
3068
3069 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
3070 {
3071 INT save_state;
3072 GpStatus retval;
3073
3074 TRACE("(%p, %p, %p)\n", graphics, pen, path);
3075
3076 if(!pen || !graphics)
3077 return InvalidParameter;
3078
3079 if(graphics->busy)
3080 return ObjectBusy;
3081
3082 if (!graphics->hdc)
3083 {
3084 FIXME("graphics object has no HDC\n");
3085 return Ok;
3086 }
3087
3088 save_state = prepare_dc(graphics, pen);
3089
3090 retval = draw_poly(graphics, pen, path->pathdata.Points,
3091 path->pathdata.Types, path->pathdata.Count, TRUE);
3092
3093 restore_dc(graphics, save_state);
3094
3095 return retval;
3096 }
3097
3098 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
3099 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3100 {
3101 INT save_state;
3102
3103 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
3104 width, height, startAngle, sweepAngle);
3105
3106 if(!graphics || !pen)
3107 return InvalidParameter;
3108
3109 if(graphics->busy)
3110 return ObjectBusy;
3111
3112 if (!graphics->hdc)
3113 {
3114 FIXME("graphics object has no HDC\n");
3115 return Ok;
3116 }
3117
3118 save_state = prepare_dc(graphics, pen);
3119 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3120
3121 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
3122
3123 restore_dc(graphics, save_state);
3124
3125 return Ok;
3126 }
3127
3128 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
3129 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3130 {
3131 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
3132 width, height, startAngle, sweepAngle);
3133
3134 return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3135 }
3136
3137 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
3138 REAL y, REAL width, REAL height)
3139 {
3140 INT save_state;
3141 GpPointF ptf[4];
3142 POINT pti[4];
3143
3144 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
3145
3146 if(!pen || !graphics)
3147 return InvalidParameter;
3148
3149 if(graphics->busy)
3150 return ObjectBusy;
3151
3152 if (!graphics->hdc)
3153 {
3154 FIXME("graphics object has no HDC\n");
3155 return Ok;
3156 }
3157
3158 ptf[0].X = x;
3159 ptf[0].Y = y;
3160 ptf[1].X = x + width;
3161 ptf[1].Y = y;
3162 ptf[2].X = x + width;
3163 ptf[2].Y = y + height;
3164 ptf[3].X = x;
3165 ptf[3].Y = y + height;
3166
3167 save_state = prepare_dc(graphics, pen);
3168 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3169
3170 transform_and_round_points(graphics, pti, ptf, 4);
3171 Polygon(graphics->hdc, pti, 4);
3172
3173 restore_dc(graphics, save_state);
3174
3175 return Ok;
3176 }
3177
3178 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
3179 INT y, INT width, INT height)
3180 {
3181 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
3182
3183 return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3184 }
3185
3186 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
3187 GDIPCONST GpRectF* rects, INT count)
3188 {
3189 GpPointF *ptf;
3190 POINT *pti;
3191 INT save_state, i;
3192
3193 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3194
3195 if(!graphics || !pen || !rects || count < 1)
3196 return InvalidParameter;
3197
3198 if(graphics->busy)
3199 return ObjectBusy;
3200
3201 if (!graphics->hdc)
3202 {
3203 FIXME("graphics object has no HDC\n");
3204 return Ok;
3205 }
3206
3207 ptf = GdipAlloc(4 * count * sizeof(GpPointF));
3208 pti = GdipAlloc(4 * count * sizeof(POINT));
3209
3210 if(!ptf || !pti){
3211 GdipFree(ptf);
3212 GdipFree(pti);
3213 return OutOfMemory;
3214 }
3215
3216 for(i = 0; i < count; i++){
3217 ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
3218 ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
3219 ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
3220 ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
3221 }
3222
3223 save_state = prepare_dc(graphics, pen);
3224 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3225
3226 transform_and_round_points(graphics, pti, ptf, 4 * count);
3227
3228 for(i = 0; i < count; i++)
3229 Polygon(graphics->hdc, &pti[4 * i], 4);
3230
3231 restore_dc(graphics, save_state);
3232
3233 GdipFree(ptf);
3234 GdipFree(pti);
3235
3236 return Ok;
3237 }
3238
3239 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
3240 GDIPCONST GpRect* rects, INT count)
3241 {
3242 GpRectF *rectsF;
3243 GpStatus ret;
3244 INT i;
3245
3246 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3247
3248 if(!rects || count<=0)
3249 return InvalidParameter;
3250
3251 rectsF = GdipAlloc(sizeof(GpRectF) * count);
3252 if(!rectsF)
3253 return OutOfMemory;
3254
3255 for(i = 0;i < count;i++){
3256 rectsF[i].X = (REAL)rects[i].X;
3257 rectsF[i].Y = (REAL)rects[i].Y;
3258 rectsF[i].Width = (REAL)rects[i].Width;
3259 rectsF[i].Height = (REAL)rects[i].Height;
3260 }
3261
3262 ret = GdipDrawRectangles(graphics, pen, rectsF, count);
3263 GdipFree(rectsF);
3264
3265 return ret;
3266 }
3267
3268 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
3269 GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
3270 {
3271 GpPath *path;
3272 GpStatus stat;
3273
3274 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3275 count, tension, fill);
3276
3277 if(!graphics || !brush || !points)
3278 return InvalidParameter;
3279
3280 if(graphics->busy)
3281 return ObjectBusy;
3282
3283 if(count == 1) /* Do nothing */
3284 return Ok;
3285
3286 stat = GdipCreatePath(fill, &path);
3287 if(stat != Ok)
3288 return stat;
3289
3290 stat = GdipAddPathClosedCurve2(path, points, count, tension);
3291 if(stat != Ok){
3292 GdipDeletePath(path);
3293 return stat;
3294 }
3295
3296 stat = GdipFillPath(graphics, brush, path);
3297 if(stat != Ok){
3298 GdipDeletePath(path);
3299 return stat;
3300 }
3301
3302 GdipDeletePath(path);
3303
3304 return Ok;
3305 }
3306
3307 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
3308 GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
3309 {
3310 GpPointF *ptf;
3311 GpStatus stat;
3312 INT i;
3313
3314 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3315 count, tension, fill);
3316
3317 if(!points || count == 0)
3318 return InvalidParameter;
3319
3320 if(count == 1) /* Do nothing */
3321 return Ok;
3322
3323 ptf = GdipAlloc(sizeof(GpPointF)*count);
3324 if(!ptf)
3325 return OutOfMemory;
3326
3327 for(i = 0;i < count;i++){
3328 ptf[i].X = (REAL)points[i].X;
3329 ptf[i].Y = (REAL)points[i].Y;
3330 }
3331
3332 stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
3333
3334 GdipFree(ptf);
3335
3336 return stat;
3337 }
3338
3339 GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
3340 GDIPCONST GpPointF *points, INT count)
3341 {
3342 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3343 return GdipFillClosedCurve2(graphics, brush, points, count,
3344 0.5f, FillModeAlternate);
3345 }
3346
3347 GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
3348 GDIPCONST GpPoint *points, INT count)
3349 {
3350 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3351 return GdipFillClosedCurve2I(graphics, brush, points, count,
3352 0.5f, FillModeAlternate);
3353 }
3354
3355 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
3356 REAL y, REAL width, REAL height)
3357 {
3358 GpStatus stat;
3359 GpPath *path;
3360
3361 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3362
3363 if(!graphics || !brush)
3364 return InvalidParameter;
3365
3366 if(graphics->busy)
3367 return ObjectBusy;
3368
3369 stat = GdipCreatePath(FillModeAlternate, &path);
3370
3371 if (stat == Ok)
3372 {
3373 stat = GdipAddPathEllipse(path, x, y, width, height);
3374
3375 if (stat == Ok)
3376 stat = GdipFillPath(graphics, brush, path);
3377
3378 GdipDeletePath(path);
3379 }
3380
3381 return stat;
3382 }
3383
3384 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
3385 INT y, INT width, INT height)
3386 {
3387 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3388
3389 return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3390 }
3391
3392 static GpStatus GDI32_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3393 {
3394 INT save_state;
3395 GpStatus retval;
3396
3397 if(!graphics->hdc || !brush_can_fill_path(brush))
3398 return NotImplemented;
3399
3400 save_state = SaveDC(graphics->hdc);
3401 EndPath(graphics->hdc);
3402 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
3403 : WINDING));
3404
3405 BeginPath(graphics->hdc);
3406 retval = draw_poly(graphics, NULL, path->pathdata.Points,
3407 path->pathdata.Types, path->pathdata.Count, FALSE);
3408
3409 if(retval != Ok)
3410 goto end;
3411
3412 EndPath(graphics->hdc);
3413 brush_fill_path(graphics, brush);
3414
3415 retval = Ok;
3416
3417 end:
3418 RestoreDC(graphics->hdc, save_state);
3419
3420 return retval;
3421 }
3422
3423 static GpStatus SOFTWARE_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3424 {
3425 GpStatus stat;
3426 GpRegion *rgn;
3427
3428 if (!brush_can_fill_pixels(brush))
3429 return NotImplemented;
3430
3431 /* FIXME: This could probably be done more efficiently without regions. */
3432
3433 stat = GdipCreateRegionPath(path, &rgn);
3434
3435 if (stat == Ok)
3436 {
3437 stat = GdipFillRegion(graphics, brush, rgn);
3438
3439 GdipDeleteRegion(rgn);
3440 }
3441
3442 return stat;
3443 }
3444
3445 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3446 {
3447 GpStatus stat = NotImplemented;
3448
3449 TRACE("(%p, %p, %p)\n", graphics, brush, path);
3450
3451 if(!brush || !graphics || !path)
3452 return InvalidParameter;
3453
3454 if(graphics->busy)
3455 return ObjectBusy;
3456
3457 if (!graphics->image)
3458 stat = GDI32_GdipFillPath(graphics, brush, path);
3459
3460 if (stat == NotImplemented)
3461 stat = SOFTWARE_GdipFillPath(graphics, brush, path);
3462
3463 if (stat == NotImplemented)
3464 {
3465 FIXME("Not implemented for brushtype %i\n", brush->bt);
3466 stat = Ok;
3467 }
3468
3469 return stat;
3470 }
3471
3472 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
3473 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3474 {
3475 GpStatus stat;
3476 GpPath *path;
3477
3478 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
3479 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3480
3481 if(!graphics || !brush)
3482 return InvalidParameter;
3483
3484 if(graphics->busy)
3485 return ObjectBusy;
3486
3487 stat = GdipCreatePath(FillModeAlternate, &path);
3488
3489 if (stat == Ok)
3490 {
3491 stat = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
3492
3493 if (stat == Ok)
3494 stat = GdipFillPath(graphics, brush, path);
3495
3496 GdipDeletePath(path);
3497 }
3498
3499 return stat;
3500 }
3501
3502 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
3503 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3504 {
3505 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
3506 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3507
3508 return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3509 }
3510
3511 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
3512 GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
3513 {
3514 INT save_state;
3515 GpPointF *ptf = NULL;
3516 POINT *pti = NULL;
3517 GpStatus retval = Ok;
3518
3519 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3520
3521 if(!graphics || !brush || !points || !count)
3522 return InvalidParameter;
3523
3524 if(graphics->busy)
3525 return ObjectBusy;
3526
3527 if(!graphics->hdc)
3528 {
3529 FIXME("graphics object has no HDC\n");
3530 return Ok;
3531 }
3532
3533 ptf = GdipAlloc(count * sizeof(GpPointF));
3534 pti = GdipAlloc(count * sizeof(POINT));
3535 if(!ptf || !pti){
3536 retval = OutOfMemory;
3537 goto end;
3538 }
3539
3540 memcpy(ptf, points, count * sizeof(GpPointF));
3541
3542 save_state = SaveDC(graphics->hdc);
3543 EndPath(graphics->hdc);
3544 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
3545 : WINDING));
3546
3547 transform_and_round_points(graphics, pti, ptf, count);
3548
3549 BeginPath(graphics->hdc);
3550 Polygon(graphics->hdc, pti, count);
3551 EndPath(graphics->hdc);
3552
3553 brush_fill_path(graphics, brush);
3554
3555 RestoreDC(graphics->hdc, save_state);
3556
3557 end:
3558 GdipFree(ptf);
3559 GdipFree(pti);
3560
3561 return retval;
3562 }
3563
3564 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
3565 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
3566 {
3567 INT save_state, i;
3568 GpPointF *ptf = NULL;
3569 POINT *pti = NULL;
3570 GpStatus retval = Ok;
3571
3572 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3573
3574 if(!graphics || !brush || !points || !count)
3575 return InvalidParameter;
3576
3577 if(graphics->busy)
3578 return ObjectBusy;
3579
3580 if(!graphics->hdc)
3581 {
3582 FIXME("graphics object has no HDC\n");
3583 return Ok;
3584 }
3585
3586 ptf = GdipAlloc(count * sizeof(GpPointF));
3587 pti = GdipAlloc(count * sizeof(POINT));
3588 if(!ptf || !pti){
3589 retval = OutOfMemory;
3590 goto end;
3591 }
3592
3593 for(i = 0; i < count; i ++){
3594 ptf[i].X = (REAL) points[i].X;
3595 ptf[i].Y = (REAL) points[i].Y;
3596 }
3597
3598 save_state = SaveDC(graphics->hdc);
3599 EndPath(graphics->hdc);
3600 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
3601 : WINDING));
3602
3603 transform_and_round_points(graphics, pti, ptf, count);
3604
3605 BeginPath(graphics->hdc);
3606 Polygon(graphics->hdc, pti, count);
3607 EndPath(graphics->hdc);
3608
3609 brush_fill_path(graphics, brush);
3610
3611 RestoreDC(graphics->hdc, save_state);
3612
3613 end:
3614 GdipFree(ptf);
3615 GdipFree(pti);
3616
3617 return retval;
3618 }
3619
3620 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
3621 GDIPCONST GpPointF *points, INT count)
3622 {
3623 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3624
3625 return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
3626 }
3627
3628 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
3629 GDIPCONST GpPoint *points, INT count)
3630 {
3631 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3632
3633 return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
3634 }
3635
3636 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
3637 REAL x, REAL y, REAL width, REAL height)
3638 {
3639 INT save_state;
3640 GpPointF ptf[4];
3641 POINT pti[4];
3642
3643 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3644
3645 if(!graphics || !brush)
3646 return InvalidParameter;
3647
3648 if(graphics->busy)
3649 return ObjectBusy;
3650
3651 if(!graphics->hdc)
3652 {
3653 FIXME("graphics object has no HDC\n");
3654 return Ok;
3655 }
3656
3657 ptf[0].X = x;
3658 ptf[0].Y = y;
3659 ptf[1].X = x + width;
3660 ptf[1].Y = y;
3661 ptf[2].X = x + width;
3662 ptf[2].Y = y + height;
3663 ptf[3].X = x;
3664 ptf[3].Y = y + height;
3665
3666 save_state = SaveDC(graphics->hdc);
3667 EndPath(graphics->hdc);
3668
3669 transform_and_round_points(graphics, pti, ptf, 4);
3670
3671 BeginPath(graphics->hdc);
3672 Polygon(graphics->hdc, pti, 4);
3673 EndPath(graphics->hdc);
3674
3675 brush_fill_path(graphics, brush);
3676
3677 RestoreDC(graphics->hdc, save_state);
3678
3679 return Ok;
3680 }
3681
3682 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
3683 INT x, INT y, INT width, INT height)
3684 {
3685 INT save_state;
3686 GpPointF ptf[4];
3687 POINT pti[4];
3688
3689 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3690
3691 if(!graphics || !brush)
3692 return InvalidParameter;
3693
3694 if(graphics->busy)
3695 return ObjectBusy;
3696
3697 if(!graphics->hdc)
3698 {
3699 FIXME("graphics object has no HDC\n");
3700 return Ok;
3701 }
3702
3703 ptf[0].X = x;
3704 ptf[0].Y = y;
3705 ptf[1].X = x + width;
3706 ptf[1].Y = y;
3707 ptf[2].X = x + width;
3708 ptf[2].Y = y + height;
3709 ptf[3].X = x;
3710 ptf[3].Y = y + height;
3711
3712 save_state = SaveDC(graphics->hdc);
3713 EndPath(graphics->hdc);
3714
3715 transform_and_round_points(graphics, pti, ptf, 4);
3716
3717 BeginPath(graphics->hdc);
3718 Polygon(graphics->hdc, pti, 4);
3719 EndPath(graphics->hdc);
3720
3721 brush_fill_path(graphics, brush);
3722
3723 RestoreDC(graphics->hdc, save_state);
3724
3725 return Ok;
3726 }
3727
3728 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
3729 INT count)
3730 {
3731 GpStatus ret;
3732 INT i;
3733
3734 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3735
3736 if(!rects)
3737 return InvalidParameter;
3738
3739 for(i = 0; i < count; i++){
3740 ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
3741 if(ret != Ok) return ret;
3742 }
3743
3744 return Ok;
3745 }
3746
3747 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
3748 INT count)
3749 {
3750 GpRectF *rectsF;
3751 GpStatus ret;
3752 INT i;
3753
3754 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3755
3756 if(!rects || count <= 0)
3757 return InvalidParameter;
3758
3759 rectsF = GdipAlloc(sizeof(GpRectF)*count);
3760 if(!rectsF)
3761 return OutOfMemory;
3762
3763 for(i = 0; i < count; i++){
3764 rectsF[i].X = (REAL)rects[i].X;
3765 rectsF[i].Y = (REAL)rects[i].Y;
3766 rectsF[i].X = (REAL)rects[i].Width;
3767 rectsF[i].Height = (REAL)rects[i].Height;
3768 }
3769
3770 ret = GdipFillRectangles(graphics,brush,rectsF,count);
3771 GdipFree(rectsF);
3772
3773 return ret;
3774 }
3775
3776 static GpStatus GDI32_GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3777 GpRegion* region)
3778 {
3779 INT save_state;
3780 GpStatus status;
3781 HRGN hrgn;
3782 RECT rc;
3783
3784 if(!graphics->hdc || !brush_can_fill_path(brush))
3785 return NotImplemented;
3786
3787 status = GdipGetRegionHRgn(region, graphics, &hrgn);
3788 if(status != Ok)
3789 return status;
3790
3791 save_state = SaveDC(graphics->hdc);
3792 EndPath(graphics->hdc);
3793
3794 ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3795
3796 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
3797 {
3798 BeginPath(graphics->hdc);
3799 Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
3800 EndPath(graphics->hdc);
3801
3802 brush_fill_path(graphics, brush);
3803 }
3804
3805 RestoreDC(graphics->hdc, save_state);
3806
3807 DeleteObject(hrgn);
3808
3809 return Ok;
3810 }
3811
3812 static GpStatus SOFTWARE_GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
3813 GpRegion* region)
3814 {
3815 GpStatus stat;
3816 GpRegion *temp_region;
3817 GpMatrix *world_to_device, *identity;
3818 GpRectF graphics_bounds;
3819 UINT scans_count, i;
3820 INT dummy;
3821 GpRect *scans;
3822 DWORD *pixel_data;
3823
3824 if (!brush_can_fill_pixels(brush))
3825 return NotImplemented;
3826
3827 stat = get_graphics_bounds(graphics, &graphics_bounds);
3828
3829 if (stat == Ok)
3830 stat = GdipCloneRegion(region, &temp_region);
3831
3832 if (stat == Ok)
3833 {
3834 stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
3835 CoordinateSpaceWorld, &world_to_device);
3836
3837 if (stat == Ok)
3838 {
3839 stat = GdipTransformRegion(temp_region, world_to_device);
3840
3841 GdipDeleteMatrix(world_to_device);
3842 }
3843
3844 if (stat == Ok)
3845 stat = GdipCombineRegionRect(temp_region, &graphics_bounds, CombineModeIntersect);
3846
3847 if (stat == Ok)
3848 stat = GdipCreateMatrix(&identity);
3849
3850 if (stat == Ok)
3851 {
3852 stat = GdipGetRegionScansCount(temp_region, &scans_count, identity);
3853
3854 if (stat == Ok && scans_count != 0)
3855 {
3856 scans = GdipAlloc(sizeof(*scans) * scans_count);
3857 if (!scans)
3858 stat = OutOfMemory;
3859
3860 if (stat == Ok)
3861 {
3862 stat = GdipGetRegionScansI(temp_region, scans, &dummy, identity);
3863
3864 if (stat != Ok)
3865 GdipFree(scans);
3866 }
3867 }
3868
3869 GdipDeleteMatrix(identity);
3870 }
3871
3872 GdipDeleteRegion(temp_region);
3873 }
3874
3875 if (stat == Ok && scans_count == 0)
3876 return Ok;
3877
3878 if (stat == Ok)
3879 {
3880 if (!graphics->image)
3881 {
3882 /* If we have to go through gdi32, use as few alpha blends as possible. */
3883 INT min_x, min_y, max_x, max_y;
3884 UINT data_width, data_height;
3885
3886 min_x = scans[0].X;
3887 min_y = scans[0].Y;
3888 max_x = scans[0].X+scans[0].Width;
3889 max_y = scans[0].Y+scans[0].Height;
3890
3891 for (i=1; i<scans_count; i++)
3892 {
3893 min_x = min(min_x, scans[i].X);
3894 min_y = min(min_y, scans[i].Y);
3895 max_x = max(max_x, scans[i].X+scans[i].Width);
3896 max_y = max(max_y, scans[i].Y+scans[i].Height);
3897 }
3898
3899 data_width = max_x - min_x;
3900 data_height = max_y - min_y;
3901
3902 pixel_data = GdipAlloc(sizeof(*pixel_data) * data_width * data_height);
3903 if (!pixel_data)
3904 stat = OutOfMemory;
3905
3906 if (stat == Ok)
3907 {
3908 for (i=0; i<scans_count; i++)
3909 {
3910 stat = brush_fill_pixels(graphics, brush,
3911 pixel_data + (scans[i].X - min_x) + (scans[i].Y - min_y) * data_width,
3912 &scans[i], data_width);
3913
3914 if (stat != Ok)
3915 break;
3916 }
3917
3918 if (stat == Ok)
3919 {
3920 stat = alpha_blend_pixels(graphics, min_x, min_y,
3921 (BYTE*)pixel_data, data_width, data_height,
3922 data_width * 4);
3923 }
3924
3925 GdipFree(pixel_data);
3926 }
3927 }
3928 else
3929 {
3930 UINT max_size=0;
3931
3932 for (i=0; i<scans_count; i++)
3933 {
3934 UINT size = scans[i].Width * scans[i].Height;
3935
3936 if (size > max_size)
3937 max_size = size;
3938 }
3939
3940 pixel_data = GdipAlloc(sizeof(*pixel_data) * max_size);
3941 if (!pixel_data)
3942 stat = OutOfMemory;
3943
3944 if (stat == Ok)
3945 {
3946 for (i=0; i<scans_count; i++)
3947 {
3948 stat = brush_fill_pixels(graphics, brush, pixel_data, &scans[i],
3949 scans[i].Width);
3950
3951 if (stat == Ok)
3952 {
3953 stat = alpha_blend_pixels(graphics, scans[i].X, scans[i].Y,
3954 (BYTE*)pixel_data, scans[i].Width, scans[i].Height,
3955 scans[i].Width * 4);
3956 }
3957
3958 if (stat != Ok)
3959 break;
3960 }
3961
3962 GdipFree(pixel_data);
3963 }
3964 }
3965
3966 GdipFree(scans);
3967 }
3968
3969 return stat;
3970 }
3971
3972 /*****************************************************************************
3973 * GdipFillRegion [GDIPLUS.@]
3974 */
3975 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3976 GpRegion* region)
3977 {
3978 GpStatus stat = NotImplemented;
3979
3980 TRACE("(%p, %p, %p)\n", graphics, brush, region);
3981
3982 if (!(graphics && brush && region))
3983 return InvalidParameter;
3984
3985 if(graphics->busy)
3986 return ObjectBusy;
3987
3988 if (!graphics->image)
3989 stat = GDI32_GdipFillRegion(graphics, brush, region);
3990
3991 if (stat == NotImplemented)
3992 stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
3993
3994 if (stat == NotImplemented)
3995 {
3996 FIXME("not implemented for brushtype %i\n", brush->bt);
3997 stat = Ok;
3998 }
3999
4000 return stat;
4001 }
4002
4003 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
4004 {
4005 TRACE("(%p,%u)\n", graphics, intention);
4006
4007 if(!graphics)
4008 return InvalidParameter;
4009
4010 if(graphics->busy)
4011 return ObjectBusy;
4012
4013 /* We have no internal operation queue, so there's no need to clear it. */
4014
4015 if (graphics->hdc)
4016 GdiFlush();
4017
4018 return Ok;
4019 }
4020
4021 /*****************************************************************************
4022 * GdipGetClipBounds [GDIPLUS.@]
4023 */
4024 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
4025 {
4026 TRACE("(%p, %p)\n", graphics, rect);
4027
4028 if(!graphics)
4029 return InvalidParameter;
4030
4031 if(graphics->busy)
4032 return ObjectBusy;
4033
4034 return GdipGetRegionBounds(graphics->clip, graphics, rect);
4035 }
4036
4037 /*****************************************************************************
4038 * GdipGetClipBoundsI [GDIPLUS.@]
4039 */
4040 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
4041 {
4042 TRACE("(%p, %p)\n", graphics, rect);
4043
4044 if(!graphics)
4045 return InvalidParameter;
4046
4047 if(graphics->busy)
4048 return ObjectBusy;
4049
4050 return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
4051 }
4052
4053 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
4054 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
4055 CompositingMode *mode)
4056 {
4057 TRACE("(%p, %p)\n", graphics, mode);
4058
4059 if(!graphics || !mode)
4060 return InvalidParameter;
4061
4062 if(graphics->busy)
4063 return ObjectBusy;
4064
4065 *mode = graphics->compmode;
4066
4067 return Ok;
4068 }
4069
4070 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
4071 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
4072 CompositingQuality *quality)
4073 {
4074 TRACE("(%p, %p)\n", graphics, quality);
4075
4076 if(!graphics || !quality)
4077 return InvalidParameter;
4078
4079 if(graphics->busy)
4080 return ObjectBusy;
4081
4082 *quality = graphics->compqual;
4083
4084 return Ok;
4085 }
4086
4087 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
4088 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
4089 InterpolationMode *mode)
4090 {
4091 TRACE("(%p, %p)\n", graphics, mode);
4092
4093 if(!graphics || !mode)
4094 return InvalidParameter;
4095
4096 if(graphics->busy)
4097 return ObjectBusy;
4098
4099 *mode = graphics->interpolation;
4100
4101 return Ok;
4102 }
4103
4104 /* FIXME: Need to handle color depths less than 24bpp */
4105 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
4106 {
4107 FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
4108
4109 if(!graphics || !argb)
4110 return InvalidParameter;
4111
4112 if(graphics->busy)
4113 return ObjectBusy;
4114
4115 return Ok;
4116 }
4117
4118 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
4119 {
4120 TRACE("(%p, %p)\n", graphics, scale);
4121
4122 if(!graphics || !scale)
4123 return InvalidParameter;
4124
4125 if(graphics->busy)
4126 return ObjectBusy;
4127
4128 *scale = graphics->scale;
4129
4130 return Ok;
4131 }
4132
4133 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
4134 {
4135 TRACE("(%p, %p)\n", graphics, unit);
4136
4137 if(!graphics || !unit)
4138 return InvalidParameter;
4139
4140 if(graphics->busy)
4141 return ObjectBusy;
4142
4143 *unit = graphics->unit;
4144
4145 return Ok;
4146 }
4147
4148 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
4149 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4150 *mode)
4151 {
4152 TRACE("(%p, %p)\n", graphics, mode);
4153
4154 if(!graphics || !mode)
4155 return InvalidParameter;
4156
4157 if(graphics->busy)
4158 return ObjectBusy;
4159
4160 *mode = graphics->pixeloffset;
4161
4162 return Ok;
4163 }
4164
4165 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
4166 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
4167 {
4168 TRACE("(%p, %p)\n", graphics, mode);
4169
4170 if(!graphics || !mode)
4171 return InvalidParameter;
4172
4173 if(graphics->busy)
4174 return ObjectBusy;
4175
4176 *mode = graphics->smoothing;
4177
4178 return Ok;
4179 }
4180
4181 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
4182 {
4183 TRACE("(%p, %p)\n", graphics, contrast);
4184
4185 if(!graphics || !contrast)
4186 return InvalidParameter;
4187
4188 *contrast = graphics->textcontrast;
4189
4190 return Ok;
4191 }
4192
4193 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
4194 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
4195 TextRenderingHint *hint)
4196 {
4197 TRACE("(%p, %p)\n", graphics, hint);
4198
4199 if(!graphics || !hint)
4200 return InvalidParameter;
4201
4202 if(graphics->busy)
4203 return ObjectBusy;
4204
4205 *hint = graphics->texthint;
4206
4207 return Ok;
4208 }
4209
4210 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
4211 {
4212 GpRegion *clip_rgn;
4213 GpStatus stat;
4214
4215 TRACE("(%p, %p)\n", graphics, rect);
4216
4217 if(!graphics || !rect)
4218 return InvalidParameter;
4219
4220 if(graphics->busy)
4221 return ObjectBusy;
4222
4223 /* intersect window and graphics clipping regions */
4224 if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
4225 return stat;
4226
4227 if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
4228 goto cleanup;
4229
4230 /* get bounds of the region */
4231 stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
4232
4233 cleanup:
4234 GdipDeleteRegion(clip_rgn);
4235
4236 return stat;
4237 }
4238
4239 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
4240 {
4241 GpRectF rectf;
4242 GpStatus stat;
4243
4244 TRACE("(%p, %p)\n", graphics, rect);
4245
4246 if(!graphics || !rect)
4247 return InvalidParameter;
4248
4249 if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
4250 {
4251 rect->X = roundr(rectf.X);
4252 rect->Y = roundr(rectf.Y);
4253 rect->Width = roundr(rectf.Width);
4254 rect->Height = roundr(rectf.Height);
4255 }
4256
4257 return stat;
4258 }
4259
4260 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4261 {
4262 TRACE("(%p, %p)\n", graphics, matrix);
4263
4264 if(!graphics || !matrix)
4265 return InvalidParameter;
4266
4267 if(graphics->busy)
4268 return ObjectBusy;
4269
4270 *matrix = *graphics->worldtrans;
4271 return Ok;
4272 }
4273
4274 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
4275 {
4276 GpSolidFill *brush;
4277 GpStatus stat;
4278 GpRectF wnd_rect;
4279
4280 TRACE("(%p, %x)\n", graphics, color);
4281
4282 if(!graphics)
4283 return InvalidParameter;
4284
4285 if(graphics->busy)
4286 return ObjectBusy;
4287
4288 if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
4289 return stat;
4290
4291 if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
4292 GdipDeleteBrush((GpBrush*)brush);
4293 return stat;
4294 }
4295
4296 GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
4297 wnd_rect.Width, wnd_rect.Height);
4298
4299 GdipDeleteBrush((GpBrush*)brush);
4300
4301 return Ok;
4302 }
4303
4304 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
4305 {
4306 TRACE("(%p, %p)\n", graphics, res);
4307
4308 if(!graphics || !res)
4309 return InvalidParameter;
4310
4311 return GdipIsEmptyRegion(graphics->clip, graphics, res);
4312 }
4313
4314 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
4315 {
4316 GpStatus stat;
4317 GpRegion* rgn;
4318 GpPointF pt;
4319
4320 TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
4321
4322 if(!graphics || !result)
4323 return InvalidParameter;
4324
4325 if(graphics->busy)
4326 return ObjectBusy;
4327
4328 pt.X = x;
4329 pt.Y = y;
4330 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4331 CoordinateSpaceWorld, &pt, 1)) != Ok)
4332 return stat;
4333
4334 if((stat = GdipCreateRegion(&rgn)) != Ok)
4335 return stat;
4336
4337 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4338 goto cleanup;
4339
4340 stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
4341
4342 cleanup:
4343 GdipDeleteRegion(rgn);
4344 return stat;
4345 }
4346
4347 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
4348 {
4349 return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
4350 }
4351
4352 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
4353 {
4354 GpStatus stat;
4355 GpRegion* rgn;
4356 GpPointF pts[2];
4357
4358 TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
4359
4360 if(!graphics || !result)
4361 return InvalidParameter;
4362
4363 if(graphics->busy)
4364 return ObjectBusy;
4365
4366 pts[0].X = x;
4367 pts[0].Y = y;
4368 pts[1].X = x + width;
4369 pts[1].Y = y + height;
4370
4371 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4372 CoordinateSpaceWorld, pts, 2)) != Ok)
4373 return stat;
4374
4375 pts[1].X -= pts[0].X;
4376 pts[1].Y -= pts[0].Y;
4377
4378 if((stat = GdipCreateRegion(&rgn)) != Ok)
4379 return stat;
4380
4381 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4382 goto cleanup;
4383
4384 stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
4385
4386 cleanup:
4387 GdipDeleteRegion(rgn);
4388 return stat;
4389 }
4390
4391 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4392 {
4393 return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
4394 }
4395
4396 GpStatus gdip_format_string(HDC hdc,
4397 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4398 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4399 gdip_format_string_callback callback, void *user_data)
4400 {
4401 WCHAR* stringdup;
4402 int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
4403 nheight, lineend, lineno = 0;
4404 RectF bounds;
4405 StringAlignment halign;
4406 GpStatus stat = Ok;
4407 SIZE size;
4408
4409 if(length == -1) length = lstrlenW(string);
4410
4411 stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
4412 if(!stringdup) return OutOfMemory;
4413
4414 nwidth = roundr(rect->Width);
4415 nheight = roundr(rect->Height);
4416
4417 if (rect->Width >= INT_MAX || rect->Width < 0.5) nwidth = INT_MAX;
4418 if (rect->Height >= INT_MAX || rect->Width < 0.5) nheight = INT_MAX;
4419
4420 for(i = 0, j = 0; i < length; i++){
4421 /* FIXME: This makes the indexes passed to callback inaccurate. */
4422 if(!isprintW(string[i]) && (string[i] != '\n'))
4423 continue;
4424
4425 stringdup[j] = string[i];
4426 j++;
4427 }
4428
4429 length = j;
4430
4431 if (format) halign = format->align;
4432 else halign = StringAlignmentNear;
4433
4434 while(sum < length){
4435 GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
4436 nwidth, &fit, NULL, &size);
4437 fitcpy = fit;
4438
4439 if(fit == 0)
4440 break;
4441
4442 for(lret = 0; lret < fit; lret++)
4443 if(*(stringdup + sum + lret) == '\n')
4444 break;
4445
4446 /* Line break code (may look strange, but it imitates windows). */
4447 if(lret < fit)
4448 lineend = fit = lret; /* this is not an off-by-one error */
4449 else if(fit < (length - sum)){
4450 if(*(stringdup + sum + fit) == ' ')
4451 while(*(stringdup + sum + fit) == ' ')
4452 fit++;
4453 else
4454 while(*(stringdup + sum + fit - 1) != ' '){
4455 fit--;
4456
4457 if(*(stringdup + sum + fit) == '\t')
4458 break;
4459
4460 if(fit == 0){
4461 fit = fitcpy;
4462 break;
4463 }
4464 }
4465 lineend = fit;
4466 while(*(stringdup + sum + lineend - 1) == ' ' ||
4467 *(stringdup + sum + lineend - 1) == '\t')
4468 lineend--;
4469 }
4470 else
4471 lineend = fit;
4472
4473 GetTextExtentExPointW(hdc, stringdup + sum, lineend,
4474 nwidth, &j, NULL, &size);
4475
4476 bounds.Width = size.cx;
4477
4478 if(height + size.cy > nheight)
4479 bounds.Height = nheight - (height + size.cy);
4480 else
4481 bounds.Height = size.cy;
4482
4483 bounds.Y = rect->Y + height;
4484
4485 switch (halign)
4486 {
4487 case StringAlignmentNear:
4488 default:
4489 bounds.X = rect->X;
4490 break;
4491 case StringAlignmentCenter:
4492 bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
4493 break;
4494 case StringAlignmentFar:
4495 bounds.X = rect->X + rect->Width - bounds.Width;
4496 break;
4497 }
4498
4499 stat = callback(hdc, stringdup, sum, lineend,
4500 font, rect, format, lineno, &bounds, user_data);
4501
4502 if (stat != Ok)
4503 break;
4504
4505 sum += fit + (lret < fitcpy ? 1 : 0);
4506 height += size.cy;
4507 lineno++;
4508
4509 if(height > nheight)
4510 break;
4511
4512 /* Stop if this was a linewrap (but not if it was a linebreak). */
4513 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
4514 break;
4515 }
4516
4517 GdipFree(stringdup);
4518
4519 return stat;
4520 }
4521
4522 struct measure_ranges_args {
4523 GpRegion **regions;
4524 };
4525
4526 static GpStatus measure_ranges_callback(HDC hdc,
4527 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4528 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4529 INT lineno, const RectF *bounds, void *user_data)
4530 {
4531 int i;
4532 GpStatus stat = Ok;
4533 struct measure_ranges_args *args = user_data;
4534
4535 for (i=0; i<format->range_count; i++)
4536 {
4537 INT range_start = max(index, format->character_ranges[i].First);
4538 INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
4539 if (range_start < range_end)
4540 {
4541 GpRectF range_rect;
4542 SIZE range_size;
4543
4544 range_rect.Y = bounds->Y;
4545 range_rect.Height = bounds->Height;
4546
4547 GetTextExtentExPointW(hdc, string + index, range_start - index,
4548 INT_MAX, NULL, NULL, &range_size);
4549 range_rect.X = bounds->X + range_size.cx;
4550
4551 GetTextExtentExPointW(hdc, string + index, range_end - index,
4552 INT_MAX, NULL, NULL, &range_size);
4553 range_rect.Width = (bounds->X + range_size.cx) - range_rect.X;
4554
4555 stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
4556 if (stat != Ok)
4557 break;
4558 }
4559 }
4560
4561 return stat;
4562 }
4563
4564 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
4565 GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
4566 GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
4567 INT regionCount, GpRegion** regions)
4568 {
4569 GpStatus stat;
4570 int i;
4571 HFONT oldfont;
4572 struct measure_ranges_args args;
4573 HDC hdc, temp_hdc=NULL;
4574
4575 TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
4576 length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
4577
4578 if (!(graphics && string && font && layoutRect && stringFormat && regions))
4579 return InvalidParameter;
4580
4581 if (regionCount < stringFormat->range_count)
4582 return InvalidParameter;
4583
4584 if(!graphics->hdc)
4585 {
4586 hdc = temp_hdc = CreateCompatibleDC(0);
4587 if (!temp_hdc) return OutOfMemory;
4588 }
4589 else
4590 hdc = graphics->hdc;
4591
4592 if (stringFormat->attr)
4593 TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
4594
4595 oldfont = SelectObject(hdc, CreateFontIndirectW(&font->lfw));
4596
4597 for (i=0; i<stringFormat->range_count; i++)
4598 {
4599 stat = GdipSetEmpty(regions[i]);
4600 if (stat != Ok)
4601 return stat;
4602 }
4603
4604 args.regions = regions;
4605
4606 stat = gdip_format_string(hdc, string, length, font, layoutRect, stringFormat,
4607 measure_ranges_callback, &args);
4608
4609 DeleteObject(SelectObject(hdc, oldfont));
4610
4611 if (temp_hdc)
4612 DeleteDC(temp_hdc);
4613
4614 return stat;
4615 }
4616
4617 struct measure_string_args {
4618 RectF *bounds;
4619 INT *codepointsfitted;
4620 INT *linesfilled;
4621 };
4622
4623 static GpStatus measure_string_callback(HDC hdc,
4624 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4625 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4626 INT lineno, const RectF *bounds, void *user_data)
4627 {
4628 struct measure_string_args *args = user_data;
4629
4630 if (bounds->Width > args->bounds->Width)
4631 args->bounds->Width = bounds->Width;
4632
4633 if (bounds->Height + bounds->Y > args->bounds->Height + args->bounds->Y)
4634 args->bounds->Height = bounds->Height + bounds->Y - args->bounds->Y;
4635
4636 if (args->codepointsfitted)
4637 *args->codepointsfitted = index + length;
4638
4639 if (args->linesfilled)
4640 (*args->linesfilled)++;
4641
4642 return Ok;
4643 }
4644
4645 /* Find the smallest rectangle that bounds the text when it is printed in rect
4646 * according to the format options listed in format. If rect has 0 width and
4647 * height, then just find the smallest rectangle that bounds the text when it's
4648 * printed at location (rect->X, rect-Y). */
4649 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
4650 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4651 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
4652 INT *codepointsfitted, INT *linesfilled)
4653 {
4654 HFONT oldfont;
4655 struct measure_string_args args;
4656 HDC temp_hdc=NULL;
4657
4658 TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
4659 debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
4660 bounds, codepointsfitted, linesfilled);
4661
4662 if(!graphics || !string || !font || !rect || !bounds)
4663 return InvalidParameter;
4664
4665 if(!graphics->hdc)
4666 {
4667 temp_hdc = CreateCompatibleDC(0);
4668 if (!temp_hdc) return OutOfMemory;
4669 }
4670
4671 if(linesfilled) *linesfilled = 0;
4672 if(codepointsfitted) *codepointsfitted = 0;
4673
4674 if(format)
4675 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4676
4677 oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
4678
4679 bounds->X = rect->X;
4680 bounds->Y = rect->Y;
4681 bounds->Width = 0.0;
4682 bounds->Height = 0.0;
4683
4684 args.bounds = bounds;
4685 args.codepointsfitted = codepointsfitted;
4686 args.linesfilled = linesfilled;
4687
4688 gdip_format_string(graphics->hdc ? graphics->hdc : temp_hdc, string, length, font, rect, format,
4689 measure_string_callback, &args);
4690
4691 DeleteObject(SelectObject(graphics->hdc, oldfont));
4692
4693 if (temp_hdc)
4694 DeleteDC(temp_hdc);
4695
4696 return Ok;
4697 }
4698
4699 struct draw_string_args {
4700 POINT drawbase;
4701 UINT drawflags;
4702 REAL ang_cos, ang_sin;
4703 };
4704
4705 static GpStatus draw_string_callback(HDC hdc,
4706 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4707 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4708 INT lineno, const RectF *bounds, void *user_data)
4709 {
4710 struct draw_string_args *args = user_data;
4711 RECT drawcoord;
4712
4713 drawcoord.left = drawcoord.right = args->drawbase.x + roundr(args->ang_sin * bounds->Y);
4714 drawcoord.top = drawcoord.bottom = args->drawbase.y + roundr(args->ang_cos * bounds->Y);
4715
4716 DrawTextW(hdc, string + index, length, &drawcoord, args->drawflags);
4717
4718 return Ok;
4719 }
4720
4721 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
4722 INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
4723 GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
4724 {
4725 HRGN rgn = NULL;
4726 HFONT gdifont;
4727 LOGFONTW lfw;
4728 TEXTMETRICW textmet;
4729 GpPointF pt[3], rectcpy[4];
4730 POINT corners[4];
4731 REAL angle, rel_width, rel_height;
4732 INT offsety = 0, save_state;
4733 struct draw_string_args args;
4734 RectF scaled_rect;
4735
4736 TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
4737 length, font, debugstr_rectf(rect), format, brush);
4738
4739 if(!graphics || !string || !font || !brush || !rect)
4740 return InvalidParameter;
4741
4742 if((brush->bt != BrushTypeSolidColor)){
4743 FIXME("not implemented for given parameters\n");
4744 return NotImplemented;
4745 }
4746
4747 if(!graphics->hdc)
4748 {
4749 FIXME("graphics object has no HDC\n");
4750 return Ok;
4751 }
4752
4753 if(format){
4754 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4755
4756 /* Should be no need to explicitly test for StringAlignmentNear as
4757 * that is default behavior if no alignment is passed. */
4758 if(format->vertalign != StringAlignmentNear){
4759 RectF bounds;
4760 GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
4761
4762 if(format->vertalign == StringAlignmentCenter)
4763 offsety = (rect->Height - bounds.Height) / 2;
4764 else if(format->vertalign == StringAlignmentFar)
4765 offsety = (rect->Height - bounds.Height);
4766 }
4767 }
4768
4769 save_state = SaveDC(graphics->hdc);
4770 SetBkMode(graphics->hdc, TRANSPARENT);
4771 SetTextColor(graphics->hdc, brush->lb.lbColor);
4772
4773 pt[0].X = 0.0;
4774 pt[0].Y = 0.0;
4775 pt[1].X = 1.0;
4776 pt[1].Y = 0.0;
4777 pt[2].X = 0.0;
4778 pt[2].Y = 1.0;
4779 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4780 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
4781 args.ang_cos = cos(angle);
4782 args.ang_sin = sin(angle);
4783 rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4784 (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4785 rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4786 (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4787
4788 rectcpy[3].X = rectcpy[0].X = rect->X;
4789 rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
4790 rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
4791 rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
4792 transform_and_round_points(graphics, corners, rectcpy, 4);
4793
4794 scaled_rect.X = 0.0;
4795 scaled_rect.Y = 0.0;
4796 scaled_rect.Width = rel_width * rect->Width;
4797 scaled_rect.Height = rel_height * rect->Height;
4798
4799 if (roundr(scaled_rect.Width) != 0 && roundr(scaled_rect.Height) != 0)
4800 {
4801 /* FIXME: If only the width or only the height is 0, we should probably still clip */
4802 rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
4803 SelectClipRgn(graphics->hdc, rgn);
4804 }
4805
4806 /* Use gdi to find the font, then perform transformations on it (height,
4807 * width, angle). */
4808 SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
4809 GetTextMetricsW(graphics->hdc, &textmet);
4810 lfw = font->lfw;
4811
4812 lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
4813 lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
4814
4815 lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
4816
4817 gdifont = CreateFontIndirectW(&lfw);
4818 DeleteObject(SelectObject(graphics->hdc, gdifont));
4819
4820 if (!format || format->align == StringAlignmentNear)
4821 {
4822 args.drawbase.x = corners[0].x;
4823 args.drawbase.y = corners[0].y;
4824 args.drawflags = DT_NOCLIP | DT_EXPANDTABS;
4825 }
4826 else if (format->align == StringAlignmentCenter)
4827 {
4828 args.drawbase.x = (corners[0].x + corners[1].x)/2;
4829 args.drawbase.y = (corners[0].y + corners[1].y)/2;
4830 args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_CENTER;
4831 }
4832 else /* (format->align == StringAlignmentFar) */
4833 {
4834 args.drawbase.x = corners[1].x;
4835 args.drawbase.y = corners[1].y;
4836 args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_RIGHT;
4837 }
4838
4839 gdip_format_string(graphics->hdc, string, length, font, &scaled_rect, format,
4840 draw_string_callback, &args);
4841
4842 DeleteObject(rgn);
4843 DeleteObject(gdifont);
4844
4845 RestoreDC(graphics->hdc, save_state);
4846
4847 return Ok;
4848 }
4849
4850 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
4851 {
4852 TRACE("(%p)\n", graphics);
4853
4854 if(!graphics)
4855 return InvalidParameter;
4856
4857 if(graphics->busy)
4858 return ObjectBusy;
4859
4860 return GdipSetInfinite(graphics->clip);
4861 }
4862
4863 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
4864 {
4865 TRACE("(%p)\n", graphics);
4866
4867 if(!graphics)
4868 return InvalidParameter;
4869
4870 if(graphics->busy)
4871 return ObjectBusy;
4872
4873 graphics->worldtrans->matrix[0] = 1.0;
4874 graphics->worldtrans->matrix[1] = 0.0;
4875 graphics->worldtrans->matrix[2] = 0.0;
4876 graphics->worldtrans->matrix[3] = 1.0;
4877 graphics->worldtrans->matrix[4] = 0.0;
4878 graphics->worldtrans->matrix[5] = 0.0;
4879
4880 return Ok;
4881 }
4882
4883 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
4884 {
4885 return GdipEndContainer(graphics, state);
4886 }
4887
4888 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
4889 GpMatrixOrder order)
4890 {
4891 TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
4892
4893 if(!graphics)
4894 return InvalidParameter;
4895
4896 if(graphics->busy)
4897 return ObjectBusy;
4898
4899 return GdipRotateMatrix(graphics->worldtrans, angle, order);
4900 }
4901
4902 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
4903 {
4904 return GdipBeginContainer2(graphics, state);
4905 }
4906
4907 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
4908 GraphicsContainer *state)
4909 {
4910 GraphicsContainerItem *container;
4911 GpStatus sts;
4912
4913 TRACE("(%p, %p)\n", graphics, state);
4914
4915 if(!graphics || !state)
4916 return InvalidParameter;
4917
4918 sts = init_container(&container, graphics);
4919 if(sts != Ok)
4920 return sts;
4921
4922 list_add_head(&graphics->containers, &container->entry);
4923 *state = graphics->contid = container->contid;
4924
4925 return Ok;
4926 }
4927
4928 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
4929 {
4930 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4931 return NotImplemented;
4932 }
4933
4934 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
4935 {
4936 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4937 return NotImplemented;
4938 }
4939
4940 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
4941 {
4942 FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
4943 return NotImplemented;
4944 }
4945
4946 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
4947 {
4948 GpStatus sts;
4949 GraphicsContainerItem *container, *container2;
4950
4951 TRACE("(%p, %x)\n", graphics, state);
4952
4953 if(!graphics)
4954 return InvalidParameter;
4955
4956 LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
4957 if(container->contid == state)
4958 break;
4959 }
4960
4961 /* did not find a matching container */
4962 if(&container->entry == &graphics->containers)
4963 return Ok;
4964
4965 sts = restore_container(graphics, container);
4966 if(sts != Ok)
4967 return sts;
4968
4969 /* remove all of the containers on top of the found container */
4970 LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
4971 if(container->contid == state)
4972 break;
4973 list_remove(&container->entry);
4974 delete_container(container);
4975 }
4976
4977 list_remove(&container->entry);
4978 delete_container(container);
4979
4980 return Ok;
4981 }
4982
4983 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
4984 REAL sy, GpMatrixOrder order)
4985 {
4986 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
4987
4988 if(!graphics)
4989 return InvalidParameter;
4990
4991 if(graphics->busy)
4992 return ObjectBusy;
4993
4994 return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
4995 }
4996
4997 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
4998 CombineMode mode)
4999 {
5000 TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
5001
5002 if(!graphics || !srcgraphics)
5003 return InvalidParameter;
5004
5005 return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
5006 }
5007
5008 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
5009 CompositingMode mode)
5010 {
5011 TRACE("(%p, %d)\n", graphics, mode);
5012
5013 if(!graphics)
5014 return InvalidParameter;
5015
5016 if(graphics->busy)
5017 return ObjectBusy;
5018
5019 graphics->compmode = mode;
5020
5021 return Ok;
5022 }
5023
5024 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
5025 CompositingQuality quality)
5026 {
5027 TRACE("(%p, %d)\n", graphics, quality);
5028
5029 if(!graphics)
5030 return InvalidParameter;
5031
5032 if(graphics->busy)
5033 return ObjectBusy;
5034
5035 graphics->compqual = quality;
5036
5037 return Ok;
5038 }
5039
5040 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
5041 InterpolationMode mode)
5042 {
5043 TRACE("(%p, %d)\n", graphics, mode);
5044
5045 if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
5046 return InvalidParameter;
5047
5048 if(graphics->busy)
5049 return ObjectBusy;
5050
5051 if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
5052 mode = InterpolationModeBilinear;
5053
5054 if (mode == InterpolationModeHighQuality)
5055 mode = InterpolationModeHighQualityBicubic;
5056
5057 graphics->interpolation = mode;
5058
5059 return Ok;
5060 }
5061
5062 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
5063 {
5064 TRACE("(%p, %.2f)\n", graphics, scale);
5065
5066 if(!graphics || (scale <= 0.0))
5067 return InvalidParameter;
5068
5069 if(graphics->busy)
5070 return ObjectBusy;
5071
5072 graphics->scale = scale;
5073
5074 return Ok;
5075 }
5076
5077 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
5078 {
5079 TRACE("(%p, %d)\n", graphics, unit);
5080
5081 if(!graphics)
5082 return InvalidParameter;
5083
5084 if(graphics->busy)
5085 return ObjectBusy;
5086
5087 if(unit == UnitWorld)
5088 return InvalidParameter;
5089
5090 graphics->unit = unit;
5091
5092 return Ok;
5093 }
5094
5095 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
5096 mode)
5097 {
5098 TRACE("(%p, %d)\n", graphics, mode);
5099
5100 if(!graphics)
5101 return InvalidParameter;
5102
5103 if(graphics->busy)
5104 return ObjectBusy;
5105
5106 graphics->pixeloffset = mode;
5107
5108 return Ok;
5109 }
5110
5111 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
5112 {
5113 static int calls;
5114
5115 TRACE("(%p,%i,%i)\n", graphics, x, y);
5116
5117 if (!(calls++))
5118 FIXME("not implemented\n");
5119
5120 return NotImplemented;
5121 }
5122
5123 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
5124 {
5125 static int calls;
5126
5127 TRACE("(%p,%p,%p)\n", graphics, x, y);
5128
5129 if (!(calls++))
5130 FIXME("not implemented\n");
5131
5132 *x = *y = 0;
5133
5134 return NotImplemented;
5135 }
5136
5137 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
5138 {
5139 TRACE("(%p, %d)\n", graphics, mode);
5140
5141 if(!graphics)
5142 return InvalidParameter;
5143
5144 if(graphics->busy)
5145 return ObjectBusy;
5146
5147 graphics->smoothing = mode;
5148
5149 return Ok;
5150 }
5151
5152 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
5153 {
5154 TRACE("(%p, %d)\n", graphics, contrast);
5155
5156 if(!graphics)
5157 return InvalidParameter;
5158
5159 graphics->textcontrast = contrast;
5160
5161 return Ok;
5162 }
5163
5164 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
5165 TextRenderingHint hint)
5166 {
5167 TRACE("(%p, %d)\n", graphics, hint);
5168
5169 if(!graphics)
5170 return InvalidParameter;
5171
5172 if(graphics->busy)
5173 return ObjectBusy;
5174
5175 graphics->texthint = hint;
5176
5177 return Ok;
5178 }
5179
5180 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
5181 {
5182 TRACE("(%p, %p)\n", graphics, matrix);
5183
5184 if(!graphics || !matrix)
5185 return InvalidParameter;
5186
5187 if(graphics->busy)
5188 return ObjectBusy;
5189
5190 GdipDeleteMatrix(graphics->worldtrans);
5191 return GdipCloneMatrix(matrix, &graphics->worldtrans);
5192 }
5193
5194 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
5195 REAL dy, GpMatrixOrder order)
5196 {
5197 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
5198
5199 if(!graphics)
5200 return InvalidParameter;
5201
5202 if(graphics->busy)
5203 return ObjectBusy;
5204
5205 return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
5206 }
5207
5208 /*****************************************************************************
5209 * GdipSetClipHrgn [GDIPLUS.@]
5210 */
5211 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
5212 {
5213 GpRegion *region;
5214 GpStatus status;
5215
5216 TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
5217
5218 if(!graphics)
5219 return InvalidParameter;
5220
5221 status = GdipCreateRegionHrgn(hrgn, &region);
5222 if(status != Ok)
5223 return status;
5224
5225 status = GdipSetClipRegion(graphics, region, mode);
5226
5227 GdipDeleteRegion(region);
5228 return status;
5229 }
5230
5231 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
5232 {
5233 TRACE("(%p, %p, %d)\n", graphics, path, mode);
5234
5235 if(!graphics)
5236 return InvalidParameter;
5237
5238 if(graphics->busy)
5239 return ObjectBusy;
5240
5241 return GdipCombineRegionPath(graphics->clip, path, mode);
5242 }
5243
5244 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
5245 REAL width, REAL height,
5246 CombineMode mode)
5247 {
5248 GpRectF rect;
5249
5250 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
5251
5252 if(!graphics)
5253 return InvalidParameter;
5254
5255 if(graphics->busy)
5256 return ObjectBusy;
5257
5258 rect.X = x;
5259 rect.Y = y;
5260 rect.Width = width;
5261 rect.Height = height;
5262
5263 return GdipCombineRegionRect(graphics->clip, &rect, mode);
5264 }
5265
5266 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
5267 INT width, INT height,
5268 CombineMode mode)
5269 {
5270 TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
5271
5272 if(!graphics)
5273 return InvalidParameter;
5274
5275 if(graphics->busy)
5276 return ObjectBusy;
5277
5278 return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
5279 }
5280
5281 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
5282 CombineMode mode)
5283 {
5284 TRACE("(%p, %p, %d)\n", graphics, region, mode);
5285
5286 if(!graphics || !region)
5287 return InvalidParameter;
5288
5289 if(graphics->busy)
5290 return ObjectBusy;
5291
5292 return GdipCombineRegionRegion(graphics->clip, region, mode);
5293 }
5294
5295 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
5296 UINT limitDpi)
5297 {
5298 static int calls;
5299
5300 TRACE("(%p,%u)\n", metafile, limitDpi);
5301
5302 if(!(calls++))
5303 FIXME("not implemented\n");
5304
5305 return NotImplemented;
5306 }
5307
5308 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
5309 INT count)
5310 {
5311 INT save_state;
5312 POINT *pti;
5313
5314 TRACE("(%p, %p, %d)\n", graphics, points, count);
5315
5316 if(!graphics || !pen || count<=0)
5317 return InvalidParameter;
5318
5319 if(graphics->busy)
5320 return ObjectBusy;
5321
5322 if (!graphics->hdc)
5323 {
5324 FIXME("graphics object has no HDC\n");
5325 return Ok;
5326 }
5327
5328 pti = GdipAlloc(sizeof(POINT) * count);
5329
5330 save_state = prepare_dc(graphics, pen);
5331 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
5332
5333 transform_and_round_points(graphics, pti, (GpPointF*)points, count);
5334 Polygon(graphics->hdc, pti, count);
5335
5336 restore_dc(graphics, save_state);
5337 GdipFree(pti);
5338
5339 return Ok;
5340 }
5341
5342 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
5343 INT count)
5344 {
5345 GpStatus ret;
5346 GpPointF *ptf;
5347 INT i;
5348
5349 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
5350
5351 if(count<=0) return InvalidParameter;
5352 ptf = GdipAlloc(sizeof(GpPointF) * count);
5353
5354 for(i = 0;i < count; i++){
5355 ptf[i].X = (REAL)points[i].X;
5356 ptf[i].Y = (REAL)points[i].Y;
5357 }
5358
5359 ret = GdipDrawPolygon(graphics,pen,ptf,count);
5360 GdipFree(ptf);
5361
5362 return ret;
5363 }
5364
5365 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
5366 {
5367 TRACE("(%p, %p)\n", graphics, dpi);
5368
5369 if(!graphics || !dpi)
5370 return InvalidParameter;
5371
5372 if(graphics->busy)
5373 return ObjectBusy;
5374
5375 if (graphics->image)
5376 *dpi = graphics->image->xres;
5377 else
5378 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
5379
5380 return Ok;
5381 }
5382
5383 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
5384 {
5385 TRACE("(%p, %p)\n", graphics, dpi);
5386
5387 if(!graphics || !dpi)
5388 return InvalidParameter;
5389
5390 if(graphics->busy)
5391 return ObjectBusy;
5392
5393 if (graphics->image)
5394 *dpi = graphics->image->yres;
5395 else
5396 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
5397
5398 return Ok;
5399 }
5400
5401 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
5402 GpMatrixOrder order)
5403 {
5404 GpMatrix m;
5405 GpStatus ret;
5406
5407 TRACE("(%p, %p, %d)\n", graphics, matrix, order);
5408
5409 if(!graphics || !matrix)
5410 return InvalidParameter;
5411
5412 if(graphics->busy)
5413 return ObjectBusy;
5414
5415 m = *(graphics->worldtrans);
5416
5417 ret = GdipMultiplyMatrix(&m, matrix, order);
5418 if(ret == Ok)
5419 *(graphics->worldtrans) = m;
5420
5421 return ret;
5422 }
5423
5424 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
5425 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
5426
5427 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
5428 {
5429 TRACE("(%p, %p)\n", graphics, hdc);
5430
5431 if(!graphics || !hdc)
5432 return InvalidParameter;
5433
5434 if(graphics->busy)
5435 return ObjectBusy;
5436
5437 if (!graphics->hdc ||
5438 (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
5439 {
5440 /* Create a fake HDC and fill it with a constant color. */
5441 HDC temp_hdc;
5442 HBITMAP hbitmap;
5443 GpStatus stat;
5444 GpRectF bounds;
5445 BITMAPINFOHEADER bmih;
5446 int i;
5447
5448 stat = get_graphics_bounds(graphics, &bounds);
5449 if (stat != Ok)
5450 return stat;
5451
5452 graphics->temp_hbitmap_width = bounds.Width;
5453 graphics->temp_hbitmap_height = bounds.Height;
5454
5455 bmih.biSize = sizeof(bmih);
5456 bmih.biWidth = graphics->temp_hbitmap_width;
5457 bmih.biHeight = -graphics->temp_hbitmap_height;
5458 bmih.biPlanes = 1;
5459 bmih.biBitCount = 32;
5460 bmih.biCompression = BI_RGB;
5461 bmih.biSizeImage = 0;
5462 bmih.biXPelsPerMeter = 0;
5463 bmih.biYPelsPerMeter = 0;
5464 bmih.biClrUsed = 0;
5465 bmih.biClrImportant = 0;
5466
5467 hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
5468 (void**)&graphics->temp_bits, NULL, 0);
5469 if (!hbitmap)
5470 return GenericError;
5471
5472 temp_hdc = CreateCompatibleDC(0);
5473 if (!temp_hdc)
5474 {
5475 DeleteObject(hbitmap);
5476 return GenericError;
5477 }
5478
5479 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5480 ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
5481
5482 SelectObject(temp_hdc, hbitmap);
5483
5484 graphics->temp_hbitmap = hbitmap;
5485 *hdc = graphics->temp_hdc = temp_hdc;
5486 }
5487 else
5488 {
5489 *hdc = graphics->hdc;
5490 }
5491
5492 graphics->busy = TRUE;
5493
5494 return Ok;
5495 }
5496
5497 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
5498 {
5499 TRACE("(%p, %p)\n", graphics, hdc);
5500
5501 if(!graphics || !hdc)
5502 return InvalidParameter;
5503
5504 if((graphics->hdc != hdc && graphics->temp_hdc != hdc) || !(graphics->busy))
5505 return InvalidParameter;
5506
5507 if (graphics->temp_hdc == hdc)
5508 {
5509 DWORD* pos;
5510 int i;
5511
5512 /* Find the pixels that have changed, and mark them as opaque. */
5513 pos = (DWORD*)graphics->temp_bits;
5514 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5515 {
5516 if (*pos != DC_BACKGROUND_KEY)
5517 {
5518 *pos |= 0xff000000;
5519 }
5520 pos++;
5521 }
5522
5523 /* Write the changed pixels to the real target. */
5524 alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
5525 graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
5526 graphics->temp_hbitmap_width * 4);
5527
5528 /* Clean up. */
5529 DeleteDC(graphics->temp_hdc);
5530 DeleteObject(graphics->temp_hbitmap);
5531 graphics->temp_hdc = NULL;
5532 graphics->temp_hbitmap = NULL;
5533 }
5534
5535 graphics->busy = FALSE;
5536
5537 return Ok;
5538 }
5539
5540 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
5541 {
5542 GpRegion *clip;
5543 GpStatus status;
5544
5545 TRACE("(%p, %p)\n", graphics, region);
5546
5547 if(!graphics || !region)
5548 return InvalidParameter;
5549
5550 if(graphics->busy)
5551 return ObjectBusy;
5552
5553 if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
5554 return status;
5555
5556 /* free everything except root node and header */
5557 delete_element(&region->node);
5558 memcpy(region, clip, sizeof(GpRegion));
5559 GdipFree(clip);
5560
5561 return Ok;
5562 }
5563
5564 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
5565 GpCoordinateSpace src_space, GpMatrix **matrix)
5566 {
5567 GpStatus stat = GdipCreateMatrix(matrix);
5568 REAL unitscale;
5569
5570 if (dst_space != src_space && stat == Ok)
5571 {
5572 unitscale = convert_unit(graphics_res(graphics), graphics->unit);
5573
5574 if(graphics->unit != UnitDisplay)
5575 unitscale *= graphics->scale;
5576
5577 /* transform from src_space to CoordinateSpacePage */
5578 switch (src_space)
5579 {
5580 case CoordinateSpaceWorld:
5581 GdipMultiplyMatrix(*matrix, graphics->worldtrans, MatrixOrderAppend);
5582 break;
5583 case CoordinateSpacePage:
5584 break;
5585 case CoordinateSpaceDevice:
5586 GdipScaleMatrix(*matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
5587 break;
5588 }
5589
5590 /* transform from CoordinateSpacePage to dst_space */
5591 switch (dst_space)
5592 {
5593 case CoordinateSpaceWorld:
5594 {
5595 GpMatrix *inverted_transform;
5596 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
5597 if (stat == Ok)
5598 {
5599 stat = GdipInvertMatrix(inverted_transform);
5600 if (stat == Ok)
5601 GdipMultiplyMatrix(*matrix, inverted_transform, MatrixOrderAppend);
5602 GdipDeleteMatrix(inverted_transform);
5603 }
5604 break;
5605 }
5606 case CoordinateSpacePage:
5607 break;
5608 case CoordinateSpaceDevice:
5609 GdipScaleMatrix(*matrix, unitscale, unitscale, MatrixOrderAppend);
5610 break;
5611 }
5612 }
5613 return stat;
5614 }
5615
5616 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
5617 GpCoordinateSpace src_space, GpPointF *points, INT count)
5618 {
5619 GpMatrix *matrix;
5620 GpStatus stat;
5621
5622 if(!graphics || !points || count <= 0)
5623 return InvalidParameter;
5624
5625 if(graphics->busy)
5626 return ObjectBusy;
5627
5628 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5629
5630 if (src_space == dst_space) return Ok;
5631
5632 stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
5633
5634 if (stat == Ok)
5635 {
5636 stat = GdipTransformMatrixPoints(matrix, points, count);
5637
5638 GdipDeleteMatrix(matrix);
5639 }
5640
5641 return stat;
5642 }
5643
5644 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
5645 GpCoordinateSpace src_space, GpPoint *points, INT count)
5646 {
5647 GpPointF *pointsF;
5648 GpStatus ret;
5649 INT i;
5650
5651 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5652
5653 if(count <= 0)
5654 return InvalidParameter;
5655
5656 pointsF = GdipAlloc(sizeof(GpPointF) * count);
5657 if(!pointsF)
5658 return OutOfMemory;
5659
5660 for(i = 0; i < count; i++){
5661 pointsF[i].X = (REAL)points[i].X;
5662 pointsF[i].Y = (REAL)points[i].Y;
5663 }
5664
5665 ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
5666
5667 if(ret == Ok)
5668 for(i = 0; i < count; i++){
5669 points[i].X = roundr(pointsF[i].X);
5670 points[i].Y = roundr(pointsF[i].Y);
5671 }
5672 GdipFree(pointsF);
5673
5674 return ret;
5675 }
5676
5677 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
5678 {
5679 static int calls;
5680
5681 TRACE("\n");
5682
5683 if (!calls++)
5684 FIXME("stub\n");
5685
5686 return NULL;
5687 }
5688
5689 /*****************************************************************************
5690 * GdipTranslateClip [GDIPLUS.@]
5691 */
5692 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
5693 {
5694 TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
5695
5696 if(!graphics)
5697 return InvalidParameter;
5698
5699 if(graphics->busy)
5700 return ObjectBusy;
5701
5702 return GdipTranslateRegion(graphics->clip, dx, dy);
5703 }
5704
5705 /*****************************************************************************
5706 * GdipTranslateClipI [GDIPLUS.@]
5707 */
5708 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
5709 {
5710 TRACE("(%p, %d, %d)\n", graphics, dx, dy);
5711
5712 if(!graphics)
5713 return InvalidParameter;
5714
5715 if(graphics->busy)
5716 return ObjectBusy;
5717
5718 return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
5719 }
5720
5721
5722 /*****************************************************************************
5723 * GdipMeasureDriverString [GDIPLUS.@]
5724 */
5725 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5726 GDIPCONST GpFont *font, GDIPCONST PointF *positions,
5727 INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
5728 {
5729 FIXME("(%p %p %d %p %p %d %p %p): stub\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
5730 return NotImplemented;
5731 }
5732
5733 /*****************************************************************************
5734 * GdipDrawDriverString [GDIPLUS.@]
5735 */
5736 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5737 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
5738 GDIPCONST PointF *positions, INT flags,
5739 GDIPCONST GpMatrix *matrix )
5740 {
5741 FIXME("(%p %p %d %p %p %p %d %p): stub\n", graphics, text, length, font, brush, positions, flags, matrix);
5742 return NotImplemented;
5743 }
5744
5745 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
5746 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5747 {
5748 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
5749 return NotImplemented;
5750 }
5751
5752 /*****************************************************************************
5753 * GdipRecordMetafileI [GDIPLUS.@]
5754 */
5755 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
5756 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5757 {
5758 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
5759 return NotImplemented;
5760 }
5761
5762 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
5763 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5764 {
5765 FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
5766 return NotImplemented;
5767 }
5768
5769 /*****************************************************************************
5770 * GdipIsVisibleClipEmpty [GDIPLUS.@]
5771 */
5772 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
5773 {
5774 GpStatus stat;
5775 GpRegion* rgn;
5776
5777 TRACE("(%p, %p)\n", graphics, res);
5778
5779 if((stat = GdipCreateRegion(&rgn)) != Ok)
5780 return stat;
5781
5782 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
5783 goto cleanup;
5784
5785 stat = GdipIsEmptyRegion(rgn, graphics, res);
5786
5787 cleanup:
5788 GdipDeleteRegion(rgn);
5789 return stat;
5790 }
5791
5792 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
5793 {
5794 FIXME("(%p,%p): stub\n", metafile, hEmf);
5795
5796 if (!metafile || !hEmf)
5797 return InvalidParameter;
5798
5799 *hEmf = NULL;
5800
5801 return NotImplemented;
5802 }
Quick hack tree for wine patches julliard doesn't want to commit