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