?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gdiplus: Call GdiAlphaBlend only once per GdipFillRegion call.
[wine.git] / dlls / gdiplus / graphics.c
blob83e0f248d529bac1ae76d6e6aa8012fb616f51bd
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 INT save_state;
3359 GpPointF ptf[2];
3360 POINT pti[2];
3361
3362 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3363
3364 if(!graphics || !brush)
3365 return InvalidParameter;
3366
3367 if(graphics->busy)
3368 return ObjectBusy;
3369
3370 if(!graphics->hdc)
3371 {
3372 FIXME("graphics object has no HDC\n");
3373 return Ok;
3374 }
3375
3376 ptf[0].X = x;
3377 ptf[0].Y = y;
3378 ptf[1].X = x + width;
3379 ptf[1].Y = y + height;
3380
3381 save_state = SaveDC(graphics->hdc);
3382 EndPath(graphics->hdc);
3383
3384 transform_and_round_points(graphics, pti, ptf, 2);
3385
3386 BeginPath(graphics->hdc);
3387 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
3388 EndPath(graphics->hdc);
3389
3390 brush_fill_path(graphics, brush);
3391
3392 RestoreDC(graphics->hdc, save_state);
3393
3394 return Ok;
3395 }
3396
3397 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
3398 INT y, INT width, INT height)
3399 {
3400 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3401
3402 return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3403 }
3404
3405 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3406 {
3407 INT save_state;
3408 GpStatus retval;
3409
3410 TRACE("(%p, %p, %p)\n", graphics, brush, path);
3411
3412 if(!brush || !graphics || !path)
3413 return InvalidParameter;
3414
3415 if(graphics->busy)
3416 return ObjectBusy;
3417
3418 if(!graphics->hdc)
3419 {
3420 FIXME("graphics object has no HDC\n");
3421 return Ok;
3422 }
3423
3424 save_state = SaveDC(graphics->hdc);
3425 EndPath(graphics->hdc);
3426 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
3427 : WINDING));
3428
3429 BeginPath(graphics->hdc);
3430 retval = draw_poly(graphics, NULL, path->pathdata.Points,
3431 path->pathdata.Types, path->pathdata.Count, FALSE);
3432
3433 if(retval != Ok)
3434 goto end;
3435
3436 EndPath(graphics->hdc);
3437 brush_fill_path(graphics, brush);
3438
3439 retval = Ok;
3440
3441 end:
3442 RestoreDC(graphics->hdc, save_state);
3443
3444 return retval;
3445 }
3446
3447 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
3448 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3449 {
3450 INT save_state;
3451
3452 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
3453 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3454
3455 if(!graphics || !brush)
3456 return InvalidParameter;
3457
3458 if(graphics->busy)
3459 return ObjectBusy;
3460
3461 if(!graphics->hdc)
3462 {
3463 FIXME("graphics object has no HDC\n");
3464 return Ok;
3465 }
3466
3467 save_state = SaveDC(graphics->hdc);
3468 EndPath(graphics->hdc);
3469
3470 BeginPath(graphics->hdc);
3471 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
3472 EndPath(graphics->hdc);
3473
3474 brush_fill_path(graphics, brush);
3475
3476 RestoreDC(graphics->hdc, save_state);
3477
3478 return Ok;
3479 }
3480
3481 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
3482 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3483 {
3484 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
3485 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3486
3487 return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3488 }
3489
3490 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
3491 GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
3492 {
3493 INT save_state;
3494 GpPointF *ptf = NULL;
3495 POINT *pti = NULL;
3496 GpStatus retval = Ok;
3497
3498 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3499
3500 if(!graphics || !brush || !points || !count)
3501 return InvalidParameter;
3502
3503 if(graphics->busy)
3504 return ObjectBusy;
3505
3506 if(!graphics->hdc)
3507 {
3508 FIXME("graphics object has no HDC\n");
3509 return Ok;
3510 }
3511
3512 ptf = GdipAlloc(count * sizeof(GpPointF));
3513 pti = GdipAlloc(count * sizeof(POINT));
3514 if(!ptf || !pti){
3515 retval = OutOfMemory;
3516 goto end;
3517 }
3518
3519 memcpy(ptf, points, count * sizeof(GpPointF));
3520
3521 save_state = SaveDC(graphics->hdc);
3522 EndPath(graphics->hdc);
3523 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
3524 : WINDING));
3525
3526 transform_and_round_points(graphics, pti, ptf, count);
3527
3528 BeginPath(graphics->hdc);
3529 Polygon(graphics->hdc, pti, count);
3530 EndPath(graphics->hdc);
3531
3532 brush_fill_path(graphics, brush);
3533
3534 RestoreDC(graphics->hdc, save_state);
3535
3536 end:
3537 GdipFree(ptf);
3538 GdipFree(pti);
3539
3540 return retval;
3541 }
3542
3543 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
3544 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
3545 {
3546 INT save_state, i;
3547 GpPointF *ptf = NULL;
3548 POINT *pti = NULL;
3549 GpStatus retval = Ok;
3550
3551 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3552
3553 if(!graphics || !brush || !points || !count)
3554 return InvalidParameter;
3555
3556 if(graphics->busy)
3557 return ObjectBusy;
3558
3559 if(!graphics->hdc)
3560 {
3561 FIXME("graphics object has no HDC\n");
3562 return Ok;
3563 }
3564
3565 ptf = GdipAlloc(count * sizeof(GpPointF));
3566 pti = GdipAlloc(count * sizeof(POINT));
3567 if(!ptf || !pti){
3568 retval = OutOfMemory;
3569 goto end;
3570 }
3571
3572 for(i = 0; i < count; i ++){
3573 ptf[i].X = (REAL) points[i].X;
3574 ptf[i].Y = (REAL) points[i].Y;
3575 }
3576
3577 save_state = SaveDC(graphics->hdc);
3578 EndPath(graphics->hdc);
3579 SetPolyFillMode(graphics->hdc, (fillMode == FillModeAlternate ? ALTERNATE
3580 : WINDING));
3581
3582 transform_and_round_points(graphics, pti, ptf, count);
3583
3584 BeginPath(graphics->hdc);
3585 Polygon(graphics->hdc, pti, count);
3586 EndPath(graphics->hdc);
3587
3588 brush_fill_path(graphics, brush);
3589
3590 RestoreDC(graphics->hdc, save_state);
3591
3592 end:
3593 GdipFree(ptf);
3594 GdipFree(pti);
3595
3596 return retval;
3597 }
3598
3599 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
3600 GDIPCONST GpPointF *points, INT count)
3601 {
3602 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3603
3604 return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
3605 }
3606
3607 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
3608 GDIPCONST GpPoint *points, INT count)
3609 {
3610 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3611
3612 return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
3613 }
3614
3615 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
3616 REAL x, REAL y, REAL width, REAL height)
3617 {
3618 INT save_state;
3619 GpPointF ptf[4];
3620 POINT pti[4];
3621
3622 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3623
3624 if(!graphics || !brush)
3625 return InvalidParameter;
3626
3627 if(graphics->busy)
3628 return ObjectBusy;
3629
3630 if(!graphics->hdc)
3631 {
3632 FIXME("graphics object has no HDC\n");
3633 return Ok;
3634 }
3635
3636 ptf[0].X = x;
3637 ptf[0].Y = y;
3638 ptf[1].X = x + width;
3639 ptf[1].Y = y;
3640 ptf[2].X = x + width;
3641 ptf[2].Y = y + height;
3642 ptf[3].X = x;
3643 ptf[3].Y = y + height;
3644
3645 save_state = SaveDC(graphics->hdc);
3646 EndPath(graphics->hdc);
3647
3648 transform_and_round_points(graphics, pti, ptf, 4);
3649
3650 BeginPath(graphics->hdc);
3651 Polygon(graphics->hdc, pti, 4);
3652 EndPath(graphics->hdc);
3653
3654 brush_fill_path(graphics, brush);
3655
3656 RestoreDC(graphics->hdc, save_state);
3657
3658 return Ok;
3659 }
3660
3661 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
3662 INT x, INT y, INT width, INT height)
3663 {
3664 INT save_state;
3665 GpPointF ptf[4];
3666 POINT pti[4];
3667
3668 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3669
3670 if(!graphics || !brush)
3671 return InvalidParameter;
3672
3673 if(graphics->busy)
3674 return ObjectBusy;
3675
3676 if(!graphics->hdc)
3677 {
3678 FIXME("graphics object has no HDC\n");
3679 return Ok;
3680 }
3681
3682 ptf[0].X = x;
3683 ptf[0].Y = y;
3684 ptf[1].X = x + width;
3685 ptf[1].Y = y;
3686 ptf[2].X = x + width;
3687 ptf[2].Y = y + height;
3688 ptf[3].X = x;
3689 ptf[3].Y = y + height;
3690
3691 save_state = SaveDC(graphics->hdc);
3692 EndPath(graphics->hdc);
3693
3694 transform_and_round_points(graphics, pti, ptf, 4);
3695
3696 BeginPath(graphics->hdc);
3697 Polygon(graphics->hdc, pti, 4);
3698 EndPath(graphics->hdc);
3699
3700 brush_fill_path(graphics, brush);
3701
3702 RestoreDC(graphics->hdc, save_state);
3703
3704 return Ok;
3705 }
3706
3707 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
3708 INT count)
3709 {
3710 GpStatus ret;
3711 INT i;
3712
3713 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3714
3715 if(!rects)
3716 return InvalidParameter;
3717
3718 for(i = 0; i < count; i++){
3719 ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
3720 if(ret != Ok) return ret;
3721 }
3722
3723 return Ok;
3724 }
3725
3726 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
3727 INT count)
3728 {
3729 GpRectF *rectsF;
3730 GpStatus ret;
3731 INT i;
3732
3733 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3734
3735 if(!rects || count <= 0)
3736 return InvalidParameter;
3737
3738 rectsF = GdipAlloc(sizeof(GpRectF)*count);
3739 if(!rectsF)
3740 return OutOfMemory;
3741
3742 for(i = 0; i < count; i++){
3743 rectsF[i].X = (REAL)rects[i].X;
3744 rectsF[i].Y = (REAL)rects[i].Y;
3745 rectsF[i].X = (REAL)rects[i].Width;
3746 rectsF[i].Height = (REAL)rects[i].Height;
3747 }
3748
3749 ret = GdipFillRectangles(graphics,brush,rectsF,count);
3750 GdipFree(rectsF);
3751
3752 return ret;
3753 }
3754
3755 static GpStatus GDI32_GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3756 GpRegion* region)
3757 {
3758 INT save_state;
3759 GpStatus status;
3760 HRGN hrgn;
3761 RECT rc;
3762
3763 if(!graphics->hdc || !brush_can_fill_path(brush))
3764 return NotImplemented;
3765
3766 status = GdipGetRegionHRgn(region, graphics, &hrgn);
3767 if(status != Ok)
3768 return status;
3769
3770 save_state = SaveDC(graphics->hdc);
3771 EndPath(graphics->hdc);
3772
3773 ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3774
3775 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
3776 {
3777 BeginPath(graphics->hdc);
3778 Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
3779 EndPath(graphics->hdc);
3780
3781 brush_fill_path(graphics, brush);
3782 }
3783
3784 RestoreDC(graphics->hdc, save_state);
3785
3786 DeleteObject(hrgn);
3787
3788 return Ok;
3789 }
3790
3791 static GpStatus SOFTWARE_GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
3792 GpRegion* region)
3793 {
3794 GpStatus stat;
3795 GpRegion *temp_region;
3796 GpMatrix *world_to_device, *identity;
3797 GpRectF graphics_bounds;
3798 UINT scans_count, i;
3799 INT dummy;
3800 GpRect *scans;
3801 DWORD *pixel_data;
3802
3803 if (!brush_can_fill_pixels(brush))
3804 return NotImplemented;
3805
3806 stat = get_graphics_bounds(graphics, &graphics_bounds);
3807
3808 if (stat == Ok)
3809 stat = GdipCloneRegion(region, &temp_region);
3810
3811 if (stat == Ok)
3812 {
3813 stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
3814 CoordinateSpaceWorld, &world_to_device);
3815
3816 if (stat == Ok)
3817 {
3818 stat = GdipTransformRegion(temp_region, world_to_device);
3819
3820 GdipDeleteMatrix(world_to_device);
3821 }
3822
3823 if (stat == Ok)
3824 stat = GdipCombineRegionRect(temp_region, &graphics_bounds, CombineModeIntersect);
3825
3826 if (stat == Ok)
3827 stat = GdipCreateMatrix(&identity);
3828
3829 if (stat == Ok)
3830 {
3831 stat = GdipGetRegionScansCount(temp_region, &scans_count, identity);
3832
3833 if (stat == Ok && scans_count != 0)
3834 {
3835 scans = GdipAlloc(sizeof(*scans) * scans_count);
3836 if (!scans)
3837 stat = OutOfMemory;
3838
3839 if (stat == Ok)
3840 {
3841 stat = GdipGetRegionScansI(temp_region, scans, &dummy, identity);
3842
3843 if (stat != Ok)
3844 GdipFree(scans);
3845 }
3846 }
3847
3848 GdipDeleteMatrix(identity);
3849 }
3850
3851 GdipDeleteRegion(temp_region);
3852 }
3853
3854 if (stat == Ok && scans_count == 0)
3855 return Ok;
3856
3857 if (stat == Ok)
3858 {
3859 if (!graphics->image)
3860 {
3861 /* If we have to go through gdi32, use as few alpha blends as possible. */
3862 INT min_x, min_y, max_x, max_y;
3863 UINT data_width, data_height;
3864
3865 min_x = scans[0].X;
3866 min_y = scans[0].Y;
3867 max_x = scans[0].X+scans[0].Width;
3868 max_y = scans[0].Y+scans[0].Height;
3869
3870 for (i=1; i<scans_count; i++)
3871 {
3872 min_x = min(min_x, scans[i].X);
3873 min_y = min(min_y, scans[i].Y);
3874 max_x = max(max_x, scans[i].X+scans[i].Width);
3875 max_y = max(max_y, scans[i].Y+scans[i].Height);
3876 }
3877
3878 data_width = max_x - min_x;
3879 data_height = max_y - min_y;
3880
3881 pixel_data = GdipAlloc(sizeof(*pixel_data) * data_width * data_height);
3882 if (!pixel_data)
3883 stat = OutOfMemory;
3884
3885 if (stat == Ok)
3886 {
3887 for (i=0; i<scans_count; i++)
3888 {
3889 stat = brush_fill_pixels(graphics, brush,
3890 pixel_data + (scans[i].X - min_x) + (scans[i].Y - min_y) * data_width,
3891 &scans[i], data_width);
3892
3893 if (stat != Ok)
3894 break;
3895 }
3896
3897 if (stat == Ok)
3898 {
3899 stat = alpha_blend_pixels(graphics, min_x, min_y,
3900 (BYTE*)pixel_data, data_width, data_height,
3901 data_width * 4);
3902 }
3903
3904 GdipFree(pixel_data);
3905 }
3906 }
3907 else
3908 {
3909 UINT max_size=0;
3910
3911 for (i=0; i<scans_count; i++)
3912 {
3913 UINT size = scans[i].Width * scans[i].Height;
3914
3915 if (size > max_size)
3916 max_size = size;
3917 }
3918
3919 pixel_data = GdipAlloc(sizeof(*pixel_data) * max_size);
3920 if (!pixel_data)
3921 stat = OutOfMemory;
3922
3923 if (stat == Ok)
3924 {
3925 for (i=0; i<scans_count; i++)
3926 {
3927 stat = brush_fill_pixels(graphics, brush, pixel_data, &scans[i],
3928 scans[i].Width);
3929
3930 if (stat == Ok)
3931 {
3932 stat = alpha_blend_pixels(graphics, scans[i].X, scans[i].Y,
3933 (BYTE*)pixel_data, scans[i].Width, scans[i].Height,
3934 scans[i].Width * 4);
3935 }
3936
3937 if (stat != Ok)
3938 break;
3939 }
3940
3941 GdipFree(pixel_data);
3942 }
3943 }
3944
3945 GdipFree(scans);
3946 }
3947
3948 return stat;
3949 }
3950
3951 /*****************************************************************************
3952 * GdipFillRegion [GDIPLUS.@]
3953 */
3954 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3955 GpRegion* region)
3956 {
3957 GpStatus stat = NotImplemented;
3958
3959 TRACE("(%p, %p, %p)\n", graphics, brush, region);
3960
3961 if (!(graphics && brush && region))
3962 return InvalidParameter;
3963
3964 if(graphics->busy)
3965 return ObjectBusy;
3966
3967 if (!graphics->image)
3968 stat = GDI32_GdipFillRegion(graphics, brush, region);
3969
3970 if (stat == NotImplemented)
3971 stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
3972
3973 if (stat == NotImplemented)
3974 {
3975 FIXME("not implemented for brushtype %i\n", brush->bt);
3976 stat = Ok;
3977 }
3978
3979 return stat;
3980 }
3981
3982 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
3983 {
3984 TRACE("(%p,%u)\n", graphics, intention);
3985
3986 if(!graphics)
3987 return InvalidParameter;
3988
3989 if(graphics->busy)
3990 return ObjectBusy;
3991
3992 /* We have no internal operation queue, so there's no need to clear it. */
3993
3994 if (graphics->hdc)
3995 GdiFlush();
3996
3997 return Ok;
3998 }
3999
4000 /*****************************************************************************
4001 * GdipGetClipBounds [GDIPLUS.@]
4002 */
4003 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
4004 {
4005 TRACE("(%p, %p)\n", graphics, rect);
4006
4007 if(!graphics)
4008 return InvalidParameter;
4009
4010 if(graphics->busy)
4011 return ObjectBusy;
4012
4013 return GdipGetRegionBounds(graphics->clip, graphics, rect);
4014 }
4015
4016 /*****************************************************************************
4017 * GdipGetClipBoundsI [GDIPLUS.@]
4018 */
4019 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
4020 {
4021 TRACE("(%p, %p)\n", graphics, rect);
4022
4023 if(!graphics)
4024 return InvalidParameter;
4025
4026 if(graphics->busy)
4027 return ObjectBusy;
4028
4029 return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
4030 }
4031
4032 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
4033 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
4034 CompositingMode *mode)
4035 {
4036 TRACE("(%p, %p)\n", graphics, mode);
4037
4038 if(!graphics || !mode)
4039 return InvalidParameter;
4040
4041 if(graphics->busy)
4042 return ObjectBusy;
4043
4044 *mode = graphics->compmode;
4045
4046 return Ok;
4047 }
4048
4049 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
4050 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
4051 CompositingQuality *quality)
4052 {
4053 TRACE("(%p, %p)\n", graphics, quality);
4054
4055 if(!graphics || !quality)
4056 return InvalidParameter;
4057
4058 if(graphics->busy)
4059 return ObjectBusy;
4060
4061 *quality = graphics->compqual;
4062
4063 return Ok;
4064 }
4065
4066 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
4067 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
4068 InterpolationMode *mode)
4069 {
4070 TRACE("(%p, %p)\n", graphics, mode);
4071
4072 if(!graphics || !mode)
4073 return InvalidParameter;
4074
4075 if(graphics->busy)
4076 return ObjectBusy;
4077
4078 *mode = graphics->interpolation;
4079
4080 return Ok;
4081 }
4082
4083 /* FIXME: Need to handle color depths less than 24bpp */
4084 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
4085 {
4086 FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
4087
4088 if(!graphics || !argb)
4089 return InvalidParameter;
4090
4091 if(graphics->busy)
4092 return ObjectBusy;
4093
4094 return Ok;
4095 }
4096
4097 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
4098 {
4099 TRACE("(%p, %p)\n", graphics, scale);
4100
4101 if(!graphics || !scale)
4102 return InvalidParameter;
4103
4104 if(graphics->busy)
4105 return ObjectBusy;
4106
4107 *scale = graphics->scale;
4108
4109 return Ok;
4110 }
4111
4112 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
4113 {
4114 TRACE("(%p, %p)\n", graphics, unit);
4115
4116 if(!graphics || !unit)
4117 return InvalidParameter;
4118
4119 if(graphics->busy)
4120 return ObjectBusy;
4121
4122 *unit = graphics->unit;
4123
4124 return Ok;
4125 }
4126
4127 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
4128 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4129 *mode)
4130 {
4131 TRACE("(%p, %p)\n", graphics, mode);
4132
4133 if(!graphics || !mode)
4134 return InvalidParameter;
4135
4136 if(graphics->busy)
4137 return ObjectBusy;
4138
4139 *mode = graphics->pixeloffset;
4140
4141 return Ok;
4142 }
4143
4144 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
4145 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
4146 {
4147 TRACE("(%p, %p)\n", graphics, mode);
4148
4149 if(!graphics || !mode)
4150 return InvalidParameter;
4151
4152 if(graphics->busy)
4153 return ObjectBusy;
4154
4155 *mode = graphics->smoothing;
4156
4157 return Ok;
4158 }
4159
4160 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
4161 {
4162 TRACE("(%p, %p)\n", graphics, contrast);
4163
4164 if(!graphics || !contrast)
4165 return InvalidParameter;
4166
4167 *contrast = graphics->textcontrast;
4168
4169 return Ok;
4170 }
4171
4172 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
4173 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
4174 TextRenderingHint *hint)
4175 {
4176 TRACE("(%p, %p)\n", graphics, hint);
4177
4178 if(!graphics || !hint)
4179 return InvalidParameter;
4180
4181 if(graphics->busy)
4182 return ObjectBusy;
4183
4184 *hint = graphics->texthint;
4185
4186 return Ok;
4187 }
4188
4189 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
4190 {
4191 GpRegion *clip_rgn;
4192 GpStatus stat;
4193
4194 TRACE("(%p, %p)\n", graphics, rect);
4195
4196 if(!graphics || !rect)
4197 return InvalidParameter;
4198
4199 if(graphics->busy)
4200 return ObjectBusy;
4201
4202 /* intersect window and graphics clipping regions */
4203 if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
4204 return stat;
4205
4206 if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
4207 goto cleanup;
4208
4209 /* get bounds of the region */
4210 stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
4211
4212 cleanup:
4213 GdipDeleteRegion(clip_rgn);
4214
4215 return stat;
4216 }
4217
4218 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
4219 {
4220 GpRectF rectf;
4221 GpStatus stat;
4222
4223 TRACE("(%p, %p)\n", graphics, rect);
4224
4225 if(!graphics || !rect)
4226 return InvalidParameter;
4227
4228 if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
4229 {
4230 rect->X = roundr(rectf.X);
4231 rect->Y = roundr(rectf.Y);
4232 rect->Width = roundr(rectf.Width);
4233 rect->Height = roundr(rectf.Height);
4234 }
4235
4236 return stat;
4237 }
4238
4239 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4240 {
4241 TRACE("(%p, %p)\n", graphics, matrix);
4242
4243 if(!graphics || !matrix)
4244 return InvalidParameter;
4245
4246 if(graphics->busy)
4247 return ObjectBusy;
4248
4249 *matrix = *graphics->worldtrans;
4250 return Ok;
4251 }
4252
4253 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
4254 {
4255 GpSolidFill *brush;
4256 GpStatus stat;
4257 GpRectF wnd_rect;
4258
4259 TRACE("(%p, %x)\n", graphics, color);
4260
4261 if(!graphics)
4262 return InvalidParameter;
4263
4264 if(graphics->busy)
4265 return ObjectBusy;
4266
4267 if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
4268 return stat;
4269
4270 if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
4271 GdipDeleteBrush((GpBrush*)brush);
4272 return stat;
4273 }
4274
4275 GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
4276 wnd_rect.Width, wnd_rect.Height);
4277
4278 GdipDeleteBrush((GpBrush*)brush);
4279
4280 return Ok;
4281 }
4282
4283 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
4284 {
4285 TRACE("(%p, %p)\n", graphics, res);
4286
4287 if(!graphics || !res)
4288 return InvalidParameter;
4289
4290 return GdipIsEmptyRegion(graphics->clip, graphics, res);
4291 }
4292
4293 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
4294 {
4295 GpStatus stat;
4296 GpRegion* rgn;
4297 GpPointF pt;
4298
4299 TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
4300
4301 if(!graphics || !result)
4302 return InvalidParameter;
4303
4304 if(graphics->busy)
4305 return ObjectBusy;
4306
4307 pt.X = x;
4308 pt.Y = y;
4309 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4310 CoordinateSpaceWorld, &pt, 1)) != Ok)
4311 return stat;
4312
4313 if((stat = GdipCreateRegion(&rgn)) != Ok)
4314 return stat;
4315
4316 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4317 goto cleanup;
4318
4319 stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
4320
4321 cleanup:
4322 GdipDeleteRegion(rgn);
4323 return stat;
4324 }
4325
4326 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
4327 {
4328 return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
4329 }
4330
4331 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
4332 {
4333 GpStatus stat;
4334 GpRegion* rgn;
4335 GpPointF pts[2];
4336
4337 TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
4338
4339 if(!graphics || !result)
4340 return InvalidParameter;
4341
4342 if(graphics->busy)
4343 return ObjectBusy;
4344
4345 pts[0].X = x;
4346 pts[0].Y = y;
4347 pts[1].X = x + width;
4348 pts[1].Y = y + height;
4349
4350 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4351 CoordinateSpaceWorld, pts, 2)) != Ok)
4352 return stat;
4353
4354 pts[1].X -= pts[0].X;
4355 pts[1].Y -= pts[0].Y;
4356
4357 if((stat = GdipCreateRegion(&rgn)) != Ok)
4358 return stat;
4359
4360 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4361 goto cleanup;
4362
4363 stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
4364
4365 cleanup:
4366 GdipDeleteRegion(rgn);
4367 return stat;
4368 }
4369
4370 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4371 {
4372 return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
4373 }
4374
4375 GpStatus gdip_format_string(HDC hdc,
4376 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4377 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4378 gdip_format_string_callback callback, void *user_data)
4379 {
4380 WCHAR* stringdup;
4381 int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
4382 nheight, lineend, lineno = 0;
4383 RectF bounds;
4384 StringAlignment halign;
4385 GpStatus stat = Ok;
4386 SIZE size;
4387
4388 if(length == -1) length = lstrlenW(string);
4389
4390 stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
4391 if(!stringdup) return OutOfMemory;
4392
4393 nwidth = roundr(rect->Width);
4394 nheight = roundr(rect->Height);
4395
4396 if (rect->Width >= INT_MAX || rect->Width < 0.5) nwidth = INT_MAX;
4397 if (rect->Height >= INT_MAX || rect->Width < 0.5) nheight = INT_MAX;
4398
4399 for(i = 0, j = 0; i < length; i++){
4400 /* FIXME: This makes the indexes passed to callback inaccurate. */
4401 if(!isprintW(string[i]) && (string[i] != '\n'))
4402 continue;
4403
4404 stringdup[j] = string[i];
4405 j++;
4406 }
4407
4408 length = j;
4409
4410 if (format) halign = format->align;
4411 else halign = StringAlignmentNear;
4412
4413 while(sum < length){
4414 GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
4415 nwidth, &fit, NULL, &size);
4416 fitcpy = fit;
4417
4418 if(fit == 0)
4419 break;
4420
4421 for(lret = 0; lret < fit; lret++)
4422 if(*(stringdup + sum + lret) == '\n')
4423 break;
4424
4425 /* Line break code (may look strange, but it imitates windows). */
4426 if(lret < fit)
4427 lineend = fit = lret; /* this is not an off-by-one error */
4428 else if(fit < (length - sum)){
4429 if(*(stringdup + sum + fit) == ' ')
4430 while(*(stringdup + sum + fit) == ' ')
4431 fit++;
4432 else
4433 while(*(stringdup + sum + fit - 1) != ' '){
4434 fit--;
4435
4436 if(*(stringdup + sum + fit) == '\t')
4437 break;
4438
4439 if(fit == 0){
4440 fit = fitcpy;
4441 break;
4442 }
4443 }
4444 lineend = fit;
4445 while(*(stringdup + sum + lineend - 1) == ' ' ||
4446 *(stringdup + sum + lineend - 1) == '\t')
4447 lineend--;
4448 }
4449 else
4450 lineend = fit;
4451
4452 GetTextExtentExPointW(hdc, stringdup + sum, lineend,
4453 nwidth, &j, NULL, &size);
4454
4455 bounds.Width = size.cx;
4456
4457 if(height + size.cy > nheight)
4458 bounds.Height = nheight - (height + size.cy);
4459 else
4460 bounds.Height = size.cy;
4461
4462 bounds.Y = rect->Y + height;
4463
4464 switch (halign)
4465 {
4466 case StringAlignmentNear:
4467 default:
4468 bounds.X = rect->X;
4469 break;
4470 case StringAlignmentCenter:
4471 bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
4472 break;
4473 case StringAlignmentFar:
4474 bounds.X = rect->X + rect->Width - bounds.Width;
4475 break;
4476 }
4477
4478 stat = callback(hdc, stringdup, sum, lineend,
4479 font, rect, format, lineno, &bounds, user_data);
4480
4481 if (stat != Ok)
4482 break;
4483
4484 sum += fit + (lret < fitcpy ? 1 : 0);
4485 height += size.cy;
4486 lineno++;
4487
4488 if(height > nheight)
4489 break;
4490
4491 /* Stop if this was a linewrap (but not if it was a linebreak). */
4492 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
4493 break;
4494 }
4495
4496 GdipFree(stringdup);
4497
4498 return stat;
4499 }
4500
4501 struct measure_ranges_args {
4502 GpRegion **regions;
4503 };
4504
4505 static GpStatus measure_ranges_callback(HDC hdc,
4506 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4507 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4508 INT lineno, const RectF *bounds, void *user_data)
4509 {
4510 int i;
4511 GpStatus stat = Ok;
4512 struct measure_ranges_args *args = user_data;
4513
4514 for (i=0; i<format->range_count; i++)
4515 {
4516 INT range_start = max(index, format->character_ranges[i].First);
4517 INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
4518 if (range_start < range_end)
4519 {
4520 GpRectF range_rect;
4521 SIZE range_size;
4522
4523 range_rect.Y = bounds->Y;
4524 range_rect.Height = bounds->Height;
4525
4526 GetTextExtentExPointW(hdc, string + index, range_start - index,
4527 INT_MAX, NULL, NULL, &range_size);
4528 range_rect.X = bounds->X + range_size.cx;
4529
4530 GetTextExtentExPointW(hdc, string + index, range_end - index,
4531 INT_MAX, NULL, NULL, &range_size);
4532 range_rect.Width = (bounds->X + range_size.cx) - range_rect.X;
4533
4534 stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
4535 if (stat != Ok)
4536 break;
4537 }
4538 }
4539
4540 return stat;
4541 }
4542
4543 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
4544 GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
4545 GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
4546 INT regionCount, GpRegion** regions)
4547 {
4548 GpStatus stat;
4549 int i;
4550 HFONT oldfont;
4551 struct measure_ranges_args args;
4552 HDC hdc, temp_hdc=NULL;
4553
4554 TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
4555 length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
4556
4557 if (!(graphics && string && font && layoutRect && stringFormat && regions))
4558 return InvalidParameter;
4559
4560 if (regionCount < stringFormat->range_count)
4561 return InvalidParameter;
4562
4563 if(!graphics->hdc)
4564 {
4565 hdc = temp_hdc = CreateCompatibleDC(0);
4566 if (!temp_hdc) return OutOfMemory;
4567 }
4568 else
4569 hdc = graphics->hdc;
4570
4571 if (stringFormat->attr)
4572 TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
4573
4574 oldfont = SelectObject(hdc, CreateFontIndirectW(&font->lfw));
4575
4576 for (i=0; i<stringFormat->range_count; i++)
4577 {
4578 stat = GdipSetEmpty(regions[i]);
4579 if (stat != Ok)
4580 return stat;
4581 }
4582
4583 args.regions = regions;
4584
4585 stat = gdip_format_string(hdc, string, length, font, layoutRect, stringFormat,
4586 measure_ranges_callback, &args);
4587
4588 DeleteObject(SelectObject(hdc, oldfont));
4589
4590 if (temp_hdc)
4591 DeleteDC(temp_hdc);
4592
4593 return stat;
4594 }
4595
4596 struct measure_string_args {
4597 RectF *bounds;
4598 INT *codepointsfitted;
4599 INT *linesfilled;
4600 };
4601
4602 static GpStatus measure_string_callback(HDC hdc,
4603 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4604 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4605 INT lineno, const RectF *bounds, void *user_data)
4606 {
4607 struct measure_string_args *args = user_data;
4608
4609 if (bounds->Width > args->bounds->Width)
4610 args->bounds->Width = bounds->Width;
4611
4612 if (bounds->Height + bounds->Y > args->bounds->Height + args->bounds->Y)
4613 args->bounds->Height = bounds->Height + bounds->Y - args->bounds->Y;
4614
4615 if (args->codepointsfitted)
4616 *args->codepointsfitted = index + length;
4617
4618 if (args->linesfilled)
4619 (*args->linesfilled)++;
4620
4621 return Ok;
4622 }
4623
4624 /* Find the smallest rectangle that bounds the text when it is printed in rect
4625 * according to the format options listed in format. If rect has 0 width and
4626 * height, then just find the smallest rectangle that bounds the text when it's
4627 * printed at location (rect->X, rect-Y). */
4628 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
4629 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4630 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
4631 INT *codepointsfitted, INT *linesfilled)
4632 {
4633 HFONT oldfont;
4634 struct measure_string_args args;
4635 HDC temp_hdc=NULL;
4636
4637 TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
4638 debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
4639 bounds, codepointsfitted, linesfilled);
4640
4641 if(!graphics || !string || !font || !rect || !bounds)
4642 return InvalidParameter;
4643
4644 if(!graphics->hdc)
4645 {
4646 temp_hdc = CreateCompatibleDC(0);
4647 if (!temp_hdc) return OutOfMemory;
4648 }
4649
4650 if(linesfilled) *linesfilled = 0;
4651 if(codepointsfitted) *codepointsfitted = 0;
4652
4653 if(format)
4654 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4655
4656 oldfont = SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
4657
4658 bounds->X = rect->X;
4659 bounds->Y = rect->Y;
4660 bounds->Width = 0.0;
4661 bounds->Height = 0.0;
4662
4663 args.bounds = bounds;
4664 args.codepointsfitted = codepointsfitted;
4665 args.linesfilled = linesfilled;
4666
4667 gdip_format_string(graphics->hdc ? graphics->hdc : temp_hdc, string, length, font, rect, format,
4668 measure_string_callback, &args);
4669
4670 DeleteObject(SelectObject(graphics->hdc, oldfont));
4671
4672 if (temp_hdc)
4673 DeleteDC(temp_hdc);
4674
4675 return Ok;
4676 }
4677
4678 struct draw_string_args {
4679 POINT drawbase;
4680 UINT drawflags;
4681 REAL ang_cos, ang_sin;
4682 };
4683
4684 static GpStatus draw_string_callback(HDC hdc,
4685 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4686 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4687 INT lineno, const RectF *bounds, void *user_data)
4688 {
4689 struct draw_string_args *args = user_data;
4690 RECT drawcoord;
4691
4692 drawcoord.left = drawcoord.right = args->drawbase.x + roundr(args->ang_sin * bounds->Y);
4693 drawcoord.top = drawcoord.bottom = args->drawbase.y + roundr(args->ang_cos * bounds->Y);
4694
4695 DrawTextW(hdc, string + index, length, &drawcoord, args->drawflags);
4696
4697 return Ok;
4698 }
4699
4700 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
4701 INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
4702 GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
4703 {
4704 HRGN rgn = NULL;
4705 HFONT gdifont;
4706 LOGFONTW lfw;
4707 TEXTMETRICW textmet;
4708 GpPointF pt[3], rectcpy[4];
4709 POINT corners[4];
4710 REAL angle, rel_width, rel_height;
4711 INT offsety = 0, save_state;
4712 struct draw_string_args args;
4713 RectF scaled_rect;
4714
4715 TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
4716 length, font, debugstr_rectf(rect), format, brush);
4717
4718 if(!graphics || !string || !font || !brush || !rect)
4719 return InvalidParameter;
4720
4721 if((brush->bt != BrushTypeSolidColor)){
4722 FIXME("not implemented for given parameters\n");
4723 return NotImplemented;
4724 }
4725
4726 if(!graphics->hdc)
4727 {
4728 FIXME("graphics object has no HDC\n");
4729 return Ok;
4730 }
4731
4732 if(format){
4733 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4734
4735 /* Should be no need to explicitly test for StringAlignmentNear as
4736 * that is default behavior if no alignment is passed. */
4737 if(format->vertalign != StringAlignmentNear){
4738 RectF bounds;
4739 GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
4740
4741 if(format->vertalign == StringAlignmentCenter)
4742 offsety = (rect->Height - bounds.Height) / 2;
4743 else if(format->vertalign == StringAlignmentFar)
4744 offsety = (rect->Height - bounds.Height);
4745 }
4746 }
4747
4748 save_state = SaveDC(graphics->hdc);
4749 SetBkMode(graphics->hdc, TRANSPARENT);
4750 SetTextColor(graphics->hdc, brush->lb.lbColor);
4751
4752 pt[0].X = 0.0;
4753 pt[0].Y = 0.0;
4754 pt[1].X = 1.0;
4755 pt[1].Y = 0.0;
4756 pt[2].X = 0.0;
4757 pt[2].Y = 1.0;
4758 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4759 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
4760 args.ang_cos = cos(angle);
4761 args.ang_sin = sin(angle);
4762 rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4763 (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4764 rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4765 (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4766
4767 rectcpy[3].X = rectcpy[0].X = rect->X;
4768 rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
4769 rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
4770 rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
4771 transform_and_round_points(graphics, corners, rectcpy, 4);
4772
4773 scaled_rect.X = 0.0;
4774 scaled_rect.Y = 0.0;
4775 scaled_rect.Width = rel_width * rect->Width;
4776 scaled_rect.Height = rel_height * rect->Height;
4777
4778 if (roundr(scaled_rect.Width) != 0 && roundr(scaled_rect.Height) != 0)
4779 {
4780 /* FIXME: If only the width or only the height is 0, we should probably still clip */
4781 rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
4782 SelectClipRgn(graphics->hdc, rgn);
4783 }
4784
4785 /* Use gdi to find the font, then perform transformations on it (height,
4786 * width, angle). */
4787 SelectObject(graphics->hdc, CreateFontIndirectW(&font->lfw));
4788 GetTextMetricsW(graphics->hdc, &textmet);
4789 lfw = font->lfw;
4790
4791 lfw.lfHeight = roundr(((REAL)lfw.lfHeight) * rel_height);
4792 lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width);
4793
4794 lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
4795
4796 gdifont = CreateFontIndirectW(&lfw);
4797 DeleteObject(SelectObject(graphics->hdc, gdifont));
4798
4799 if (!format || format->align == StringAlignmentNear)
4800 {
4801 args.drawbase.x = corners[0].x;
4802 args.drawbase.y = corners[0].y;
4803 args.drawflags = DT_NOCLIP | DT_EXPANDTABS;
4804 }
4805 else if (format->align == StringAlignmentCenter)
4806 {
4807 args.drawbase.x = (corners[0].x + corners[1].x)/2;
4808 args.drawbase.y = (corners[0].y + corners[1].y)/2;
4809 args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_CENTER;
4810 }
4811 else /* (format->align == StringAlignmentFar) */
4812 {
4813 args.drawbase.x = corners[1].x;
4814 args.drawbase.y = corners[1].y;
4815 args.drawflags = DT_NOCLIP | DT_EXPANDTABS | DT_RIGHT;
4816 }
4817
4818 gdip_format_string(graphics->hdc, string, length, font, &scaled_rect, format,
4819 draw_string_callback, &args);
4820
4821 DeleteObject(rgn);
4822 DeleteObject(gdifont);
4823
4824 RestoreDC(graphics->hdc, save_state);
4825
4826 return Ok;
4827 }
4828
4829 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
4830 {
4831 TRACE("(%p)\n", graphics);
4832
4833 if(!graphics)
4834 return InvalidParameter;
4835
4836 if(graphics->busy)
4837 return ObjectBusy;
4838
4839 return GdipSetInfinite(graphics->clip);
4840 }
4841
4842 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
4843 {
4844 TRACE("(%p)\n", graphics);
4845
4846 if(!graphics)
4847 return InvalidParameter;
4848
4849 if(graphics->busy)
4850 return ObjectBusy;
4851
4852 graphics->worldtrans->matrix[0] = 1.0;
4853 graphics->worldtrans->matrix[1] = 0.0;
4854 graphics->worldtrans->matrix[2] = 0.0;
4855 graphics->worldtrans->matrix[3] = 1.0;
4856 graphics->worldtrans->matrix[4] = 0.0;
4857 graphics->worldtrans->matrix[5] = 0.0;
4858
4859 return Ok;
4860 }
4861
4862 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
4863 {
4864 return GdipEndContainer(graphics, state);
4865 }
4866
4867 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
4868 GpMatrixOrder order)
4869 {
4870 TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
4871
4872 if(!graphics)
4873 return InvalidParameter;
4874
4875 if(graphics->busy)
4876 return ObjectBusy;
4877
4878 return GdipRotateMatrix(graphics->worldtrans, angle, order);
4879 }
4880
4881 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
4882 {
4883 return GdipBeginContainer2(graphics, state);
4884 }
4885
4886 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
4887 GraphicsContainer *state)
4888 {
4889 GraphicsContainerItem *container;
4890 GpStatus sts;
4891
4892 TRACE("(%p, %p)\n", graphics, state);
4893
4894 if(!graphics || !state)
4895 return InvalidParameter;
4896
4897 sts = init_container(&container, graphics);
4898 if(sts != Ok)
4899 return sts;
4900
4901 list_add_head(&graphics->containers, &container->entry);
4902 *state = graphics->contid = container->contid;
4903
4904 return Ok;
4905 }
4906
4907 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
4908 {
4909 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4910 return NotImplemented;
4911 }
4912
4913 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
4914 {
4915 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4916 return NotImplemented;
4917 }
4918
4919 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
4920 {
4921 FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
4922 return NotImplemented;
4923 }
4924
4925 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
4926 {
4927 GpStatus sts;
4928 GraphicsContainerItem *container, *container2;
4929
4930 TRACE("(%p, %x)\n", graphics, state);
4931
4932 if(!graphics)
4933 return InvalidParameter;
4934
4935 LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
4936 if(container->contid == state)
4937 break;
4938 }
4939
4940 /* did not find a matching container */
4941 if(&container->entry == &graphics->containers)
4942 return Ok;
4943
4944 sts = restore_container(graphics, container);
4945 if(sts != Ok)
4946 return sts;
4947
4948 /* remove all of the containers on top of the found container */
4949 LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
4950 if(container->contid == state)
4951 break;
4952 list_remove(&container->entry);
4953 delete_container(container);
4954 }
4955
4956 list_remove(&container->entry);
4957 delete_container(container);
4958
4959 return Ok;
4960 }
4961
4962 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
4963 REAL sy, GpMatrixOrder order)
4964 {
4965 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
4966
4967 if(!graphics)
4968 return InvalidParameter;
4969
4970 if(graphics->busy)
4971 return ObjectBusy;
4972
4973 return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
4974 }
4975
4976 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
4977 CombineMode mode)
4978 {
4979 TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
4980
4981 if(!graphics || !srcgraphics)
4982 return InvalidParameter;
4983
4984 return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
4985 }
4986
4987 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
4988 CompositingMode mode)
4989 {
4990 TRACE("(%p, %d)\n", graphics, mode);
4991
4992 if(!graphics)
4993 return InvalidParameter;
4994
4995 if(graphics->busy)
4996 return ObjectBusy;
4997
4998 graphics->compmode = mode;
4999
5000 return Ok;
5001 }
5002
5003 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
5004 CompositingQuality quality)
5005 {
5006 TRACE("(%p, %d)\n", graphics, quality);
5007
5008 if(!graphics)
5009 return InvalidParameter;
5010
5011 if(graphics->busy)
5012 return ObjectBusy;
5013
5014 graphics->compqual = quality;
5015
5016 return Ok;
5017 }
5018
5019 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
5020 InterpolationMode mode)
5021 {
5022 TRACE("(%p, %d)\n", graphics, mode);
5023
5024 if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
5025 return InvalidParameter;
5026
5027 if(graphics->busy)
5028 return ObjectBusy;
5029
5030 if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
5031 mode = InterpolationModeBilinear;
5032
5033 if (mode == InterpolationModeHighQuality)
5034 mode = InterpolationModeHighQualityBicubic;
5035
5036 graphics->interpolation = mode;
5037
5038 return Ok;
5039 }
5040
5041 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
5042 {
5043 TRACE("(%p, %.2f)\n", graphics, scale);
5044
5045 if(!graphics || (scale <= 0.0))
5046 return InvalidParameter;
5047
5048 if(graphics->busy)
5049 return ObjectBusy;
5050
5051 graphics->scale = scale;
5052
5053 return Ok;
5054 }
5055
5056 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
5057 {
5058 TRACE("(%p, %d)\n", graphics, unit);
5059
5060 if(!graphics)
5061 return InvalidParameter;
5062
5063 if(graphics->busy)
5064 return ObjectBusy;
5065
5066 if(unit == UnitWorld)
5067 return InvalidParameter;
5068
5069 graphics->unit = unit;
5070
5071 return Ok;
5072 }
5073
5074 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
5075 mode)
5076 {
5077 TRACE("(%p, %d)\n", graphics, mode);
5078
5079 if(!graphics)
5080 return InvalidParameter;
5081
5082 if(graphics->busy)
5083 return ObjectBusy;
5084
5085 graphics->pixeloffset = mode;
5086
5087 return Ok;
5088 }
5089
5090 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
5091 {
5092 static int calls;
5093
5094 TRACE("(%p,%i,%i)\n", graphics, x, y);
5095
5096 if (!(calls++))
5097 FIXME("not implemented\n");
5098
5099 return NotImplemented;
5100 }
5101
5102 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
5103 {
5104 static int calls;
5105
5106 TRACE("(%p,%p,%p)\n", graphics, x, y);
5107
5108 if (!(calls++))
5109 FIXME("not implemented\n");
5110
5111 *x = *y = 0;
5112
5113 return NotImplemented;
5114 }
5115
5116 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
5117 {
5118 TRACE("(%p, %d)\n", graphics, mode);
5119
5120 if(!graphics)
5121 return InvalidParameter;
5122
5123 if(graphics->busy)
5124 return ObjectBusy;
5125
5126 graphics->smoothing = mode;
5127
5128 return Ok;
5129 }
5130
5131 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
5132 {
5133 TRACE("(%p, %d)\n", graphics, contrast);
5134
5135 if(!graphics)
5136 return InvalidParameter;
5137
5138 graphics->textcontrast = contrast;
5139
5140 return Ok;
5141 }
5142
5143 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
5144 TextRenderingHint hint)
5145 {
5146 TRACE("(%p, %d)\n", graphics, hint);
5147
5148 if(!graphics)
5149 return InvalidParameter;
5150
5151 if(graphics->busy)
5152 return ObjectBusy;
5153
5154 graphics->texthint = hint;
5155
5156 return Ok;
5157 }
5158
5159 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
5160 {
5161 TRACE("(%p, %p)\n", graphics, matrix);
5162
5163 if(!graphics || !matrix)
5164 return InvalidParameter;
5165
5166 if(graphics->busy)
5167 return ObjectBusy;
5168
5169 GdipDeleteMatrix(graphics->worldtrans);
5170 return GdipCloneMatrix(matrix, &graphics->worldtrans);
5171 }
5172
5173 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
5174 REAL dy, GpMatrixOrder order)
5175 {
5176 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
5177
5178 if(!graphics)
5179 return InvalidParameter;
5180
5181 if(graphics->busy)
5182 return ObjectBusy;
5183
5184 return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
5185 }
5186
5187 /*****************************************************************************
5188 * GdipSetClipHrgn [GDIPLUS.@]
5189 */
5190 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
5191 {
5192 GpRegion *region;
5193 GpStatus status;
5194
5195 TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
5196
5197 if(!graphics)
5198 return InvalidParameter;
5199
5200 status = GdipCreateRegionHrgn(hrgn, &region);
5201 if(status != Ok)
5202 return status;
5203
5204 status = GdipSetClipRegion(graphics, region, mode);
5205
5206 GdipDeleteRegion(region);
5207 return status;
5208 }
5209
5210 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
5211 {
5212 TRACE("(%p, %p, %d)\n", graphics, path, mode);
5213
5214 if(!graphics)
5215 return InvalidParameter;
5216
5217 if(graphics->busy)
5218 return ObjectBusy;
5219
5220 return GdipCombineRegionPath(graphics->clip, path, mode);
5221 }
5222
5223 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
5224 REAL width, REAL height,
5225 CombineMode mode)
5226 {
5227 GpRectF rect;
5228
5229 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
5230
5231 if(!graphics)
5232 return InvalidParameter;
5233
5234 if(graphics->busy)
5235 return ObjectBusy;
5236
5237 rect.X = x;
5238 rect.Y = y;
5239 rect.Width = width;
5240 rect.Height = height;
5241
5242 return GdipCombineRegionRect(graphics->clip, &rect, mode);
5243 }
5244
5245 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
5246 INT width, INT height,
5247 CombineMode mode)
5248 {
5249 TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
5250
5251 if(!graphics)
5252 return InvalidParameter;
5253
5254 if(graphics->busy)
5255 return ObjectBusy;
5256
5257 return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
5258 }
5259
5260 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
5261 CombineMode mode)
5262 {
5263 TRACE("(%p, %p, %d)\n", graphics, region, mode);
5264
5265 if(!graphics || !region)
5266 return InvalidParameter;
5267
5268 if(graphics->busy)
5269 return ObjectBusy;
5270
5271 return GdipCombineRegionRegion(graphics->clip, region, mode);
5272 }
5273
5274 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
5275 UINT limitDpi)
5276 {
5277 static int calls;
5278
5279 TRACE("(%p,%u)\n", metafile, limitDpi);
5280
5281 if(!(calls++))
5282 FIXME("not implemented\n");
5283
5284 return NotImplemented;
5285 }
5286
5287 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
5288 INT count)
5289 {
5290 INT save_state;
5291 POINT *pti;
5292
5293 TRACE("(%p, %p, %d)\n", graphics, points, count);
5294
5295 if(!graphics || !pen || count<=0)
5296 return InvalidParameter;
5297
5298 if(graphics->busy)
5299 return ObjectBusy;
5300
5301 if (!graphics->hdc)
5302 {
5303 FIXME("graphics object has no HDC\n");
5304 return Ok;
5305 }
5306
5307 pti = GdipAlloc(sizeof(POINT) * count);
5308
5309 save_state = prepare_dc(graphics, pen);
5310 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
5311
5312 transform_and_round_points(graphics, pti, (GpPointF*)points, count);
5313 Polygon(graphics->hdc, pti, count);
5314
5315 restore_dc(graphics, save_state);
5316 GdipFree(pti);
5317
5318 return Ok;
5319 }
5320
5321 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
5322 INT count)
5323 {
5324 GpStatus ret;
5325 GpPointF *ptf;
5326 INT i;
5327
5328 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
5329
5330 if(count<=0) return InvalidParameter;
5331 ptf = GdipAlloc(sizeof(GpPointF) * count);
5332
5333 for(i = 0;i < count; i++){
5334 ptf[i].X = (REAL)points[i].X;
5335 ptf[i].Y = (REAL)points[i].Y;
5336 }
5337
5338 ret = GdipDrawPolygon(graphics,pen,ptf,count);
5339 GdipFree(ptf);
5340
5341 return ret;
5342 }
5343
5344 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
5345 {
5346 TRACE("(%p, %p)\n", graphics, dpi);
5347
5348 if(!graphics || !dpi)
5349 return InvalidParameter;
5350
5351 if(graphics->busy)
5352 return ObjectBusy;
5353
5354 if (graphics->image)
5355 *dpi = graphics->image->xres;
5356 else
5357 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
5358
5359 return Ok;
5360 }
5361
5362 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
5363 {
5364 TRACE("(%p, %p)\n", graphics, dpi);
5365
5366 if(!graphics || !dpi)
5367 return InvalidParameter;
5368
5369 if(graphics->busy)
5370 return ObjectBusy;
5371
5372 if (graphics->image)
5373 *dpi = graphics->image->yres;
5374 else
5375 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
5376
5377 return Ok;
5378 }
5379
5380 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
5381 GpMatrixOrder order)
5382 {
5383 GpMatrix m;
5384 GpStatus ret;
5385
5386 TRACE("(%p, %p, %d)\n", graphics, matrix, order);
5387
5388 if(!graphics || !matrix)
5389 return InvalidParameter;
5390
5391 if(graphics->busy)
5392 return ObjectBusy;
5393
5394 m = *(graphics->worldtrans);
5395
5396 ret = GdipMultiplyMatrix(&m, matrix, order);
5397 if(ret == Ok)
5398 *(graphics->worldtrans) = m;
5399
5400 return ret;
5401 }
5402
5403 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
5404 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
5405
5406 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
5407 {
5408 TRACE("(%p, %p)\n", graphics, hdc);
5409
5410 if(!graphics || !hdc)
5411 return InvalidParameter;
5412
5413 if(graphics->busy)
5414 return ObjectBusy;
5415
5416 if (!graphics->hdc ||
5417 (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
5418 {
5419 /* Create a fake HDC and fill it with a constant color. */
5420 HDC temp_hdc;
5421 HBITMAP hbitmap;
5422 GpStatus stat;
5423 GpRectF bounds;
5424 BITMAPINFOHEADER bmih;
5425 int i;
5426
5427 stat = get_graphics_bounds(graphics, &bounds);
5428 if (stat != Ok)
5429 return stat;
5430
5431 graphics->temp_hbitmap_width = bounds.Width;
5432 graphics->temp_hbitmap_height = bounds.Height;
5433
5434 bmih.biSize = sizeof(bmih);
5435 bmih.biWidth = graphics->temp_hbitmap_width;
5436 bmih.biHeight = -graphics->temp_hbitmap_height;
5437 bmih.biPlanes = 1;
5438 bmih.biBitCount = 32;
5439 bmih.biCompression = BI_RGB;
5440 bmih.biSizeImage = 0;
5441 bmih.biXPelsPerMeter = 0;
5442 bmih.biYPelsPerMeter = 0;
5443 bmih.biClrUsed = 0;
5444 bmih.biClrImportant = 0;
5445
5446 hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
5447 (void**)&graphics->temp_bits, NULL, 0);
5448 if (!hbitmap)
5449 return GenericError;
5450
5451 temp_hdc = CreateCompatibleDC(0);
5452 if (!temp_hdc)
5453 {
5454 DeleteObject(hbitmap);
5455 return GenericError;
5456 }
5457
5458 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5459 ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
5460
5461 SelectObject(temp_hdc, hbitmap);
5462
5463 graphics->temp_hbitmap = hbitmap;
5464 *hdc = graphics->temp_hdc = temp_hdc;
5465 }
5466 else
5467 {
5468 *hdc = graphics->hdc;
5469 }
5470
5471 graphics->busy = TRUE;
5472
5473 return Ok;
5474 }
5475
5476 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
5477 {
5478 TRACE("(%p, %p)\n", graphics, hdc);
5479
5480 if(!graphics || !hdc)
5481 return InvalidParameter;
5482
5483 if((graphics->hdc != hdc && graphics->temp_hdc != hdc) || !(graphics->busy))
5484 return InvalidParameter;
5485
5486 if (graphics->temp_hdc == hdc)
5487 {
5488 DWORD* pos;
5489 int i;
5490
5491 /* Find the pixels that have changed, and mark them as opaque. */
5492 pos = (DWORD*)graphics->temp_bits;
5493 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5494 {
5495 if (*pos != DC_BACKGROUND_KEY)
5496 {
5497 *pos |= 0xff000000;
5498 }
5499 pos++;
5500 }
5501
5502 /* Write the changed pixels to the real target. */
5503 alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
5504 graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
5505 graphics->temp_hbitmap_width * 4);
5506
5507 /* Clean up. */
5508 DeleteDC(graphics->temp_hdc);
5509 DeleteObject(graphics->temp_hbitmap);
5510 graphics->temp_hdc = NULL;
5511 graphics->temp_hbitmap = NULL;
5512 }
5513
5514 graphics->busy = FALSE;
5515
5516 return Ok;
5517 }
5518
5519 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
5520 {
5521 GpRegion *clip;
5522 GpStatus status;
5523
5524 TRACE("(%p, %p)\n", graphics, region);
5525
5526 if(!graphics || !region)
5527 return InvalidParameter;
5528
5529 if(graphics->busy)
5530 return ObjectBusy;
5531
5532 if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
5533 return status;
5534
5535 /* free everything except root node and header */
5536 delete_element(&region->node);
5537 memcpy(region, clip, sizeof(GpRegion));
5538 GdipFree(clip);
5539
5540 return Ok;
5541 }
5542
5543 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
5544 GpCoordinateSpace src_space, GpMatrix **matrix)
5545 {
5546 GpStatus stat = GdipCreateMatrix(matrix);
5547 REAL unitscale;
5548
5549 if (dst_space != src_space && stat == Ok)
5550 {
5551 unitscale = convert_unit(graphics_res(graphics), graphics->unit);
5552
5553 if(graphics->unit != UnitDisplay)
5554 unitscale *= graphics->scale;
5555
5556 /* transform from src_space to CoordinateSpacePage */
5557 switch (src_space)
5558 {
5559 case CoordinateSpaceWorld:
5560 GdipMultiplyMatrix(*matrix, graphics->worldtrans, MatrixOrderAppend);
5561 break;
5562 case CoordinateSpacePage:
5563 break;
5564 case CoordinateSpaceDevice:
5565 GdipScaleMatrix(*matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
5566 break;
5567 }
5568
5569 /* transform from CoordinateSpacePage to dst_space */
5570 switch (dst_space)
5571 {
5572 case CoordinateSpaceWorld:
5573 {
5574 GpMatrix *inverted_transform;
5575 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
5576 if (stat == Ok)
5577 {
5578 stat = GdipInvertMatrix(inverted_transform);
5579 if (stat == Ok)
5580 GdipMultiplyMatrix(*matrix, inverted_transform, MatrixOrderAppend);
5581 GdipDeleteMatrix(inverted_transform);
5582 }
5583 break;
5584 }
5585 case CoordinateSpacePage:
5586 break;
5587 case CoordinateSpaceDevice:
5588 GdipScaleMatrix(*matrix, unitscale, unitscale, MatrixOrderAppend);
5589 break;
5590 }
5591 }
5592 return stat;
5593 }
5594
5595 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
5596 GpCoordinateSpace src_space, GpPointF *points, INT count)
5597 {
5598 GpMatrix *matrix;
5599 GpStatus stat;
5600
5601 if(!graphics || !points || count <= 0)
5602 return InvalidParameter;
5603
5604 if(graphics->busy)
5605 return ObjectBusy;
5606
5607 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5608
5609 if (src_space == dst_space) return Ok;
5610
5611 stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
5612
5613 if (stat == Ok)
5614 {
5615 stat = GdipTransformMatrixPoints(matrix, points, count);
5616
5617 GdipDeleteMatrix(matrix);
5618 }
5619
5620 return stat;
5621 }
5622
5623 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
5624 GpCoordinateSpace src_space, GpPoint *points, INT count)
5625 {
5626 GpPointF *pointsF;
5627 GpStatus ret;
5628 INT i;
5629
5630 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5631
5632 if(count <= 0)
5633 return InvalidParameter;
5634
5635 pointsF = GdipAlloc(sizeof(GpPointF) * count);
5636 if(!pointsF)
5637 return OutOfMemory;
5638
5639 for(i = 0; i < count; i++){
5640 pointsF[i].X = (REAL)points[i].X;
5641 pointsF[i].Y = (REAL)points[i].Y;
5642 }
5643
5644 ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
5645
5646 if(ret == Ok)
5647 for(i = 0; i < count; i++){
5648 points[i].X = roundr(pointsF[i].X);
5649 points[i].Y = roundr(pointsF[i].Y);
5650 }
5651 GdipFree(pointsF);
5652
5653 return ret;
5654 }
5655
5656 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
5657 {
5658 static int calls;
5659
5660 TRACE("\n");
5661
5662 if (!calls++)
5663 FIXME("stub\n");
5664
5665 return NULL;
5666 }
5667
5668 /*****************************************************************************
5669 * GdipTranslateClip [GDIPLUS.@]
5670 */
5671 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
5672 {
5673 TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
5674
5675 if(!graphics)
5676 return InvalidParameter;
5677
5678 if(graphics->busy)
5679 return ObjectBusy;
5680
5681 return GdipTranslateRegion(graphics->clip, dx, dy);
5682 }
5683
5684 /*****************************************************************************
5685 * GdipTranslateClipI [GDIPLUS.@]
5686 */
5687 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
5688 {
5689 TRACE("(%p, %d, %d)\n", graphics, dx, dy);
5690
5691 if(!graphics)
5692 return InvalidParameter;
5693
5694 if(graphics->busy)
5695 return ObjectBusy;
5696
5697 return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
5698 }
5699
5700
5701 /*****************************************************************************
5702 * GdipMeasureDriverString [GDIPLUS.@]
5703 */
5704 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5705 GDIPCONST GpFont *font, GDIPCONST PointF *positions,
5706 INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
5707 {
5708 FIXME("(%p %p %d %p %p %d %p %p): stub\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
5709 return NotImplemented;
5710 }
5711
5712 /*****************************************************************************
5713 * GdipDrawDriverString [GDIPLUS.@]
5714 */
5715 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5716 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
5717 GDIPCONST PointF *positions, INT flags,
5718 GDIPCONST GpMatrix *matrix )
5719 {
5720 FIXME("(%p %p %d %p %p %p %d %p): stub\n", graphics, text, length, font, brush, positions, flags, matrix);
5721 return NotImplemented;
5722 }
5723
5724 GpStatus WINGDIPAPI GdipRecordMetafile(HDC hdc, EmfType type, GDIPCONST GpRectF *frameRect,
5725 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5726 {
5727 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
5728 return NotImplemented;
5729 }
5730
5731 /*****************************************************************************
5732 * GdipRecordMetafileI [GDIPLUS.@]
5733 */
5734 GpStatus WINGDIPAPI GdipRecordMetafileI(HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
5735 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5736 {
5737 FIXME("(%p %d %p %d %p %p): stub\n", hdc, type, frameRect, frameUnit, desc, metafile);
5738 return NotImplemented;
5739 }
5740
5741 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
5742 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
5743 {
5744 FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
5745 return NotImplemented;
5746 }
5747
5748 /*****************************************************************************
5749 * GdipIsVisibleClipEmpty [GDIPLUS.@]
5750 */
5751 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
5752 {
5753 GpStatus stat;
5754 GpRegion* rgn;
5755
5756 TRACE("(%p, %p)\n", graphics, res);
5757
5758 if((stat = GdipCreateRegion(&rgn)) != Ok)
5759 return stat;
5760
5761 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
5762 goto cleanup;
5763
5764 stat = GdipIsEmptyRegion(rgn, graphics, res);
5765
5766 cleanup:
5767 GdipDeleteRegion(rgn);
5768 return stat;
5769 }
5770
5771 GpStatus WINGDIPAPI GdipGetHemfFromMetafile(GpMetafile *metafile, HENHMETAFILE *hEmf)
5772 {
5773 FIXME("(%p,%p): stub\n", metafile, hEmf);
5774
5775 if (!metafile || !hEmf)
5776 return InvalidParameter;
5777
5778 *hEmf = NULL;
5779
5780 return NotImplemented;
5781 }
Windows API implementation