2 * Copyright (C) 2007 Google (Evan Stade)
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
27 #include "wine/unicode.h"
39 #include "gdiplus_private.h"
40 #include "wine/debug.h"
41 #include "wine/list.h"
43 WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
45 /* looks-right constants */
46 #define ANCHOR_WIDTH (2.0)
47 #define MAX_ITERS (50)
49 /* Converts angle (in degrees) to x/y coordinates */
50 static void deg2xy(REAL angle, REAL x_0, REAL y_0, REAL *x, REAL *y)
52 REAL radAngle, hypotenuse;
54 radAngle = deg2rad(angle);
55 hypotenuse = 50.0; /* arbitrary */
57 *x = x_0 + cos(radAngle) * hypotenuse;
58 *y = y_0 + sin(radAngle) * hypotenuse;
61 /* Converts from gdiplus path point type to gdi path point type. */
62 static BYTE convert_path_point_type(BYTE type)
66 switch(type & PathPointTypePathTypeMask){
67 case PathPointTypeBezier:
70 case PathPointTypeLine:
73 case PathPointTypeStart:
77 ERR("Bad point type\n");
81 if(type & PathPointTypeCloseSubpath)
82 ret |= PT_CLOSEFIGURE;
87 static REAL graphics_res(GpGraphics *graphics)
89 if (graphics->image) return graphics->image->xres;
90 else return (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
93 static INT prepare_dc(GpGraphics *graphics, GpPen *pen)
97 INT save_state, i, numdashes;
99 DWORD dash_array[MAX_DASHLEN];
101 save_state = SaveDC(graphics->hdc);
103 EndPath(graphics->hdc);
105 if(pen->unit == UnitPixel){
109 /* Get an estimate for the amount the pen width is affected by the world
110 * transform. (This is similar to what some of the wine drivers do.) */
115 GdipTransformMatrixPoints(graphics->worldtrans, pt, 2);
116 width = sqrt((pt[1].X - pt[0].X) * (pt[1].X - pt[0].X) +
117 (pt[1].Y - pt[0].Y) * (pt[1].Y - pt[0].Y)) / sqrt(2.0);
119 width *= pen->width * convert_unit(graphics_res(graphics),
120 pen->unit == UnitWorld ? graphics->unit : pen->unit);
123 if(pen->dash == DashStyleCustom){
124 numdashes = min(pen->numdashes, MAX_DASHLEN);
126 TRACE("dashes are: ");
127 for(i = 0; i < numdashes; i++){
128 dash_array[i] = roundr(width * pen->dashes[i]);
129 TRACE("%d, ", dash_array[i]);
131 TRACE("\n and the pen style is %x\n", pen->style);
133 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb,
134 numdashes, dash_array);
137 gdipen = ExtCreatePen(pen->style, roundr(width), &pen->brush->lb, 0, NULL);
139 SelectObject(graphics->hdc, gdipen);
144 static void restore_dc(GpGraphics *graphics, INT state)
146 DeleteObject(SelectObject(graphics->hdc, GetStockObject(NULL_PEN)));
147 RestoreDC(graphics->hdc, state);
150 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
151 GpCoordinateSpace src_space, GpMatrix **matrix);
153 /* This helper applies all the changes that the points listed in ptf need in
154 * order to be drawn on the device context. In the end, this should include at
156 * -scaling by page unit
157 * -applying world transformation
158 * -converting from float to int
159 * Native gdiplus uses gdi32 to do all this (via SetMapMode, SetViewportExtEx,
160 * SetWindowExtEx, SetWorldTransform, etc.) but we cannot because we are using
161 * gdi to draw, and these functions would irreparably mess with line widths.
163 static void transform_and_round_points(GpGraphics *graphics, POINT *pti,
164 GpPointF *ptf, INT count)
170 unitscale = convert_unit(graphics_res(graphics), graphics->unit);
172 /* apply page scale */
173 if(graphics->unit != UnitDisplay)
174 unitscale *= graphics->scale;
176 GdipCloneMatrix(graphics->worldtrans, &matrix);
177 GdipScaleMatrix(matrix, unitscale, unitscale, MatrixOrderAppend);
178 GdipTransformMatrixPoints(matrix, ptf, count);
179 GdipDeleteMatrix(matrix);
181 for(i = 0; i < count; i++){
182 pti[i].x = roundr(ptf[i].X);
183 pti[i].y = roundr(ptf[i].Y);
187 /* Draw non-premultiplied ARGB data to the given graphics object */
188 static GpStatus alpha_blend_pixels(GpGraphics *graphics, INT dst_x, INT dst_y,
189 const BYTE *src, INT src_width, INT src_height, INT src_stride)
191 if (graphics->image && graphics->image->type == ImageTypeBitmap)
193 GpBitmap *dst_bitmap = (GpBitmap*)graphics->image;
196 for (x=0; x<src_width; x++)
198 for (y=0; y<src_height; y++)
200 ARGB dst_color, src_color;
201 GdipBitmapGetPixel(dst_bitmap, x+dst_x, y+dst_y, &dst_color);
202 src_color = ((ARGB*)(src + src_stride * y))[x];
203 GdipBitmapSetPixel(dst_bitmap, x+dst_x, y+dst_y, color_over(dst_color, src_color));
209 else if (graphics->image && graphics->image->type == ImageTypeMetafile)
211 ERR("This should not be used for metafiles; fix caller\n");
212 return NotImplemented;
217 HBITMAP hbitmap, old_hbm=NULL;
218 BITMAPINFOHEADER bih;
222 hdc = CreateCompatibleDC(0);
224 bih.biSize = sizeof(BITMAPINFOHEADER);
225 bih.biWidth = src_width;
226 bih.biHeight = -src_height;
229 bih.biCompression = BI_RGB;
231 bih.biXPelsPerMeter = 0;
232 bih.biYPelsPerMeter = 0;
234 bih.biClrImportant = 0;
236 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
237 (void**)&temp_bits, NULL, 0);
239 convert_32bppARGB_to_32bppPARGB(src_width, src_height, temp_bits,
240 4 * src_width, src, src_stride);
242 old_hbm = SelectObject(hdc, hbitmap);
244 bf.BlendOp = AC_SRC_OVER;
246 bf.SourceConstantAlpha = 255;
247 bf.AlphaFormat = AC_SRC_ALPHA;
249 GdiAlphaBlend(graphics->hdc, dst_x, dst_y, src_width, src_height,
250 hdc, 0, 0, src_width, src_height, bf);
252 SelectObject(hdc, old_hbm);
254 DeleteObject(hbitmap);
260 static ARGB blend_colors(ARGB start, ARGB end, REAL position)
266 a1 = (start >> 24) & 0xff;
267 a2 = (end >> 24) & 0xff;
269 a3 = (int)(a1*(1.0f - position)+a2*(position));
273 for (i=0xff; i<=0xff0000; i = i << 8)
274 result |= (int)((start&i)*(1.0f - position)+(end&i)*(position))&i;
278 static ARGB blend_line_gradient(GpLineGradient* brush, REAL position)
282 /* clamp to between 0.0 and 1.0, using the wrap mode */
283 if (brush->wrap == WrapModeTile)
285 position = fmodf(position, 1.0f);
286 if (position < 0.0f) position += 1.0f;
288 else /* WrapModeFlip* */
290 position = fmodf(position, 2.0f);
291 if (position < 0.0f) position += 2.0f;
292 if (position > 1.0f) position = 2.0f - position;
295 if (brush->blendcount == 1)
300 REAL left_blendpos, left_blendfac, right_blendpos, right_blendfac;
303 /* locate the blend positions surrounding this position */
304 while (position > brush->blendpos[i])
307 /* interpolate between the blend positions */
308 left_blendpos = brush->blendpos[i-1];
309 left_blendfac = brush->blendfac[i-1];
310 right_blendpos = brush->blendpos[i];
311 right_blendfac = brush->blendfac[i];
312 range = right_blendpos - left_blendpos;
313 blendfac = (left_blendfac * (right_blendpos - position) +
314 right_blendfac * (position - left_blendpos)) / range;
317 if (brush->pblendcount == 0)
318 return blend_colors(brush->startcolor, brush->endcolor, blendfac);
322 ARGB left_blendcolor, right_blendcolor;
323 REAL left_blendpos, right_blendpos;
325 /* locate the blend colors surrounding this position */
326 while (blendfac > brush->pblendpos[i])
329 /* interpolate between the blend colors */
330 left_blendpos = brush->pblendpos[i-1];
331 left_blendcolor = brush->pblendcolor[i-1];
332 right_blendpos = brush->pblendpos[i];
333 right_blendcolor = brush->pblendcolor[i];
334 blendfac = (blendfac - left_blendpos) / (right_blendpos - left_blendpos);
335 return blend_colors(left_blendcolor, right_blendcolor, blendfac);
339 static ARGB transform_color(ARGB color, const ColorMatrix *matrix)
343 unsigned char a, r, g, b;
345 val[0] = ((color >> 16) & 0xff) / 255.0; /* red */
346 val[1] = ((color >> 8) & 0xff) / 255.0; /* green */
347 val[2] = (color & 0xff) / 255.0; /* blue */
348 val[3] = ((color >> 24) & 0xff) / 255.0; /* alpha */
349 val[4] = 1.0; /* translation */
356 res[i] += matrix->m[j][i] * val[j];
359 a = min(max(floorf(res[3]*255.0), 0.0), 255.0);
360 r = min(max(floorf(res[0]*255.0), 0.0), 255.0);
361 g = min(max(floorf(res[1]*255.0), 0.0), 255.0);
362 b = min(max(floorf(res[2]*255.0), 0.0), 255.0);
364 return (a << 24) | (r << 16) | (g << 8) | b;
367 static int color_is_gray(ARGB color)
369 unsigned char r, g, b;
371 r = (color >> 16) & 0xff;
372 g = (color >> 8) & 0xff;
375 return (r == g) && (g == b);
378 static void apply_image_attributes(const GpImageAttributes *attributes, LPBYTE data,
379 UINT width, UINT height, INT stride, ColorAdjustType type)
383 if (attributes->colorkeys[type].enabled ||
384 attributes->colorkeys[ColorAdjustTypeDefault].enabled)
386 const struct color_key *key;
387 BYTE min_blue, min_green, min_red;
388 BYTE max_blue, max_green, max_red;
390 if (attributes->colorkeys[type].enabled)
391 key = &attributes->colorkeys[type];
393 key = &attributes->colorkeys[ColorAdjustTypeDefault];
395 min_blue = key->low&0xff;
396 min_green = (key->low>>8)&0xff;
397 min_red = (key->low>>16)&0xff;
399 max_blue = key->high&0xff;
400 max_green = (key->high>>8)&0xff;
401 max_red = (key->high>>16)&0xff;
403 for (x=0; x<width; x++)
404 for (y=0; y<height; y++)
407 BYTE blue, green, red;
408 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
409 blue = *src_color&0xff;
410 green = (*src_color>>8)&0xff;
411 red = (*src_color>>16)&0xff;
412 if (blue >= min_blue && green >= min_green && red >= min_red &&
413 blue <= max_blue && green <= max_green && red <= max_red)
414 *src_color = 0x00000000;
418 if (attributes->colorremaptables[type].enabled ||
419 attributes->colorremaptables[ColorAdjustTypeDefault].enabled)
421 const struct color_remap_table *table;
423 if (attributes->colorremaptables[type].enabled)
424 table = &attributes->colorremaptables[type];
426 table = &attributes->colorremaptables[ColorAdjustTypeDefault];
428 for (x=0; x<width; x++)
429 for (y=0; y<height; y++)
432 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
433 for (i=0; i<table->mapsize; i++)
435 if (*src_color == table->colormap[i].oldColor.Argb)
437 *src_color = table->colormap[i].newColor.Argb;
444 if (attributes->colormatrices[type].enabled ||
445 attributes->colormatrices[ColorAdjustTypeDefault].enabled)
447 const struct color_matrix *colormatrices;
449 if (attributes->colormatrices[type].enabled)
450 colormatrices = &attributes->colormatrices[type];
452 colormatrices = &attributes->colormatrices[ColorAdjustTypeDefault];
454 for (x=0; x<width; x++)
455 for (y=0; y<height; y++)
458 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
460 if (colormatrices->flags == ColorMatrixFlagsDefault ||
461 !color_is_gray(*src_color))
463 *src_color = transform_color(*src_color, &colormatrices->colormatrix);
465 else if (colormatrices->flags == ColorMatrixFlagsAltGray)
467 *src_color = transform_color(*src_color, &colormatrices->graymatrix);
472 if (attributes->gamma_enabled[type] ||
473 attributes->gamma_enabled[ColorAdjustTypeDefault])
477 if (attributes->gamma_enabled[type])
478 gamma = attributes->gamma[type];
480 gamma = attributes->gamma[ColorAdjustTypeDefault];
482 for (x=0; x<width; x++)
483 for (y=0; y<height; y++)
486 BYTE blue, green, red;
487 src_color = (ARGB*)(data + stride * y + sizeof(ARGB) * x);
489 blue = *src_color&0xff;
490 green = (*src_color>>8)&0xff;
491 red = (*src_color>>16)&0xff;
493 /* FIXME: We should probably use a table for this. */
494 blue = floorf(powf(blue / 255.0, gamma) * 255.0);
495 green = floorf(powf(green / 255.0, gamma) * 255.0);
496 red = floorf(powf(red / 255.0, gamma) * 255.0);
498 *src_color = (*src_color & 0xff000000) | (red << 16) | (green << 8) | blue;
503 /* Given a bitmap and its source rectangle, find the smallest rectangle in the
504 * bitmap that contains all the pixels we may need to draw it. */
505 static void get_bitmap_sample_size(InterpolationMode interpolation, WrapMode wrap,
506 GpBitmap* bitmap, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
509 INT left, top, right, bottom;
511 switch (interpolation)
513 case InterpolationModeHighQualityBilinear:
514 case InterpolationModeHighQualityBicubic:
515 /* FIXME: Include a greater range for the prefilter? */
516 case InterpolationModeBicubic:
517 case InterpolationModeBilinear:
518 left = (INT)(floorf(srcx));
519 top = (INT)(floorf(srcy));
520 right = (INT)(ceilf(srcx+srcwidth));
521 bottom = (INT)(ceilf(srcy+srcheight));
523 case InterpolationModeNearestNeighbor:
527 right = roundr(srcx+srcwidth);
528 bottom = roundr(srcy+srcheight);
532 if (wrap == WrapModeClamp)
538 if (right >= bitmap->width)
539 right = bitmap->width-1;
540 if (bottom >= bitmap->height)
541 bottom = bitmap->height-1;
545 /* In some cases we can make the rectangle smaller here, but the logic
546 * is hard to get right, and tiling suggests we're likely to use the
547 * entire source image. */
548 if (left < 0 || right >= bitmap->width)
551 right = bitmap->width-1;
554 if (top < 0 || bottom >= bitmap->height)
557 bottom = bitmap->height-1;
563 rect->Width = right - left + 1;
564 rect->Height = bottom - top + 1;
567 static ARGB sample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
568 UINT height, INT x, INT y, GDIPCONST GpImageAttributes *attributes)
570 if (attributes->wrap == WrapModeClamp)
572 if (x < 0 || y < 0 || x >= width || y >= height)
573 return attributes->outside_color;
577 /* Tiling. Make sure co-ordinates are positive as it simplifies the math. */
579 x = width*2 + x % (width * 2);
581 y = height*2 + y % (height * 2);
583 if ((attributes->wrap & 1) == 1)
586 if ((x / width) % 2 == 0)
589 x = width - 1 - x % width;
594 if ((attributes->wrap & 2) == 2)
597 if ((y / height) % 2 == 0)
600 y = height - 1 - y % height;
606 if (x < src_rect->X || y < src_rect->Y || x >= src_rect->X + src_rect->Width || y >= src_rect->Y + src_rect->Height)
608 ERR("out of range pixel requested\n");
612 return ((DWORD*)(bits))[(x - src_rect->X) + (y - src_rect->Y) * src_rect->Width];
615 static ARGB resample_bitmap_pixel(GDIPCONST GpRect *src_rect, LPBYTE bits, UINT width,
616 UINT height, GpPointF *point, GDIPCONST GpImageAttributes *attributes,
617 InterpolationMode interpolation)
621 switch (interpolation)
625 FIXME("Unimplemented interpolation %i\n", interpolation);
627 case InterpolationModeBilinear:
630 INT leftx, rightx, topy, bottomy;
631 ARGB topleft, topright, bottomleft, bottomright;
635 leftxf = floorf(point->X);
637 rightx = (INT)ceilf(point->X);
638 topyf = floorf(point->Y);
640 bottomy = (INT)ceilf(point->Y);
642 if (leftx == rightx && topy == bottomy)
643 return sample_bitmap_pixel(src_rect, bits, width, height,
644 leftx, topy, attributes);
646 topleft = sample_bitmap_pixel(src_rect, bits, width, height,
647 leftx, topy, attributes);
648 topright = sample_bitmap_pixel(src_rect, bits, width, height,
649 rightx, topy, attributes);
650 bottomleft = sample_bitmap_pixel(src_rect, bits, width, height,
651 leftx, bottomy, attributes);
652 bottomright = sample_bitmap_pixel(src_rect, bits, width, height,
653 rightx, bottomy, attributes);
655 x_offset = point->X - leftxf;
656 top = blend_colors(topleft, topright, x_offset);
657 bottom = blend_colors(bottomleft, bottomright, x_offset);
659 return blend_colors(top, bottom, point->Y - topyf);
661 case InterpolationModeNearestNeighbor:
662 return sample_bitmap_pixel(src_rect, bits, width, height,
663 roundr(point->X), roundr(point->Y), attributes);
667 static INT brush_can_fill_path(GpBrush *brush)
671 case BrushTypeSolidColor:
673 case BrushTypeHatchFill:
675 GpHatch *hatch = (GpHatch*)brush;
676 return ((hatch->forecol & 0xff000000) == 0xff000000) &&
677 ((hatch->backcol & 0xff000000) == 0xff000000);
679 case BrushTypeLinearGradient:
680 case BrushTypeTextureFill:
681 /* Gdi32 isn't much help with these, so we should use brush_fill_pixels instead. */
687 static void brush_fill_path(GpGraphics *graphics, GpBrush* brush)
691 case BrushTypeSolidColor:
693 GpSolidFill *fill = (GpSolidFill*)brush;
697 /* partially transparent fill */
699 SelectClipPath(graphics->hdc, RGN_AND);
700 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
702 HDC hdc = CreateCompatibleDC(NULL);
708 oldbmp = SelectObject(hdc, fill->bmp);
710 bf.BlendOp = AC_SRC_OVER;
712 bf.SourceConstantAlpha = 255;
713 bf.AlphaFormat = AC_SRC_ALPHA;
715 GdiAlphaBlend(graphics->hdc, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, hdc, 0, 0, 1, 1, bf);
717 SelectObject(hdc, oldbmp);
723 /* else fall through */
726 SelectObject(graphics->hdc, brush->gdibrush);
727 FillPath(graphics->hdc);
732 static INT brush_can_fill_pixels(GpBrush *brush)
736 case BrushTypeSolidColor:
737 case BrushTypeHatchFill:
738 case BrushTypeLinearGradient:
739 case BrushTypeTextureFill:
746 static GpStatus brush_fill_pixels(GpGraphics *graphics, GpBrush *brush,
747 DWORD *argb_pixels, GpRect *fill_area, UINT cdwStride)
751 case BrushTypeSolidColor:
754 GpSolidFill *fill = (GpSolidFill*)brush;
755 for (x=0; x<fill_area->Width; x++)
756 for (y=0; y<fill_area->Height; y++)
757 argb_pixels[x + y*cdwStride] = fill->color;
760 case BrushTypeHatchFill:
763 GpHatch *fill = (GpHatch*)brush;
764 const char *hatch_data;
766 if (get_hatch_data(fill->hatchstyle, &hatch_data) != Ok)
767 return NotImplemented;
769 for (x=0; x<fill_area->Width; x++)
770 for (y=0; y<fill_area->Height; y++)
774 /* FIXME: Account for the rendering origin */
775 hx = (x + fill_area->X) % 8;
776 hy = (y + fill_area->Y) % 8;
778 if ((hatch_data[7-hy] & (0x80 >> hx)) != 0)
779 argb_pixels[x + y*cdwStride] = fill->forecol;
781 argb_pixels[x + y*cdwStride] = fill->backcol;
786 case BrushTypeLinearGradient:
788 GpLineGradient *fill = (GpLineGradient*)brush;
789 GpPointF draw_points[3], line_points[3];
791 static const GpRectF box_1 = { 0.0, 0.0, 1.0, 1.0 };
792 GpMatrix *world_to_gradient; /* FIXME: Store this in the brush? */
795 draw_points[0].X = fill_area->X;
796 draw_points[0].Y = fill_area->Y;
797 draw_points[1].X = fill_area->X+1;
798 draw_points[1].Y = fill_area->Y;
799 draw_points[2].X = fill_area->X;
800 draw_points[2].Y = fill_area->Y+1;
802 /* Transform the points to a co-ordinate space where X is the point's
803 * position in the gradient, 0.0 being the start point and 1.0 the
805 stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
806 CoordinateSpaceDevice, draw_points, 3);
810 line_points[0] = fill->startpoint;
811 line_points[1] = fill->endpoint;
812 line_points[2].X = fill->startpoint.X + (fill->startpoint.Y - fill->endpoint.Y);
813 line_points[2].Y = fill->startpoint.Y + (fill->endpoint.X - fill->startpoint.X);
815 stat = GdipCreateMatrix3(&box_1, line_points, &world_to_gradient);
820 stat = GdipInvertMatrix(world_to_gradient);
823 stat = GdipTransformMatrixPoints(world_to_gradient, draw_points, 3);
825 GdipDeleteMatrix(world_to_gradient);
830 REAL x_delta = draw_points[1].X - draw_points[0].X;
831 REAL y_delta = draw_points[2].X - draw_points[0].X;
833 for (y=0; y<fill_area->Height; y++)
835 for (x=0; x<fill_area->Width; x++)
837 REAL pos = draw_points[0].X + x * x_delta + y * y_delta;
839 argb_pixels[x + y*cdwStride] = blend_line_gradient(fill, pos);
846 case BrushTypeTextureFill:
848 GpTexture *fill = (GpTexture*)brush;
849 GpPointF draw_points[3];
851 GpMatrix *world_to_texture;
857 if (fill->image->type != ImageTypeBitmap)
859 FIXME("metafile texture brushes not implemented\n");
860 return NotImplemented;
863 bitmap = (GpBitmap*)fill->image;
864 src_stride = sizeof(ARGB) * bitmap->width;
866 src_area.X = src_area.Y = 0;
867 src_area.Width = bitmap->width;
868 src_area.Height = bitmap->height;
870 draw_points[0].X = fill_area->X;
871 draw_points[0].Y = fill_area->Y;
872 draw_points[1].X = fill_area->X+1;
873 draw_points[1].Y = fill_area->Y;
874 draw_points[2].X = fill_area->X;
875 draw_points[2].Y = fill_area->Y+1;
877 /* Transform the points to the co-ordinate space of the bitmap. */
878 stat = GdipTransformPoints(graphics, CoordinateSpaceWorld,
879 CoordinateSpaceDevice, draw_points, 3);
883 stat = GdipCloneMatrix(fill->transform, &world_to_texture);
888 stat = GdipInvertMatrix(world_to_texture);
891 stat = GdipTransformMatrixPoints(world_to_texture, draw_points, 3);
893 GdipDeleteMatrix(world_to_texture);
896 if (stat == Ok && !fill->bitmap_bits)
898 BitmapData lockeddata;
900 fill->bitmap_bits = GdipAlloc(sizeof(ARGB) * bitmap->width * bitmap->height);
901 if (!fill->bitmap_bits)
906 lockeddata.Width = bitmap->width;
907 lockeddata.Height = bitmap->height;
908 lockeddata.Stride = src_stride;
909 lockeddata.PixelFormat = PixelFormat32bppARGB;
910 lockeddata.Scan0 = fill->bitmap_bits;
912 stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
913 PixelFormat32bppARGB, &lockeddata);
917 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
920 apply_image_attributes(fill->imageattributes, fill->bitmap_bits,
921 bitmap->width, bitmap->height,
922 src_stride, ColorAdjustTypeBitmap);
926 GdipFree(fill->bitmap_bits);
927 fill->bitmap_bits = NULL;
933 REAL x_dx = draw_points[1].X - draw_points[0].X;
934 REAL x_dy = draw_points[1].Y - draw_points[0].Y;
935 REAL y_dx = draw_points[2].X - draw_points[0].X;
936 REAL y_dy = draw_points[2].Y - draw_points[0].Y;
938 for (y=0; y<fill_area->Height; y++)
940 for (x=0; x<fill_area->Width; x++)
943 point.X = draw_points[0].X + x * x_dx + y * y_dx;
944 point.Y = draw_points[0].Y + y * x_dy + y * y_dy;
946 argb_pixels[x + y*cdwStride] = resample_bitmap_pixel(
947 &src_area, fill->bitmap_bits, bitmap->width, bitmap->height,
948 &point, fill->imageattributes, graphics->interpolation);
956 return NotImplemented;
960 /* GdipDrawPie/GdipFillPie helper function */
961 static void draw_pie(GpGraphics *graphics, REAL x, REAL y, REAL width,
962 REAL height, REAL startAngle, REAL sweepAngle)
969 ptf[1].X = x + width;
970 ptf[1].Y = y + height;
972 deg2xy(startAngle+sweepAngle, x + width / 2.0, y + width / 2.0, &ptf[2].X, &ptf[2].Y);
973 deg2xy(startAngle, x + width / 2.0, y + width / 2.0, &ptf[3].X, &ptf[3].Y);
975 transform_and_round_points(graphics, pti, ptf, 4);
977 Pie(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y, pti[2].x,
978 pti[2].y, pti[3].x, pti[3].y);
981 /* Draws the linecap the specified color and size on the hdc. The linecap is in
982 * direction of the line from x1, y1 to x2, y2 and is anchored on x2, y2. Probably
983 * should not be called on an hdc that has a path you care about. */
984 static void draw_cap(GpGraphics *graphics, COLORREF color, GpLineCap cap, REAL size,
985 const GpCustomLineCap *custom, REAL x1, REAL y1, REAL x2, REAL y2)
987 HGDIOBJ oldbrush = NULL, oldpen = NULL;
988 GpMatrix *matrix = NULL;
991 PointF ptf[4], *custptf = NULL;
992 POINT pt[4], *custpt = NULL;
994 REAL theta, dsmall, dbig, dx, dy = 0.0;
999 if((x1 == x2) && (y1 == y2))
1002 theta = gdiplus_atan2(y2 - y1, x2 - x1);
1004 customstroke = (cap == LineCapCustom) && custom && (!custom->fill);
1006 brush = CreateSolidBrush(color);
1007 lb.lbStyle = BS_SOLID;
1010 pen = ExtCreatePen(PS_GEOMETRIC | PS_SOLID | PS_ENDCAP_FLAT |
1011 PS_JOIN_MITER, 1, &lb, 0,
1013 oldbrush = SelectObject(graphics->hdc, brush);
1014 oldpen = SelectObject(graphics->hdc, pen);
1021 case LineCapSquareAnchor:
1022 case LineCapDiamondAnchor:
1023 size = size * (cap & LineCapNoAnchor ? ANCHOR_WIDTH : 1.0) / 2.0;
1024 if(cap == LineCapDiamondAnchor){
1025 dsmall = cos(theta + M_PI_2) * size;
1026 dbig = sin(theta + M_PI_2) * size;
1029 dsmall = cos(theta + M_PI_4) * size;
1030 dbig = sin(theta + M_PI_4) * size;
1033 ptf[0].X = x2 - dsmall;
1034 ptf[1].X = x2 + dbig;
1036 ptf[0].Y = y2 - dbig;
1037 ptf[3].Y = y2 + dsmall;
1039 ptf[1].Y = y2 - dsmall;
1040 ptf[2].Y = y2 + dbig;
1042 ptf[3].X = x2 - dbig;
1043 ptf[2].X = x2 + dsmall;
1045 transform_and_round_points(graphics, pt, ptf, 4);
1046 Polygon(graphics->hdc, pt, 4);
1049 case LineCapArrowAnchor:
1050 size = size * 4.0 / sqrt(3.0);
1052 dx = cos(M_PI / 6.0 + theta) * size;
1053 dy = sin(M_PI / 6.0 + theta) * size;
1058 dx = cos(- M_PI / 6.0 + theta) * size;
1059 dy = sin(- M_PI / 6.0 + theta) * size;
1067 transform_and_round_points(graphics, pt, ptf, 3);
1068 Polygon(graphics->hdc, pt, 3);
1071 case LineCapRoundAnchor:
1072 dx = dy = ANCHOR_WIDTH * size / 2.0;
1079 transform_and_round_points(graphics, pt, ptf, 2);
1080 Ellipse(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y);
1083 case LineCapTriangle:
1085 dx = cos(M_PI_2 + theta) * size;
1086 dy = sin(M_PI_2 + theta) * size;
1093 dx = cos(theta) * size;
1094 dy = sin(theta) * size;
1099 transform_and_round_points(graphics, pt, ptf, 3);
1100 Polygon(graphics->hdc, pt, 3);
1104 dx = dy = size / 2.0;
1111 dx = -cos(M_PI_2 + theta) * size;
1112 dy = -sin(M_PI_2 + theta) * size;
1119 transform_and_round_points(graphics, pt, ptf, 4);
1120 Pie(graphics->hdc, pt[0].x, pt[0].y, pt[1].x, pt[1].y, pt[2].x,
1121 pt[2].y, pt[3].x, pt[3].y);
1128 count = custom->pathdata.Count;
1129 custptf = GdipAlloc(count * sizeof(PointF));
1130 custpt = GdipAlloc(count * sizeof(POINT));
1131 tp = GdipAlloc(count);
1133 if(!custptf || !custpt || !tp || (GdipCreateMatrix(&matrix) != Ok))
1136 memcpy(custptf, custom->pathdata.Points, count * sizeof(PointF));
1138 GdipScaleMatrix(matrix, size, size, MatrixOrderAppend);
1139 GdipRotateMatrix(matrix, (180.0 / M_PI) * (theta - M_PI_2),
1141 GdipTranslateMatrix(matrix, x2, y2, MatrixOrderAppend);
1142 GdipTransformMatrixPoints(matrix, custptf, count);
1144 transform_and_round_points(graphics, custpt, custptf, count);
1146 for(i = 0; i < count; i++)
1147 tp[i] = convert_path_point_type(custom->pathdata.Types[i]);
1150 BeginPath(graphics->hdc);
1151 PolyDraw(graphics->hdc, custpt, tp, count);
1152 EndPath(graphics->hdc);
1153 StrokeAndFillPath(graphics->hdc);
1156 PolyDraw(graphics->hdc, custpt, tp, count);
1162 GdipDeleteMatrix(matrix);
1169 SelectObject(graphics->hdc, oldbrush);
1170 SelectObject(graphics->hdc, oldpen);
1171 DeleteObject(brush);
1176 /* Shortens the line by the given percent by changing x2, y2.
1177 * If percent is > 1.0 then the line will change direction.
1178 * If percent is negative it can lengthen the line. */
1179 static void shorten_line_percent(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL percent)
1181 REAL dist, theta, dx, dy;
1183 if((y1 == *y2) && (x1 == *x2))
1186 dist = sqrt((*x2 - x1) * (*x2 - x1) + (*y2 - y1) * (*y2 - y1)) * -percent;
1187 theta = gdiplus_atan2((*y2 - y1), (*x2 - x1));
1188 dx = cos(theta) * dist;
1189 dy = sin(theta) * dist;
1195 /* Shortens the line by the given amount by changing x2, y2.
1196 * If the amount is greater than the distance, the line will become length 0.
1197 * If the amount is negative, it can lengthen the line. */
1198 static void shorten_line_amt(REAL x1, REAL y1, REAL *x2, REAL *y2, REAL amt)
1200 REAL dx, dy, percent;
1204 if(dx == 0 && dy == 0)
1207 percent = amt / sqrt(dx * dx + dy * dy);
1214 shorten_line_percent(x1, y1, x2, y2, percent);
1217 /* Draws lines between the given points, and if caps is true then draws an endcap
1218 * at the end of the last line. */
1219 static GpStatus draw_polyline(GpGraphics *graphics, GpPen *pen,
1220 GDIPCONST GpPointF * pt, INT count, BOOL caps)
1223 GpPointF *ptcopy = NULL;
1224 GpStatus status = GenericError;
1229 pti = GdipAlloc(count * sizeof(POINT));
1230 ptcopy = GdipAlloc(count * sizeof(GpPointF));
1232 if(!pti || !ptcopy){
1233 status = OutOfMemory;
1237 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1240 if(pen->endcap == LineCapArrowAnchor)
1241 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1242 &ptcopy[count-1].X, &ptcopy[count-1].Y, pen->width);
1243 else if((pen->endcap == LineCapCustom) && pen->customend)
1244 shorten_line_amt(ptcopy[count-2].X, ptcopy[count-2].Y,
1245 &ptcopy[count-1].X, &ptcopy[count-1].Y,
1246 pen->customend->inset * pen->width);
1248 if(pen->startcap == LineCapArrowAnchor)
1249 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1250 &ptcopy[0].X, &ptcopy[0].Y, pen->width);
1251 else if((pen->startcap == LineCapCustom) && pen->customstart)
1252 shorten_line_amt(ptcopy[1].X, ptcopy[1].Y,
1253 &ptcopy[0].X, &ptcopy[0].Y,
1254 pen->customstart->inset * pen->width);
1256 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1257 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X, pt[count - 1].Y);
1258 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1259 pt[1].X, pt[1].Y, pt[0].X, pt[0].Y);
1262 transform_and_round_points(graphics, pti, ptcopy, count);
1264 if(Polyline(graphics->hdc, pti, count))
1274 /* Conducts a linear search to find the bezier points that will back off
1275 * the endpoint of the curve by a distance of amt. Linear search works
1276 * better than binary in this case because there are multiple solutions,
1277 * and binary searches often find a bad one. I don't think this is what
1278 * Windows does but short of rendering the bezier without GDI's help it's
1279 * the best we can do. If rev then work from the start of the passed points
1280 * instead of the end. */
1281 static void shorten_bezier_amt(GpPointF * pt, REAL amt, BOOL rev)
1284 REAL percent = 0.00, dx, dy, origx, origy, diff = -1.0;
1285 INT i, first = 0, second = 1, third = 2, fourth = 3;
1294 origx = pt[fourth].X;
1295 origy = pt[fourth].Y;
1296 memcpy(origpt, pt, sizeof(GpPointF) * 4);
1298 for(i = 0; (i < MAX_ITERS) && (diff < amt); i++){
1299 /* reset bezier points to original values */
1300 memcpy(pt, origpt, sizeof(GpPointF) * 4);
1301 /* Perform magic on bezier points. Order is important here.*/
1302 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1303 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1304 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1305 shorten_line_percent(pt[first].X, pt[first].Y, &pt[second].X, &pt[second].Y, percent);
1306 shorten_line_percent(pt[second].X, pt[second].Y, &pt[third].X, &pt[third].Y, percent);
1307 shorten_line_percent(pt[third].X, pt[third].Y, &pt[fourth].X, &pt[fourth].Y, percent);
1309 dx = pt[fourth].X - origx;
1310 dy = pt[fourth].Y - origy;
1312 diff = sqrt(dx * dx + dy * dy);
1313 percent += 0.0005 * amt;
1317 /* Draws bezier curves between given points, and if caps is true then draws an
1318 * endcap at the end of the last line. */
1319 static GpStatus draw_polybezier(GpGraphics *graphics, GpPen *pen,
1320 GDIPCONST GpPointF * pt, INT count, BOOL caps)
1324 GpStatus status = GenericError;
1329 pti = GdipAlloc(count * sizeof(POINT));
1330 ptcopy = GdipAlloc(count * sizeof(GpPointF));
1332 if(!pti || !ptcopy){
1333 status = OutOfMemory;
1337 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1340 if(pen->endcap == LineCapArrowAnchor)
1341 shorten_bezier_amt(&ptcopy[count-4], pen->width, FALSE);
1342 else if((pen->endcap == LineCapCustom) && pen->customend)
1343 shorten_bezier_amt(&ptcopy[count-4], pen->width * pen->customend->inset,
1346 if(pen->startcap == LineCapArrowAnchor)
1347 shorten_bezier_amt(ptcopy, pen->width, TRUE);
1348 else if((pen->startcap == LineCapCustom) && pen->customstart)
1349 shorten_bezier_amt(ptcopy, pen->width * pen->customstart->inset, TRUE);
1351 /* the direction of the line cap is parallel to the direction at the
1352 * end of the bezier (which, if it has been shortened, is not the same
1353 * as the direction from pt[count-2] to pt[count-1]) */
1354 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1355 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1356 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1357 pt[count - 1].X, pt[count - 1].Y);
1359 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1360 pt[0].X - (ptcopy[0].X - ptcopy[1].X),
1361 pt[0].Y - (ptcopy[0].Y - ptcopy[1].Y), pt[0].X, pt[0].Y);
1364 transform_and_round_points(graphics, pti, ptcopy, count);
1366 PolyBezier(graphics->hdc, pti, count);
1377 /* Draws a combination of bezier curves and lines between points. */
1378 static GpStatus draw_poly(GpGraphics *graphics, GpPen *pen, GDIPCONST GpPointF * pt,
1379 GDIPCONST BYTE * types, INT count, BOOL caps)
1381 POINT *pti = GdipAlloc(count * sizeof(POINT));
1382 BYTE *tp = GdipAlloc(count);
1383 GpPointF *ptcopy = GdipAlloc(count * sizeof(GpPointF));
1385 GpStatus status = GenericError;
1391 if(!pti || !tp || !ptcopy){
1392 status = OutOfMemory;
1396 for(i = 1; i < count; i++){
1397 if((types[i] & PathPointTypePathTypeMask) == PathPointTypeBezier){
1398 if((i + 2 >= count) || !(types[i + 1] & PathPointTypeBezier)
1399 || !(types[i + 1] & PathPointTypeBezier)){
1400 ERR("Bad bezier points\n");
1407 memcpy(ptcopy, pt, count * sizeof(GpPointF));
1409 /* If we are drawing caps, go through the points and adjust them accordingly,
1410 * and draw the caps. */
1412 switch(types[count - 1] & PathPointTypePathTypeMask){
1413 case PathPointTypeBezier:
1414 if(pen->endcap == LineCapArrowAnchor)
1415 shorten_bezier_amt(&ptcopy[count - 4], pen->width, FALSE);
1416 else if((pen->endcap == LineCapCustom) && pen->customend)
1417 shorten_bezier_amt(&ptcopy[count - 4],
1418 pen->width * pen->customend->inset, FALSE);
1420 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1421 pt[count - 1].X - (ptcopy[count - 1].X - ptcopy[count - 2].X),
1422 pt[count - 1].Y - (ptcopy[count - 1].Y - ptcopy[count - 2].Y),
1423 pt[count - 1].X, pt[count - 1].Y);
1426 case PathPointTypeLine:
1427 if(pen->endcap == LineCapArrowAnchor)
1428 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1429 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1431 else if((pen->endcap == LineCapCustom) && pen->customend)
1432 shorten_line_amt(ptcopy[count - 2].X, ptcopy[count - 2].Y,
1433 &ptcopy[count - 1].X, &ptcopy[count - 1].Y,
1434 pen->customend->inset * pen->width);
1436 draw_cap(graphics, pen->brush->lb.lbColor, pen->endcap, pen->width, pen->customend,
1437 pt[count - 2].X, pt[count - 2].Y, pt[count - 1].X,
1442 ERR("Bad path last point\n");
1446 /* Find start of points */
1447 for(j = 1; j < count && ((types[j] & PathPointTypePathTypeMask)
1448 == PathPointTypeStart); j++);
1450 switch(types[j] & PathPointTypePathTypeMask){
1451 case PathPointTypeBezier:
1452 if(pen->startcap == LineCapArrowAnchor)
1453 shorten_bezier_amt(&ptcopy[j - 1], pen->width, TRUE);
1454 else if((pen->startcap == LineCapCustom) && pen->customstart)
1455 shorten_bezier_amt(&ptcopy[j - 1],
1456 pen->width * pen->customstart->inset, TRUE);
1458 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1459 pt[j - 1].X - (ptcopy[j - 1].X - ptcopy[j].X),
1460 pt[j - 1].Y - (ptcopy[j - 1].Y - ptcopy[j].Y),
1461 pt[j - 1].X, pt[j - 1].Y);
1464 case PathPointTypeLine:
1465 if(pen->startcap == LineCapArrowAnchor)
1466 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1467 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1469 else if((pen->startcap == LineCapCustom) && pen->customstart)
1470 shorten_line_amt(ptcopy[j].X, ptcopy[j].Y,
1471 &ptcopy[j - 1].X, &ptcopy[j - 1].Y,
1472 pen->customstart->inset * pen->width);
1474 draw_cap(graphics, pen->brush->lb.lbColor, pen->startcap, pen->width, pen->customstart,
1475 pt[j].X, pt[j].Y, pt[j - 1].X,
1480 ERR("Bad path points\n");
1485 transform_and_round_points(graphics, pti, ptcopy, count);
1487 for(i = 0; i < count; i++){
1488 tp[i] = convert_path_point_type(types[i]);
1491 PolyDraw(graphics->hdc, pti, tp, count);
1503 GpStatus trace_path(GpGraphics *graphics, GpPath *path)
1507 BeginPath(graphics->hdc);
1508 result = draw_poly(graphics, NULL, path->pathdata.Points,
1509 path->pathdata.Types, path->pathdata.Count, FALSE);
1510 EndPath(graphics->hdc);
1514 typedef struct _GraphicsContainerItem {
1516 GraphicsContainer contid;
1518 SmoothingMode smoothing;
1519 CompositingQuality compqual;
1520 InterpolationMode interpolation;
1521 CompositingMode compmode;
1522 TextRenderingHint texthint;
1525 PixelOffsetMode pixeloffset;
1527 GpMatrix* worldtrans;
1529 } GraphicsContainerItem;
1531 static GpStatus init_container(GraphicsContainerItem** container,
1532 GDIPCONST GpGraphics* graphics){
1535 *container = GdipAlloc(sizeof(GraphicsContainerItem));
1539 (*container)->contid = graphics->contid + 1;
1541 (*container)->smoothing = graphics->smoothing;
1542 (*container)->compqual = graphics->compqual;
1543 (*container)->interpolation = graphics->interpolation;
1544 (*container)->compmode = graphics->compmode;
1545 (*container)->texthint = graphics->texthint;
1546 (*container)->scale = graphics->scale;
1547 (*container)->unit = graphics->unit;
1548 (*container)->textcontrast = graphics->textcontrast;
1549 (*container)->pixeloffset = graphics->pixeloffset;
1551 sts = GdipCloneMatrix(graphics->worldtrans, &(*container)->worldtrans);
1553 GdipFree(*container);
1558 sts = GdipCloneRegion(graphics->clip, &(*container)->clip);
1560 GdipDeleteMatrix((*container)->worldtrans);
1561 GdipFree(*container);
1569 static void delete_container(GraphicsContainerItem* container){
1570 GdipDeleteMatrix(container->worldtrans);
1571 GdipDeleteRegion(container->clip);
1572 GdipFree(container);
1575 static GpStatus restore_container(GpGraphics* graphics,
1576 GDIPCONST GraphicsContainerItem* container){
1581 sts = GdipCloneMatrix(container->worldtrans, &newTrans);
1585 sts = GdipCloneRegion(container->clip, &newClip);
1587 GdipDeleteMatrix(newTrans);
1591 GdipDeleteMatrix(graphics->worldtrans);
1592 graphics->worldtrans = newTrans;
1594 GdipDeleteRegion(graphics->clip);
1595 graphics->clip = newClip;
1597 graphics->contid = container->contid - 1;
1599 graphics->smoothing = container->smoothing;
1600 graphics->compqual = container->compqual;
1601 graphics->interpolation = container->interpolation;
1602 graphics->compmode = container->compmode;
1603 graphics->texthint = container->texthint;
1604 graphics->scale = container->scale;
1605 graphics->unit = container->unit;
1606 graphics->textcontrast = container->textcontrast;
1607 graphics->pixeloffset = container->pixeloffset;
1612 static GpStatus get_graphics_bounds(GpGraphics* graphics, GpRectF* rect)
1618 if(graphics->hwnd) {
1619 if(!GetClientRect(graphics->hwnd, &wnd_rect))
1620 return GenericError;
1622 rect->X = wnd_rect.left;
1623 rect->Y = wnd_rect.top;
1624 rect->Width = wnd_rect.right - wnd_rect.left;
1625 rect->Height = wnd_rect.bottom - wnd_rect.top;
1626 }else if (graphics->image){
1627 stat = GdipGetImageBounds(graphics->image, rect, &unit);
1628 if (stat == Ok && unit != UnitPixel)
1629 FIXME("need to convert from unit %i\n", unit);
1633 rect->Width = GetDeviceCaps(graphics->hdc, HORZRES);
1634 rect->Height = GetDeviceCaps(graphics->hdc, VERTRES);
1640 /* on success, rgn will contain the region of the graphics object which
1641 * is visible after clipping has been applied */
1642 static GpStatus get_visible_clip_region(GpGraphics *graphics, GpRegion *rgn)
1648 if((stat = get_graphics_bounds(graphics, &rectf)) != Ok)
1651 if((stat = GdipCreateRegion(&tmp)) != Ok)
1654 if((stat = GdipCombineRegionRect(tmp, &rectf, CombineModeReplace)) != Ok)
1657 if((stat = GdipCombineRegionRegion(tmp, graphics->clip, CombineModeIntersect)) != Ok)
1660 stat = GdipCombineRegionRegion(rgn, tmp, CombineModeReplace);
1663 GdipDeleteRegion(tmp);
1667 void get_font_hfont(GpGraphics *graphics, GDIPCONST GpFont *font, HFONT *hfont)
1669 HDC hdc = CreateCompatibleDC(0);
1671 REAL angle, rel_width, rel_height;
1673 HFONT unscaled_font;
1674 TEXTMETRICW textmet;
1683 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
1684 angle = -gdiplus_atan2((pt[1].Y - pt[0].Y), (pt[1].X - pt[0].X));
1685 rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
1686 (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
1687 rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
1688 (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
1691 lfw.lfHeight = roundr(-font->pixel_size * rel_height);
1692 unscaled_font = CreateFontIndirectW(&lfw);
1694 SelectObject(hdc, unscaled_font);
1695 GetTextMetricsW(hdc, &textmet);
1698 lfw.lfHeight = roundr(-font->pixel_size * rel_height);
1699 lfw.lfWidth = roundr(textmet.tmAveCharWidth * rel_width / rel_height);
1700 lfw.lfEscapement = lfw.lfOrientation = roundr((angle / M_PI) * 1800.0);
1702 *hfont = CreateFontIndirectW(&lfw);
1705 DeleteObject(unscaled_font);
1708 GpStatus WINGDIPAPI GdipCreateFromHDC(HDC hdc, GpGraphics **graphics)
1710 TRACE("(%p, %p)\n", hdc, graphics);
1712 return GdipCreateFromHDC2(hdc, NULL, graphics);
1715 GpStatus WINGDIPAPI GdipCreateFromHDC2(HDC hdc, HANDLE hDevice, GpGraphics **graphics)
1719 TRACE("(%p, %p, %p)\n", hdc, hDevice, graphics);
1721 if(hDevice != NULL) {
1722 FIXME("Don't know how to handle parameter hDevice\n");
1723 return NotImplemented;
1729 if(graphics == NULL)
1730 return InvalidParameter;
1732 *graphics = GdipAlloc(sizeof(GpGraphics));
1733 if(!*graphics) return OutOfMemory;
1735 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1736 GdipFree(*graphics);
1740 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1741 GdipFree((*graphics)->worldtrans);
1742 GdipFree(*graphics);
1746 (*graphics)->hdc = hdc;
1747 (*graphics)->hwnd = WindowFromDC(hdc);
1748 (*graphics)->owndc = FALSE;
1749 (*graphics)->smoothing = SmoothingModeDefault;
1750 (*graphics)->compqual = CompositingQualityDefault;
1751 (*graphics)->interpolation = InterpolationModeBilinear;
1752 (*graphics)->pixeloffset = PixelOffsetModeDefault;
1753 (*graphics)->compmode = CompositingModeSourceOver;
1754 (*graphics)->unit = UnitDisplay;
1755 (*graphics)->scale = 1.0;
1756 (*graphics)->busy = FALSE;
1757 (*graphics)->textcontrast = 4;
1758 list_init(&(*graphics)->containers);
1759 (*graphics)->contid = 0;
1761 TRACE("<-- %p\n", *graphics);
1766 GpStatus graphics_from_image(GpImage *image, GpGraphics **graphics)
1770 *graphics = GdipAlloc(sizeof(GpGraphics));
1771 if(!*graphics) return OutOfMemory;
1773 if((retval = GdipCreateMatrix(&(*graphics)->worldtrans)) != Ok){
1774 GdipFree(*graphics);
1778 if((retval = GdipCreateRegion(&(*graphics)->clip)) != Ok){
1779 GdipFree((*graphics)->worldtrans);
1780 GdipFree(*graphics);
1784 (*graphics)->hdc = NULL;
1785 (*graphics)->hwnd = NULL;
1786 (*graphics)->owndc = FALSE;
1787 (*graphics)->image = image;
1788 (*graphics)->smoothing = SmoothingModeDefault;
1789 (*graphics)->compqual = CompositingQualityDefault;
1790 (*graphics)->interpolation = InterpolationModeBilinear;
1791 (*graphics)->pixeloffset = PixelOffsetModeDefault;
1792 (*graphics)->compmode = CompositingModeSourceOver;
1793 (*graphics)->unit = UnitDisplay;
1794 (*graphics)->scale = 1.0;
1795 (*graphics)->busy = FALSE;
1796 (*graphics)->textcontrast = 4;
1797 list_init(&(*graphics)->containers);
1798 (*graphics)->contid = 0;
1800 TRACE("<-- %p\n", *graphics);
1805 GpStatus WINGDIPAPI GdipCreateFromHWND(HWND hwnd, GpGraphics **graphics)
1810 TRACE("(%p, %p)\n", hwnd, graphics);
1814 if((ret = GdipCreateFromHDC(hdc, graphics)) != Ok)
1816 ReleaseDC(hwnd, hdc);
1820 (*graphics)->hwnd = hwnd;
1821 (*graphics)->owndc = TRUE;
1826 /* FIXME: no icm handling */
1827 GpStatus WINGDIPAPI GdipCreateFromHWNDICM(HWND hwnd, GpGraphics **graphics)
1829 TRACE("(%p, %p)\n", hwnd, graphics);
1831 return GdipCreateFromHWND(hwnd, graphics);
1834 GpStatus WINGDIPAPI GdipCreateMetafileFromEmf(HENHMETAFILE hemf, BOOL delete,
1835 GpMetafile **metafile)
1839 TRACE("(%p,%i,%p)\n", hemf, delete, metafile);
1841 if(!hemf || !metafile)
1842 return InvalidParameter;
1845 FIXME("not implemented\n");
1847 return NotImplemented;
1850 GpStatus WINGDIPAPI GdipCreateMetafileFromWmf(HMETAFILE hwmf, BOOL delete,
1851 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1853 IStream *stream = NULL;
1857 GpStatus retval = Ok;
1859 TRACE("(%p, %d, %p, %p)\n", hwmf, delete, placeable, metafile);
1861 if(!hwmf || !metafile || !placeable)
1862 return InvalidParameter;
1865 read = GetMetaFileBitsEx(hwmf, 0, NULL);
1867 return GenericError;
1868 copy = GdipAlloc(read);
1869 GetMetaFileBitsEx(hwmf, read, copy);
1871 hemf = SetWinMetaFileBits(read, copy, NULL, NULL);
1874 read = GetEnhMetaFileBits(hemf, 0, NULL);
1875 copy = GdipAlloc(read);
1876 GetEnhMetaFileBits(hemf, read, copy);
1877 DeleteEnhMetaFile(hemf);
1879 if(CreateStreamOnHGlobal(copy, TRUE, &stream) != S_OK){
1880 ERR("could not make stream\n");
1882 retval = GenericError;
1886 *metafile = GdipAlloc(sizeof(GpMetafile));
1888 retval = OutOfMemory;
1892 if(OleLoadPicture(stream, 0, FALSE, &IID_IPicture,
1893 (LPVOID*) &((*metafile)->image.picture)) != S_OK)
1895 retval = GenericError;
1900 (*metafile)->image.type = ImageTypeMetafile;
1901 memcpy(&(*metafile)->image.format, &ImageFormatWMF, sizeof(GUID));
1902 (*metafile)->image.palette_flags = 0;
1903 (*metafile)->image.palette_count = 0;
1904 (*metafile)->image.palette_size = 0;
1905 (*metafile)->image.palette_entries = NULL;
1906 (*metafile)->image.xres = (REAL)placeable->Inch;
1907 (*metafile)->image.yres = (REAL)placeable->Inch;
1908 (*metafile)->bounds.X = ((REAL) placeable->BoundingBox.Left) / ((REAL) placeable->Inch);
1909 (*metafile)->bounds.Y = ((REAL) placeable->BoundingBox.Top) / ((REAL) placeable->Inch);
1910 (*metafile)->bounds.Width = ((REAL) (placeable->BoundingBox.Right
1911 - placeable->BoundingBox.Left));
1912 (*metafile)->bounds.Height = ((REAL) (placeable->BoundingBox.Bottom
1913 - placeable->BoundingBox.Top));
1914 (*metafile)->unit = UnitPixel;
1917 DeleteMetaFile(hwmf);
1919 TRACE("<-- %p\n", *metafile);
1923 GdipFree(*metafile);
1924 IStream_Release(stream);
1928 GpStatus WINGDIPAPI GdipCreateMetafileFromWmfFile(GDIPCONST WCHAR *file,
1929 GDIPCONST WmfPlaceableFileHeader * placeable, GpMetafile **metafile)
1931 HMETAFILE hmf = GetMetaFileW(file);
1933 TRACE("(%s, %p, %p)\n", debugstr_w(file), placeable, metafile);
1935 if(!hmf) return InvalidParameter;
1937 return GdipCreateMetafileFromWmf(hmf, TRUE, placeable, metafile);
1940 GpStatus WINGDIPAPI GdipCreateMetafileFromFile(GDIPCONST WCHAR *file,
1941 GpMetafile **metafile)
1943 FIXME("(%p, %p): stub\n", file, metafile);
1944 return NotImplemented;
1947 GpStatus WINGDIPAPI GdipCreateMetafileFromStream(IStream *stream,
1948 GpMetafile **metafile)
1950 FIXME("(%p, %p): stub\n", stream, metafile);
1951 return NotImplemented;
1954 GpStatus WINGDIPAPI GdipCreateStreamOnFile(GDIPCONST WCHAR * filename,
1955 UINT access, IStream **stream)
1960 TRACE("(%s, %u, %p)\n", debugstr_w(filename), access, stream);
1962 if(!stream || !filename)
1963 return InvalidParameter;
1965 if(access & GENERIC_WRITE)
1966 dwMode = STGM_SHARE_DENY_WRITE | STGM_WRITE | STGM_CREATE;
1967 else if(access & GENERIC_READ)
1968 dwMode = STGM_SHARE_DENY_WRITE | STGM_READ | STGM_FAILIFTHERE;
1970 return InvalidParameter;
1972 ret = SHCreateStreamOnFileW(filename, dwMode, stream);
1974 return hresult_to_status(ret);
1977 GpStatus WINGDIPAPI GdipDeleteGraphics(GpGraphics *graphics)
1979 GraphicsContainerItem *cont, *next;
1981 TRACE("(%p)\n", graphics);
1983 if(!graphics) return InvalidParameter;
1984 if(graphics->busy) return ObjectBusy;
1986 if (graphics->image && graphics->image->type == ImageTypeMetafile)
1988 stat = METAFILE_GraphicsDeleted((GpMetafile*)graphics->image);
1994 ReleaseDC(graphics->hwnd, graphics->hdc);
1996 LIST_FOR_EACH_ENTRY_SAFE(cont, next, &graphics->containers, GraphicsContainerItem, entry){
1997 list_remove(&cont->entry);
1998 delete_container(cont);
2001 GdipDeleteRegion(graphics->clip);
2002 GdipDeleteMatrix(graphics->worldtrans);
2008 GpStatus WINGDIPAPI GdipDrawArc(GpGraphics *graphics, GpPen *pen, REAL x,
2009 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
2011 INT save_state, num_pts;
2012 GpPointF points[MAX_ARC_PTS];
2015 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
2016 width, height, startAngle, sweepAngle);
2018 if(!graphics || !pen || width <= 0 || height <= 0)
2019 return InvalidParameter;
2026 FIXME("graphics object has no HDC\n");
2030 num_pts = arc2polybezier(points, x, y, width, height, startAngle, sweepAngle);
2032 save_state = prepare_dc(graphics, pen);
2034 retval = draw_polybezier(graphics, pen, points, num_pts, TRUE);
2036 restore_dc(graphics, save_state);
2041 GpStatus WINGDIPAPI GdipDrawArcI(GpGraphics *graphics, GpPen *pen, INT x,
2042 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
2044 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
2045 width, height, startAngle, sweepAngle);
2047 return GdipDrawArc(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
2050 GpStatus WINGDIPAPI GdipDrawBezier(GpGraphics *graphics, GpPen *pen, REAL x1,
2051 REAL y1, REAL x2, REAL y2, REAL x3, REAL y3, REAL x4, REAL y4)
2057 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1,
2058 x2, y2, x3, y3, x4, y4);
2060 if(!graphics || !pen)
2061 return InvalidParameter;
2068 FIXME("graphics object has no HDC\n");
2081 save_state = prepare_dc(graphics, pen);
2083 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2085 restore_dc(graphics, save_state);
2090 GpStatus WINGDIPAPI GdipDrawBezierI(GpGraphics *graphics, GpPen *pen, INT x1,
2091 INT y1, INT x2, INT y2, INT x3, INT y3, INT x4, INT y4)
2097 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d)\n", graphics, pen, x1, y1,
2098 x2, y2, x3, y3, x4, y4);
2100 if(!graphics || !pen)
2101 return InvalidParameter;
2108 FIXME("graphics object has no HDC\n");
2121 save_state = prepare_dc(graphics, pen);
2123 retval = draw_polybezier(graphics, pen, pt, 4, TRUE);
2125 restore_dc(graphics, save_state);
2130 GpStatus WINGDIPAPI GdipDrawBeziers(GpGraphics *graphics, GpPen *pen,
2131 GDIPCONST GpPointF *points, INT count)
2136 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2138 if(!graphics || !pen || !points || (count <= 0))
2139 return InvalidParameter;
2144 for(i = 0; i < floor(count / 4); i++){
2145 ret = GdipDrawBezier(graphics, pen,
2146 points[4*i].X, points[4*i].Y,
2147 points[4*i + 1].X, points[4*i + 1].Y,
2148 points[4*i + 2].X, points[4*i + 2].Y,
2149 points[4*i + 3].X, points[4*i + 3].Y);
2157 GpStatus WINGDIPAPI GdipDrawBeziersI(GpGraphics *graphics, GpPen *pen,
2158 GDIPCONST GpPoint *points, INT count)
2164 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2166 if(!graphics || !pen || !points || (count <= 0))
2167 return InvalidParameter;
2172 pts = GdipAlloc(sizeof(GpPointF) * count);
2176 for(i = 0; i < count; i++){
2177 pts[i].X = (REAL)points[i].X;
2178 pts[i].Y = (REAL)points[i].Y;
2181 ret = GdipDrawBeziers(graphics,pen,pts,count);
2188 GpStatus WINGDIPAPI GdipDrawClosedCurve(GpGraphics *graphics, GpPen *pen,
2189 GDIPCONST GpPointF *points, INT count)
2191 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2193 return GdipDrawClosedCurve2(graphics, pen, points, count, 1.0);
2196 GpStatus WINGDIPAPI GdipDrawClosedCurveI(GpGraphics *graphics, GpPen *pen,
2197 GDIPCONST GpPoint *points, INT count)
2199 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2201 return GdipDrawClosedCurve2I(graphics, pen, points, count, 1.0);
2204 GpStatus WINGDIPAPI GdipDrawClosedCurve2(GpGraphics *graphics, GpPen *pen,
2205 GDIPCONST GpPointF *points, INT count, REAL tension)
2210 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2212 if(!graphics || !pen || !points || count <= 0)
2213 return InvalidParameter;
2218 if((stat = GdipCreatePath(FillModeAlternate, &path)) != Ok)
2221 stat = GdipAddPathClosedCurve2(path, points, count, tension);
2223 GdipDeletePath(path);
2227 stat = GdipDrawPath(graphics, pen, path);
2229 GdipDeletePath(path);
2234 GpStatus WINGDIPAPI GdipDrawClosedCurve2I(GpGraphics *graphics, GpPen *pen,
2235 GDIPCONST GpPoint *points, INT count, REAL tension)
2241 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2243 if(!points || count <= 0)
2244 return InvalidParameter;
2246 ptf = GdipAlloc(sizeof(GpPointF)*count);
2250 for(i = 0; i < count; i++){
2251 ptf[i].X = (REAL)points[i].X;
2252 ptf[i].Y = (REAL)points[i].Y;
2255 stat = GdipDrawClosedCurve2(graphics, pen, ptf, count, tension);
2262 GpStatus WINGDIPAPI GdipDrawCurve(GpGraphics *graphics, GpPen *pen,
2263 GDIPCONST GpPointF *points, INT count)
2265 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2267 return GdipDrawCurve2(graphics,pen,points,count,1.0);
2270 GpStatus WINGDIPAPI GdipDrawCurveI(GpGraphics *graphics, GpPen *pen,
2271 GDIPCONST GpPoint *points, INT count)
2277 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
2280 return InvalidParameter;
2282 pointsF = GdipAlloc(sizeof(GpPointF)*count);
2286 for(i = 0; i < count; i++){
2287 pointsF[i].X = (REAL)points[i].X;
2288 pointsF[i].Y = (REAL)points[i].Y;
2291 ret = GdipDrawCurve(graphics,pen,pointsF,count);
2297 /* Approximates cardinal spline with Bezier curves. */
2298 GpStatus WINGDIPAPI GdipDrawCurve2(GpGraphics *graphics, GpPen *pen,
2299 GDIPCONST GpPointF *points, INT count, REAL tension)
2301 /* PolyBezier expects count*3-2 points. */
2302 INT i, len_pt = count*3-2, save_state;
2304 REAL x1, x2, y1, y2;
2307 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2309 if(!graphics || !pen)
2310 return InvalidParameter;
2316 return InvalidParameter;
2320 FIXME("graphics object has no HDC\n");
2324 pt = GdipAlloc(len_pt * sizeof(GpPointF));
2328 tension = tension * TENSION_CONST;
2330 calc_curve_bezier_endp(points[0].X, points[0].Y, points[1].X, points[1].Y,
2333 pt[0].X = points[0].X;
2334 pt[0].Y = points[0].Y;
2338 for(i = 0; i < count-2; i++){
2339 calc_curve_bezier(&(points[i]), tension, &x1, &y1, &x2, &y2);
2343 pt[3*i+3].X = points[i+1].X;
2344 pt[3*i+3].Y = points[i+1].Y;
2349 calc_curve_bezier_endp(points[count-1].X, points[count-1].Y,
2350 points[count-2].X, points[count-2].Y, tension, &x1, &y1);
2352 pt[len_pt-2].X = x1;
2353 pt[len_pt-2].Y = y1;
2354 pt[len_pt-1].X = points[count-1].X;
2355 pt[len_pt-1].Y = points[count-1].Y;
2357 save_state = prepare_dc(graphics, pen);
2359 retval = draw_polybezier(graphics, pen, pt, len_pt, TRUE);
2362 restore_dc(graphics, save_state);
2367 GpStatus WINGDIPAPI GdipDrawCurve2I(GpGraphics *graphics, GpPen *pen,
2368 GDIPCONST GpPoint *points, INT count, REAL tension)
2374 TRACE("(%p, %p, %p, %d, %.2f)\n", graphics, pen, points, count, tension);
2377 return InvalidParameter;
2379 pointsF = GdipAlloc(sizeof(GpPointF)*count);
2383 for(i = 0; i < count; i++){
2384 pointsF[i].X = (REAL)points[i].X;
2385 pointsF[i].Y = (REAL)points[i].Y;
2388 ret = GdipDrawCurve2(graphics,pen,pointsF,count,tension);
2394 GpStatus WINGDIPAPI GdipDrawCurve3(GpGraphics *graphics, GpPen *pen,
2395 GDIPCONST GpPointF *points, INT count, INT offset, INT numberOfSegments,
2398 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2400 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2401 return InvalidParameter;
2404 return GdipDrawCurve2(graphics, pen, points + offset, numberOfSegments + 1, tension);
2407 GpStatus WINGDIPAPI GdipDrawCurve3I(GpGraphics *graphics, GpPen *pen,
2408 GDIPCONST GpPoint *points, INT count, INT offset, INT numberOfSegments,
2411 TRACE("(%p, %p, %p, %d, %d, %d, %.2f)\n", graphics, pen, points, count, offset, numberOfSegments, tension);
2417 if(offset >= count || numberOfSegments > count - offset - 1 || numberOfSegments <= 0){
2418 return InvalidParameter;
2421 return GdipDrawCurve2I(graphics, pen, points + offset, numberOfSegments + 1, tension);
2424 GpStatus WINGDIPAPI GdipDrawEllipse(GpGraphics *graphics, GpPen *pen, REAL x,
2425 REAL y, REAL width, REAL height)
2431 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
2433 if(!graphics || !pen)
2434 return InvalidParameter;
2441 FIXME("graphics object has no HDC\n");
2447 ptf[1].X = x + width;
2448 ptf[1].Y = y + height;
2450 save_state = prepare_dc(graphics, pen);
2451 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
2453 transform_and_round_points(graphics, pti, ptf, 2);
2455 Ellipse(graphics->hdc, pti[0].x, pti[0].y, pti[1].x, pti[1].y);
2457 restore_dc(graphics, save_state);
2462 GpStatus WINGDIPAPI GdipDrawEllipseI(GpGraphics *graphics, GpPen *pen, INT x,
2463 INT y, INT width, INT height)
2465 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
2467 return GdipDrawEllipse(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
2471 GpStatus WINGDIPAPI GdipDrawImage(GpGraphics *graphics, GpImage *image, REAL x, REAL y)
2476 TRACE("(%p, %p, %.2f, %.2f)\n", graphics, image, x, y);
2478 if(!graphics || !image)
2479 return InvalidParameter;
2481 GdipGetImageWidth(image, &width);
2482 GdipGetImageHeight(image, &height);
2484 /* FIXME: we should use the graphics and image dpi, somehow */
2486 points[0].X = points[2].X = x;
2487 points[0].Y = points[1].Y = y;
2488 points[1].X = x + width;
2489 points[2].Y = y + height;
2491 return GdipDrawImagePointsRect(graphics, image, points, 3, 0, 0, width, height,
2492 UnitPixel, NULL, NULL, NULL);
2495 GpStatus WINGDIPAPI GdipDrawImageI(GpGraphics *graphics, GpImage *image, INT x,
2498 TRACE("(%p, %p, %d, %d)\n", graphics, image, x, y);
2500 return GdipDrawImage(graphics, image, (REAL)x, (REAL)y);
2503 GpStatus WINGDIPAPI GdipDrawImagePointRect(GpGraphics *graphics, GpImage *image,
2504 REAL x, REAL y, REAL srcx, REAL srcy, REAL srcwidth, REAL srcheight,
2508 TRACE("(%p, %p, %f, %f, %f, %f, %f, %f, %d)\n", graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2510 points[0].X = points[2].X = x;
2511 points[0].Y = points[1].Y = y;
2513 /* FIXME: convert image coordinates to Graphics coordinates? */
2514 points[1].X = x + srcwidth;
2515 points[2].Y = y + srcheight;
2517 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2518 srcwidth, srcheight, srcUnit, NULL, NULL, NULL);
2521 GpStatus WINGDIPAPI GdipDrawImagePointRectI(GpGraphics *graphics, GpImage *image,
2522 INT x, INT y, INT srcx, INT srcy, INT srcwidth, INT srcheight,
2525 return GdipDrawImagePointRect(graphics, image, x, y, srcx, srcy, srcwidth, srcheight, srcUnit);
2528 GpStatus WINGDIPAPI GdipDrawImagePoints(GpGraphics *graphics, GpImage *image,
2529 GDIPCONST GpPointF *dstpoints, INT count)
2533 TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
2536 return InvalidParameter;
2538 GdipGetImageWidth(image, &width);
2539 GdipGetImageHeight(image, &height);
2541 return GdipDrawImagePointsRect(graphics, image, dstpoints, count, 0, 0,
2542 width, height, UnitPixel, NULL, NULL, NULL);
2545 GpStatus WINGDIPAPI GdipDrawImagePointsI(GpGraphics *graphics, GpImage *image,
2546 GDIPCONST GpPoint *dstpoints, INT count)
2550 TRACE("(%p, %p, %p, %d)\n", graphics, image, dstpoints, count);
2552 if (count != 3 || !dstpoints)
2553 return InvalidParameter;
2555 ptf[0].X = (REAL)dstpoints[0].X;
2556 ptf[0].Y = (REAL)dstpoints[0].Y;
2557 ptf[1].X = (REAL)dstpoints[1].X;
2558 ptf[1].Y = (REAL)dstpoints[1].Y;
2559 ptf[2].X = (REAL)dstpoints[2].X;
2560 ptf[2].Y = (REAL)dstpoints[2].Y;
2562 return GdipDrawImagePoints(graphics, image, ptf, count);
2565 GpStatus WINGDIPAPI GdipDrawImagePointsRect(GpGraphics *graphics, GpImage *image,
2566 GDIPCONST GpPointF *points, INT count, REAL srcx, REAL srcy, REAL srcwidth,
2567 REAL srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2568 DrawImageAbort callback, VOID * callbackData)
2575 TRACE("(%p, %p, %p, %d, %f, %f, %f, %f, %d, %p, %p, %p)\n", graphics, image, points,
2576 count, srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2580 return NotImplemented;
2582 if(!graphics || !image || !points || count != 3)
2583 return InvalidParameter;
2585 TRACE("%s %s %s\n", debugstr_pointf(&points[0]), debugstr_pointf(&points[1]),
2586 debugstr_pointf(&points[2]));
2588 memcpy(ptf, points, 3 * sizeof(GpPointF));
2589 ptf[3].X = ptf[2].X + ptf[1].X - ptf[0].X;
2590 ptf[3].Y = ptf[2].Y + ptf[1].Y - ptf[0].Y;
2591 if (!srcwidth || !srcheight || ptf[3].X == ptf[0].X || ptf[3].Y == ptf[0].Y)
2593 transform_and_round_points(graphics, pti, ptf, 4);
2599 FIXME("graphics object has no HDC\n");
2602 /* FIXME: partially implemented (only works for rectangular parallelograms) */
2603 if(srcUnit == UnitInch)
2604 dx = dy = (REAL) INCH_HIMETRIC;
2605 else if(srcUnit == UnitPixel){
2606 dx = ((REAL) INCH_HIMETRIC) /
2607 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSX));
2608 dy = ((REAL) INCH_HIMETRIC) /
2609 ((REAL) GetDeviceCaps(graphics->hdc, LOGPIXELSY));
2612 return NotImplemented;
2614 if(IPicture_Render(image->picture, graphics->hdc,
2615 pti[0].x, pti[0].y, pti[1].x - pti[0].x, pti[2].y - pti[0].y,
2616 srcx * dx, srcy * dy,
2617 srcwidth * dx, srcheight * dy,
2620 callback(callbackData);
2621 return GenericError;
2624 else if (image->type == ImageTypeBitmap)
2626 GpBitmap* bitmap = (GpBitmap*)image;
2629 if (srcUnit == UnitInch)
2630 dx = dy = 96.0; /* FIXME: use the image resolution */
2631 else if (srcUnit == UnitPixel)
2634 return NotImplemented;
2638 srcwidth = srcwidth * dx;
2639 srcheight = srcheight * dy;
2641 if (imageAttributes ||
2642 (graphics->image && graphics->image->type == ImageTypeBitmap) ||
2643 !((GpBitmap*)image)->hbitmap ||
2644 ptf[1].Y != ptf[0].Y || ptf[2].X != ptf[0].X ||
2645 ptf[1].X - ptf[0].X != srcwidth || ptf[2].Y - ptf[0].Y != srcheight ||
2646 srcx < 0 || srcy < 0 ||
2647 srcx + srcwidth > bitmap->width || srcy + srcheight > bitmap->height)
2654 int i, x, y, src_stride, dst_stride;
2655 GpMatrix *dst_to_src;
2656 REAL m11, m12, m21, m22, mdx, mdy;
2657 LPBYTE src_data, dst_data;
2658 BitmapData lockeddata;
2659 InterpolationMode interpolation = graphics->interpolation;
2660 GpPointF dst_to_src_points[3] = {{0.0, 0.0}, {1.0, 0.0}, {0.0, 1.0}};
2661 REAL x_dx, x_dy, y_dx, y_dy;
2662 static const GpImageAttributes defaultImageAttributes = {WrapModeClamp, 0, FALSE};
2664 if (!imageAttributes)
2665 imageAttributes = &defaultImageAttributes;
2667 dst_area.left = dst_area.right = pti[0].x;
2668 dst_area.top = dst_area.bottom = pti[0].y;
2671 if (dst_area.left > pti[i].x) dst_area.left = pti[i].x;
2672 if (dst_area.right < pti[i].x) dst_area.right = pti[i].x;
2673 if (dst_area.top > pti[i].y) dst_area.top = pti[i].y;
2674 if (dst_area.bottom < pti[i].y) dst_area.bottom = pti[i].y;
2677 m11 = (ptf[1].X - ptf[0].X) / srcwidth;
2678 m21 = (ptf[2].X - ptf[0].X) / srcheight;
2679 mdx = ptf[0].X - m11 * srcx - m21 * srcy;
2680 m12 = (ptf[1].Y - ptf[0].Y) / srcwidth;
2681 m22 = (ptf[2].Y - ptf[0].Y) / srcheight;
2682 mdy = ptf[0].Y - m12 * srcx - m22 * srcy;
2684 stat = GdipCreateMatrix2(m11, m12, m21, m22, mdx, mdy, &dst_to_src);
2685 if (stat != Ok) return stat;
2687 stat = GdipInvertMatrix(dst_to_src);
2690 GdipDeleteMatrix(dst_to_src);
2694 dst_data = GdipAlloc(sizeof(ARGB) * (dst_area.right - dst_area.left) * (dst_area.bottom - dst_area.top));
2697 GdipDeleteMatrix(dst_to_src);
2701 dst_stride = sizeof(ARGB) * (dst_area.right - dst_area.left);
2703 get_bitmap_sample_size(interpolation, imageAttributes->wrap,
2704 bitmap, srcx, srcy, srcwidth, srcheight, &src_area);
2706 src_data = GdipAlloc(sizeof(ARGB) * src_area.Width * src_area.Height);
2710 GdipDeleteMatrix(dst_to_src);
2713 src_stride = sizeof(ARGB) * src_area.Width;
2715 /* Read the bits we need from the source bitmap into an ARGB buffer. */
2716 lockeddata.Width = src_area.Width;
2717 lockeddata.Height = src_area.Height;
2718 lockeddata.Stride = src_stride;
2719 lockeddata.PixelFormat = PixelFormat32bppARGB;
2720 lockeddata.Scan0 = src_data;
2722 stat = GdipBitmapLockBits(bitmap, &src_area, ImageLockModeRead|ImageLockModeUserInputBuf,
2723 PixelFormat32bppARGB, &lockeddata);
2726 stat = GdipBitmapUnlockBits(bitmap, &lockeddata);
2730 if (src_data != dst_data)
2733 GdipDeleteMatrix(dst_to_src);
2737 apply_image_attributes(imageAttributes, src_data,
2738 src_area.Width, src_area.Height,
2739 src_stride, ColorAdjustTypeBitmap);
2741 /* Transform the bits as needed to the destination. */
2742 GdipTransformMatrixPoints(dst_to_src, dst_to_src_points, 3);
2744 x_dx = dst_to_src_points[1].X - dst_to_src_points[0].X;
2745 x_dy = dst_to_src_points[1].Y - dst_to_src_points[0].Y;
2746 y_dx = dst_to_src_points[2].X - dst_to_src_points[0].X;
2747 y_dy = dst_to_src_points[2].Y - dst_to_src_points[0].Y;
2749 for (x=dst_area.left; x<dst_area.right; x++)
2751 for (y=dst_area.top; y<dst_area.bottom; y++)
2753 GpPointF src_pointf;
2756 src_pointf.X = dst_to_src_points[0].X + x * x_dx + y * y_dx;
2757 src_pointf.Y = dst_to_src_points[0].Y + x * x_dy + y * y_dy;
2759 dst_color = (ARGB*)(dst_data + dst_stride * (y - dst_area.top) + sizeof(ARGB) * (x - dst_area.left));
2761 if (src_pointf.X >= srcx && src_pointf.X < srcx + srcwidth && src_pointf.Y >= srcy && src_pointf.Y < srcy+srcheight)
2762 *dst_color = resample_bitmap_pixel(&src_area, src_data, bitmap->width, bitmap->height, &src_pointf, imageAttributes, interpolation);
2768 GdipDeleteMatrix(dst_to_src);
2772 stat = alpha_blend_pixels(graphics, dst_area.left, dst_area.top,
2773 dst_data, dst_area.right - dst_area.left, dst_area.bottom - dst_area.top, dst_stride);
2782 int temp_hdc=0, temp_bitmap=0;
2783 HBITMAP hbitmap, old_hbm=NULL;
2785 if (!(bitmap->format == PixelFormat16bppRGB555 ||
2786 bitmap->format == PixelFormat24bppRGB ||
2787 bitmap->format == PixelFormat32bppRGB ||
2788 bitmap->format == PixelFormat32bppPARGB))
2790 BITMAPINFOHEADER bih;
2792 PixelFormat dst_format;
2794 /* we can't draw a bitmap of this format directly */
2795 hdc = CreateCompatibleDC(0);
2799 bih.biSize = sizeof(BITMAPINFOHEADER);
2800 bih.biWidth = bitmap->width;
2801 bih.biHeight = -bitmap->height;
2803 bih.biBitCount = 32;
2804 bih.biCompression = BI_RGB;
2805 bih.biSizeImage = 0;
2806 bih.biXPelsPerMeter = 0;
2807 bih.biYPelsPerMeter = 0;
2809 bih.biClrImportant = 0;
2811 hbitmap = CreateDIBSection(hdc, (BITMAPINFO*)&bih, DIB_RGB_COLORS,
2812 (void**)&temp_bits, NULL, 0);
2814 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2815 dst_format = PixelFormat32bppPARGB;
2817 dst_format = PixelFormat32bppRGB;
2819 convert_pixels(bitmap->width, bitmap->height,
2820 bitmap->width*4, temp_bits, dst_format,
2821 bitmap->stride, bitmap->bits, bitmap->format, bitmap->image.palette_entries);
2825 hbitmap = bitmap->hbitmap;
2827 temp_hdc = (hdc == 0);
2832 if (!hdc) hdc = CreateCompatibleDC(0);
2833 old_hbm = SelectObject(hdc, hbitmap);
2836 if (bitmap->format & (PixelFormatAlpha|PixelFormatPAlpha))
2840 bf.BlendOp = AC_SRC_OVER;
2842 bf.SourceConstantAlpha = 255;
2843 bf.AlphaFormat = AC_SRC_ALPHA;
2845 GdiAlphaBlend(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2846 hdc, srcx, srcy, srcwidth, srcheight, bf);
2850 StretchBlt(graphics->hdc, pti[0].x, pti[0].y, pti[1].x-pti[0].x, pti[2].y-pti[0].y,
2851 hdc, srcx, srcy, srcwidth, srcheight, SRCCOPY);
2856 SelectObject(hdc, old_hbm);
2861 DeleteObject(hbitmap);
2866 ERR("GpImage with no IPicture or HBITMAP?!\n");
2867 return NotImplemented;
2873 GpStatus WINGDIPAPI GdipDrawImagePointsRectI(GpGraphics *graphics, GpImage *image,
2874 GDIPCONST GpPoint *points, INT count, INT srcx, INT srcy, INT srcwidth,
2875 INT srcheight, GpUnit srcUnit, GDIPCONST GpImageAttributes* imageAttributes,
2876 DrawImageAbort callback, VOID * callbackData)
2878 GpPointF pointsF[3];
2881 TRACE("(%p, %p, %p, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n", graphics, image, points, count,
2882 srcx, srcy, srcwidth, srcheight, srcUnit, imageAttributes, callback,
2885 if(!points || count!=3)
2886 return InvalidParameter;
2888 for(i = 0; i < count; i++){
2889 pointsF[i].X = (REAL)points[i].X;
2890 pointsF[i].Y = (REAL)points[i].Y;
2893 return GdipDrawImagePointsRect(graphics, image, pointsF, count, (REAL)srcx, (REAL)srcy,
2894 (REAL)srcwidth, (REAL)srcheight, srcUnit, imageAttributes,
2895 callback, callbackData);
2898 GpStatus WINGDIPAPI GdipDrawImageRectRect(GpGraphics *graphics, GpImage *image,
2899 REAL dstx, REAL dsty, REAL dstwidth, REAL dstheight, REAL srcx, REAL srcy,
2900 REAL srcwidth, REAL srcheight, GpUnit srcUnit,
2901 GDIPCONST GpImageAttributes* imageattr, DrawImageAbort callback,
2902 VOID * callbackData)
2906 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f, %d, %p, %p, %p)\n",
2907 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2908 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2912 points[1].X = dstx + dstwidth;
2915 points[2].Y = dsty + dstheight;
2917 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2918 srcwidth, srcheight, srcUnit, imageattr, callback, callbackData);
2921 GpStatus WINGDIPAPI GdipDrawImageRectRectI(GpGraphics *graphics, GpImage *image,
2922 INT dstx, INT dsty, INT dstwidth, INT dstheight, INT srcx, INT srcy,
2923 INT srcwidth, INT srcheight, GpUnit srcUnit,
2924 GDIPCONST GpImageAttributes* imageAttributes, DrawImageAbort callback,
2925 VOID * callbackData)
2929 TRACE("(%p, %p, %d, %d, %d, %d, %d, %d, %d, %d, %d, %p, %p, %p)\n",
2930 graphics, image, dstx, dsty, dstwidth, dstheight, srcx, srcy,
2931 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2935 points[1].X = dstx + dstwidth;
2938 points[2].Y = dsty + dstheight;
2940 return GdipDrawImagePointsRect(graphics, image, points, 3, srcx, srcy,
2941 srcwidth, srcheight, srcUnit, imageAttributes, callback, callbackData);
2944 GpStatus WINGDIPAPI GdipDrawImageRect(GpGraphics *graphics, GpImage *image,
2945 REAL x, REAL y, REAL width, REAL height)
2951 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, image, x, y, width, height);
2953 if(!graphics || !image)
2954 return InvalidParameter;
2956 ret = GdipGetImageBounds(image, &bounds, &unit);
2960 return GdipDrawImageRectRect(graphics, image, x, y, width, height,
2961 bounds.X, bounds.Y, bounds.Width, bounds.Height,
2962 unit, NULL, NULL, NULL);
2965 GpStatus WINGDIPAPI GdipDrawImageRectI(GpGraphics *graphics, GpImage *image,
2966 INT x, INT y, INT width, INT height)
2968 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, image, x, y, width, height);
2970 return GdipDrawImageRect(graphics, image, (REAL)x, (REAL)y, (REAL)width, (REAL)height);
2973 GpStatus WINGDIPAPI GdipDrawLine(GpGraphics *graphics, GpPen *pen, REAL x1,
2974 REAL y1, REAL x2, REAL y2)
2980 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x1, y1, x2, y2);
2982 if(!pen || !graphics)
2983 return InvalidParameter;
2990 FIXME("graphics object has no HDC\n");
2999 save_state = prepare_dc(graphics, pen);
3001 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
3003 restore_dc(graphics, save_state);
3008 GpStatus WINGDIPAPI GdipDrawLineI(GpGraphics *graphics, GpPen *pen, INT x1,
3009 INT y1, INT x2, INT y2)
3015 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x1, y1, x2, y2);
3017 if(!pen || !graphics)
3018 return InvalidParameter;
3025 FIXME("graphics object has no HDC\n");
3034 save_state = prepare_dc(graphics, pen);
3036 retval = draw_polyline(graphics, pen, pt, 2, TRUE);
3038 restore_dc(graphics, save_state);
3043 GpStatus WINGDIPAPI GdipDrawLines(GpGraphics *graphics, GpPen *pen, GDIPCONST
3044 GpPointF *points, INT count)
3049 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3051 if(!pen || !graphics || (count < 2))
3052 return InvalidParameter;
3059 FIXME("graphics object has no HDC\n");
3063 save_state = prepare_dc(graphics, pen);
3065 retval = draw_polyline(graphics, pen, points, count, TRUE);
3067 restore_dc(graphics, save_state);
3072 GpStatus WINGDIPAPI GdipDrawLinesI(GpGraphics *graphics, GpPen *pen, GDIPCONST
3073 GpPoint *points, INT count)
3077 GpPointF *ptf = NULL;
3080 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
3082 if(!pen || !graphics || (count < 2))
3083 return InvalidParameter;
3090 FIXME("graphics object has no HDC\n");
3094 ptf = GdipAlloc(count * sizeof(GpPointF));
3095 if(!ptf) return OutOfMemory;
3097 for(i = 0; i < count; i ++){
3098 ptf[i].X = (REAL) points[i].X;
3099 ptf[i].Y = (REAL) points[i].Y;
3102 save_state = prepare_dc(graphics, pen);
3104 retval = draw_polyline(graphics, pen, ptf, count, TRUE);
3106 restore_dc(graphics, save_state);
3112 GpStatus WINGDIPAPI GdipDrawPath(GpGraphics *graphics, GpPen *pen, GpPath *path)
3117 TRACE("(%p, %p, %p)\n", graphics, pen, path);
3119 if(!pen || !graphics)
3120 return InvalidParameter;
3127 FIXME("graphics object has no HDC\n");
3131 save_state = prepare_dc(graphics, pen);
3133 retval = draw_poly(graphics, pen, path->pathdata.Points,
3134 path->pathdata.Types, path->pathdata.Count, TRUE);
3136 restore_dc(graphics, save_state);
3141 GpStatus WINGDIPAPI GdipDrawPie(GpGraphics *graphics, GpPen *pen, REAL x,
3142 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3146 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y,
3147 width, height, startAngle, sweepAngle);
3149 if(!graphics || !pen)
3150 return InvalidParameter;
3157 FIXME("graphics object has no HDC\n");
3161 save_state = prepare_dc(graphics, pen);
3162 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3164 draw_pie(graphics, x, y, width, height, startAngle, sweepAngle);
3166 restore_dc(graphics, save_state);
3171 GpStatus WINGDIPAPI GdipDrawPieI(GpGraphics *graphics, GpPen *pen, INT x,
3172 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3174 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n", graphics, pen, x, y,
3175 width, height, startAngle, sweepAngle);
3177 return GdipDrawPie(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3180 GpStatus WINGDIPAPI GdipDrawRectangle(GpGraphics *graphics, GpPen *pen, REAL x,
3181 REAL y, REAL width, REAL height)
3187 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, pen, x, y, width, height);
3189 if(!pen || !graphics)
3190 return InvalidParameter;
3197 FIXME("graphics object has no HDC\n");
3203 ptf[1].X = x + width;
3205 ptf[2].X = x + width;
3206 ptf[2].Y = y + height;
3208 ptf[3].Y = y + height;
3210 save_state = prepare_dc(graphics, pen);
3211 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3213 transform_and_round_points(graphics, pti, ptf, 4);
3214 Polygon(graphics->hdc, pti, 4);
3216 restore_dc(graphics, save_state);
3221 GpStatus WINGDIPAPI GdipDrawRectangleI(GpGraphics *graphics, GpPen *pen, INT x,
3222 INT y, INT width, INT height)
3224 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, pen, x, y, width, height);
3226 return GdipDrawRectangle(graphics,pen,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3229 GpStatus WINGDIPAPI GdipDrawRectangles(GpGraphics *graphics, GpPen *pen,
3230 GDIPCONST GpRectF* rects, INT count)
3236 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3238 if(!graphics || !pen || !rects || count < 1)
3239 return InvalidParameter;
3246 FIXME("graphics object has no HDC\n");
3250 ptf = GdipAlloc(4 * count * sizeof(GpPointF));
3251 pti = GdipAlloc(4 * count * sizeof(POINT));
3259 for(i = 0; i < count; i++){
3260 ptf[4 * i + 3].X = ptf[4 * i].X = rects[i].X;
3261 ptf[4 * i + 1].Y = ptf[4 * i].Y = rects[i].Y;
3262 ptf[4 * i + 2].X = ptf[4 * i + 1].X = rects[i].X + rects[i].Width;
3263 ptf[4 * i + 3].Y = ptf[4 * i + 2].Y = rects[i].Y + rects[i].Height;
3266 save_state = prepare_dc(graphics, pen);
3267 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
3269 transform_and_round_points(graphics, pti, ptf, 4 * count);
3271 for(i = 0; i < count; i++)
3272 Polygon(graphics->hdc, &pti[4 * i], 4);
3274 restore_dc(graphics, save_state);
3282 GpStatus WINGDIPAPI GdipDrawRectanglesI(GpGraphics *graphics, GpPen *pen,
3283 GDIPCONST GpRect* rects, INT count)
3289 TRACE("(%p, %p, %p, %d)\n", graphics, pen, rects, count);
3291 if(!rects || count<=0)
3292 return InvalidParameter;
3294 rectsF = GdipAlloc(sizeof(GpRectF) * count);
3298 for(i = 0;i < count;i++){
3299 rectsF[i].X = (REAL)rects[i].X;
3300 rectsF[i].Y = (REAL)rects[i].Y;
3301 rectsF[i].Width = (REAL)rects[i].Width;
3302 rectsF[i].Height = (REAL)rects[i].Height;
3305 ret = GdipDrawRectangles(graphics, pen, rectsF, count);
3311 GpStatus WINGDIPAPI GdipFillClosedCurve2(GpGraphics *graphics, GpBrush *brush,
3312 GDIPCONST GpPointF *points, INT count, REAL tension, GpFillMode fill)
3317 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3318 count, tension, fill);
3320 if(!graphics || !brush || !points)
3321 return InvalidParameter;
3326 if(count == 1) /* Do nothing */
3329 stat = GdipCreatePath(fill, &path);
3333 stat = GdipAddPathClosedCurve2(path, points, count, tension);
3335 GdipDeletePath(path);
3339 stat = GdipFillPath(graphics, brush, path);
3341 GdipDeletePath(path);
3345 GdipDeletePath(path);
3350 GpStatus WINGDIPAPI GdipFillClosedCurve2I(GpGraphics *graphics, GpBrush *brush,
3351 GDIPCONST GpPoint *points, INT count, REAL tension, GpFillMode fill)
3357 TRACE("(%p, %p, %p, %d, %.2f, %d)\n", graphics, brush, points,
3358 count, tension, fill);
3360 if(!points || count == 0)
3361 return InvalidParameter;
3363 if(count == 1) /* Do nothing */
3366 ptf = GdipAlloc(sizeof(GpPointF)*count);
3370 for(i = 0;i < count;i++){
3371 ptf[i].X = (REAL)points[i].X;
3372 ptf[i].Y = (REAL)points[i].Y;
3375 stat = GdipFillClosedCurve2(graphics, brush, ptf, count, tension, fill);
3382 GpStatus WINGDIPAPI GdipFillClosedCurve(GpGraphics *graphics, GpBrush *brush,
3383 GDIPCONST GpPointF *points, INT count)
3385 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3386 return GdipFillClosedCurve2(graphics, brush, points, count,
3387 0.5f, FillModeAlternate);
3390 GpStatus WINGDIPAPI GdipFillClosedCurveI(GpGraphics *graphics, GpBrush *brush,
3391 GDIPCONST GpPoint *points, INT count)
3393 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3394 return GdipFillClosedCurve2I(graphics, brush, points, count,
3395 0.5f, FillModeAlternate);
3398 GpStatus WINGDIPAPI GdipFillEllipse(GpGraphics *graphics, GpBrush *brush, REAL x,
3399 REAL y, REAL width, REAL height)
3404 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3406 if(!graphics || !brush)
3407 return InvalidParameter;
3412 stat = GdipCreatePath(FillModeAlternate, &path);
3416 stat = GdipAddPathEllipse(path, x, y, width, height);
3419 stat = GdipFillPath(graphics, brush, path);
3421 GdipDeletePath(path);
3427 GpStatus WINGDIPAPI GdipFillEllipseI(GpGraphics *graphics, GpBrush *brush, INT x,
3428 INT y, INT width, INT height)
3430 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3432 return GdipFillEllipse(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height);
3435 static GpStatus GDI32_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3440 if(!graphics->hdc || !brush_can_fill_path(brush))
3441 return NotImplemented;
3443 save_state = SaveDC(graphics->hdc);
3444 EndPath(graphics->hdc);
3445 SetPolyFillMode(graphics->hdc, (path->fill == FillModeAlternate ? ALTERNATE
3448 BeginPath(graphics->hdc);
3449 retval = draw_poly(graphics, NULL, path->pathdata.Points,
3450 path->pathdata.Types, path->pathdata.Count, FALSE);
3455 EndPath(graphics->hdc);
3456 brush_fill_path(graphics, brush);
3461 RestoreDC(graphics->hdc, save_state);
3466 static GpStatus SOFTWARE_GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3471 if (!brush_can_fill_pixels(brush))
3472 return NotImplemented;
3474 /* FIXME: This could probably be done more efficiently without regions. */
3476 stat = GdipCreateRegionPath(path, &rgn);
3480 stat = GdipFillRegion(graphics, brush, rgn);
3482 GdipDeleteRegion(rgn);
3488 GpStatus WINGDIPAPI GdipFillPath(GpGraphics *graphics, GpBrush *brush, GpPath *path)
3490 GpStatus stat = NotImplemented;
3492 TRACE("(%p, %p, %p)\n", graphics, brush, path);
3494 if(!brush || !graphics || !path)
3495 return InvalidParameter;
3500 if (!graphics->image)
3501 stat = GDI32_GdipFillPath(graphics, brush, path);
3503 if (stat == NotImplemented)
3504 stat = SOFTWARE_GdipFillPath(graphics, brush, path);
3506 if (stat == NotImplemented)
3508 FIXME("Not implemented for brushtype %i\n", brush->bt);
3515 GpStatus WINGDIPAPI GdipFillPie(GpGraphics *graphics, GpBrush *brush, REAL x,
3516 REAL y, REAL width, REAL height, REAL startAngle, REAL sweepAngle)
3521 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %.2f, %.2f)\n",
3522 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3524 if(!graphics || !brush)
3525 return InvalidParameter;
3530 stat = GdipCreatePath(FillModeAlternate, &path);
3534 stat = GdipAddPathPie(path, x, y, width, height, startAngle, sweepAngle);
3537 stat = GdipFillPath(graphics, brush, path);
3539 GdipDeletePath(path);
3545 GpStatus WINGDIPAPI GdipFillPieI(GpGraphics *graphics, GpBrush *brush, INT x,
3546 INT y, INT width, INT height, REAL startAngle, REAL sweepAngle)
3548 TRACE("(%p, %p, %d, %d, %d, %d, %.2f, %.2f)\n",
3549 graphics, brush, x, y, width, height, startAngle, sweepAngle);
3551 return GdipFillPie(graphics,brush,(REAL)x,(REAL)y,(REAL)width,(REAL)height,startAngle,sweepAngle);
3554 GpStatus WINGDIPAPI GdipFillPolygon(GpGraphics *graphics, GpBrush *brush,
3555 GDIPCONST GpPointF *points, INT count, GpFillMode fillMode)
3560 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3562 if(!graphics || !brush || !points || !count)
3563 return InvalidParameter;
3568 stat = GdipCreatePath(fillMode, &path);
3572 stat = GdipAddPathPolygon(path, points, count);
3575 stat = GdipFillPath(graphics, brush, path);
3577 GdipDeletePath(path);
3583 GpStatus WINGDIPAPI GdipFillPolygonI(GpGraphics *graphics, GpBrush *brush,
3584 GDIPCONST GpPoint *points, INT count, GpFillMode fillMode)
3589 TRACE("(%p, %p, %p, %d, %d)\n", graphics, brush, points, count, fillMode);
3591 if(!graphics || !brush || !points || !count)
3592 return InvalidParameter;
3597 stat = GdipCreatePath(fillMode, &path);
3601 stat = GdipAddPathPolygonI(path, points, count);
3604 stat = GdipFillPath(graphics, brush, path);
3606 GdipDeletePath(path);
3612 GpStatus WINGDIPAPI GdipFillPolygon2(GpGraphics *graphics, GpBrush *brush,
3613 GDIPCONST GpPointF *points, INT count)
3615 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3617 return GdipFillPolygon(graphics, brush, points, count, FillModeAlternate);
3620 GpStatus WINGDIPAPI GdipFillPolygon2I(GpGraphics *graphics, GpBrush *brush,
3621 GDIPCONST GpPoint *points, INT count)
3623 TRACE("(%p, %p, %p, %d)\n", graphics, brush, points, count);
3625 return GdipFillPolygonI(graphics, brush, points, count, FillModeAlternate);
3628 GpStatus WINGDIPAPI GdipFillRectangle(GpGraphics *graphics, GpBrush *brush,
3629 REAL x, REAL y, REAL width, REAL height)
3634 TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f)\n", graphics, brush, x, y, width, height);
3636 if(!graphics || !brush)
3637 return InvalidParameter;
3642 stat = GdipCreatePath(FillModeAlternate, &path);
3646 stat = GdipAddPathRectangle(path, x, y, width, height);
3649 stat = GdipFillPath(graphics, brush, path);
3651 GdipDeletePath(path);
3657 GpStatus WINGDIPAPI GdipFillRectangleI(GpGraphics *graphics, GpBrush *brush,
3658 INT x, INT y, INT width, INT height)
3660 TRACE("(%p, %p, %d, %d, %d, %d)\n", graphics, brush, x, y, width, height);
3662 return GdipFillRectangle(graphics, brush, x, y, width, height);
3665 GpStatus WINGDIPAPI GdipFillRectangles(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRectF *rects,
3671 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3674 return InvalidParameter;
3676 for(i = 0; i < count; i++){
3677 ret = GdipFillRectangle(graphics, brush, rects[i].X, rects[i].Y, rects[i].Width, rects[i].Height);
3678 if(ret != Ok) return ret;
3684 GpStatus WINGDIPAPI GdipFillRectanglesI(GpGraphics *graphics, GpBrush *brush, GDIPCONST GpRect *rects,
3691 TRACE("(%p, %p, %p, %d)\n", graphics, brush, rects, count);
3693 if(!rects || count <= 0)
3694 return InvalidParameter;
3696 rectsF = GdipAlloc(sizeof(GpRectF)*count);
3700 for(i = 0; i < count; i++){
3701 rectsF[i].X = (REAL)rects[i].X;
3702 rectsF[i].Y = (REAL)rects[i].Y;
3703 rectsF[i].X = (REAL)rects[i].Width;
3704 rectsF[i].Height = (REAL)rects[i].Height;
3707 ret = GdipFillRectangles(graphics,brush,rectsF,count);
3713 static GpStatus GDI32_GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3721 if(!graphics->hdc || !brush_can_fill_path(brush))
3722 return NotImplemented;
3724 status = GdipGetRegionHRgn(region, graphics, &hrgn);
3728 save_state = SaveDC(graphics->hdc);
3729 EndPath(graphics->hdc);
3731 ExtSelectClipRgn(graphics->hdc, hrgn, RGN_AND);
3733 if (GetClipBox(graphics->hdc, &rc) != NULLREGION)
3735 BeginPath(graphics->hdc);
3736 Rectangle(graphics->hdc, rc.left, rc.top, rc.right, rc.bottom);
3737 EndPath(graphics->hdc);
3739 brush_fill_path(graphics, brush);
3742 RestoreDC(graphics->hdc, save_state);
3749 static GpStatus SOFTWARE_GdipFillRegion(GpGraphics *graphics, GpBrush *brush,
3753 GpRegion *temp_region;
3754 GpMatrix *world_to_device, *identity;
3755 GpRectF graphics_bounds;
3756 UINT scans_count, i;
3758 GpRect *scans = NULL;
3761 if (!brush_can_fill_pixels(brush))
3762 return NotImplemented;
3764 stat = get_graphics_bounds(graphics, &graphics_bounds);
3767 stat = GdipCloneRegion(region, &temp_region);
3771 stat = get_graphics_transform(graphics, CoordinateSpaceDevice,
3772 CoordinateSpaceWorld, &world_to_device);
3776 stat = GdipTransformRegion(temp_region, world_to_device);
3778 GdipDeleteMatrix(world_to_device);
3782 stat = GdipCombineRegionRect(temp_region, &graphics_bounds, CombineModeIntersect);
3785 stat = GdipCreateMatrix(&identity);
3789 stat = GdipGetRegionScansCount(temp_region, &scans_count, identity);
3791 if (stat == Ok && scans_count != 0)
3793 scans = GdipAlloc(sizeof(*scans) * scans_count);
3799 stat = GdipGetRegionScansI(temp_region, scans, &dummy, identity);
3806 GdipDeleteMatrix(identity);
3809 GdipDeleteRegion(temp_region);
3812 if (stat == Ok && scans_count == 0)
3817 if (!graphics->image)
3819 /* If we have to go through gdi32, use as few alpha blends as possible. */
3820 INT min_x, min_y, max_x, max_y;
3821 UINT data_width, data_height;
3825 max_x = scans[0].X+scans[0].Width;
3826 max_y = scans[0].Y+scans[0].Height;
3828 for (i=1; i<scans_count; i++)
3830 min_x = min(min_x, scans[i].X);
3831 min_y = min(min_y, scans[i].Y);
3832 max_x = max(max_x, scans[i].X+scans[i].Width);
3833 max_y = max(max_y, scans[i].Y+scans[i].Height);
3836 data_width = max_x - min_x;
3837 data_height = max_y - min_y;
3839 pixel_data = GdipAlloc(sizeof(*pixel_data) * data_width * data_height);
3845 for (i=0; i<scans_count; i++)
3847 stat = brush_fill_pixels(graphics, brush,
3848 pixel_data + (scans[i].X - min_x) + (scans[i].Y - min_y) * data_width,
3849 &scans[i], data_width);
3857 stat = alpha_blend_pixels(graphics, min_x, min_y,
3858 (BYTE*)pixel_data, data_width, data_height,
3862 GdipFree(pixel_data);
3869 for (i=0; i<scans_count; i++)
3871 UINT size = scans[i].Width * scans[i].Height;
3873 if (size > max_size)
3877 pixel_data = GdipAlloc(sizeof(*pixel_data) * max_size);
3883 for (i=0; i<scans_count; i++)
3885 stat = brush_fill_pixels(graphics, brush, pixel_data, &scans[i],
3890 stat = alpha_blend_pixels(graphics, scans[i].X, scans[i].Y,
3891 (BYTE*)pixel_data, scans[i].Width, scans[i].Height,
3892 scans[i].Width * 4);
3899 GdipFree(pixel_data);
3909 /*****************************************************************************
3910 * GdipFillRegion [GDIPLUS.@]
3912 GpStatus WINGDIPAPI GdipFillRegion(GpGraphics* graphics, GpBrush* brush,
3915 GpStatus stat = NotImplemented;
3917 TRACE("(%p, %p, %p)\n", graphics, brush, region);
3919 if (!(graphics && brush && region))
3920 return InvalidParameter;
3925 if (!graphics->image)
3926 stat = GDI32_GdipFillRegion(graphics, brush, region);
3928 if (stat == NotImplemented)
3929 stat = SOFTWARE_GdipFillRegion(graphics, brush, region);
3931 if (stat == NotImplemented)
3933 FIXME("not implemented for brushtype %i\n", brush->bt);
3940 GpStatus WINGDIPAPI GdipFlush(GpGraphics *graphics, GpFlushIntention intention)
3942 TRACE("(%p,%u)\n", graphics, intention);
3945 return InvalidParameter;
3950 /* We have no internal operation queue, so there's no need to clear it. */
3958 /*****************************************************************************
3959 * GdipGetClipBounds [GDIPLUS.@]
3961 GpStatus WINGDIPAPI GdipGetClipBounds(GpGraphics *graphics, GpRectF *rect)
3963 TRACE("(%p, %p)\n", graphics, rect);
3966 return InvalidParameter;
3971 return GdipGetRegionBounds(graphics->clip, graphics, rect);
3974 /*****************************************************************************
3975 * GdipGetClipBoundsI [GDIPLUS.@]
3977 GpStatus WINGDIPAPI GdipGetClipBoundsI(GpGraphics *graphics, GpRect *rect)
3979 TRACE("(%p, %p)\n", graphics, rect);
3982 return InvalidParameter;
3987 return GdipGetRegionBoundsI(graphics->clip, graphics, rect);
3990 /* FIXME: Compositing mode is not used anywhere except the getter/setter. */
3991 GpStatus WINGDIPAPI GdipGetCompositingMode(GpGraphics *graphics,
3992 CompositingMode *mode)
3994 TRACE("(%p, %p)\n", graphics, mode);
3996 if(!graphics || !mode)
3997 return InvalidParameter;
4002 *mode = graphics->compmode;
4007 /* FIXME: Compositing quality is not used anywhere except the getter/setter. */
4008 GpStatus WINGDIPAPI GdipGetCompositingQuality(GpGraphics *graphics,
4009 CompositingQuality *quality)
4011 TRACE("(%p, %p)\n", graphics, quality);
4013 if(!graphics || !quality)
4014 return InvalidParameter;
4019 *quality = graphics->compqual;
4024 /* FIXME: Interpolation mode is not used anywhere except the getter/setter. */
4025 GpStatus WINGDIPAPI GdipGetInterpolationMode(GpGraphics *graphics,
4026 InterpolationMode *mode)
4028 TRACE("(%p, %p)\n", graphics, mode);
4030 if(!graphics || !mode)
4031 return InvalidParameter;
4036 *mode = graphics->interpolation;
4041 /* FIXME: Need to handle color depths less than 24bpp */
4042 GpStatus WINGDIPAPI GdipGetNearestColor(GpGraphics *graphics, ARGB* argb)
4044 FIXME("(%p, %p): Passing color unmodified\n", graphics, argb);
4046 if(!graphics || !argb)
4047 return InvalidParameter;
4055 GpStatus WINGDIPAPI GdipGetPageScale(GpGraphics *graphics, REAL *scale)
4057 TRACE("(%p, %p)\n", graphics, scale);
4059 if(!graphics || !scale)
4060 return InvalidParameter;
4065 *scale = graphics->scale;
4070 GpStatus WINGDIPAPI GdipGetPageUnit(GpGraphics *graphics, GpUnit *unit)
4072 TRACE("(%p, %p)\n", graphics, unit);
4074 if(!graphics || !unit)
4075 return InvalidParameter;
4080 *unit = graphics->unit;
4085 /* FIXME: Pixel offset mode is not used anywhere except the getter/setter. */
4086 GpStatus WINGDIPAPI GdipGetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
4089 TRACE("(%p, %p)\n", graphics, mode);
4091 if(!graphics || !mode)
4092 return InvalidParameter;
4097 *mode = graphics->pixeloffset;
4102 /* FIXME: Smoothing mode is not used anywhere except the getter/setter. */
4103 GpStatus WINGDIPAPI GdipGetSmoothingMode(GpGraphics *graphics, SmoothingMode *mode)
4105 TRACE("(%p, %p)\n", graphics, mode);
4107 if(!graphics || !mode)
4108 return InvalidParameter;
4113 *mode = graphics->smoothing;
4118 GpStatus WINGDIPAPI GdipGetTextContrast(GpGraphics *graphics, UINT *contrast)
4120 TRACE("(%p, %p)\n", graphics, contrast);
4122 if(!graphics || !contrast)
4123 return InvalidParameter;
4125 *contrast = graphics->textcontrast;
4130 /* FIXME: Text rendering hint is not used anywhere except the getter/setter. */
4131 GpStatus WINGDIPAPI GdipGetTextRenderingHint(GpGraphics *graphics,
4132 TextRenderingHint *hint)
4134 TRACE("(%p, %p)\n", graphics, hint);
4136 if(!graphics || !hint)
4137 return InvalidParameter;
4142 *hint = graphics->texthint;
4147 GpStatus WINGDIPAPI GdipGetVisibleClipBounds(GpGraphics *graphics, GpRectF *rect)
4152 TRACE("(%p, %p)\n", graphics, rect);
4154 if(!graphics || !rect)
4155 return InvalidParameter;
4160 /* intersect window and graphics clipping regions */
4161 if((stat = GdipCreateRegion(&clip_rgn)) != Ok)
4164 if((stat = get_visible_clip_region(graphics, clip_rgn)) != Ok)
4167 /* get bounds of the region */
4168 stat = GdipGetRegionBounds(clip_rgn, graphics, rect);
4171 GdipDeleteRegion(clip_rgn);
4176 GpStatus WINGDIPAPI GdipGetVisibleClipBoundsI(GpGraphics *graphics, GpRect *rect)
4181 TRACE("(%p, %p)\n", graphics, rect);
4183 if(!graphics || !rect)
4184 return InvalidParameter;
4186 if((stat = GdipGetVisibleClipBounds(graphics, &rectf)) == Ok)
4188 rect->X = roundr(rectf.X);
4189 rect->Y = roundr(rectf.Y);
4190 rect->Width = roundr(rectf.Width);
4191 rect->Height = roundr(rectf.Height);
4197 GpStatus WINGDIPAPI GdipGetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
4199 TRACE("(%p, %p)\n", graphics, matrix);
4201 if(!graphics || !matrix)
4202 return InvalidParameter;
4207 *matrix = *graphics->worldtrans;
4211 GpStatus WINGDIPAPI GdipGraphicsClear(GpGraphics *graphics, ARGB color)
4217 TRACE("(%p, %x)\n", graphics, color);
4220 return InvalidParameter;
4225 if((stat = GdipCreateSolidFill(color, &brush)) != Ok)
4228 if((stat = get_graphics_bounds(graphics, &wnd_rect)) != Ok){
4229 GdipDeleteBrush((GpBrush*)brush);
4233 GdipFillRectangle(graphics, (GpBrush*)brush, wnd_rect.X, wnd_rect.Y,
4234 wnd_rect.Width, wnd_rect.Height);
4236 GdipDeleteBrush((GpBrush*)brush);
4241 GpStatus WINGDIPAPI GdipIsClipEmpty(GpGraphics *graphics, BOOL *res)
4243 TRACE("(%p, %p)\n", graphics, res);
4245 if(!graphics || !res)
4246 return InvalidParameter;
4248 return GdipIsEmptyRegion(graphics->clip, graphics, res);
4251 GpStatus WINGDIPAPI GdipIsVisiblePoint(GpGraphics *graphics, REAL x, REAL y, BOOL *result)
4257 TRACE("(%p, %.2f, %.2f, %p)\n", graphics, x, y, result);
4259 if(!graphics || !result)
4260 return InvalidParameter;
4267 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4268 CoordinateSpaceWorld, &pt, 1)) != Ok)
4271 if((stat = GdipCreateRegion(&rgn)) != Ok)
4274 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4277 stat = GdipIsVisibleRegionPoint(rgn, pt.X, pt.Y, graphics, result);
4280 GdipDeleteRegion(rgn);
4284 GpStatus WINGDIPAPI GdipIsVisiblePointI(GpGraphics *graphics, INT x, INT y, BOOL *result)
4286 return GdipIsVisiblePoint(graphics, (REAL)x, (REAL)y, result);
4289 GpStatus WINGDIPAPI GdipIsVisibleRect(GpGraphics *graphics, REAL x, REAL y, REAL width, REAL height, BOOL *result)
4295 TRACE("(%p %.2f %.2f %.2f %.2f %p)\n", graphics, x, y, width, height, result);
4297 if(!graphics || !result)
4298 return InvalidParameter;
4305 pts[1].X = x + width;
4306 pts[1].Y = y + height;
4308 if((stat = GdipTransformPoints(graphics, CoordinateSpaceDevice,
4309 CoordinateSpaceWorld, pts, 2)) != Ok)
4312 pts[1].X -= pts[0].X;
4313 pts[1].Y -= pts[0].Y;
4315 if((stat = GdipCreateRegion(&rgn)) != Ok)
4318 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
4321 stat = GdipIsVisibleRegionRect(rgn, pts[0].X, pts[0].Y, pts[1].X, pts[1].Y, graphics, result);
4324 GdipDeleteRegion(rgn);
4328 GpStatus WINGDIPAPI GdipIsVisibleRectI(GpGraphics *graphics, INT x, INT y, INT width, INT height, BOOL *result)
4330 return GdipIsVisibleRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, result);
4333 GpStatus gdip_format_string(HDC hdc,
4334 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4335 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4336 gdip_format_string_callback callback, void *user_data)
4339 int sum = 0, height = 0, fit, fitcpy, i, j, lret, nwidth,
4340 nheight, lineend, lineno = 0;
4342 StringAlignment halign;
4346 if(length == -1) length = lstrlenW(string);
4348 stringdup = GdipAlloc((length + 1) * sizeof(WCHAR));
4349 if(!stringdup) return OutOfMemory;
4351 nwidth = roundr(rect->Width);
4352 nheight = roundr(rect->Height);
4354 if (rect->Width >= INT_MAX || rect->Width < 0.5) nwidth = INT_MAX;
4355 if (rect->Height >= INT_MAX || rect->Height < 0.5) nheight = INT_MAX;
4357 for(i = 0, j = 0; i < length; i++){
4358 /* FIXME: This makes the indexes passed to callback inaccurate. */
4359 if(!isprintW(string[i]) && (string[i] != '\n'))
4362 stringdup[j] = string[i];
4368 if (format) halign = format->align;
4369 else halign = StringAlignmentNear;
4371 while(sum < length){
4372 GetTextExtentExPointW(hdc, stringdup + sum, length - sum,
4373 nwidth, &fit, NULL, &size);
4379 for(lret = 0; lret < fit; lret++)
4380 if(*(stringdup + sum + lret) == '\n')
4383 /* Line break code (may look strange, but it imitates windows). */
4385 lineend = fit = lret; /* this is not an off-by-one error */
4386 else if(fit < (length - sum)){
4387 if(*(stringdup + sum + fit) == ' ')
4388 while(*(stringdup + sum + fit) == ' ')
4391 while(*(stringdup + sum + fit - 1) != ' '){
4394 if(*(stringdup + sum + fit) == '\t')
4403 while(*(stringdup + sum + lineend - 1) == ' ' ||
4404 *(stringdup + sum + lineend - 1) == '\t')
4410 GetTextExtentExPointW(hdc, stringdup + sum, lineend,
4411 nwidth, &j, NULL, &size);
4413 bounds.Width = size.cx;
4415 if(height + size.cy > nheight)
4416 bounds.Height = nheight - (height + size.cy);
4418 bounds.Height = size.cy;
4420 bounds.Y = rect->Y + height;
4424 case StringAlignmentNear:
4428 case StringAlignmentCenter:
4429 bounds.X = rect->X + (rect->Width/2) - (bounds.Width/2);
4431 case StringAlignmentFar:
4432 bounds.X = rect->X + rect->Width - bounds.Width;
4436 stat = callback(hdc, stringdup, sum, lineend,
4437 font, rect, format, lineno, &bounds, user_data);
4442 sum += fit + (lret < fitcpy ? 1 : 0);
4446 if(height > nheight)
4449 /* Stop if this was a linewrap (but not if it was a linebreak). */
4450 if((lret == fitcpy) && format && (format->attr & StringFormatFlagsNoWrap))
4454 GdipFree(stringdup);
4459 struct measure_ranges_args {
4463 static GpStatus measure_ranges_callback(HDC hdc,
4464 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4465 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4466 INT lineno, const RectF *bounds, void *user_data)
4470 struct measure_ranges_args *args = user_data;
4472 for (i=0; i<format->range_count; i++)
4474 INT range_start = max(index, format->character_ranges[i].First);
4475 INT range_end = min(index+length, format->character_ranges[i].First+format->character_ranges[i].Length);
4476 if (range_start < range_end)
4481 range_rect.Y = bounds->Y;
4482 range_rect.Height = bounds->Height;
4484 GetTextExtentExPointW(hdc, string + index, range_start - index,
4485 INT_MAX, NULL, NULL, &range_size);
4486 range_rect.X = bounds->X + range_size.cx;
4488 GetTextExtentExPointW(hdc, string + index, range_end - index,
4489 INT_MAX, NULL, NULL, &range_size);
4490 range_rect.Width = (bounds->X + range_size.cx) - range_rect.X;
4492 stat = GdipCombineRegionRect(args->regions[i], &range_rect, CombineModeUnion);
4501 GpStatus WINGDIPAPI GdipMeasureCharacterRanges(GpGraphics* graphics,
4502 GDIPCONST WCHAR* string, INT length, GDIPCONST GpFont* font,
4503 GDIPCONST RectF* layoutRect, GDIPCONST GpStringFormat *stringFormat,
4504 INT regionCount, GpRegion** regions)
4509 struct measure_ranges_args args;
4510 HDC hdc, temp_hdc=NULL;
4512 TRACE("(%p %s %d %p %s %p %d %p)\n", graphics, debugstr_w(string),
4513 length, font, debugstr_rectf(layoutRect), stringFormat, regionCount, regions);
4515 if (!(graphics && string && font && layoutRect && stringFormat && regions))
4516 return InvalidParameter;
4518 if (regionCount < stringFormat->range_count)
4519 return InvalidParameter;
4523 hdc = temp_hdc = CreateCompatibleDC(0);
4524 if (!temp_hdc) return OutOfMemory;
4527 hdc = graphics->hdc;
4529 if (stringFormat->attr)
4530 TRACE("may be ignoring some format flags: attr %x\n", stringFormat->attr);
4532 oldfont = SelectObject(hdc, CreateFontIndirectW(&font->lfw));
4534 for (i=0; i<stringFormat->range_count; i++)
4536 stat = GdipSetEmpty(regions[i]);
4541 args.regions = regions;
4543 stat = gdip_format_string(hdc, string, length, font, layoutRect, stringFormat,
4544 measure_ranges_callback, &args);
4546 DeleteObject(SelectObject(hdc, oldfont));
4554 struct measure_string_args {
4556 INT *codepointsfitted;
4560 static GpStatus measure_string_callback(HDC hdc,
4561 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4562 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4563 INT lineno, const RectF *bounds, void *user_data)
4565 struct measure_string_args *args = user_data;
4567 if (bounds->Width > args->bounds->Width)
4568 args->bounds->Width = bounds->Width;
4570 if (bounds->Height + bounds->Y > args->bounds->Height + args->bounds->Y)
4571 args->bounds->Height = bounds->Height + bounds->Y - args->bounds->Y;
4573 if (args->codepointsfitted)
4574 *args->codepointsfitted = index + length;
4576 if (args->linesfilled)
4577 (*args->linesfilled)++;
4582 /* Find the smallest rectangle that bounds the text when it is printed in rect
4583 * according to the format options listed in format. If rect has 0 width and
4584 * height, then just find the smallest rectangle that bounds the text when it's
4585 * printed at location (rect->X, rect-Y). */
4586 GpStatus WINGDIPAPI GdipMeasureString(GpGraphics *graphics,
4587 GDIPCONST WCHAR *string, INT length, GDIPCONST GpFont *font,
4588 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format, RectF *bounds,
4589 INT *codepointsfitted, INT *linesfilled)
4592 struct measure_string_args args;
4593 HDC temp_hdc=NULL, hdc;
4595 TRACE("(%p, %s, %i, %p, %s, %p, %p, %p, %p)\n", graphics,
4596 debugstr_wn(string, length), length, font, debugstr_rectf(rect), format,
4597 bounds, codepointsfitted, linesfilled);
4599 if(!graphics || !string || !font || !rect || !bounds)
4600 return InvalidParameter;
4604 hdc = temp_hdc = CreateCompatibleDC(0);
4605 if (!temp_hdc) return OutOfMemory;
4608 hdc = graphics->hdc;
4610 if(linesfilled) *linesfilled = 0;
4611 if(codepointsfitted) *codepointsfitted = 0;
4614 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4616 oldfont = SelectObject(hdc, CreateFontIndirectW(&font->lfw));
4618 bounds->X = rect->X;
4619 bounds->Y = rect->Y;
4620 bounds->Width = 0.0;
4621 bounds->Height = 0.0;
4623 args.bounds = bounds;
4624 args.codepointsfitted = codepointsfitted;
4625 args.linesfilled = linesfilled;
4627 gdip_format_string(hdc, string, length, font, rect, format,
4628 measure_string_callback, &args);
4630 DeleteObject(SelectObject(hdc, oldfont));
4638 struct draw_string_args {
4639 GpGraphics *graphics;
4640 GDIPCONST GpBrush *brush;
4641 REAL x, y, rel_width, rel_height, ascent;
4644 static GpStatus draw_string_callback(HDC hdc,
4645 GDIPCONST WCHAR *string, INT index, INT length, GDIPCONST GpFont *font,
4646 GDIPCONST RectF *rect, GDIPCONST GpStringFormat *format,
4647 INT lineno, const RectF *bounds, void *user_data)
4649 struct draw_string_args *args = user_data;
4652 position.X = args->x + bounds->X / args->rel_width;
4653 position.Y = args->y + bounds->Y / args->rel_height + args->ascent;
4655 return GdipDrawDriverString(args->graphics, &string[index], length, font,
4656 args->brush, &position,
4657 DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance, NULL);
4660 GpStatus WINGDIPAPI GdipDrawString(GpGraphics *graphics, GDIPCONST WCHAR *string,
4661 INT length, GDIPCONST GpFont *font, GDIPCONST RectF *rect,
4662 GDIPCONST GpStringFormat *format, GDIPCONST GpBrush *brush)
4666 GpPointF pt[3], rectcpy[4];
4668 REAL rel_width, rel_height;
4671 struct draw_string_args args;
4673 HDC hdc, temp_hdc=NULL;
4674 TEXTMETRICW textmetric;
4676 TRACE("(%p, %s, %i, %p, %s, %p, %p)\n", graphics, debugstr_wn(string, length),
4677 length, font, debugstr_rectf(rect), format, brush);
4679 if(!graphics || !string || !font || !brush || !rect)
4680 return InvalidParameter;
4684 hdc = graphics->hdc;
4688 hdc = temp_hdc = CreateCompatibleDC(0);
4692 TRACE("may be ignoring some format flags: attr %x\n", format->attr);
4694 /* Should be no need to explicitly test for StringAlignmentNear as
4695 * that is default behavior if no alignment is passed. */
4696 if(format->vertalign != StringAlignmentNear){
4698 GdipMeasureString(graphics, string, length, font, rect, format, &bounds, 0, 0);
4700 if(format->vertalign == StringAlignmentCenter)
4701 offsety = (rect->Height - bounds.Height) / 2;
4702 else if(format->vertalign == StringAlignmentFar)
4703 offsety = (rect->Height - bounds.Height);
4707 save_state = SaveDC(hdc);
4715 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
4716 rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
4717 (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
4718 rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
4719 (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
4721 rectcpy[3].X = rectcpy[0].X = rect->X;
4722 rectcpy[1].Y = rectcpy[0].Y = rect->Y + offsety;
4723 rectcpy[2].X = rectcpy[1].X = rect->X + rect->Width;
4724 rectcpy[3].Y = rectcpy[2].Y = rect->Y + offsety + rect->Height;
4725 transform_and_round_points(graphics, corners, rectcpy, 4);
4727 scaled_rect.X = 0.0;
4728 scaled_rect.Y = 0.0;
4729 scaled_rect.Width = rel_width * rect->Width;
4730 scaled_rect.Height = rel_height * rect->Height;
4732 if (roundr(scaled_rect.Width) != 0 && roundr(scaled_rect.Height) != 0)
4734 /* FIXME: If only the width or only the height is 0, we should probably still clip */
4735 rgn = CreatePolygonRgn(corners, 4, ALTERNATE);
4736 SelectClipRgn(hdc, rgn);
4739 get_font_hfont(graphics, font, &gdifont);
4740 SelectObject(hdc, gdifont);
4742 args.graphics = graphics;
4746 args.y = rect->Y + offsety;
4748 args.rel_width = rel_width;
4749 args.rel_height = rel_height;
4751 GetTextMetricsW(hdc, &textmetric);
4752 args.ascent = textmetric.tmAscent / rel_height;
4754 gdip_format_string(hdc, string, length, font, &scaled_rect, format,
4755 draw_string_callback, &args);
4758 DeleteObject(gdifont);
4760 RestoreDC(hdc, save_state);
4767 GpStatus WINGDIPAPI GdipResetClip(GpGraphics *graphics)
4769 TRACE("(%p)\n", graphics);
4772 return InvalidParameter;
4777 return GdipSetInfinite(graphics->clip);
4780 GpStatus WINGDIPAPI GdipResetWorldTransform(GpGraphics *graphics)
4782 TRACE("(%p)\n", graphics);
4785 return InvalidParameter;
4790 graphics->worldtrans->matrix[0] = 1.0;
4791 graphics->worldtrans->matrix[1] = 0.0;
4792 graphics->worldtrans->matrix[2] = 0.0;
4793 graphics->worldtrans->matrix[3] = 1.0;
4794 graphics->worldtrans->matrix[4] = 0.0;
4795 graphics->worldtrans->matrix[5] = 0.0;
4800 GpStatus WINGDIPAPI GdipRestoreGraphics(GpGraphics *graphics, GraphicsState state)
4802 return GdipEndContainer(graphics, state);
4805 GpStatus WINGDIPAPI GdipRotateWorldTransform(GpGraphics *graphics, REAL angle,
4806 GpMatrixOrder order)
4808 TRACE("(%p, %.2f, %d)\n", graphics, angle, order);
4811 return InvalidParameter;
4816 return GdipRotateMatrix(graphics->worldtrans, angle, order);
4819 GpStatus WINGDIPAPI GdipSaveGraphics(GpGraphics *graphics, GraphicsState *state)
4821 return GdipBeginContainer2(graphics, state);
4824 GpStatus WINGDIPAPI GdipBeginContainer2(GpGraphics *graphics,
4825 GraphicsContainer *state)
4827 GraphicsContainerItem *container;
4830 TRACE("(%p, %p)\n", graphics, state);
4832 if(!graphics || !state)
4833 return InvalidParameter;
4835 sts = init_container(&container, graphics);
4839 list_add_head(&graphics->containers, &container->entry);
4840 *state = graphics->contid = container->contid;
4845 GpStatus WINGDIPAPI GdipBeginContainer(GpGraphics *graphics, GDIPCONST GpRectF *dstrect, GDIPCONST GpRectF *srcrect, GpUnit unit, GraphicsContainer *state)
4847 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4848 return NotImplemented;
4851 GpStatus WINGDIPAPI GdipBeginContainerI(GpGraphics *graphics, GDIPCONST GpRect *dstrect, GDIPCONST GpRect *srcrect, GpUnit unit, GraphicsContainer *state)
4853 FIXME("(%p, %p, %p, %d, %p): stub\n", graphics, dstrect, srcrect, unit, state);
4854 return NotImplemented;
4857 GpStatus WINGDIPAPI GdipComment(GpGraphics *graphics, UINT sizeData, GDIPCONST BYTE *data)
4859 FIXME("(%p, %d, %p): stub\n", graphics, sizeData, data);
4860 return NotImplemented;
4863 GpStatus WINGDIPAPI GdipEndContainer(GpGraphics *graphics, GraphicsContainer state)
4866 GraphicsContainerItem *container, *container2;
4868 TRACE("(%p, %x)\n", graphics, state);
4871 return InvalidParameter;
4873 LIST_FOR_EACH_ENTRY(container, &graphics->containers, GraphicsContainerItem, entry){
4874 if(container->contid == state)
4878 /* did not find a matching container */
4879 if(&container->entry == &graphics->containers)
4882 sts = restore_container(graphics, container);
4886 /* remove all of the containers on top of the found container */
4887 LIST_FOR_EACH_ENTRY_SAFE(container, container2, &graphics->containers, GraphicsContainerItem, entry){
4888 if(container->contid == state)
4890 list_remove(&container->entry);
4891 delete_container(container);
4894 list_remove(&container->entry);
4895 delete_container(container);
4900 GpStatus WINGDIPAPI GdipScaleWorldTransform(GpGraphics *graphics, REAL sx,
4901 REAL sy, GpMatrixOrder order)
4903 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, sx, sy, order);
4906 return InvalidParameter;
4911 return GdipScaleMatrix(graphics->worldtrans, sx, sy, order);
4914 GpStatus WINGDIPAPI GdipSetClipGraphics(GpGraphics *graphics, GpGraphics *srcgraphics,
4917 TRACE("(%p, %p, %d)\n", graphics, srcgraphics, mode);
4919 if(!graphics || !srcgraphics)
4920 return InvalidParameter;
4922 return GdipCombineRegionRegion(graphics->clip, srcgraphics->clip, mode);
4925 GpStatus WINGDIPAPI GdipSetCompositingMode(GpGraphics *graphics,
4926 CompositingMode mode)
4928 TRACE("(%p, %d)\n", graphics, mode);
4931 return InvalidParameter;
4936 graphics->compmode = mode;
4941 GpStatus WINGDIPAPI GdipSetCompositingQuality(GpGraphics *graphics,
4942 CompositingQuality quality)
4944 TRACE("(%p, %d)\n", graphics, quality);
4947 return InvalidParameter;
4952 graphics->compqual = quality;
4957 GpStatus WINGDIPAPI GdipSetInterpolationMode(GpGraphics *graphics,
4958 InterpolationMode mode)
4960 TRACE("(%p, %d)\n", graphics, mode);
4962 if(!graphics || mode == InterpolationModeInvalid || mode > InterpolationModeHighQualityBicubic)
4963 return InvalidParameter;
4968 if (mode == InterpolationModeDefault || mode == InterpolationModeLowQuality)
4969 mode = InterpolationModeBilinear;
4971 if (mode == InterpolationModeHighQuality)
4972 mode = InterpolationModeHighQualityBicubic;
4974 graphics->interpolation = mode;
4979 GpStatus WINGDIPAPI GdipSetPageScale(GpGraphics *graphics, REAL scale)
4981 TRACE("(%p, %.2f)\n", graphics, scale);
4983 if(!graphics || (scale <= 0.0))
4984 return InvalidParameter;
4989 graphics->scale = scale;
4994 GpStatus WINGDIPAPI GdipSetPageUnit(GpGraphics *graphics, GpUnit unit)
4996 TRACE("(%p, %d)\n", graphics, unit);
4999 return InvalidParameter;
5004 if(unit == UnitWorld)
5005 return InvalidParameter;
5007 graphics->unit = unit;
5012 GpStatus WINGDIPAPI GdipSetPixelOffsetMode(GpGraphics *graphics, PixelOffsetMode
5015 TRACE("(%p, %d)\n", graphics, mode);
5018 return InvalidParameter;
5023 graphics->pixeloffset = mode;
5028 GpStatus WINGDIPAPI GdipSetRenderingOrigin(GpGraphics *graphics, INT x, INT y)
5032 TRACE("(%p,%i,%i)\n", graphics, x, y);
5035 FIXME("not implemented\n");
5037 return NotImplemented;
5040 GpStatus WINGDIPAPI GdipGetRenderingOrigin(GpGraphics *graphics, INT *x, INT *y)
5044 TRACE("(%p,%p,%p)\n", graphics, x, y);
5047 FIXME("not implemented\n");
5051 return NotImplemented;
5054 GpStatus WINGDIPAPI GdipSetSmoothingMode(GpGraphics *graphics, SmoothingMode mode)
5056 TRACE("(%p, %d)\n", graphics, mode);
5059 return InvalidParameter;
5064 graphics->smoothing = mode;
5069 GpStatus WINGDIPAPI GdipSetTextContrast(GpGraphics *graphics, UINT contrast)
5071 TRACE("(%p, %d)\n", graphics, contrast);
5074 return InvalidParameter;
5076 graphics->textcontrast = contrast;
5081 GpStatus WINGDIPAPI GdipSetTextRenderingHint(GpGraphics *graphics,
5082 TextRenderingHint hint)
5084 TRACE("(%p, %d)\n", graphics, hint);
5086 if(!graphics || hint > TextRenderingHintClearTypeGridFit)
5087 return InvalidParameter;
5092 graphics->texthint = hint;
5097 GpStatus WINGDIPAPI GdipSetWorldTransform(GpGraphics *graphics, GpMatrix *matrix)
5099 TRACE("(%p, %p)\n", graphics, matrix);
5101 if(!graphics || !matrix)
5102 return InvalidParameter;
5107 GdipDeleteMatrix(graphics->worldtrans);
5108 return GdipCloneMatrix(matrix, &graphics->worldtrans);
5111 GpStatus WINGDIPAPI GdipTranslateWorldTransform(GpGraphics *graphics, REAL dx,
5112 REAL dy, GpMatrixOrder order)
5114 TRACE("(%p, %.2f, %.2f, %d)\n", graphics, dx, dy, order);
5117 return InvalidParameter;
5122 return GdipTranslateMatrix(graphics->worldtrans, dx, dy, order);
5125 /*****************************************************************************
5126 * GdipSetClipHrgn [GDIPLUS.@]
5128 GpStatus WINGDIPAPI GdipSetClipHrgn(GpGraphics *graphics, HRGN hrgn, CombineMode mode)
5133 TRACE("(%p, %p, %d)\n", graphics, hrgn, mode);
5136 return InvalidParameter;
5138 status = GdipCreateRegionHrgn(hrgn, ®ion);
5142 status = GdipSetClipRegion(graphics, region, mode);
5144 GdipDeleteRegion(region);
5148 GpStatus WINGDIPAPI GdipSetClipPath(GpGraphics *graphics, GpPath *path, CombineMode mode)
5150 TRACE("(%p, %p, %d)\n", graphics, path, mode);
5153 return InvalidParameter;
5158 return GdipCombineRegionPath(graphics->clip, path, mode);
5161 GpStatus WINGDIPAPI GdipSetClipRect(GpGraphics *graphics, REAL x, REAL y,
5162 REAL width, REAL height,
5167 TRACE("(%p, %.2f, %.2f, %.2f, %.2f, %d)\n", graphics, x, y, width, height, mode);
5170 return InvalidParameter;
5178 rect.Height = height;
5180 return GdipCombineRegionRect(graphics->clip, &rect, mode);
5183 GpStatus WINGDIPAPI GdipSetClipRectI(GpGraphics *graphics, INT x, INT y,
5184 INT width, INT height,
5187 TRACE("(%p, %d, %d, %d, %d, %d)\n", graphics, x, y, width, height, mode);
5190 return InvalidParameter;
5195 return GdipSetClipRect(graphics, (REAL)x, (REAL)y, (REAL)width, (REAL)height, mode);
5198 GpStatus WINGDIPAPI GdipSetClipRegion(GpGraphics *graphics, GpRegion *region,
5201 TRACE("(%p, %p, %d)\n", graphics, region, mode);
5203 if(!graphics || !region)
5204 return InvalidParameter;
5209 return GdipCombineRegionRegion(graphics->clip, region, mode);
5212 GpStatus WINGDIPAPI GdipSetMetafileDownLevelRasterizationLimit(GpMetafile *metafile,
5217 TRACE("(%p,%u)\n", metafile, limitDpi);
5220 FIXME("not implemented\n");
5222 return NotImplemented;
5225 GpStatus WINGDIPAPI GdipDrawPolygon(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPointF *points,
5231 TRACE("(%p, %p, %d)\n", graphics, points, count);
5233 if(!graphics || !pen || count<=0)
5234 return InvalidParameter;
5241 FIXME("graphics object has no HDC\n");
5245 pti = GdipAlloc(sizeof(POINT) * count);
5247 save_state = prepare_dc(graphics, pen);
5248 SelectObject(graphics->hdc, GetStockObject(NULL_BRUSH));
5250 transform_and_round_points(graphics, pti, (GpPointF*)points, count);
5251 Polygon(graphics->hdc, pti, count);
5253 restore_dc(graphics, save_state);
5259 GpStatus WINGDIPAPI GdipDrawPolygonI(GpGraphics *graphics,GpPen *pen,GDIPCONST GpPoint *points,
5266 TRACE("(%p, %p, %p, %d)\n", graphics, pen, points, count);
5268 if(count<=0) return InvalidParameter;
5269 ptf = GdipAlloc(sizeof(GpPointF) * count);
5271 for(i = 0;i < count; i++){
5272 ptf[i].X = (REAL)points[i].X;
5273 ptf[i].Y = (REAL)points[i].Y;
5276 ret = GdipDrawPolygon(graphics,pen,ptf,count);
5282 GpStatus WINGDIPAPI GdipGetDpiX(GpGraphics *graphics, REAL* dpi)
5284 TRACE("(%p, %p)\n", graphics, dpi);
5286 if(!graphics || !dpi)
5287 return InvalidParameter;
5292 if (graphics->image)
5293 *dpi = graphics->image->xres;
5295 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSX);
5300 GpStatus WINGDIPAPI GdipGetDpiY(GpGraphics *graphics, REAL* dpi)
5302 TRACE("(%p, %p)\n", graphics, dpi);
5304 if(!graphics || !dpi)
5305 return InvalidParameter;
5310 if (graphics->image)
5311 *dpi = graphics->image->yres;
5313 *dpi = (REAL)GetDeviceCaps(graphics->hdc, LOGPIXELSY);
5318 GpStatus WINGDIPAPI GdipMultiplyWorldTransform(GpGraphics *graphics, GDIPCONST GpMatrix *matrix,
5319 GpMatrixOrder order)
5324 TRACE("(%p, %p, %d)\n", graphics, matrix, order);
5326 if(!graphics || !matrix)
5327 return InvalidParameter;
5332 m = *(graphics->worldtrans);
5334 ret = GdipMultiplyMatrix(&m, matrix, order);
5336 *(graphics->worldtrans) = m;
5341 /* Color used to fill bitmaps so we can tell which parts have been drawn over by gdi32. */
5342 static const COLORREF DC_BACKGROUND_KEY = 0x0c0b0d;
5344 GpStatus WINGDIPAPI GdipGetDC(GpGraphics *graphics, HDC *hdc)
5348 TRACE("(%p, %p)\n", graphics, hdc);
5350 if(!graphics || !hdc)
5351 return InvalidParameter;
5356 if (graphics->image && graphics->image->type == ImageTypeMetafile)
5358 stat = METAFILE_GetDC((GpMetafile*)graphics->image, hdc);
5360 else if (!graphics->hdc ||
5361 (graphics->image && graphics->image->type == ImageTypeBitmap && ((GpBitmap*)graphics->image)->format & PixelFormatAlpha))
5363 /* Create a fake HDC and fill it with a constant color. */
5367 BITMAPINFOHEADER bmih;
5370 stat = get_graphics_bounds(graphics, &bounds);
5374 graphics->temp_hbitmap_width = bounds.Width;
5375 graphics->temp_hbitmap_height = bounds.Height;
5377 bmih.biSize = sizeof(bmih);
5378 bmih.biWidth = graphics->temp_hbitmap_width;
5379 bmih.biHeight = -graphics->temp_hbitmap_height;
5381 bmih.biBitCount = 32;
5382 bmih.biCompression = BI_RGB;
5383 bmih.biSizeImage = 0;
5384 bmih.biXPelsPerMeter = 0;
5385 bmih.biYPelsPerMeter = 0;
5387 bmih.biClrImportant = 0;
5389 hbitmap = CreateDIBSection(NULL, (BITMAPINFO*)&bmih, DIB_RGB_COLORS,
5390 (void**)&graphics->temp_bits, NULL, 0);
5392 return GenericError;
5394 temp_hdc = CreateCompatibleDC(0);
5397 DeleteObject(hbitmap);
5398 return GenericError;
5401 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5402 ((DWORD*)graphics->temp_bits)[i] = DC_BACKGROUND_KEY;
5404 SelectObject(temp_hdc, hbitmap);
5406 graphics->temp_hbitmap = hbitmap;
5407 *hdc = graphics->temp_hdc = temp_hdc;
5411 *hdc = graphics->hdc;
5415 graphics->busy = TRUE;
5420 GpStatus WINGDIPAPI GdipReleaseDC(GpGraphics *graphics, HDC hdc)
5424 TRACE("(%p, %p)\n", graphics, hdc);
5426 if(!graphics || !hdc || !graphics->busy)
5427 return InvalidParameter;
5429 if (graphics->image && graphics->image->type == ImageTypeMetafile)
5431 stat = METAFILE_ReleaseDC((GpMetafile*)graphics->image, hdc);
5433 else if (graphics->temp_hdc == hdc)
5438 /* Find the pixels that have changed, and mark them as opaque. */
5439 pos = (DWORD*)graphics->temp_bits;
5440 for (i=0; i<(graphics->temp_hbitmap_width * graphics->temp_hbitmap_height); i++)
5442 if (*pos != DC_BACKGROUND_KEY)
5449 /* Write the changed pixels to the real target. */
5450 alpha_blend_pixels(graphics, 0, 0, graphics->temp_bits,
5451 graphics->temp_hbitmap_width, graphics->temp_hbitmap_height,
5452 graphics->temp_hbitmap_width * 4);
5455 DeleteDC(graphics->temp_hdc);
5456 DeleteObject(graphics->temp_hbitmap);
5457 graphics->temp_hdc = NULL;
5458 graphics->temp_hbitmap = NULL;
5460 else if (hdc != graphics->hdc)
5462 stat = InvalidParameter;
5466 graphics->busy = FALSE;
5471 GpStatus WINGDIPAPI GdipGetClip(GpGraphics *graphics, GpRegion *region)
5476 TRACE("(%p, %p)\n", graphics, region);
5478 if(!graphics || !region)
5479 return InvalidParameter;
5484 if((status = GdipCloneRegion(graphics->clip, &clip)) != Ok)
5487 /* free everything except root node and header */
5488 delete_element(®ion->node);
5489 memcpy(region, clip, sizeof(GpRegion));
5495 static GpStatus get_graphics_transform(GpGraphics *graphics, GpCoordinateSpace dst_space,
5496 GpCoordinateSpace src_space, GpMatrix **matrix)
5498 GpStatus stat = GdipCreateMatrix(matrix);
5501 if (dst_space != src_space && stat == Ok)
5503 unitscale = convert_unit(graphics_res(graphics), graphics->unit);
5505 if(graphics->unit != UnitDisplay)
5506 unitscale *= graphics->scale;
5508 /* transform from src_space to CoordinateSpacePage */
5511 case CoordinateSpaceWorld:
5512 GdipMultiplyMatrix(*matrix, graphics->worldtrans, MatrixOrderAppend);
5514 case CoordinateSpacePage:
5516 case CoordinateSpaceDevice:
5517 GdipScaleMatrix(*matrix, 1.0/unitscale, 1.0/unitscale, MatrixOrderAppend);
5521 /* transform from CoordinateSpacePage to dst_space */
5524 case CoordinateSpaceWorld:
5526 GpMatrix *inverted_transform;
5527 stat = GdipCloneMatrix(graphics->worldtrans, &inverted_transform);
5530 stat = GdipInvertMatrix(inverted_transform);
5532 GdipMultiplyMatrix(*matrix, inverted_transform, MatrixOrderAppend);
5533 GdipDeleteMatrix(inverted_transform);
5537 case CoordinateSpacePage:
5539 case CoordinateSpaceDevice:
5540 GdipScaleMatrix(*matrix, unitscale, unitscale, MatrixOrderAppend);
5547 GpStatus WINGDIPAPI GdipTransformPoints(GpGraphics *graphics, GpCoordinateSpace dst_space,
5548 GpCoordinateSpace src_space, GpPointF *points, INT count)
5553 if(!graphics || !points || count <= 0)
5554 return InvalidParameter;
5559 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5561 if (src_space == dst_space) return Ok;
5563 stat = get_graphics_transform(graphics, dst_space, src_space, &matrix);
5567 stat = GdipTransformMatrixPoints(matrix, points, count);
5569 GdipDeleteMatrix(matrix);
5575 GpStatus WINGDIPAPI GdipTransformPointsI(GpGraphics *graphics, GpCoordinateSpace dst_space,
5576 GpCoordinateSpace src_space, GpPoint *points, INT count)
5582 TRACE("(%p, %d, %d, %p, %d)\n", graphics, dst_space, src_space, points, count);
5585 return InvalidParameter;
5587 pointsF = GdipAlloc(sizeof(GpPointF) * count);
5591 for(i = 0; i < count; i++){
5592 pointsF[i].X = (REAL)points[i].X;
5593 pointsF[i].Y = (REAL)points[i].Y;
5596 ret = GdipTransformPoints(graphics, dst_space, src_space, pointsF, count);
5599 for(i = 0; i < count; i++){
5600 points[i].X = roundr(pointsF[i].X);
5601 points[i].Y = roundr(pointsF[i].Y);
5608 HPALETTE WINGDIPAPI GdipCreateHalftonePalette(void)
5620 /*****************************************************************************
5621 * GdipTranslateClip [GDIPLUS.@]
5623 GpStatus WINGDIPAPI GdipTranslateClip(GpGraphics *graphics, REAL dx, REAL dy)
5625 TRACE("(%p, %.2f, %.2f)\n", graphics, dx, dy);
5628 return InvalidParameter;
5633 return GdipTranslateRegion(graphics->clip, dx, dy);
5636 /*****************************************************************************
5637 * GdipTranslateClipI [GDIPLUS.@]
5639 GpStatus WINGDIPAPI GdipTranslateClipI(GpGraphics *graphics, INT dx, INT dy)
5641 TRACE("(%p, %d, %d)\n", graphics, dx, dy);
5644 return InvalidParameter;
5649 return GdipTranslateRegion(graphics->clip, (REAL)dx, (REAL)dy);
5653 /*****************************************************************************
5654 * GdipMeasureDriverString [GDIPLUS.@]
5656 GpStatus WINGDIPAPI GdipMeasureDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5657 GDIPCONST GpFont *font, GDIPCONST PointF *positions,
5658 INT flags, GDIPCONST GpMatrix *matrix, RectF *boundingBox)
5660 static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
5663 REAL min_x, min_y, max_x, max_y, x, y;
5665 TEXTMETRICW textmetric;
5666 const WORD *glyph_indices;
5667 WORD *dynamic_glyph_indices=NULL;
5668 REAL rel_width, rel_height, ascent, descent;
5671 TRACE("(%p %p %d %p %p %d %p %p)\n", graphics, text, length, font, positions, flags, matrix, boundingBox);
5673 if (!graphics || !text || !font || !positions || !boundingBox)
5674 return InvalidParameter;
5677 length = strlenW(text);
5681 boundingBox->X = 0.0;
5682 boundingBox->Y = 0.0;
5683 boundingBox->Width = 0.0;
5684 boundingBox->Height = 0.0;
5687 if (flags & unsupported_flags)
5688 FIXME("Ignoring flags %x\n", flags & unsupported_flags);
5691 FIXME("Ignoring matrix\n");
5693 get_font_hfont(graphics, font, &hfont);
5695 hdc = CreateCompatibleDC(0);
5696 SelectObject(hdc, hfont);
5698 GetTextMetricsW(hdc, &textmetric);
5706 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, pt, 3);
5707 rel_width = sqrt((pt[1].Y-pt[0].Y)*(pt[1].Y-pt[0].Y)+
5708 (pt[1].X-pt[0].X)*(pt[1].X-pt[0].X));
5709 rel_height = sqrt((pt[2].Y-pt[0].Y)*(pt[2].Y-pt[0].Y)+
5710 (pt[2].X-pt[0].X)*(pt[2].X-pt[0].X));
5712 if (flags & DriverStringOptionsCmapLookup)
5714 glyph_indices = dynamic_glyph_indices = GdipAlloc(sizeof(WORD) * length);
5718 DeleteObject(hfont);
5722 GetGlyphIndicesW(hdc, text, length, dynamic_glyph_indices, 0);
5725 glyph_indices = text;
5727 min_x = max_x = x = positions[0].X;
5728 min_y = max_y = y = positions[0].Y;
5730 ascent = textmetric.tmAscent / rel_height;
5731 descent = textmetric.tmDescent / rel_height;
5733 for (i=0; i<length; i++)
5738 if (!(flags & DriverStringOptionsRealizedAdvance))
5744 GetCharABCWidthsW(hdc, glyph_indices[i], glyph_indices[i], &abc);
5745 char_width = abc.abcA + abc.abcB + abc.abcB;
5747 if (min_y > y - ascent) min_y = y - ascent;
5748 if (max_y < y + descent) max_y = y + descent;
5749 if (min_x > x) min_x = x;
5751 x += char_width / rel_width;
5753 if (max_x < x) max_x = x;
5756 GdipFree(dynamic_glyph_indices);
5758 DeleteObject(hfont);
5760 boundingBox->X = min_x;
5761 boundingBox->Y = min_y;
5762 boundingBox->Width = max_x - min_x;
5763 boundingBox->Height = max_y - min_y;
5768 static GpStatus GDI32_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5769 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
5770 GDIPCONST PointF *positions, INT flags,
5771 GDIPCONST GpMatrix *matrix )
5773 static const INT unsupported_flags = ~(DriverStringOptionsRealizedAdvance|DriverStringOptionsCmapLookup);
5779 if (flags & unsupported_flags)
5780 FIXME("Ignoring flags %x\n", flags & unsupported_flags);
5783 FIXME("Ignoring matrix\n");
5785 if (!(flags & DriverStringOptionsCmapLookup))
5786 eto_flags |= ETO_GLYPH_INDEX;
5788 save_state = SaveDC(graphics->hdc);
5789 SetBkMode(graphics->hdc, TRANSPARENT);
5790 SetTextColor(graphics->hdc, brush->lb.lbColor);
5793 GdipTransformPoints(graphics, CoordinateSpaceDevice, CoordinateSpaceWorld, &pt, 1);
5795 get_font_hfont(graphics, font, &hfont);
5796 SelectObject(graphics->hdc, hfont);
5798 SetTextAlign(graphics->hdc, TA_BASELINE|TA_LEFT);
5800 ExtTextOutW(graphics->hdc, roundr(pt.X), roundr(pt.Y), eto_flags, NULL, text, length, NULL);
5802 RestoreDC(graphics->hdc, save_state);
5804 DeleteObject(hfont);
5809 static GpStatus SOFTWARE_GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
5810 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
5811 GDIPCONST PointF *positions, INT flags,
5812 GDIPCONST GpMatrix *matrix )
5814 static const INT unsupported_flags = ~(DriverStringOptionsCmapLookup|DriverStringOptionsRealizedAdvance);
5816 PointF *real_positions, real_position;
5820 int min_x=INT_MAX, min_y=INT_MAX, max_x=INT_MIN, max_y=INT_MIN, i, x, y;
5821 DWORD max_glyphsize=0;
5822 GLYPHMETRICS glyphmetrics;
5823 static const MAT2 identity = {{0,1}, {0,0}, {0,0}, {0,1}};
5826 int text_mask_stride;
5828 int pixel_data_stride;
5830 UINT ggo_flags = GGO_GRAY8_BITMAP;
5835 if (!(flags & DriverStringOptionsCmapLookup))
5836 ggo_flags |= GGO_GLYPH_INDEX;
5838 if (flags & unsupported_flags)
5839 FIXME("Ignoring flags %x\n", flags & unsupported_flags);
5842 FIXME("Ignoring matrix\n");
5844 pti = GdipAlloc(sizeof(POINT) * length);
5848 if (flags & DriverStringOptionsRealizedAdvance)
5850 real_position = positions[0];
5852 transform_and_round_points(graphics, pti, &real_position, 1);
5856 real_positions = GdipAlloc(sizeof(PointF) * length);
5857 if (!real_positions)
5863 memcpy(real_positions, positions, sizeof(PointF) * length);
5865 transform_and_round_points(graphics, pti, real_positions, length);
5867 GdipFree(real_positions);
5870 get_font_hfont(graphics, font, &hfont);
5872 hdc = CreateCompatibleDC(0);
5873 SelectObject(hdc, hfont);
5875 /* Get the boundaries of the text to be drawn */
5876 for (i=0; i<length; i++)
5879 int left, top, right, bottom;
5881 glyphsize = GetGlyphOutlineW(hdc, text[i], ggo_flags,
5882 &glyphmetrics, 0, NULL, &identity);
5884 if (glyphsize == GDI_ERROR)
5886 ERR("GetGlyphOutlineW failed\n");
5889 DeleteObject(hfont);
5890 return GenericError;
5893 if (glyphsize > max_glyphsize)
5894 max_glyphsize = glyphsize;
5896 left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
5897 top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
5898 right = pti[i].x + glyphmetrics.gmptGlyphOrigin.x + glyphmetrics.gmBlackBoxX;
5899 bottom = pti[i].y - glyphmetrics.gmptGlyphOrigin.y + glyphmetrics.gmBlackBoxY;
5901 if (left < min_x) min_x = left;
5902 if (top < min_y) min_y = top;
5903 if (right > max_x) max_x = right;
5904 if (bottom > max_y) max_y = bottom;
5906 if (i+1 < length && (flags & DriverStringOptionsRealizedAdvance) == DriverStringOptionsRealizedAdvance)
5908 pti[i+1].x = pti[i].x + glyphmetrics.gmCellIncX;
5909 pti[i+1].y = pti[i].y + glyphmetrics.gmCellIncY;
5913 glyph_mask = GdipAlloc(max_glyphsize);
5914 text_mask = GdipAlloc((max_x - min_x) * (max_y - min_y));
5915 text_mask_stride = max_x - min_x;
5917 if (!(glyph_mask && text_mask))
5919 GdipFree(glyph_mask);
5920 GdipFree(text_mask);
5923 DeleteObject(hfont);
5927 /* Generate a mask for the text */
5928 for (i=0; i<length; i++)
5930 int left, top, stride;
5932 GetGlyphOutlineW(hdc, text[i], ggo_flags,
5933 &glyphmetrics, max_glyphsize, glyph_mask, &identity);
5935 left = pti[i].x + glyphmetrics.gmptGlyphOrigin.x;
5936 top = pti[i].y - glyphmetrics.gmptGlyphOrigin.y;
5937 stride = (glyphmetrics.gmBlackBoxX + 3) & (~3);
5939 for (y=0; y<glyphmetrics.gmBlackBoxY; y++)
5941 BYTE *glyph_val = glyph_mask + y * stride;
5942 BYTE *text_val = text_mask + (left - min_x) + (top - min_y + y) * text_mask_stride;
5943 for (x=0; x<glyphmetrics.gmBlackBoxX; x++)
5945 *text_val = min(64, *text_val + *glyph_val);
5954 DeleteObject(hfont);
5955 GdipFree(glyph_mask);
5957 /* get the brush data */
5958 pixel_data = GdipAlloc(4 * (max_x - min_x) * (max_y - min_y));
5961 GdipFree(text_mask);
5965 pixel_area.X = min_x;
5966 pixel_area.Y = min_y;
5967 pixel_area.Width = max_x - min_x;
5968 pixel_area.Height = max_y - min_y;
5969 pixel_data_stride = pixel_area.Width * 4;
5971 stat = brush_fill_pixels(graphics, (GpBrush*)brush, (DWORD*)pixel_data, &pixel_area, pixel_area.Width);
5974 GdipFree(text_mask);
5975 GdipFree(pixel_data);
5979 /* multiply the brush data by the mask */
5980 for (y=0; y<pixel_area.Height; y++)
5982 BYTE *text_val = text_mask + text_mask_stride * y;
5983 BYTE *pixel_val = pixel_data + pixel_data_stride * y + 3;
5984 for (x=0; x<pixel_area.Width; x++)
5986 *pixel_val = (*pixel_val) * (*text_val) / 64;
5992 GdipFree(text_mask);
5994 /* draw the result */
5995 stat = alpha_blend_pixels(graphics, min_x, min_y, pixel_data, pixel_area.Width,
5996 pixel_area.Height, pixel_data_stride);
5998 GdipFree(pixel_data);
6003 /*****************************************************************************
6004 * GdipDrawDriverString [GDIPLUS.@]
6006 GpStatus WINGDIPAPI GdipDrawDriverString(GpGraphics *graphics, GDIPCONST UINT16 *text, INT length,
6007 GDIPCONST GpFont *font, GDIPCONST GpBrush *brush,
6008 GDIPCONST PointF *positions, INT flags,
6009 GDIPCONST GpMatrix *matrix )
6011 GpStatus stat=NotImplemented;
6013 TRACE("(%p %s %p %p %p %d %p)\n", graphics, debugstr_wn(text, length), font, brush, positions, flags, matrix);
6015 if (!graphics || !text || !font || !brush || !positions)
6016 return InvalidParameter;
6019 length = strlenW(text);
6021 if (graphics->hdc &&
6022 ((flags & DriverStringOptionsRealizedAdvance) || length <= 1) &&
6023 brush->bt == BrushTypeSolidColor &&
6024 (((GpSolidFill*)brush)->color & 0xff000000) == 0xff000000)
6025 stat = GDI32_GdipDrawDriverString(graphics, text, length, font, brush,
6026 positions, flags, matrix);
6028 if (stat == NotImplemented)
6029 stat = SOFTWARE_GdipDrawDriverString(graphics, text, length, font, brush,
6030 positions, flags, matrix);
6035 GpStatus WINGDIPAPI GdipRecordMetafileStream(IStream *stream, HDC hdc, EmfType type, GDIPCONST GpRect *frameRect,
6036 MetafileFrameUnit frameUnit, GDIPCONST WCHAR *desc, GpMetafile **metafile)
6038 FIXME("(%p %p %d %p %d %p %p): stub\n", stream, hdc, type, frameRect, frameUnit, desc, metafile);
6039 return NotImplemented;
6042 /*****************************************************************************
6043 * GdipIsVisibleClipEmpty [GDIPLUS.@]
6045 GpStatus WINGDIPAPI GdipIsVisibleClipEmpty(GpGraphics *graphics, BOOL *res)
6050 TRACE("(%p, %p)\n", graphics, res);
6052 if((stat = GdipCreateRegion(&rgn)) != Ok)
6055 if((stat = get_visible_clip_region(graphics, rgn)) != Ok)
6058 stat = GdipIsEmptyRegion(rgn, graphics, res);
6061 GdipDeleteRegion(rgn);