mingw-w64-headers/include/gdiplusbrush.h - mingw-w64 - Git at Google

 /**
  * This file has no copyright assigned and is placed in the Public Domain.
  * This file is part of the w64 mingw-runtime package.
  * No warranty is given; refer to the file DISCLAIMER within this package.
  */
 #ifndef _GDIPLUSBRUSH_H
 #define _GDIPLUSBRUSH_H

 class GraphicsPath;

 class Brush : public GdiplusBase {
 public:
   friend class Pen;
   friend class Graphics;
   virtual ~Brush() { DllExports::GdipDeleteBrush(nativeBrush); }
   virtual Brush *Clone() const {
     GpBrush *brush = NULL;
     SetStatus(DllExports::GdipCloneBrush(nativeBrush,&brush));
     Brush *newBrush = new Brush(brush,lastResult);
     if(!newBrush) {
       DllExports::GdipDeleteBrush(brush);
     }
     return newBrush;
   }
   BrushType GetType() const {
     BrushType type = static_cast<BrushType>(-1);
     SetStatus(DllExports::GdipGetBrushType(nativeBrush,&type));
     return type;
   }
   Status GetLastStatus() const {
     Status lastStatus = lastResult;
     lastResult = Ok;
     return lastStatus;
   }
 protected:
   Brush() {
     SetStatus(NotImplemented);
   }
 private:
   Brush(const Brush &brush);
   Brush &operator=(const Brush &brush);
 protected:
   Brush(GpBrush *nativeBrush,Status status) {
     lastResult = status;
     SetNativeBrush(nativeBrush);
   }
   VOID SetNativeBrush(GpBrush *nativeBrush) { this->nativeBrush = nativeBrush; }
   Status SetStatus(Status status) const {
     if(status!=Ok) return (lastResult = status);
     else return status;
   }
   GpBrush *nativeBrush;
   mutable Status lastResult;
 };

 class SolidBrush : public Brush {
 public:
   friend class Pen;
   SolidBrush(const Color &color) {
     GpSolidFill *brush = NULL;
     lastResult = DllExports::GdipCreateSolidFill(color.GetValue(),&brush);
     SetNativeBrush(brush);
   }
   Status GetColor(Color *color) const {
     ARGB argb;
     if(!color) return SetStatus(InvalidParameter);
     SetStatus(DllExports::GdipGetSolidFillColor((GpSolidFill*)nativeBrush,&argb));
     *color = Color(argb);
     return lastResult;
   }

   Status SetColor(const Color &color) { return SetStatus(DllExports::GdipSetSolidFillColor((GpSolidFill*)nativeBrush,color.GetValue())); }
 private:
   SolidBrush(const SolidBrush &);
   SolidBrush &operator=(const SolidBrush &);
 protected:
   SolidBrush() { }
 };

 class TextureBrush : public Brush {
 public:
   friend class Pen;
   TextureBrush(Image *image,WrapMode wrapMode = WrapModeTile) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTexture(image->nativeImage,wrapMode,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,WrapMode wrapMode,const RectF &dstRect) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTexture2(image->nativeImage,wrapMode,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,const RectF &dstRect,const ImageAttributes *imageAttributes = NULL) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTextureIA(image->nativeImage,(imageAttributes)?imageAttributes->nativeImageAttr:NULL,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,const Rect &dstRect,const ImageAttributes *imageAttributes = NULL) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTextureIAI(image->nativeImage,(imageAttributes)?imageAttributes->nativeImageAttr:NULL,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,WrapMode wrapMode,const Rect &dstRect) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTexture2I(image->nativeImage,wrapMode,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,WrapMode wrapMode,REAL dstX,REAL dstY,REAL dstWidth,REAL dstHeight) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTexture2(image->nativeImage,wrapMode,dstX,dstY,dstWidth,dstHeight,&texture);
     SetNativeBrush(texture);
   }
   TextureBrush(Image *image,WrapMode wrapMode,INT dstX,INT dstY,INT dstWidth,INT dstHeight) {
     GpTexture *texture = NULL;
     lastResult = DllExports::GdipCreateTexture2I(image->nativeImage,wrapMode,dstX,dstY,dstWidth,dstHeight,&texture);
     SetNativeBrush(texture);
   }
   Status SetTransform(const Matrix *matrix) { return SetStatus(DllExports::GdipSetTextureTransform((GpTexture*)nativeBrush,matrix->nativeMatrix)); }
   Status GetTransform(Matrix *matrix) const { return SetStatus(DllExports::GdipGetTextureTransform((GpTexture*)nativeBrush,matrix->nativeMatrix)); }
   Status ResetTransform() { return SetStatus(DllExports::GdipResetTextureTransform((GpTexture*)nativeBrush)); }
   Status MultiplyTransform(const Matrix *matrix,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipMultiplyTextureTransform((GpTexture*)nativeBrush,matrix->nativeMatrix,order)); }
   Status TranslateTransform(REAL dx,REAL dy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipTranslateTextureTransform((GpTexture*)nativeBrush,dx,dy,order)); }
   Status ScaleTransform(REAL sx,REAL sy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipScaleTextureTransform((GpTexture*)nativeBrush,sx,sy,order)); }
   Status RotateTransform(REAL angle,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipRotateTextureTransform((GpTexture*)nativeBrush,angle,order)); }
   Status SetWrapMode(WrapMode wrapMode) { return SetStatus(DllExports::GdipSetTextureWrapMode((GpTexture*)nativeBrush,wrapMode)); }
   WrapMode GetWrapMode() const {
     WrapMode wrapMode;
     SetStatus(DllExports::GdipGetTextureWrapMode((GpTexture*)nativeBrush,&wrapMode));
     return wrapMode;
   }
   Image *GetImage() const {
     GpImage *image;
     SetStatus(DllExports::GdipGetTextureImage((GpTexture *)nativeBrush,&image));
     Image *retimage = new Image(image,lastResult);
     if(!retimage) DllExports::GdipDisposeImage(image);
     return retimage;
   }
 private:
   TextureBrush(const TextureBrush &);
   TextureBrush &operator=(const TextureBrush &);
 protected:
   TextureBrush() { }
 };

 class LinearGradientBrush : public Brush {
 public:
   friend class Pen;
   LinearGradientBrush(const PointF &point1,const PointF &point2,const Color &color1,const Color &color2) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrush(&point1,&point2,color1.GetValue(),color2.GetValue(),WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   LinearGradientBrush(const Point &point1,const Point &point2,const Color &color1,const Color &color2) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrushI(&point1,&point2,color1.GetValue(),color2.GetValue(),WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   LinearGradientBrush(const RectF &rect,const Color &color1,const Color &color2,LinearGradientMode mode) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrushFromRect(&rect,color1.GetValue(),color2.GetValue(),mode,WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   LinearGradientBrush(const Rect &rect,const Color &color1,const Color &color2,LinearGradientMode mode) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrushFromRectI(&rect,color1.GetValue(),color2.GetValue(),mode,WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   LinearGradientBrush(const RectF &rect,const Color &color1,const Color &color2,REAL angle,WINBOOL isAngleScalable = FALSE) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrushFromRectWithAngle(&rect,color1.GetValue(),color2.GetValue(),angle,isAngleScalable,WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   LinearGradientBrush(const Rect &rect,const Color &color1,const Color &color2,REAL angle,WINBOOL isAngleScalable = FALSE) {
     GpLineGradient *brush = NULL;
     lastResult = DllExports::GdipCreateLineBrushFromRectWithAngleI(&rect,color1.GetValue(),color2.GetValue(),angle,isAngleScalable,WrapModeTile,&brush);
     SetNativeBrush(brush);
   }
   Status SetLinearColors(const Color &color1,const Color &color2) { return SetStatus(DllExports::GdipSetLineColors((GpLineGradient*)nativeBrush,color1.GetValue(),color2.GetValue())); }
   Status GetLinearColors(Color *colors) const {
     ARGB argb[2];
     if(!colors) return SetStatus(InvalidParameter);
     SetStatus(DllExports::GdipGetLineColors((GpLineGradient*) nativeBrush,argb));
     if(lastResult==Ok) {
       colors[0] = Color(argb[0]);
       colors[1] = Color(argb[1]);
     }
     return lastResult;
   }
   Status GetRectangle(RectF *rect) const { return SetStatus(DllExports::GdipGetLineRect((GpLineGradient*)nativeBrush,rect)); }
   Status GetRectangle(Rect *rect) const { return SetStatus(DllExports::GdipGetLineRectI((GpLineGradient*)nativeBrush,rect)); }
   Status SetGammaCorrection(WINBOOL useGammaCorrection) { return SetStatus(DllExports::GdipSetLineGammaCorrection((GpLineGradient*)nativeBrush,useGammaCorrection)); }
   WINBOOL GetGammaCorrection() const {
     WINBOOL useGammaCorrection;
     SetStatus(DllExports::GdipGetLineGammaCorrection((GpLineGradient*)nativeBrush,&useGammaCorrection));
     return useGammaCorrection;
   }
   INT GetBlendCount() const {
     INT count = 0;
     SetStatus(DllExports::GdipGetLineBlendCount((GpLineGradient*) nativeBrush,&count));
     return count;
   }
   Status SetBlend(const REAL *blendFactors,const REAL *blendPositions,INT count) { return SetStatus(DllExports::GdipSetLineBlend((GpLineGradient*) nativeBrush,blendFactors,blendPositions,count)); }
   Status GetBlend(REAL *blendFactors,REAL *blendPositions,INT count) const { return SetStatus(DllExports::GdipGetLineBlend((GpLineGradient*)nativeBrush,blendFactors,blendPositions,count)); }
   INT GetInterpolationColorCount() const {
     INT count = 0;
     SetStatus(DllExports::GdipGetLinePresetBlendCount((GpLineGradient*) nativeBrush,&count));
     return count;
   }
   Status SetInterpolationColors(const Color *presetColors,const REAL *blendPositions,INT count) {
     if((count <= 0) || !presetColors) return SetStatus(InvalidParameter);
     ARGB *argbs = (ARGB*) new BYTE[count*sizeof(ARGB)];
     if(argbs) {
       for(INT i = 0;i < count;i++) {
 	argbs[i] = presetColors[i].GetValue();
       }
       Status status = SetStatus(DllExports::GdipSetLinePresetBlend((GpLineGradient*) nativeBrush,argbs,blendPositions,count));
       delete [] argbs;
       return status;
     } else return SetStatus(OutOfMemory);
   }
   Status GetInterpolationColors(Color *presetColors,REAL *blendPositions,INT count) const {
     if((count <= 0) || !presetColors) return SetStatus(InvalidParameter);
     ARGB *argbs = (ARGB*) new BYTE[count*sizeof(ARGB)];
     if(!argbs) return SetStatus(OutOfMemory);
     Status status = SetStatus(DllExports::GdipGetLinePresetBlend((GpLineGradient*)nativeBrush,argbs,blendPositions,count));
     if(status==Ok) {
       for(INT i = 0;i < count;i++) {
 	presetColors[i] = Color(argbs[i]);
       }
     }
     delete [] argbs;
     return status;
   }
   Status SetBlendBellShape(REAL focus,REAL scale = 1.0f) { return SetStatus(DllExports::GdipSetLineSigmaBlend((GpLineGradient*)nativeBrush,focus,scale)); }
   Status SetBlendTriangularShape(REAL focus,REAL scale = 1.0f) { return SetStatus(DllExports::GdipSetLineLinearBlend((GpLineGradient*)nativeBrush,focus,scale)); }
   Status SetTransform(const Matrix *matrix) { return SetStatus(DllExports::GdipSetLineTransform((GpLineGradient*)nativeBrush,matrix->nativeMatrix)); }
   Status GetTransform(Matrix *matrix) const { return SetStatus(DllExports::GdipGetLineTransform((GpLineGradient*)nativeBrush,matrix->nativeMatrix)); }
   Status ResetTransform() { return SetStatus(DllExports::GdipResetLineTransform((GpLineGradient*)nativeBrush)); }
   Status MultiplyTransform(const Matrix *matrix,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipMultiplyLineTransform((GpLineGradient*)nativeBrush,matrix->nativeMatrix,order)); }
   Status TranslateTransform(REAL dx,REAL dy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipTranslateLineTransform((GpLineGradient*)nativeBrush,dx,dy,order)); }
   Status ScaleTransform(REAL sx,REAL sy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipScaleLineTransform((GpLineGradient*)nativeBrush,sx,sy,order)); }
   Status RotateTransform(REAL angle,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipRotateLineTransform((GpLineGradient*)nativeBrush,angle,order)); }
   Status SetWrapMode(WrapMode wrapMode) { return SetStatus(DllExports::GdipSetLineWrapMode((GpLineGradient*)nativeBrush,wrapMode)); }
   WrapMode GetWrapMode() const {
     WrapMode wrapMode;
     SetStatus(DllExports::GdipGetLineWrapMode((GpLineGradient*) nativeBrush,&wrapMode));
     return wrapMode;
   }
 private:
   LinearGradientBrush(const LinearGradientBrush &);
   LinearGradientBrush &operator=(const LinearGradientBrush &);
 protected:
   LinearGradientBrush() { }
 };

 class HatchBrush : public Brush {
 public:
   friend class Pen;
   HatchBrush(HatchStyle hatchStyle,const Color &foreColor,const Color &backColor = Color()) {
     GpHatch *brush = NULL;
     lastResult = DllExports::GdipCreateHatchBrush(hatchStyle,foreColor.GetValue(),backColor.GetValue(),&brush);
     SetNativeBrush(brush);
   }
   HatchStyle GetHatchStyle() const {
     HatchStyle hatchStyle;
     SetStatus(DllExports::GdipGetHatchStyle((GpHatch*)nativeBrush,&hatchStyle));
     return hatchStyle;
   }
   Status GetForegroundColor(Color *color) const {
     ARGB argb;
     if(!color) return SetStatus(InvalidParameter);
     Status status = SetStatus(DllExports::GdipGetHatchForegroundColor((GpHatch*)nativeBrush,&argb));
     color->SetValue(argb);
     return status;
   }
   Status GetBackgroundColor(Color *color) const {
     ARGB argb;
     if(!color) return SetStatus(InvalidParameter);
     Status status = SetStatus(DllExports::GdipGetHatchBackgroundColor((GpHatch*)nativeBrush,&argb));
     color->SetValue(argb);
     return status;
   }
 private:
   HatchBrush(const HatchBrush &);
   HatchBrush &operator=(const HatchBrush &);
 protected:
   HatchBrush() { }
 };
 #endif
	/**
	* This file has no copyright assigned and is placed in the Public Domain.
	* This file is part of the w64 mingw-runtime package.
	* No warranty is given; refer to the file DISCLAIMER within this package.
	*/
	#ifndef _GDIPLUSBRUSH_H
	#define _GDIPLUSBRUSH_H

	class GraphicsPath;

	class Brush : public GdiplusBase {
	public:
	friend class Pen;
	friend class Graphics;
	virtual ~Brush() { DllExports::GdipDeleteBrush(nativeBrush); }
	virtual Brush *Clone() const {
	GpBrush *brush = NULL;
	SetStatus(DllExports::GdipCloneBrush(nativeBrush,&brush));
	Brush *newBrush = new Brush(brush,lastResult);
	if(!newBrush) {
	DllExports::GdipDeleteBrush(brush);
	}
	return newBrush;
	}
	BrushType GetType() const {
	BrushType type = static_cast<BrushType>(-1);
	SetStatus(DllExports::GdipGetBrushType(nativeBrush,&type));
	return type;
	}
	Status GetLastStatus() const {
	Status lastStatus = lastResult;
	lastResult = Ok;
	return lastStatus;
	}
	protected:
	Brush() {
	SetStatus(NotImplemented);
	}
	private:
	Brush(const Brush &brush);
	Brush &operator=(const Brush &brush);
	protected:
	Brush(GpBrush *nativeBrush,Status status) {
	lastResult = status;
	SetNativeBrush(nativeBrush);
	}
	VOID SetNativeBrush(GpBrush *nativeBrush) { this->nativeBrush = nativeBrush; }
	Status SetStatus(Status status) const {
	if(status!=Ok) return (lastResult = status);
	else return status;
	}
	GpBrush *nativeBrush;
	mutable Status lastResult;
	};

	class SolidBrush : public Brush {
	public:
	friend class Pen;
	SolidBrush(const Color &color) {
	GpSolidFill *brush = NULL;
	lastResult = DllExports::GdipCreateSolidFill(color.GetValue(),&brush);
	SetNativeBrush(brush);
	}
	Status GetColor(Color *color) const {
	ARGB argb;
	if(!color) return SetStatus(InvalidParameter);
	SetStatus(DllExports::GdipGetSolidFillColor((GpSolidFill*)nativeBrush,&argb));
	*color = Color(argb);
	return lastResult;
	}

	Status SetColor(const Color &color) { return SetStatus(DllExports::GdipSetSolidFillColor((GpSolidFill*)nativeBrush,color.GetValue())); }
	private:
	SolidBrush(const SolidBrush &);
	SolidBrush &operator=(const SolidBrush &);
	protected:
	SolidBrush() { }
	};

	class TextureBrush : public Brush {
	public:
	friend class Pen;
	TextureBrush(Image *image,WrapMode wrapMode = WrapModeTile) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTexture(image->nativeImage,wrapMode,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image *image,WrapMode wrapMode,const RectF &dstRect) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTexture2(image->nativeImage,wrapMode,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image image,const RectF &dstRect,const ImageAttributes imageAttributes = NULL) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTextureIA(image->nativeImage,(imageAttributes)?imageAttributes->nativeImageAttr:NULL,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image image,const Rect &dstRect,const ImageAttributes imageAttributes = NULL) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTextureIAI(image->nativeImage,(imageAttributes)?imageAttributes->nativeImageAttr:NULL,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image *image,WrapMode wrapMode,const Rect &dstRect) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTexture2I(image->nativeImage,wrapMode,dstRect.X,dstRect.Y,dstRect.Width,dstRect.Height,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image *image,WrapMode wrapMode,REAL dstX,REAL dstY,REAL dstWidth,REAL dstHeight) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTexture2(image->nativeImage,wrapMode,dstX,dstY,dstWidth,dstHeight,&texture);
	SetNativeBrush(texture);
	}
	TextureBrush(Image *image,WrapMode wrapMode,INT dstX,INT dstY,INT dstWidth,INT dstHeight) {
	GpTexture *texture = NULL;
	lastResult = DllExports::GdipCreateTexture2I(image->nativeImage,wrapMode,dstX,dstY,dstWidth,dstHeight,&texture);
	SetNativeBrush(texture);
	}
	Status SetTransform(const Matrix matrix) { return SetStatus(DllExports::GdipSetTextureTransform((GpTexture)nativeBrush,matrix->nativeMatrix)); }
	Status GetTransform(Matrix matrix) const { return SetStatus(DllExports::GdipGetTextureTransform((GpTexture)nativeBrush,matrix->nativeMatrix)); }
	Status ResetTransform() { return SetStatus(DllExports::GdipResetTextureTransform((GpTexture*)nativeBrush)); }
	Status MultiplyTransform(const Matrix matrix,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipMultiplyTextureTransform((GpTexture)nativeBrush,matrix->nativeMatrix,order)); }
	Status TranslateTransform(REAL dx,REAL dy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipTranslateTextureTransform((GpTexture*)nativeBrush,dx,dy,order)); }
	Status ScaleTransform(REAL sx,REAL sy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipScaleTextureTransform((GpTexture*)nativeBrush,sx,sy,order)); }
	Status RotateTransform(REAL angle,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipRotateTextureTransform((GpTexture*)nativeBrush,angle,order)); }
	Status SetWrapMode(WrapMode wrapMode) { return SetStatus(DllExports::GdipSetTextureWrapMode((GpTexture*)nativeBrush,wrapMode)); }
	WrapMode GetWrapMode() const {
	WrapMode wrapMode;
	SetStatus(DllExports::GdipGetTextureWrapMode((GpTexture*)nativeBrush,&wrapMode));
	return wrapMode;
	}
	Image *GetImage() const {
	GpImage *image;
	SetStatus(DllExports::GdipGetTextureImage((GpTexture *)nativeBrush,&image));
	Image *retimage = new Image(image,lastResult);
	if(!retimage) DllExports::GdipDisposeImage(image);
	return retimage;
	}
	private:
	TextureBrush(const TextureBrush &);
	TextureBrush &operator=(const TextureBrush &);
	protected:
	TextureBrush() { }
	};

	class LinearGradientBrush : public Brush {
	public:
	friend class Pen;
	LinearGradientBrush(const PointF &point1,const PointF &point2,const Color &color1,const Color &color2) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrush(&point1,&point2,color1.GetValue(),color2.GetValue(),WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	LinearGradientBrush(const Point &point1,const Point &point2,const Color &color1,const Color &color2) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrushI(&point1,&point2,color1.GetValue(),color2.GetValue(),WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	LinearGradientBrush(const RectF &rect,const Color &color1,const Color &color2,LinearGradientMode mode) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrushFromRect(&rect,color1.GetValue(),color2.GetValue(),mode,WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	LinearGradientBrush(const Rect &rect,const Color &color1,const Color &color2,LinearGradientMode mode) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrushFromRectI(&rect,color1.GetValue(),color2.GetValue(),mode,WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	LinearGradientBrush(const RectF &rect,const Color &color1,const Color &color2,REAL angle,WINBOOL isAngleScalable = FALSE) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrushFromRectWithAngle(&rect,color1.GetValue(),color2.GetValue(),angle,isAngleScalable,WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	LinearGradientBrush(const Rect &rect,const Color &color1,const Color &color2,REAL angle,WINBOOL isAngleScalable = FALSE) {
	GpLineGradient *brush = NULL;
	lastResult = DllExports::GdipCreateLineBrushFromRectWithAngleI(&rect,color1.GetValue(),color2.GetValue(),angle,isAngleScalable,WrapModeTile,&brush);
	SetNativeBrush(brush);
	}
	Status SetLinearColors(const Color &color1,const Color &color2) { return SetStatus(DllExports::GdipSetLineColors((GpLineGradient*)nativeBrush,color1.GetValue(),color2.GetValue())); }
	Status GetLinearColors(Color *colors) const {
	ARGB argb[2];
	if(!colors) return SetStatus(InvalidParameter);
	SetStatus(DllExports::GdipGetLineColors((GpLineGradient*) nativeBrush,argb));
	if(lastResult==Ok) {
	colors[0] = Color(argb[0]);
	colors[1] = Color(argb[1]);
	}
	return lastResult;
	}
	Status GetRectangle(RectF rect) const { return SetStatus(DllExports::GdipGetLineRect((GpLineGradient)nativeBrush,rect)); }
	Status GetRectangle(Rect rect) const { return SetStatus(DllExports::GdipGetLineRectI((GpLineGradient)nativeBrush,rect)); }
	Status SetGammaCorrection(WINBOOL useGammaCorrection) { return SetStatus(DllExports::GdipSetLineGammaCorrection((GpLineGradient*)nativeBrush,useGammaCorrection)); }
	WINBOOL GetGammaCorrection() const {
	WINBOOL useGammaCorrection;
	SetStatus(DllExports::GdipGetLineGammaCorrection((GpLineGradient*)nativeBrush,&useGammaCorrection));
	return useGammaCorrection;
	}
	INT GetBlendCount() const {
	INT count = 0;
	SetStatus(DllExports::GdipGetLineBlendCount((GpLineGradient*) nativeBrush,&count));
	return count;
	}
	Status SetBlend(const REAL blendFactors,const REAL blendPositions,INT count) { return SetStatus(DllExports::GdipSetLineBlend((GpLineGradient*) nativeBrush,blendFactors,blendPositions,count)); }
	Status GetBlend(REAL blendFactors,REAL blendPositions,INT count) const { return SetStatus(DllExports::GdipGetLineBlend((GpLineGradient*)nativeBrush,blendFactors,blendPositions,count)); }
	INT GetInterpolationColorCount() const {
	INT count = 0;
	SetStatus(DllExports::GdipGetLinePresetBlendCount((GpLineGradient*) nativeBrush,&count));
	return count;
	}
	Status SetInterpolationColors(const Color presetColors,const REAL blendPositions,INT count) {
	if((count <= 0) \|\| !presetColors) return SetStatus(InvalidParameter);
	ARGB argbs = (ARGB) new BYTE[count*sizeof(ARGB)];
	if(argbs) {
	for(INT i = 0;i < count;i++) {
	argbs[i] = presetColors[i].GetValue();
	}
	Status status = SetStatus(DllExports::GdipSetLinePresetBlend((GpLineGradient*) nativeBrush,argbs,blendPositions,count));
	delete [] argbs;
	return status;
	} else return SetStatus(OutOfMemory);
	}
	Status GetInterpolationColors(Color presetColors,REAL blendPositions,INT count) const {
	if((count <= 0) \|\| !presetColors) return SetStatus(InvalidParameter);
	ARGB argbs = (ARGB) new BYTE[count*sizeof(ARGB)];
	if(!argbs) return SetStatus(OutOfMemory);
	Status status = SetStatus(DllExports::GdipGetLinePresetBlend((GpLineGradient*)nativeBrush,argbs,blendPositions,count));
	if(status==Ok) {
	for(INT i = 0;i < count;i++) {
	presetColors[i] = Color(argbs[i]);
	}
	}
	delete [] argbs;
	return status;
	}
	Status SetBlendBellShape(REAL focus,REAL scale = 1.0f) { return SetStatus(DllExports::GdipSetLineSigmaBlend((GpLineGradient*)nativeBrush,focus,scale)); }
	Status SetBlendTriangularShape(REAL focus,REAL scale = 1.0f) { return SetStatus(DllExports::GdipSetLineLinearBlend((GpLineGradient*)nativeBrush,focus,scale)); }
	Status SetTransform(const Matrix matrix) { return SetStatus(DllExports::GdipSetLineTransform((GpLineGradient)nativeBrush,matrix->nativeMatrix)); }
	Status GetTransform(Matrix matrix) const { return SetStatus(DllExports::GdipGetLineTransform((GpLineGradient)nativeBrush,matrix->nativeMatrix)); }
	Status ResetTransform() { return SetStatus(DllExports::GdipResetLineTransform((GpLineGradient*)nativeBrush)); }
	Status MultiplyTransform(const Matrix matrix,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipMultiplyLineTransform((GpLineGradient)nativeBrush,matrix->nativeMatrix,order)); }
	Status TranslateTransform(REAL dx,REAL dy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipTranslateLineTransform((GpLineGradient*)nativeBrush,dx,dy,order)); }
	Status ScaleTransform(REAL sx,REAL sy,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipScaleLineTransform((GpLineGradient*)nativeBrush,sx,sy,order)); }
	Status RotateTransform(REAL angle,MatrixOrder order = MatrixOrderPrepend) { return SetStatus(DllExports::GdipRotateLineTransform((GpLineGradient*)nativeBrush,angle,order)); }
	Status SetWrapMode(WrapMode wrapMode) { return SetStatus(DllExports::GdipSetLineWrapMode((GpLineGradient*)nativeBrush,wrapMode)); }
	WrapMode GetWrapMode() const {
	WrapMode wrapMode;
	SetStatus(DllExports::GdipGetLineWrapMode((GpLineGradient*) nativeBrush,&wrapMode));
	return wrapMode;
	}
	private:
	LinearGradientBrush(const LinearGradientBrush &);
	LinearGradientBrush &operator=(const LinearGradientBrush &);
	protected:
	LinearGradientBrush() { }
	};

	class HatchBrush : public Brush {
	public:
	friend class Pen;
	HatchBrush(HatchStyle hatchStyle,const Color &foreColor,const Color &backColor = Color()) {
	GpHatch *brush = NULL;
	lastResult = DllExports::GdipCreateHatchBrush(hatchStyle,foreColor.GetValue(),backColor.GetValue(),&brush);
	SetNativeBrush(brush);
	}
	HatchStyle GetHatchStyle() const {
	HatchStyle hatchStyle;
	SetStatus(DllExports::GdipGetHatchStyle((GpHatch*)nativeBrush,&hatchStyle));
	return hatchStyle;
	}
	Status GetForegroundColor(Color *color) const {
	ARGB argb;
	if(!color) return SetStatus(InvalidParameter);
	Status status = SetStatus(DllExports::GdipGetHatchForegroundColor((GpHatch*)nativeBrush,&argb));
	color->SetValue(argb);
	return status;
	}
	Status GetBackgroundColor(Color *color) const {
	ARGB argb;
	if(!color) return SetStatus(InvalidParameter);
	Status status = SetStatus(DllExports::GdipGetHatchBackgroundColor((GpHatch*)nativeBrush,&argb));
	color->SetValue(argb);
	return status;
	}
	private:
	HatchBrush(const HatchBrush &);
	HatchBrush &operator=(const HatchBrush &);
	protected:
	HatchBrush() { }
	};
	#endif