WINE_DEFAULT_DEBUG_CHANNEL(gdiplus);
+/*
+ Unix stuff
+ Code from http://www.johndcook.com/blog/2009/01/19/stand-alone-error-function-erf/
+*/
+double erf(double x)
+{
+ const float a1 = 0.254829592;
+ const float a2 = -0.284496736;
+ const float a3 = 1.421413741;
+ const float a4 = -1.453152027;
+ const float a5 = 1.061405429;
+ const float p = 0.3275911;
+ float t, y, sign;
+
+ /* Save the sign of x */
+ sign = 1;
+ if (x < 0)
+ sign = -1;
+ x = abs(x);
+
+ /* A & S 7.1.26 */
+ t = 1.0/(1.0 + p*x);
+ y = 1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x);
+
+ return sign*y;
+}
+
+/******************************************************************************
+ * GdipCloneBrush [GDIPLUS.@]
+ */
GpStatus WINGDIPAPI GdipCloneBrush(GpBrush *brush, GpBrush **clone)
{
+ TRACE("(%p, %p)\n", brush, clone);
+
if(!brush || !clone)
return InvalidParameter;
switch(brush->bt){
case BrushTypeSolidColor:
+ {
+ GpSolidFill *fill;
*clone = GdipAlloc(sizeof(GpSolidFill));
if (!*clone) return OutOfMemory;
+ fill = (GpSolidFill*)*clone;
+
memcpy(*clone, brush, sizeof(GpSolidFill));
+ (*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
+ fill->bmp = ARGB2BMP(fill->color);
+ break;
+ }
+ case BrushTypeHatchFill:
+ *clone = GdipAlloc(sizeof(GpHatch));
+ if (!*clone) return OutOfMemory;
+
+ memcpy(*clone, brush, sizeof(GpHatch));
+
(*clone)->gdibrush = CreateBrushIndirect(&(*clone)->lb);
break;
case BrushTypePathGradient:{
memcpy(dest->pathdata.Points, src->pathdata.Points, count * sizeof(PointF));
memcpy(dest->pathdata.Types, src->pathdata.Types, count);
+ /* blending */
+ count = src->blendcount;
+ dest->blendcount = count;
+ dest->blendfac = GdipAlloc(count * sizeof(REAL));
+ dest->blendpos = GdipAlloc(count * sizeof(REAL));
+
+ if(!dest->blendfac || !dest->blendpos){
+ GdipFree(dest->pathdata.Points);
+ GdipFree(dest->pathdata.Types);
+ GdipFree(dest->blendfac);
+ GdipFree(dest->blendpos);
+ GdipFree(dest);
+ return OutOfMemory;
+ }
+
+ memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
+ memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
+
break;
}
- case BrushTypeLinearGradient:
- *clone = GdipAlloc(sizeof(GpLineGradient));
- if(!*clone) return OutOfMemory;
+ case BrushTypeLinearGradient:{
+ GpLineGradient *dest, *src;
+ INT count, pcount;
+
+ dest = GdipAlloc(sizeof(GpLineGradient));
+ if(!dest) return OutOfMemory;
+
+ src = (GpLineGradient*)brush;
+
+ memcpy(dest, src, sizeof(GpLineGradient));
+
+ dest->brush.gdibrush = CreateSolidBrush(dest->brush.lb.lbColor);
+
+ count = dest->blendcount;
+ dest->blendfac = GdipAlloc(count * sizeof(REAL));
+ dest->blendpos = GdipAlloc(count * sizeof(REAL));
+ pcount = dest->pblendcount;
+ if (pcount)
+ {
+ dest->pblendcolor = GdipAlloc(pcount * sizeof(ARGB));
+ dest->pblendpos = GdipAlloc(pcount * sizeof(REAL));
+ }
- memcpy(*clone, brush, sizeof(GpLineGradient));
+ if (!dest->blendfac || !dest->blendpos ||
+ (pcount && (!dest->pblendcolor || !dest->pblendpos)))
+ {
+ GdipFree(dest->blendfac);
+ GdipFree(dest->blendpos);
+ GdipFree(dest->pblendcolor);
+ GdipFree(dest->pblendpos);
+ DeleteObject(dest->brush.gdibrush);
+ GdipFree(dest);
+ return OutOfMemory;
+ }
+
+ memcpy(dest->blendfac, src->blendfac, count * sizeof(REAL));
+ memcpy(dest->blendpos, src->blendpos, count * sizeof(REAL));
- (*clone)->gdibrush = CreateSolidBrush((*clone)->lb.lbColor);
+ if (pcount)
+ {
+ memcpy(dest->pblendcolor, src->pblendcolor, pcount * sizeof(ARGB));
+ memcpy(dest->pblendpos, src->pblendpos, pcount * sizeof(REAL));
+ }
+
+ *clone = &dest->brush;
break;
+ }
case BrushTypeTextureFill:
*clone = GdipAlloc(sizeof(GpTexture));
if(!*clone) return OutOfMemory;
return Ok;
}
+static const char HatchBrushes[][8] = {
+ { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00 }, /* HatchStyleHorizontal */
+ { 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08 }, /* HatchStyleVertical */
+ { 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80 }, /* HatchStyleForwardDiagonal */
+ { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 }, /* HatchStyleBackwardDiagonal */
+ { 0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08 }, /* HatchStyleCross */
+ { 0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81 }, /* HatchStyleDiagonalCross */
+ { 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x80 }, /* HatchStyle05Percent */
+ { 0x00, 0x02, 0x00, 0x88, 0x00, 0x20, 0x00, 0x88 }, /* HatchStyle10Percent */
+ { 0x00, 0x22, 0x00, 0xcc, 0x00, 0x22, 0x00, 0xcc }, /* HatchStyle20Percent */
+ { 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc, 0x00, 0xcc }, /* HatchStyle25Percent */
+ { 0x00, 0xcc, 0x04, 0xcc, 0x00, 0xcc, 0x40, 0xcc }, /* HatchStyle30Percent */
+ { 0x44, 0xcc, 0x22, 0xcc, 0x44, 0xcc, 0x22, 0xcc }, /* HatchStyle40Percent */
+ { 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc, 0x55, 0xcc }, /* HatchStyle50Percent */
+ { 0x55, 0xcd, 0x55, 0xee, 0x55, 0xdc, 0x55, 0xee }, /* HatchStyle60Percent */
+ { 0x55, 0xdd, 0x55, 0xff, 0x55, 0xdd, 0x55, 0xff }, /* HatchStyle70Percent */
+ { 0x55, 0xff, 0x55, 0xff, 0x55, 0xff, 0x55, 0xff }, /* HatchStyle75Percent */
+ { 0x55, 0xff, 0x59, 0xff, 0x55, 0xff, 0x99, 0xff }, /* HatchStyle80Percent */
+ { 0x77, 0xff, 0xdd, 0xff, 0x77, 0xff, 0xfd, 0xff }, /* HatchStyle90Percent */
+ { 0x11, 0x22, 0x44, 0x88, 0x11, 0x22, 0x44, 0x88 }, /* HatchStyleLightDownwardDiagonal */
+ { 0x88, 0x44, 0x22, 0x11, 0x88, 0x44, 0x22, 0x11 }, /* HatchStyleLightUpwardDiagonal */
+ { 0x99, 0x33, 0x66, 0xcc, 0x99, 0x33, 0x66, 0xcc }, /* HatchStyleDarkDownwardDiagonal */
+ { 0xcc, 0x66, 0x33, 0x99, 0xcc, 0x66, 0x33, 0x99 }, /* HatchStyleDarkUpwardDiagonal */
+ { 0xc1, 0x83, 0x07, 0x0e, 0x1c, 0x38, 0x70, 0xe0 }, /* HatchStyleWideDownwardDiagonal */
+ { 0xe0, 0x70, 0x38, 0x1c, 0x0e, 0x07, 0x83, 0xc1 }, /* HatchStyleWideUpwardDiagonal */
+ { 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88, 0x88 }, /* HatchStyleLightVertical */
+ { 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0xff }, /* HatchStyleLightHorizontal */
+ { 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa }, /* HatchStyleNarrowVertical */
+ { 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff }, /* HatchStyleNarrowHorizontal */
+ { 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc }, /* HatchStyleDarkVertical */
+ { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0xff, 0xff }, /* HatchStyleDarkHorizontal */
+};
+
+/******************************************************************************
+ * GdipCreateHatchBrush [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipCreateHatchBrush(HatchStyle hatchstyle, ARGB forecol, ARGB backcol, GpHatch **brush)
+{
+ COLORREF fgcol = ARGB2COLORREF(forecol);
+ GpStatus stat = Ok;
+
+ TRACE("(%d, %d, %d, %p)\n", hatchstyle, forecol, backcol, brush);
+
+ if(!brush) return InvalidParameter;
+
+ *brush = GdipAlloc(sizeof(GpHatch));
+ if (!*brush) return OutOfMemory;
+
+ if (hatchstyle < sizeof(HatchBrushes) / sizeof(HatchBrushes[0]))
+ {
+ HBITMAP hbmp;
+ HDC hdc;
+ BITMAPINFOHEADER bmih;
+ DWORD* bits;
+ int x, y;
+
+ hdc = CreateCompatibleDC(0);
+
+ if (hdc)
+ {
+ bmih.biSize = sizeof(bmih);
+ bmih.biWidth = 8;
+ bmih.biHeight = 8;
+ bmih.biPlanes = 1;
+ bmih.biBitCount = 32;
+ bmih.biCompression = BI_RGB;
+ bmih.biSizeImage = 0;
+
+ hbmp = CreateDIBSection(hdc, (BITMAPINFO*)&bmih, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
+
+ if (hbmp)
+ {
+ for (y=0; y<8; y++)
+ for (x=0; x<8; x++)
+ if ((HatchBrushes[hatchstyle][y] & (0x80 >> x)) != 0)
+ bits[y*8+x] = forecol;
+ else
+ bits[y*8+x] = backcol;
+ }
+ else
+ stat = GenericError;
+
+ DeleteDC(hdc);
+ }
+ else
+ stat = GenericError;
+
+ if (stat == Ok)
+ {
+ (*brush)->brush.lb.lbStyle = BS_PATTERN;
+ (*brush)->brush.lb.lbColor = 0;
+ (*brush)->brush.lb.lbHatch = (ULONG_PTR)hbmp;
+ (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
+
+ DeleteObject(hbmp);
+ }
+ }
+ else
+ {
+ FIXME("Unimplemented hatch style %d\n", hatchstyle);
+
+ (*brush)->brush.lb.lbStyle = BS_SOLID;
+ (*brush)->brush.lb.lbColor = fgcol;
+ (*brush)->brush.lb.lbHatch = 0;
+ (*brush)->brush.gdibrush = CreateBrushIndirect(&(*brush)->brush.lb);
+ }
+
+ if (stat == Ok)
+ {
+ (*brush)->brush.bt = BrushTypeHatchFill;
+ (*brush)->forecol = forecol;
+ (*brush)->backcol = backcol;
+ (*brush)->hatchstyle = hatchstyle;
+ }
+ else
+ {
+ GdipFree(*brush);
+ *brush = NULL;
+ }
+
+ return stat;
+}
+
+/******************************************************************************
+ * GdipCreateLineBrush [GDIPLUS.@]
+ */
GpStatus WINGDIPAPI GdipCreateLineBrush(GDIPCONST GpPointF* startpoint,
GDIPCONST GpPointF* endpoint, ARGB startcolor, ARGB endcolor,
GpWrapMode wrap, GpLineGradient **line)
{
COLORREF col = ARGB2COLORREF(startcolor);
+ TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
+ startcolor, endcolor, wrap, line);
+
if(!line || !startpoint || !endpoint || wrap == WrapModeClamp)
return InvalidParameter;
(*line)->wrap = wrap;
(*line)->gamma = FALSE;
+ (*line)->rect.X = (startpoint->X < endpoint->X ? startpoint->X: endpoint->X);
+ (*line)->rect.Y = (startpoint->Y < endpoint->Y ? startpoint->Y: endpoint->Y);
+ (*line)->rect.Width = fabs(startpoint->X - endpoint->X);
+ (*line)->rect.Height = fabs(startpoint->Y - endpoint->Y);
+
+ if ((*line)->rect.Width == 0)
+ {
+ (*line)->rect.X -= (*line)->rect.Height / 2.0f;
+ (*line)->rect.Width = (*line)->rect.Height;
+ }
+ else if ((*line)->rect.Height == 0)
+ {
+ (*line)->rect.Y -= (*line)->rect.Width / 2.0f;
+ (*line)->rect.Height = (*line)->rect.Width;
+ }
+
+ (*line)->blendcount = 1;
+ (*line)->blendfac = GdipAlloc(sizeof(REAL));
+ (*line)->blendpos = GdipAlloc(sizeof(REAL));
+
+ if (!(*line)->blendfac || !(*line)->blendpos)
+ {
+ GdipFree((*line)->blendfac);
+ GdipFree((*line)->blendpos);
+ DeleteObject((*line)->brush.gdibrush);
+ GdipFree(*line);
+ *line = NULL;
+ return OutOfMemory;
+ }
+
+ (*line)->blendfac[0] = 1.0f;
+ (*line)->blendpos[0] = 1.0f;
+
+ (*line)->pblendcolor = NULL;
+ (*line)->pblendpos = NULL;
+ (*line)->pblendcount = 0;
+
return Ok;
}
GpPointF stF;
GpPointF endF;
+ TRACE("(%p, %p, %x, %x, %d, %p)\n", startpoint, endpoint,
+ startcolor, endcolor, wrap, line);
+
if(!startpoint || !endpoint)
return InvalidParameter;
GpLineGradient **line)
{
GpPointF start, end;
+ GpStatus stat;
+
+ TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
+ wrap, line);
if(!line || !rect)
return InvalidParameter;
- start.X = rect->X;
- start.Y = rect->Y;
- end.X = rect->X + rect->Width;
- end.Y = rect->Y + rect->Height;
+ switch (mode)
+ {
+ case LinearGradientModeHorizontal:
+ start.X = rect->X;
+ start.Y = rect->Y;
+ end.X = rect->X + rect->Width;
+ end.Y = rect->Y;
+ break;
+ case LinearGradientModeVertical:
+ start.X = rect->X;
+ start.Y = rect->Y;
+ end.X = rect->X;
+ end.Y = rect->Y + rect->Height;
+ break;
+ case LinearGradientModeForwardDiagonal:
+ start.X = rect->X;
+ start.Y = rect->Y;
+ end.X = rect->X + rect->Width;
+ end.Y = rect->Y + rect->Height;
+ break;
+ case LinearGradientModeBackwardDiagonal:
+ start.X = rect->X + rect->Width;
+ start.Y = rect->Y;
+ end.X = rect->X;
+ end.Y = rect->Y + rect->Height;
+ break;
+ default:
+ return InvalidParameter;
+ }
+
+ stat = GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
+
+ if (stat == Ok)
+ (*line)->rect = *rect;
- return GdipCreateLineBrush(&start, &end, startcolor, endcolor, wrap, line);
+ return stat;
}
GpStatus WINGDIPAPI GdipCreateLineBrushFromRectI(GDIPCONST GpRect* rect,
{
GpRectF rectF;
+ TRACE("(%p, %x, %x, %d, %d, %p)\n", rect, startcolor, endcolor, mode,
+ wrap, line);
+
rectF.X = (REAL) rect->X;
rectF.Y = (REAL) rect->Y;
rectF.Width = (REAL) rect->Width;
return GdipCreateLineBrushFromRect(&rectF, startcolor, endcolor, mode, wrap, line);
}
+/******************************************************************************
+ * GdipCreateLineBrushFromRectWithAngle [GDIPLUS.@]
+ *
+ * FIXME: angle value completely ignored. Don't know how to use it since native
+ * always set Brush rectangle to rect (independetly of this angle).
+ * Maybe it's used only on drawing.
+ */
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngle(GDIPCONST GpRectF* rect,
+ ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
+ GpLineGradient **line)
+{
+ TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
+ wrap, line);
+
+ return GdipCreateLineBrushFromRect(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
+ wrap, line);
+}
+
+GpStatus WINGDIPAPI GdipCreateLineBrushFromRectWithAngleI(GDIPCONST GpRect* rect,
+ ARGB startcolor, ARGB endcolor, REAL angle, BOOL isAngleScalable, GpWrapMode wrap,
+ GpLineGradient **line)
+{
+ TRACE("(%p, %x, %x, %.2f, %d, %d, %p)\n", rect, startcolor, endcolor, angle, isAngleScalable,
+ wrap, line);
+
+ return GdipCreateLineBrushFromRectI(rect, startcolor, endcolor, LinearGradientModeForwardDiagonal,
+ wrap, line);
+}
+
GpStatus WINGDIPAPI GdipCreatePathGradient(GDIPCONST GpPointF* points,
INT count, GpWrapMode wrap, GpPathGradient **grad)
{
COLORREF col = ARGB2COLORREF(0xffffffff);
+ TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
+
if(!points || !grad)
return InvalidParameter;
*grad = GdipAlloc(sizeof(GpPathGradient));
if (!*grad) return OutOfMemory;
+ (*grad)->blendfac = GdipAlloc(sizeof(REAL));
+ if(!(*grad)->blendfac){
+ GdipFree(*grad);
+ return OutOfMemory;
+ }
+ (*grad)->blendfac[0] = 1.0;
+ (*grad)->blendpos = NULL;
+ (*grad)->blendcount = 1;
+
(*grad)->pathdata.Count = count;
(*grad)->pathdata.Points = GdipAlloc(count * sizeof(PointF));
(*grad)->pathdata.Types = GdipAlloc(count);
GpStatus ret;
INT i;
+ TRACE("(%p, %d, %d, %p)\n", points, count, wrap, grad);
+
if(!points || !grad)
return InvalidParameter;
return ret;
}
-/* FIXME: path gradient brushes not truly supported (drawn as solid brushes) */
+/******************************************************************************
+ * GdipCreatePathGradientFromPath [GDIPLUS.@]
+ *
+ * FIXME: path gradient brushes not truly supported (drawn as solid brushes)
+ */
GpStatus WINGDIPAPI GdipCreatePathGradientFromPath(GDIPCONST GpPath* path,
GpPathGradient **grad)
{
COLORREF col = ARGB2COLORREF(0xffffffff);
+ TRACE("(%p, %p)\n", path, grad);
+
if(!path || !grad)
return InvalidParameter;
*grad = GdipAlloc(sizeof(GpPathGradient));
if (!*grad) return OutOfMemory;
+ (*grad)->blendfac = GdipAlloc(sizeof(REAL));
+ if(!(*grad)->blendfac){
+ GdipFree(*grad);
+ return OutOfMemory;
+ }
+ (*grad)->blendfac[0] = 1.0;
+ (*grad)->blendpos = NULL;
+ (*grad)->blendcount = 1;
+
(*grad)->pathdata.Count = path->pathdata.Count;
(*grad)->pathdata.Points = GdipAlloc(path->pathdata.Count * sizeof(PointF));
(*grad)->pathdata.Types = GdipAlloc(path->pathdata.Count);
return Ok;
}
+/******************************************************************************
+ * GdipCreateSolidFill [GDIPLUS.@]
+ */
GpStatus WINGDIPAPI GdipCreateSolidFill(ARGB color, GpSolidFill **sf)
{
COLORREF col = ARGB2COLORREF(color);
+ TRACE("(%x, %p)\n", color, sf);
+
if(!sf) return InvalidParameter;
*sf = GdipAlloc(sizeof(GpSolidFill));
(*sf)->brush.gdibrush = CreateSolidBrush(col);
(*sf)->brush.bt = BrushTypeSolidColor;
(*sf)->color = color;
+ (*sf)->bmp = ARGB2BMP(color);
return Ok;
}
-/* FIXME: imageattr ignored */
+/******************************************************************************
+ * GdipCreateTexture [GDIPLUS.@]
+ *
+ * PARAMS
+ * image [I] image to use
+ * wrapmode [I] optional
+ * texture [O] pointer to the resulting texturebrush
+ *
+ * RETURNS
+ * SUCCESS: Ok
+ * FAILURE: element of GpStatus
+ */
+GpStatus WINGDIPAPI GdipCreateTexture(GpImage *image, GpWrapMode wrapmode,
+ GpTexture **texture)
+{
+ UINT width, height;
+ GpImageAttributes attributes;
+ GpStatus stat;
+
+ TRACE("%p, %d %p\n", image, wrapmode, texture);
+
+ if (!(image && texture))
+ return InvalidParameter;
+
+ stat = GdipGetImageWidth(image, &width);
+ if (stat != Ok) return stat;
+ stat = GdipGetImageHeight(image, &height);
+ if (stat != Ok) return stat;
+ attributes.wrap = wrapmode;
+
+ return GdipCreateTextureIA(image, &attributes, 0, 0, width, height,
+ texture);
+}
+
+/******************************************************************************
+ * GdipCreateTexture2 [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipCreateTexture2(GpImage *image, GpWrapMode wrapmode,
+ REAL x, REAL y, REAL width, REAL height, GpTexture **texture)
+{
+ GpImageAttributes attributes;
+
+ TRACE("%p %d %f %f %f %f %p\n", image, wrapmode,
+ x, y, width, height, texture);
+
+ attributes.wrap = wrapmode;
+ return GdipCreateTextureIA(image, &attributes, x, y, width, height,
+ texture);
+}
+
+/******************************************************************************
+ * GdipCreateTextureIA [GDIPLUS.@]
+ *
+ * FIXME: imageattr ignored
+ */
GpStatus WINGDIPAPI GdipCreateTextureIA(GpImage *image,
GDIPCONST GpImageAttributes *imageattr, REAL x, REAL y, REAL width,
REAL height, GpTexture **texture)
{
HDC hdc;
- OLE_HANDLE hbm;
- HBITMAP old = NULL;
- BITMAPINFO bmi;
+ HBITMAP hbm, old = NULL;
+ BITMAPINFO *pbmi;
BITMAPINFOHEADER *bmih;
INT n_x, n_y, n_width, n_height, abs_height, stride, image_stride, i, bytespp;
BOOL bm_is_selected;
BYTE *dibits, *buff, *textbits;
+ GpStatus status;
+
+ TRACE("(%p, %p, %.2f, %.2f, %.2f, %.2f, %p)\n", image, imageattr, x, y, width, height,
+ texture);
if(!image || !texture || x < 0.0 || y < 0.0 || width < 0.0 || height < 0.0)
return InvalidParameter;
n_y + n_height > ((GpBitmap*)image)->height)
return InvalidParameter;
- IPicture_get_Handle(image->picture, &hbm);
+ hbm = ((GpBitmap*)image)->hbitmap;
if(!hbm) return GenericError;
- IPicture_get_CurDC(image->picture, &hdc);
+ hdc = ((GpBitmap*)image)->hdc;
bm_is_selected = (hdc != 0);
- bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- bmi.bmiHeader.biBitCount = 0;
+ pbmi = GdipAlloc(sizeof(BITMAPINFOHEADER) + 256 * sizeof(RGBQUAD));
+ if (!pbmi)
+ return OutOfMemory;
+ pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
+ pbmi->bmiHeader.biBitCount = 0;
if(!bm_is_selected){
hdc = CreateCompatibleDC(0);
- old = SelectObject(hdc, (HBITMAP)hbm);
+ old = SelectObject(hdc, hbm);
}
/* fill out bmi */
- GetDIBits(hdc, (HBITMAP)hbm, 0, 0, NULL, &bmi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, 0, NULL, pbmi, DIB_RGB_COLORS);
- bytespp = bmi.bmiHeader.biBitCount / 8;
- abs_height = abs(bmi.bmiHeader.biHeight);
+ bytespp = pbmi->bmiHeader.biBitCount / 8;
+ abs_height = abs(pbmi->bmiHeader.biHeight);
- if(n_x > bmi.bmiHeader.biWidth || n_x + n_width > bmi.bmiHeader.biWidth ||
- n_y > abs_height || n_y + n_height > abs_height)
+ if(n_x > pbmi->bmiHeader.biWidth || n_x + n_width > pbmi->bmiHeader.biWidth ||
+ n_y > abs_height || n_y + n_height > abs_height){
+ GdipFree(pbmi);
return InvalidParameter;
+ }
- dibits = GdipAlloc(bmi.bmiHeader.biSizeImage);
+ dibits = GdipAlloc(pbmi->bmiHeader.biSizeImage);
if(dibits) /* this is not a good place to error out */
- GetDIBits(hdc, (HBITMAP)hbm, 0, abs_height, dibits, &bmi, DIB_RGB_COLORS);
+ GetDIBits(hdc, hbm, 0, abs_height, dibits, pbmi, DIB_RGB_COLORS);
if(!bm_is_selected){
SelectObject(hdc, old);
DeleteDC(hdc);
}
- if(!dibits)
+ if(!dibits){
+ GdipFree(pbmi);
return OutOfMemory;
+ }
- image_stride = (bmi.bmiHeader.biWidth * bytespp + 3) & ~3;
+ image_stride = (pbmi->bmiHeader.biWidth * bytespp + 3) & ~3;
stride = (n_width * bytespp + 3) & ~3;
buff = GdipAlloc(sizeof(BITMAPINFOHEADER) + stride * n_height);
if(!buff){
+ GdipFree(pbmi);
GdipFree(dibits);
return OutOfMemory;
}
bmih->biHeight = n_height;
bmih->biCompression = BI_RGB;
bmih->biSizeImage = stride * n_height;
- bmih->biBitCount = bmi.bmiHeader.biBitCount;
+ bmih->biBitCount = pbmi->bmiHeader.biBitCount;
bmih->biClrUsed = 0;
bmih->biPlanes = 1;
/* image is flipped */
- if(bmi.bmiHeader.biHeight > 0){
- dibits += bmi.bmiHeader.biSizeImage;
+ if(pbmi->bmiHeader.biHeight > 0){
+ dibits += image_stride * (pbmi->bmiHeader.biHeight - 1);
image_stride *= -1;
textbits += stride * (n_height - 1);
stride *= -1;
}
+ GdipFree(pbmi);
+
for(i = 0; i < n_height; i++)
memcpy(&textbits[i * stride],
&dibits[n_x * bytespp + (n_y + i) * image_stride],
abs(stride));
*texture = GdipAlloc(sizeof(GpTexture));
- if (!*texture) return OutOfMemory;
+ if (!*texture){
+ GdipFree(dibits);
+ GdipFree(buff);
+ return OutOfMemory;
+ }
+
+ if((status = GdipCreateMatrix(&(*texture)->transform)) != Ok){
+ GdipFree(*texture);
+ GdipFree(dibits);
+ GdipFree(buff);
+ return status;
+ }
(*texture)->brush.lb.lbStyle = BS_DIBPATTERNPT;
(*texture)->brush.lb.lbColor = DIB_RGB_COLORS;
(*texture)->brush.gdibrush = CreateBrushIndirect(&(*texture)->brush.lb);
(*texture)->brush.bt = BrushTypeTextureFill;
+ (*texture)->wrap = imageattr->wrap;
GdipFree(dibits);
GdipFree(buff);
return Ok;
}
+/******************************************************************************
+ * GdipCreateTextureIAI [GDIPLUS.@]
+ */
GpStatus WINGDIPAPI GdipCreateTextureIAI(GpImage *image, GDIPCONST GpImageAttributes *imageattr,
INT x, INT y, INT width, INT height, GpTexture **texture)
{
+ TRACE("(%p, %p, %d, %d, %d, %d, %p)\n", image, imageattr, x, y, width, height,
+ texture);
+
return GdipCreateTextureIA(image,imageattr,(REAL)x,(REAL)y,(REAL)width,(REAL)height,texture);
}
+GpStatus WINGDIPAPI GdipCreateTexture2I(GpImage *image, GpWrapMode wrapmode,
+ INT x, INT y, INT width, INT height, GpTexture **texture)
+{
+ GpImageAttributes imageattr;
+
+ TRACE("%p %d %d %d %d %d %p\n", image, wrapmode, x, y, width, height,
+ texture);
+
+ imageattr.wrap = wrapmode;
+
+ return GdipCreateTextureIA(image, &imageattr, x, y, width, height, texture);
+}
+
GpStatus WINGDIPAPI GdipGetBrushType(GpBrush *brush, GpBrushType *type)
{
+ TRACE("(%p, %p)\n", brush, type);
+
if(!brush || !type) return InvalidParameter;
*type = brush->bt;
return Ok;
}
+GpStatus WINGDIPAPI GdipGetHatchBackgroundColor(GpHatch *brush, ARGB *backcol)
+{
+ TRACE("(%p, %p)\n", brush, backcol);
+
+ if(!brush || !backcol) return InvalidParameter;
+
+ *backcol = brush->backcol;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetHatchForegroundColor(GpHatch *brush, ARGB *forecol)
+{
+ TRACE("(%p, %p)\n", brush, forecol);
+
+ if(!brush || !forecol) return InvalidParameter;
+
+ *forecol = brush->forecol;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetHatchStyle(GpHatch *brush, HatchStyle *hatchstyle)
+{
+ TRACE("(%p, %p)\n", brush, hatchstyle);
+
+ if(!brush || !hatchstyle) return InvalidParameter;
+
+ *hatchstyle = brush->hatchstyle;
+
+ return Ok;
+}
+
GpStatus WINGDIPAPI GdipDeleteBrush(GpBrush *brush)
{
+ TRACE("(%p)\n", brush);
+
if(!brush) return InvalidParameter;
switch(brush->bt)
case BrushTypePathGradient:
GdipFree(((GpPathGradient*) brush)->pathdata.Points);
GdipFree(((GpPathGradient*) brush)->pathdata.Types);
+ GdipFree(((GpPathGradient*) brush)->blendfac);
+ GdipFree(((GpPathGradient*) brush)->blendpos);
break;
case BrushTypeSolidColor:
+ if (((GpSolidFill*)brush)->bmp)
+ DeleteObject(((GpSolidFill*)brush)->bmp);
+ break;
case BrushTypeLinearGradient:
+ GdipFree(((GpLineGradient*)brush)->blendfac);
+ GdipFree(((GpLineGradient*)brush)->blendpos);
+ GdipFree(((GpLineGradient*)brush)->pblendcolor);
+ GdipFree(((GpLineGradient*)brush)->pblendpos);
+ break;
case BrushTypeTextureFill:
+ GdipDeleteMatrix(((GpTexture*)brush)->transform);
+ break;
default:
break;
}
GpStatus WINGDIPAPI GdipGetLineGammaCorrection(GpLineGradient *line,
BOOL *usinggamma)
{
- if(!line)
+ TRACE("(%p, %p)\n", line, usinggamma);
+
+ if(!line || !usinggamma)
return InvalidParameter;
*usinggamma = line->gamma;
return Ok;
}
+GpStatus WINGDIPAPI GdipGetLineWrapMode(GpLineGradient *brush, GpWrapMode *wrapmode)
+{
+ TRACE("(%p, %p)\n", brush, wrapmode);
+
+ if(!brush || !wrapmode)
+ return InvalidParameter;
+
+ *wrapmode = brush->wrap;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientBlend(GpPathGradient *brush, REAL *blend,
+ REAL *positions, INT count)
+{
+ TRACE("(%p, %p, %p, %d)\n", brush, blend, positions, count);
+
+ if(!brush || !blend || !positions || count <= 0)
+ return InvalidParameter;
+
+ if(count < brush->blendcount)
+ return InsufficientBuffer;
+
+ memcpy(blend, brush->blendfac, count*sizeof(REAL));
+ if(brush->blendcount > 1){
+ memcpy(positions, brush->blendpos, count*sizeof(REAL));
+ }
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientBlendCount(GpPathGradient *brush, INT *count)
+{
+ TRACE("(%p, %p)\n", brush, count);
+
+ if(!brush || !count)
+ return InvalidParameter;
+
+ *count = brush->blendcount;
+
+ return Ok;
+}
+
GpStatus WINGDIPAPI GdipGetPathGradientCenterPoint(GpPathGradient *grad,
GpPointF *point)
{
+ TRACE("(%p, %p)\n", grad, point);
+
if(!grad || !point)
return InvalidParameter;
GpStatus ret;
GpPointF ptf;
+ TRACE("(%p, %p)\n", grad, point);
+
if(!point)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetPathGradientFocusScales(GpPathGradient *grad,
REAL *x, REAL *y)
{
+ TRACE("(%p, %p, %p)\n", grad, x, y);
+
if(!grad || !x || !y)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetPathGradientGammaCorrection(GpPathGradient *grad,
BOOL *gamma)
{
+ TRACE("(%p, %p)\n", grad, gamma);
+
if(!grad || !gamma)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetPathGradientPointCount(GpPathGradient *grad,
INT *count)
{
+ TRACE("(%p, %p)\n", grad, count);
+
if(!grad || !count)
return InvalidParameter;
return Ok;
}
+GpStatus WINGDIPAPI GdipGetPathGradientRect(GpPathGradient *brush, GpRectF *rect)
+{
+ GpRectF r;
+ GpPath* path;
+ GpStatus stat;
+
+ TRACE("(%p, %p)\n", brush, rect);
+
+ if(!brush || !rect)
+ return InvalidParameter;
+
+ stat = GdipCreatePath2(brush->pathdata.Points, brush->pathdata.Types,
+ brush->pathdata.Count, FillModeAlternate, &path);
+ if(stat != Ok) return stat;
+
+ stat = GdipGetPathWorldBounds(path, &r, NULL, NULL);
+ if(stat != Ok){
+ GdipDeletePath(path);
+ return stat;
+ }
+
+ memcpy(rect, &r, sizeof(GpRectF));
+
+ GdipDeletePath(path);
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetPathGradientRectI(GpPathGradient *brush, GpRect *rect)
+{
+ GpRectF rectf;
+ GpStatus stat;
+
+ TRACE("(%p, %p)\n", brush, rect);
+
+ if(!brush || !rect)
+ return InvalidParameter;
+
+ stat = GdipGetPathGradientRect(brush, &rectf);
+ if(stat != Ok) return stat;
+
+ rect->X = roundr(rectf.X);
+ rect->Y = roundr(rectf.Y);
+ rect->Width = roundr(rectf.Width);
+ rect->Height = roundr(rectf.Height);
+
+ return Ok;
+}
+
GpStatus WINGDIPAPI GdipGetPathGradientSurroundColorsWithCount(GpPathGradient
*grad, ARGB *argb, INT *count)
{
GpStatus WINGDIPAPI GdipGetPathGradientWrapMode(GpPathGradient *brush,
GpWrapMode *wrapmode)
{
+ TRACE("(%p, %p)\n", brush, wrapmode);
+
if(!brush || !wrapmode)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetSolidFillColor(GpSolidFill *sf, ARGB *argb)
{
+ TRACE("(%p, %p)\n", sf, argb);
+
if(!sf || !argb)
return InvalidParameter;
return Ok;
}
+/******************************************************************************
+ * GdipGetTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetTextureTransform(GpTexture *brush, GpMatrix *matrix)
+{
+ TRACE("(%p, %p)\n", brush, matrix);
+
+ if(!brush || !matrix)
+ return InvalidParameter;
+
+ memcpy(matrix, brush->transform, sizeof(GpMatrix));
+
+ return Ok;
+}
+
+/******************************************************************************
+ * GdipGetTextureWrapMode [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipGetTextureWrapMode(GpTexture *brush, GpWrapMode *wrapmode)
+{
+ TRACE("(%p, %p)\n", brush, wrapmode);
+
+ if(!brush || !wrapmode)
+ return InvalidParameter;
+
+ *wrapmode = brush->wrap;
+
+ return Ok;
+}
+
+/******************************************************************************
+ * GdipMultiplyTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipMultiplyTextureTransform(GpTexture* brush,
+ GDIPCONST GpMatrix *matrix, GpMatrixOrder order)
+{
+ TRACE("(%p, %p, %d)\n", brush, matrix, order);
+
+ if(!brush || !matrix)
+ return InvalidParameter;
+
+ return GdipMultiplyMatrix(brush->transform, matrix, order);
+}
+
+/******************************************************************************
+ * GdipResetTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipResetTextureTransform(GpTexture* brush)
+{
+ TRACE("(%p)\n", brush);
+
+ if(!brush)
+ return InvalidParameter;
+
+ return GdipSetMatrixElements(brush->transform, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0);
+}
+
+/******************************************************************************
+ * GdipScaleTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipScaleTextureTransform(GpTexture* brush,
+ REAL sx, REAL sy, GpMatrixOrder order)
+{
+ TRACE("(%p, %.2f, %.2f, %d)\n", brush, sx, sy, order);
+
+ if(!brush)
+ return InvalidParameter;
+
+ return GdipScaleMatrix(brush->transform, sx, sy, order);
+}
+
GpStatus WINGDIPAPI GdipSetLineBlend(GpLineGradient *brush,
- GDIPCONST REAL *blend, GDIPCONST REAL* positions, INT count)
+ GDIPCONST REAL *factors, GDIPCONST REAL* positions, INT count)
{
- static int calls;
+ REAL *new_blendfac, *new_blendpos;
- if(!brush || !blend || !positions || count <= 0)
+ TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
+
+ if(!brush || !factors || !positions || count <= 0 ||
+ (count >= 2 && (positions[0] != 0.0f || positions[count-1] != 1.0f)))
return InvalidParameter;
- if(!(calls++))
- FIXME("not implemented\n");
+ new_blendfac = GdipAlloc(count * sizeof(REAL));
+ new_blendpos = GdipAlloc(count * sizeof(REAL));
+
+ if (!new_blendfac || !new_blendpos)
+ {
+ GdipFree(new_blendfac);
+ GdipFree(new_blendpos);
+ return OutOfMemory;
+ }
+
+ memcpy(new_blendfac, factors, count * sizeof(REAL));
+ memcpy(new_blendpos, positions, count * sizeof(REAL));
+
+ GdipFree(brush->blendfac);
+ GdipFree(brush->blendpos);
+
+ brush->blendcount = count;
+ brush->blendfac = new_blendfac;
+ brush->blendpos = new_blendpos;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetLineBlend(GpLineGradient *brush, REAL *factors,
+ REAL *positions, INT count)
+{
+ TRACE("(%p, %p, %p, %i)\n", brush, factors, positions, count);
+
+ if (!brush || !factors || !positions || count <= 0)
+ return InvalidParameter;
+
+ if (count < brush->blendcount)
+ return InsufficientBuffer;
+
+ memcpy(factors, brush->blendfac, brush->blendcount * sizeof(REAL));
+ memcpy(positions, brush->blendpos, brush->blendcount * sizeof(REAL));
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetLineBlendCount(GpLineGradient *brush, INT *count)
+{
+ TRACE("(%p, %p)\n", brush, count);
+
+ if (!brush || !count)
+ return InvalidParameter;
+
+ *count = brush->blendcount;
return Ok;
}
GpStatus WINGDIPAPI GdipSetLineGammaCorrection(GpLineGradient *line,
BOOL usegamma)
{
+ TRACE("(%p, %d)\n", line, usegamma);
+
if(!line)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetLineSigmaBlend(GpLineGradient *line, REAL focus,
REAL scale)
{
- static int calls;
+ REAL factors[33];
+ REAL positions[33];
+ int num_points = 0;
+ int i;
+ const int precision = 16;
+ REAL erf_range; /* we use values erf(-erf_range) through erf(+erf_range) */
+ REAL min_erf;
+ REAL scale_erf;
+
+ TRACE("(%p, %0.2f, %0.2f)\n", line, focus, scale);
if(!line || focus < 0.0 || focus > 1.0 || scale < 0.0 || scale > 1.0)
return InvalidParameter;
- if(!(calls++))
- FIXME("not implemented\n");
+ /* we want 2 standard deviations */
+ erf_range = 2.0 / sqrt(2);
- return NotImplemented;
+ /* calculate the constants we need to normalize the error function to be
+ between 0.0 and scale over the range we need */
+ min_erf = erf(-erf_range);
+ scale_erf = scale / (-2.0 * min_erf);
+
+ if (focus != 0.0)
+ {
+ positions[0] = 0.0;
+ factors[0] = 0.0;
+ for (i=1; i<precision; i++)
+ {
+ positions[i] = focus * i / precision;
+ factors[i] = scale_erf * (erf(2 * erf_range * i / precision - erf_range) - min_erf);
+ }
+ num_points += precision;
+ }
+
+ positions[num_points] = focus;
+ factors[num_points] = scale;
+ num_points += 1;
+
+ if (focus != 1.0)
+ {
+ for (i=1; i<precision; i++)
+ {
+ positions[i+num_points-1] = (focus + ((1.0-focus) * i / precision));
+ factors[i+num_points-1] = scale_erf * (erf(erf_range - 2 * erf_range * i / precision) - min_erf);
+ }
+ num_points += precision;
+ positions[num_points-1] = 1.0;
+ factors[num_points-1] = 0.0;
+ }
+
+ return GdipSetLineBlend(line, factors, positions, num_points);
}
GpStatus WINGDIPAPI GdipSetLineWrapMode(GpLineGradient *line,
GpWrapMode wrap)
{
+ TRACE("(%p, %d)\n", line, wrap);
+
if(!line || wrap == WrapModeClamp)
return InvalidParameter;
return Ok;
}
+GpStatus WINGDIPAPI GdipSetPathGradientBlend(GpPathGradient *brush, GDIPCONST REAL *blend,
+ GDIPCONST REAL *pos, INT count)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipSetPathGradientPresetBlend(GpPathGradient *brush,
+ GDIPCONST ARGB *blend, GDIPCONST REAL *pos, INT count)
+{
+ FIXME("(%p,%p,%p,%i): stub\n", brush, blend, pos, count);
+ return NotImplemented;
+}
+
GpStatus WINGDIPAPI GdipSetPathGradientCenterColor(GpPathGradient *grad,
ARGB argb)
{
+ TRACE("(%p, %x)\n", grad, argb);
+
if(!grad)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetPathGradientCenterPoint(GpPathGradient *grad,
GpPointF *point)
{
+ TRACE("(%p, %p)\n", grad, point);
+
if(!grad || !point)
return InvalidParameter;
{
GpPointF ptf;
+ TRACE("(%p, %p)\n", grad, point);
+
if(!point)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetPathGradientFocusScales(GpPathGradient *grad,
REAL x, REAL y)
{
+ TRACE("(%p, %.2f, %.2f)\n", grad, x, y);
+
if(!grad)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetPathGradientGammaCorrection(GpPathGradient *grad,
BOOL gamma)
{
+ TRACE("(%p, %d)\n", grad, gamma);
+
if(!grad)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetPathGradientWrapMode(GpPathGradient *grad,
GpWrapMode wrap)
{
+ TRACE("(%p, %d)\n", grad, wrap);
+
if(!grad)
return InvalidParameter;
GpStatus WINGDIPAPI GdipSetSolidFillColor(GpSolidFill *sf, ARGB argb)
{
+ TRACE("(%p, %x)\n", sf, argb);
+
if(!sf)
return InvalidParameter;
return Ok;
}
+/******************************************************************************
+ * GdipSetTextureTransform [GDIPLUS.@]
+ */
GpStatus WINGDIPAPI GdipSetTextureTransform(GpTexture *texture,
GDIPCONST GpMatrix *matrix)
{
- static int calls;
+ TRACE("(%p, %p)\n", texture, matrix);
if(!texture || !matrix)
return InvalidParameter;
- if(!(calls++))
- FIXME("not implemented\n");
+ memcpy(texture->transform, matrix, sizeof(GpMatrix));
+
+ return Ok;
+}
+
+/******************************************************************************
+ * GdipSetTextureWrapMode [GDIPLUS.@]
+ *
+ * WrapMode not used, only stored
+ */
+GpStatus WINGDIPAPI GdipSetTextureWrapMode(GpTexture *brush, GpWrapMode wrapmode)
+{
+ TRACE("(%p, %d)\n", brush, wrapmode);
+
+ if(!brush)
+ return InvalidParameter;
+
+ brush->wrap = wrapmode;
return Ok;
}
GpStatus WINGDIPAPI GdipSetLineColors(GpLineGradient *brush, ARGB color1,
ARGB color2)
{
+ TRACE("(%p, %x, %x)\n", brush, color1, color2);
+
if(!brush)
return InvalidParameter;
GpStatus WINGDIPAPI GdipGetLineColors(GpLineGradient *brush, ARGB *colors)
{
+ TRACE("(%p, %p)\n", brush, colors);
+
if(!brush || !colors)
return InvalidParameter;
return Ok;
}
+/******************************************************************************
+ * GdipRotateTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipRotateTextureTransform(GpTexture* brush, REAL angle,
+ GpMatrixOrder order)
+{
+ TRACE("(%p, %.2f, %d)\n", brush, angle, order);
+
+ if(!brush)
+ return InvalidParameter;
+
+ return GdipRotateMatrix(brush->transform, angle, order);
+}
+
GpStatus WINGDIPAPI GdipSetLineLinearBlend(GpLineGradient *brush, REAL focus,
REAL scale)
{
- static int calls;
+ REAL factors[3];
+ REAL positions[3];
+ int num_points = 0;
- if(!(calls++))
- FIXME("not implemented\n");
+ TRACE("(%p,%.2f,%.2f)\n", brush, focus, scale);
- return NotImplemented;
+ if (!brush) return InvalidParameter;
+
+ if (focus != 0.0)
+ {
+ factors[num_points] = 0.0;
+ positions[num_points] = 0.0;
+ num_points++;
+ }
+
+ factors[num_points] = scale;
+ positions[num_points] = focus;
+ num_points++;
+
+ if (focus != 1.0)
+ {
+ factors[num_points] = 0.0;
+ positions[num_points] = 1.0;
+ num_points++;
+ }
+
+ return GdipSetLineBlend(brush, factors, positions, num_points);
}
GpStatus WINGDIPAPI GdipSetLinePresetBlend(GpLineGradient *brush,
GDIPCONST ARGB *blend, GDIPCONST REAL* positions, INT count)
+{
+ ARGB *new_color;
+ REAL *new_pos;
+ TRACE("(%p,%p,%p,%i)\n", brush, blend, positions, count);
+
+ if (!brush || !blend || !positions || count < 2 ||
+ positions[0] != 0.0f || positions[count-1] != 1.0f)
+ {
+ return InvalidParameter;
+ }
+
+ new_color = GdipAlloc(count * sizeof(ARGB));
+ new_pos = GdipAlloc(count * sizeof(REAL));
+ if (!new_color || !new_pos)
+ {
+ GdipFree(new_color);
+ GdipFree(new_pos);
+ return OutOfMemory;
+ }
+
+ memcpy(new_color, blend, sizeof(ARGB) * count);
+ memcpy(new_pos, positions, sizeof(REAL) * count);
+
+ GdipFree(brush->pblendcolor);
+ GdipFree(brush->pblendpos);
+
+ brush->pblendcolor = new_color;
+ brush->pblendpos = new_pos;
+ brush->pblendcount = count;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetLinePresetBlend(GpLineGradient *brush,
+ ARGB *blend, REAL* positions, INT count)
+{
+ if (!brush || !blend || !positions || count < 2)
+ return InvalidParameter;
+
+ if (brush->pblendcount == 0)
+ return GenericError;
+
+ if (count < brush->pblendcount)
+ return InsufficientBuffer;
+
+ memcpy(blend, brush->pblendcolor, sizeof(ARGB) * brush->pblendcount);
+ memcpy(positions, brush->pblendpos, sizeof(REAL) * brush->pblendcount);
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipGetLinePresetBlendCount(GpLineGradient *brush,
+ INT *count)
+{
+ if (!brush || !count)
+ return InvalidParameter;
+
+ *count = brush->pblendcount;
+
+ return Ok;
+}
+
+GpStatus WINGDIPAPI GdipResetLineTransform(GpLineGradient *brush)
{
static int calls;
return NotImplemented;
}
+GpStatus WINGDIPAPI GdipScaleLineTransform(GpLineGradient *brush, REAL sx, REAL sy,
+ GpMatrixOrder order)
+{
+ static int calls;
+
+ if(!(calls++))
+ FIXME("not implemented\n");
+
+ return NotImplemented;
+}
+
+GpStatus WINGDIPAPI GdipTranslateLineTransform(GpLineGradient* brush,
+ REAL dx, REAL dy, GpMatrixOrder order)
+{
+ FIXME("stub: %p %f %f %d\n", brush, dx, dy, order);
+
+ return NotImplemented;
+}
+
+/******************************************************************************
+ * GdipTranslateTextureTransform [GDIPLUS.@]
+ */
+GpStatus WINGDIPAPI GdipTranslateTextureTransform(GpTexture* brush, REAL dx, REAL dy,
+ GpMatrixOrder order)
+{
+ TRACE("(%p, %.2f, %.2f, %d)\n", brush, dx, dy, order);
+
+ if(!brush)
+ return InvalidParameter;
+
+ return GdipTranslateMatrix(brush->transform, dx, dy, order);
+}
+
GpStatus WINGDIPAPI GdipGetLineRect(GpLineGradient *brush, GpRectF *rect)
{
+ TRACE("(%p, %p)\n", brush, rect);
+
if(!brush || !rect)
return InvalidParameter;
- rect->X = (brush->startpoint.X < brush->endpoint.X ? brush->startpoint.X: brush->endpoint.X);
- rect->Y = (brush->startpoint.Y < brush->endpoint.Y ? brush->startpoint.Y: brush->endpoint.Y);
-
- rect->Width = fabs(brush->startpoint.X - brush->endpoint.X);
- rect->Height = fabs(brush->startpoint.Y - brush->endpoint.Y);
+ *rect = brush->rect;
return Ok;
}
GpRectF rectF;
GpStatus ret;
+ TRACE("(%p, %p)\n", brush, rect);
+
if(!rect)
return InvalidParameter;
return ret;
}
+
+GpStatus WINGDIPAPI GdipRotateLineTransform(GpLineGradient* brush,
+ REAL angle, GpMatrixOrder order)
+{
+ static int calls;
+
+ if(!brush)
+ return InvalidParameter;
+
+ if(!(calls++))
+ FIXME("(%p, %.2f, %d) stub\n", brush, angle, order);
+
+ return NotImplemented;
+}
projects / reactos.git / blobdiff