45 const float a1 = 0.254829592f;
46 const float a2 = -0.284496736f;
47 const float a3 = 1.421413741f;
48 const float a4 = -1.453152027f;
49 const float a5 = 1.061405429f;
50 const float p = 0.3275911f;
72 TRACE(
"(%p, %p)\n", brush, clone);
111 dest->transform =
src->transform;
118 dest->surroundcolors = heap_alloc_zero(
dest->surroundcolorcount *
sizeof(
ARGB));
119 pcount =
dest->pblendcount;
122 dest->pblendcolor = heap_alloc_zero(pcount *
sizeof(
ARGB));
123 dest->pblendpos = heap_alloc_zero(pcount *
sizeof(
REAL));
126 if(!
dest->blendfac || !
dest->blendpos || !
dest->surroundcolors ||
127 (pcount && (!
dest->pblendcolor || !
dest->pblendpos))){
164 pcount =
dest->pblendcount;
167 dest->pblendcolor = heap_alloc_zero(pcount *
sizeof(
ARGB));
168 dest->pblendpos = heap_alloc_zero(pcount *
sizeof(
REAL));
171 if (!
dest->blendfac || !
dest->blendpos ||
172 (pcount && (!
dest->pblendcolor || !
dest->pblendpos)))
182 dest->transform =
src->transform;
193 *clone = &
dest->brush;
213 *clone = &new_texture->
brush;
221 ERR(
"not implemented for brush type %d\n", brush->
bt);
225 TRACE(
"<-- %p\n", *clone);
230 { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 },
231 { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 },
232 { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 },
233 { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 },
234 { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 },
235 { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 },
236 { 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80 },
237 { 0x00, 0x02, 0x00, 0x88, 0x00, 0x20, 0x00, 0x88 },
238 { 0x00, 0x22, 0x00, 0xcc, 0x00, 0x22, 0x00, 0xcc },
239 { 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc },
240 { 0x00, 0xcc, 0x04, 0xcc, 0x00, 0xcc, 0x40, 0xcc },
241 { 0x44, 0xcc, 0x22, 0xcc, 0x44, 0xcc, 0x22, 0xcc },
242 { 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc },
243 { 0x55, 0xcd, 0x55, 0xee, 0x55, 0xdc, 0x55, 0xee },
244 { 0x55, 0xdd, 0x55, 0xff, 0x55, 0xdd, 0x55, 0xff },
245 { 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff },
246 { 0x55, 0xff, 0x59, 0xff, 0x55, 0xff, 0x99, 0xff },
247 { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xfd, 0xff },
248 { 0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88 },
249 { 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11 },
250 { 0x99, 0x33, 0x66, 0xcc, 0x99, 0x33, 0x66, 0xcc },
251 { 0xcc, 0x66, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99 },
252 { 0xc1, 0x83, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0 },
253 { 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x83, 0xc1 },
254 { 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88 },
255 { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff },
256 { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa },
257 { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff },
258 { 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc },
259 { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff },
278 TRACE(
"(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
285 *brush = heap_alloc_zero(
sizeof(
GpHatch));
289 (*brush)->forecol = forecol;
290 (*brush)->backcol = backcol;
291 (*brush)->hatchstyle = hatchstyle;
292 TRACE(
"<-- %p\n", *brush);
304 (*line)->startcolor = startcolor;
305 (*line)->endcolor = endcolor;
306 (*line)->wrap =
wrap;
307 (*line)->gamma =
FALSE;
308 (*line)->rect = *
rect;
309 (*line)->blendcount = 1;
310 (*line)->blendfac = heap_alloc_zero(
sizeof(
REAL));
311 (*line)->blendpos = heap_alloc_zero(
sizeof(
REAL));
313 if (!(*line)->blendfac || !(*line)->blendpos)
322 (*line)->blendfac[0] = 1.0f;
323 (*line)->blendpos[0] = 1.0f;
325 (*line)->pblendcolor =
NULL;
326 (*line)->pblendpos =
NULL;
327 (*line)->pblendcount = 0;
336 float trans_x =
line->rect.X + (
line->rect.Width / 2.f);
337 float trans_y =
line->rect.Y + (
line->rect.Height / 2.f);
340 float t_cos, t_sin, w_ratio, h_ratio;
349 w_ratio = (
fabs(t_cos) *
line->rect.Width +
fabs(t_sin) *
line->rect.Height) /
line->rect.Width;
350 h_ratio = (
fabs(t_sin) *
line->rect.Width +
fabs(t_cos) *
line->rect.Height) /
line->rect.Height;
393 if (
rect.Width == 0.0f)
398 else if (
rect.Height == 0.0f)
428 stF.
X = (
REAL)startpoint->X;
429 stF.
Y = (
REAL)startpoint->Y;
442 TRACE(
"(%p, %x, %x, %d, %d, %p)\n",
rect, startcolor, endcolor,
mode,
475 TRACE(
"(%p, %x, %x, %d, %d, %p)\n",
rect, startcolor, endcolor,
mode,
494 REAL exofs, eyofs, far_x, far_y;
495 REAL sin_angle, cos_angle, sin_cos_angle;
498 TRACE(
"(%p, %x, %x, %.2f, %d, %d, %p)\n",
rect, startcolor, endcolor,
angle, isAngleScalable,
533 sin_cos_angle = sin_angle * cos_angle;
545 else if (sin_cos_angle >= 0)
564 if (sin_cos_angle >= 0)
566 exofs =
rect->Height * sin_cos_angle +
rect->Width * cos_angle * cos_angle;
567 eyofs =
rect->Height * sin_angle * sin_angle +
rect->Width * sin_cos_angle;
571 exofs =
rect->Width * sin_angle * sin_angle +
rect->Height * sin_cos_angle;
572 eyofs = -
rect->Width * sin_cos_angle +
rect->Height * sin_angle * sin_angle;
597 TRACE(
"(%p, %x, %x, %.2f, %d, %d, %p)\n",
rect, startcolor, endcolor,
angle, isAngleScalable,
611 if (
path->pathdata.Count < 2)
624 (*grad)->blendfac = heap_alloc_zero(
sizeof(
REAL));
625 (*grad)->blendpos = heap_alloc_zero(
sizeof(
REAL));
626 (*grad)->surroundcolors = heap_alloc_zero(
sizeof(
ARGB));
627 if(!(*grad)->blendfac || !(*grad)->blendpos || !(*grad)->surroundcolors){
635 (*grad)->blendfac[0] = 1.0;
636 (*grad)->blendpos[0] = 1.0;
637 (*grad)->blendcount = 1;
639 (*grad)->path =
path;
642 (*grad)->centercolor = centercolor;
644 (*grad)->gamma =
FALSE;
646 (*grad)->center.X = bounds.
X + bounds.
Width / 2;
647 (*grad)->center.Y = bounds.
Y + bounds.
Height / 2;
648 (*grad)->focus.X = 0.0;
649 (*grad)->focus.Y = 0.0;
650 (*grad)->surroundcolors[0] = 0xffffffff;
651 (*grad)->surroundcolorcount = 1;
653 TRACE(
"<-- %p\n", *grad);
686 (*grad)->wrap =
wrap;
719 (*grad)->wrap =
wrap;
767 (*sf)->color =
color;
769 TRACE(
"<-- %p\n", *sf);
807 attributes->
wrap = wrapmode;
827 TRACE(
"%p %d %f %f %f %f %p\n",
image, wrapmode,
834 attributes->
wrap = wrapmode;
855 TRACE(
"(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n",
image, imageattr,
x,
y,
width,
height,
864 FIXME(
"not implemented for image type %d\n",
image->type);
893 (*texture)->image = new_image;
922 TRACE(
"(%p, %p, %d, %d, %d, %d, %p)\n",
image, imageattr,
x,
y,
width,
height,
941 imageattr->
wrap = wrapmode;
963 TRACE(
"(%p, %p)\n", brush, backcol);
974 TRACE(
"(%p, %p)\n", brush, forecol);
985 TRACE(
"(%p, %p)\n", brush, hatchstyle);
996 TRACE(
"(%p)\n", brush);
1035 if(!
line || !usinggamma)
1038 *usinggamma =
line->gamma;
1045 TRACE(
"(%p, %p)\n", brush, wrapmode);
1050 *wrapmode = brush->
wrap;
1058 TRACE(
"(%p, %p, %p, %d)\n", brush, blend, positions,
count);
1124 TRACE(
"(%p,%p)\n", grad, colors);
1137 TRACE(
"(%p, %p, %p)\n", grad,
x,
y);
1151 TRACE(
"(%p, %p)\n", grad, gamma);
1156 *gamma = grad->
gamma;
1168 FIXME(
"not implemented\n");
1233 if (i < grad->surroundcolorcount)
1263 TRACE(
"(%p, %p)\n", brush, wrapmode);
1268 *wrapmode = brush->
wrap;
1275 TRACE(
"(%p, %p)\n", sf, argb);
1292 if(!brush || !
image)
1318 TRACE(
"(%p, %p)\n", brush, wrapmode);
1320 if(!brush || !wrapmode)
1347 TRACE(
"(%p)\n", brush);
1361 TRACE(
"(%p, %.2f, %.2f, %d)\n", brush, sx, sy,
order);
1372 REAL *new_blendfac, *new_blendpos;
1374 TRACE(
"(%p, %p, %p, %i)\n", brush, factors, positions,
count);
1377 (
count >= 2 && (positions[0] != 0.0f || positions[
count-1] != 1.0f)))
1380 new_blendfac = heap_alloc_zero(
count *
sizeof(
REAL));
1381 new_blendpos = heap_alloc_zero(
count *
sizeof(
REAL));
1383 if (!new_blendfac || !new_blendpos)
1406 TRACE(
"(%p, %p, %p, %i)\n", brush, factors, positions,
count);
1440 line->gamma = usegamma;
1463 erf_range = 2.0 /
sqrt(2);
1467 min_erf =
erf(-erf_range);
1468 scale_erf =
scale / (-2.0 * min_erf);
1477 factors[
i] = scale_erf * (
erf(2 * erf_range *
i /
precision - erf_range) - min_erf);
1482 positions[num_points] = focus;
1483 factors[num_points] =
scale;
1490 positions[
i+num_points-1] = (focus + ((1.0-focus) *
i /
precision));
1491 factors[
i+num_points-1] = scale_erf * (
erf(erf_range - 2 * erf_range *
i /
precision) - min_erf);
1494 positions[num_points-1] = 1.0;
1495 factors[num_points-1] = 0.0;
1517 REAL *new_blendfac, *new_blendpos;
1525 new_blendfac = heap_alloc_zero(
count *
sizeof(
REAL));
1526 new_blendpos = heap_alloc_zero(
count *
sizeof(
REAL));
1528 if (!new_blendfac || !new_blendpos)
1555 TRACE(
"(%p,%0.2f,%0.2f)\n", brush, focus,
scale);
1562 factors[num_points] = 0.0;
1563 positions[num_points] = 0.0;
1567 factors[num_points] =
scale;
1568 positions[num_points] = focus;
1573 factors[num_points] = 0.0;
1574 positions[num_points] = 1.0;
1594 new_color = heap_alloc_zero(
count *
sizeof(
ARGB));
1595 new_pos = heap_alloc_zero(
count *
sizeof(
REAL));
1596 if (!new_color || !new_pos)
1633 FIXME(
"Braindead behavior on wrong-sized buffer not implemented.\n");
1659 TRACE(
"(%p, %x)\n", grad, argb);
1701 TRACE(
"(%p, %.2f, %.2f)\n", grad,
x,
y);
1715 TRACE(
"(%p, %d)\n", grad, gamma);
1720 grad->
gamma = gamma;
1732 FIXME(
"not implemented\n");
1749 TRACE(
"(%p,%0.2f,%0.2f)\n", grad, focus,
scale);
1755 erf_range = 2.0 /
sqrt(2);
1759 min_erf =
erf(-erf_range);
1760 scale_erf =
scale / (-2.0 * min_erf);
1769 factors[
i] = scale_erf * (
erf(2 * erf_range *
i /
precision - erf_range) - min_erf);
1774 positions[num_points] = focus;
1775 factors[num_points] =
scale;
1782 positions[
i+num_points-1] = (focus + ((1.0-focus) *
i /
precision));
1783 factors[
i+num_points-1] = scale_erf * (
erf(erf_range - 2 * erf_range *
i /
precision) - min_erf);
1786 positions[num_points-1] = 1.0;
1787 factors[num_points-1] = 0.0;
1796 ARGB *new_surroundcolors;
1805 num_colors = *
count;
1810 for (
i=1;
i < num_colors;
i++)
1811 if (argb[
i] != argb[
i-1])
1814 if (
i == num_colors)
1818 new_surroundcolors = heap_alloc_zero(num_colors *
sizeof(
ARGB));
1819 if (!new_surroundcolors)
1822 memcpy(new_surroundcolors, argb, num_colors *
sizeof(
ARGB));
1884 TRACE(
"(%p)\n", grad);
1906 TRACE(
"(%p,%0.2f,%0.2f,%i)\n", grad, sx, sy,
order);
1927 TRACE(
"(%p, %x)\n", sf, argb);
1959 TRACE(
"(%p, %d)\n", brush, wrapmode);
1972 TRACE(
"(%p, %x, %x)\n", brush, color1, color2);
1985 TRACE(
"(%p, %p)\n", brush, colors);
2017 TRACE(
"(%p,%.2f,%.2f)\n", brush, focus,
scale);
2023 factors[num_points] = 0.0;
2024 positions[num_points] = 0.0;
2028 factors[num_points] =
scale;
2029 positions[num_points] = focus;
2034 factors[num_points] = 0.0;
2035 positions[num_points] = 1.0;
2047 TRACE(
"(%p,%p,%p,%i)\n", brush, blend, positions,
count);
2050 positions[0] != 0.0f || positions[
count-1] != 1.0f)
2055 new_color = heap_alloc_zero(
count *
sizeof(
ARGB));
2056 new_pos = heap_alloc_zero(
count *
sizeof(
REAL));
2057 if (!new_color || !new_pos)
2108 TRACE(
"(%p)\n", brush);
2144 TRACE(
"(%p,%0.2f,%0.2f,%u)\n", brush, sx, sy,
order);
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
static size_t double int int int * sign
GpStatus WINGDIPAPI GdipGetTextureImage(GpTexture *brush, GpImage **image)
static const char HatchBrushes[][8]
GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture, GDIPCONST GpMatrix *matrix)
GpStatus WINGDIPAPI GdipGetPathGradientCenterColor(GpPathGradient *grad, ARGB *colors)
GpStatus WINGDIPAPI GdipSetMatrixElements(GpMatrix *matrix, REAL m11, REAL m12, REAL m21, REAL m22, REAL dx, REAL dy)
GLint GLint GLsizei width
GLuint GLdouble GLdouble GLint GLint order
GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient *brush, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient *brush)
static const struct update_accum a3
const char * debugstr_pointf(const PointF *pt)
GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect *rect, ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI GdipSetPathGradientTransform(GpPathGradient *grad, GpMatrix *matrix)
GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorCount(GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI GdipSetLineTransform(GpLineGradient *brush, GDIPCONST GpMatrix *matrix)
GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
GpStatus WINGDIPAPI GdipCreateLineBrushI(GDIPCONST GpPoint *startpoint, GDIPCONST GpPoint *endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI GdipGetImageWidth(GpImage *image, UINT *width)
GLsizei const GLchar ** path
GpStatus WINGDIPAPI GdipResetPathGradientTransform(GpPathGradient *grad)
GpStatus WINGDIPAPI GdipGetPathWorldBounds(GpPath *path, GpRectF *bounds, GDIPCONST GpMatrix *matrix, GDIPCONST GpPen *pen)
static GpStatus create_path_gradient(GpPath *path, ARGB centercolor, GpPathGradient **grad)
GpStatus WINGDIPAPI GdipSetPathGradientSigmaBlend(GpPathGradient *grad, REAL focus, REAL scale)
GLuint GLuint GLsizei count
GLenum GLenum GLenum GLenum GLenum scale
static const BYTE bitmap_bits[48 *48/8]
GpStatus WINGDIPAPI GdipGetPathGradientTransform(GpPathGradient *grad, GpMatrix *matrix)
GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad, GpWrapMode wrap)
GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr, INT x, INT y, INT width, INT height, GpTexture **texture)
GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode, GpTexture **texture)
GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
GLint GLint GLint GLint GLint x
GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient *brush, REAL *factors, REAL *positions, INT count)
static const struct update_accum a4
GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient *brush, INT *count)
GpStatus WINGDIPAPI GdipSetPathGradientSurroundColorsWithCount(GpPathGradient *grad, GDIPCONST ARGB *argb, INT *count)
GpStatus WINGDIPAPI GdipCloneImage(GpImage *image, GpImage **cloneImage)
GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF *points, INT count, GpWrapMode wrap, GpPathGradient **grad)
GpStatus WINGDIPAPI GdipGetPathGradientPath(GpPathGradient *grad, GpPath *path)
static REAL deg2rad(REAL degrees)
GpStatus WINGDIPAPI GdipGetPathGradientPresetBlendCount(GpPathGradient *brush, INT *count)
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect *rect, ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI GdipScalePathGradientTransform(GpPathGradient *grad, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipDeletePath(GpPath *path)
GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1, ARGB color2)
static GpStatus create_line_brush(const GpRectF *rect, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
GLfloat GLfloat GLfloat GLfloat h
_Check_return_ float __cdecl cosf(_In_ float x)
GpStatus WINGDIPAPI GdipCreatePathGradientI(GDIPCONST GpPoint *points, INT count, GpWrapMode wrap, GpPathGradient **grad)
GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF *startpoint, GDIPCONST GpPointF *endpoint, ARGB startcolor, ARGB endcolor, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI GdipGetImageHeight(GpImage *image, UINT *height)
GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad, ARGB argb)
GpImageAttributes * imageattributes
GpStatus WINGDIPAPI GdipCloneImageAttributes(GDIPCONST GpImageAttributes *imageattr, GpImageAttributes **cloneImageattr)
static void linegradient_init_transform(const GpPointF *startpoint, const GpPointF *endpoint, GpLineGradient *line)
GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient *brush, INT *count)
GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush, GDIPCONST REAL *factors, GDIPCONST REAL *positions, INT count)
GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad, BOOL gamma)
GpStatus WINGDIPAPI GdipAddPathLine2(GpPath *path, GDIPCONST GpPointF *points, INT count)
static INT gdip_round(REAL x)
GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad, GpPointF *point)
GLenum GLint GLint * precision
GpStatus WINGDIPAPI GdipMultiplyLineTransform(GpLineGradient *brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
GpStatus WINGDIPAPI GdipCreateHatchBrush(GpHatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line, GpWrapMode wrap)
GpStatus WINGDIPAPI GdipGetLineRectI(GpLineGradient *brush, GpRect *rect)
GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus, REAL scale)
GpStatus WINGDIPAPI GdipCloneBitmapArea(REAL x, REAL y, REAL width, REAL height, PixelFormat format, GpBitmap *srcBitmap, GpBitmap **dstBitmap)
GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient *brush, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipMultiplyPathGradientTransform(GpPathGradient *grad, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend, GDIPCONST REAL *pos, INT count)
static const struct update_accum a2
double __cdecl erf(double)
GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture *brush)
GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
GpStatus WINGDIPAPI GdipRotateMatrix(GpMatrix *matrix, REAL angle, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipCreateLineBrushFromRect(GDIPCONST GpRectF *rect, ARGB startcolor, ARGB endcolor, LinearGradientMode mode, GpWrapMode wrap, GpLineGradient **line)
_Check_return_ float __cdecl fmodf(_In_ float x, _In_ float y)
valarray< _Tp > atan(const valarray< _Tp > &__x)
GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode, INT x, INT y, INT width, INT height, GpTexture **texture)
GpStatus WINGDIPAPI GdipTranslatePathGradientTransform(GpPathGradient *grad, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB *backcol)
GLsizei const GLfloat * points
GpStatus WINGDIPAPI GdipAddPathLine2I(GpPath *path, GDIPCONST GpPoint *points, INT count)
GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, GpHatchStyle *hatchstyle)
GpStatus WINGDIPAPI GdipCreatePath(GpFillMode fill, GpPath **path)
GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad, REAL *x, REAL *y)
GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
GpStatus WINGDIPAPI GdipScaleMatrix(GpMatrix *matrix, REAL scaleX, REAL scaleY, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture *brush, REAL sx, REAL sy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line, BOOL *usinggamma)
#define memcpy(s1, s2, n)
GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath *path, GpPathGradient **grad)
GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture *brush, REAL dx, REAL dy, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad, REAL x, REAL y)
WINE_DEFAULT_DEBUG_CHANNEL(gdiplus)
GpStatus WINGDIPAPI GdipDisposeImage(GpImage *image)
GLint GLint GLsizei GLsizei height
GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient *brush, REAL angle, GpMatrixOrder order)
_Check_return_ _CRT_JIT_INTRINSIC double __cdecl fabs(_In_ double x)
GpStatus WINGDIPAPI GdipTranslateMatrix(GpMatrix *matrix, REAL offsetX, REAL offsetY, GpMatrixOrder order)
_CRTIMP int __cdecl stat(const char *_Filename, struct stat *_Stat)
GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient *brush, ARGB *blend, REAL *positions, INT count)
GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient *grad, ARGB *argb, INT *count)
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
GpStatus get_hatch_data(GpHatchStyle hatchstyle, const char **result)
GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB *forecol)
GpStatus WINGDIPAPI GdipRotatePathGradientTransform(GpPathGradient *grad, REAL angle, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipGetPathGradientPresetBlend(GpPathGradient *brush, ARGB *blend, REAL *pos, INT count)
_Check_return_ float __cdecl sinf(_In_ float x)
GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus, REAL scale)
GpStatus WINGDIPAPI GdipGetLineTransform(GpLineGradient *brush, GpMatrix *matrix)
GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image, GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line, BOOL usegamma)
GpStatus WINGDIPAPI GdipCreateImageAttributes(GpImageAttributes **imageattr)
GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode, REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
GLint GLint GLint GLint GLint GLint y
GpStatus WINGDIPAPI GdipGetPathGradientCenterPointI(GpPathGradient *grad, GpPoint *point)
GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad, BOOL *gamma)
GpStatus WINGDIPAPI GdipClonePath(GpPath *path, GpPath **clone)
GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
#define wrap(journal, var)
GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture *brush, GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
static const struct update_accum a1
GLuint GLuint GLsizei GLenum type
GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush, GDIPCONST ARGB *blend, GDIPCONST REAL *positions, INT count)
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF *rect, ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap, GpLineGradient **line)
GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend, REAL *positions, INT count)
_STLP_DECLSPEC complex< float > _STLP_CALL tan(const complex< float > &)
GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture *brush, REAL angle, GpMatrixOrder order)
static SERVICE_STATUS status
GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad, GpPointF *point)
GpStatus WINGDIPAPI GdipSetPathGradientLinearBlend(GpPathGradient *brush, REAL focus, REAL scale)
GpStatus WINGDIPAPI GdipSetPathGradientPath(GpPathGradient *grad, GDIPCONST GpPath *path)
GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush, GpWrapMode *wrapmode)
GpStatus WINGDIPAPI GdipDisposeImageAttributes(GpImageAttributes *imageattr)
GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad, INT *count)
static BOOL heap_free(void *mem)
GpStatus WINGDIPAPI GdipMultiplyMatrix(GpMatrix *matrix, GDIPCONST GpMatrix *matrix2, GpMatrixOrder order)
GpStatus WINGDIPAPI GdipSetPathGradientCenterPointI(GpPathGradient *grad, GpPoint *point)