| /**************************************************************************\ | |
| * | |
| * Copyright (c) 1998-2000, Microsoft Corp. All Rights Reserved. | |
| * | |
| * Module Name: | |
| * | |
| * GdiplusBrush.h | |
| * | |
| * Abstract: | |
| * | |
| * Brush API related declarations | |
| * | |
| \**************************************************************************/ | |
| #ifndef _GDIPLUSBRUSH_H | |
| #define _GDIPLUSBRUSH_H | |
| //-------------------------------------------------------------------------- | |
| // Abstract base class for various brush types | |
| //-------------------------------------------------------------------------- | |
| 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 == NULL) | |
| { | |
| 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); | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| Brush(const Brush& brush); | |
| Brush& operator=(const Brush& brush); | |
| protected: | |
| #else | |
| Brush(const Brush& brush) | |
| { | |
| brush; | |
| SetStatus(NotImplemented); | |
| } | |
| Brush& operator=(const Brush& brush) | |
| { | |
| brush; | |
| SetStatus(NotImplemented); | |
| return *this; | |
| } | |
| #endif | |
| 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; | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represent solid fill brush object | |
| //-------------------------------------------------------------------------- | |
| class SolidBrush : public Brush | |
| { | |
| public: | |
| friend class Pen; | |
| SolidBrush(IN const Color& color) | |
| { | |
| GpSolidFill *brush = NULL; | |
| lastResult = DllExports::GdipCreateSolidFill(color.GetValue(), &brush); | |
| SetNativeBrush(brush); | |
| } | |
| Status GetColor(OUT Color* color) const | |
| { | |
| ARGB argb; | |
| if (color == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| SetStatus(DllExports::GdipGetSolidFillColor((GpSolidFill*)nativeBrush, | |
| &argb)); | |
| *color = Color(argb); | |
| return lastResult; | |
| } | |
| Status SetColor(IN const Color& color) | |
| { | |
| return SetStatus(DllExports::GdipSetSolidFillColor((GpSolidFill*)nativeBrush, | |
| color.GetValue())); | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| SolidBrush(const SolidBrush &); | |
| SolidBrush& operator=(const SolidBrush &); | |
| #endif | |
| protected: | |
| SolidBrush() | |
| { | |
| } | |
| }; | |
| class TextureBrush : public Brush | |
| { | |
| public: | |
| friend class Pen; | |
| TextureBrush(IN Image* image, | |
| IN WrapMode wrapMode = WrapModeTile) | |
| { | |
| GpTexture *texture = NULL; | |
| lastResult = DllExports::GdipCreateTexture( | |
| image->nativeImage, | |
| wrapMode, &texture); | |
| SetNativeBrush(texture); | |
| } | |
| // When creating a texture brush from a metafile image, the dstRect | |
| // is used to specify the size that the metafile image should be | |
| // rendered at in the device units of the destination graphics. | |
| // It is NOT used to crop the metafile image, so only the width | |
| // and height values matter for metafiles. | |
| TextureBrush(IN Image* image, | |
| IN WrapMode wrapMode, | |
| IN const RectF &dstRect) | |
| { | |
| GpTexture *texture = NULL; | |
| lastResult = DllExports::GdipCreateTexture2( | |
| image->nativeImage, | |
| wrapMode, | |
| dstRect.X, | |
| dstRect.Y, | |
| dstRect.Width, | |
| dstRect.Height, | |
| &texture); | |
| SetNativeBrush(texture); | |
| } | |
| // When creating a texture brush from a metafile image, the dstRect | |
| // is used to specify the size that the metafile image should be | |
| // rendered at in the device units of the destination graphics. | |
| // It is NOT used to crop the metafile image, so only the width | |
| // and height values matter for metafiles. | |
| TextureBrush(IN Image *image, | |
| IN const RectF &dstRect, | |
| IN 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); | |
| } | |
| #ifdef DCR_USE_NEW_145138 | |
| TextureBrush(IN Image *image, | |
| IN const Rect &dstRect, | |
| IN 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); | |
| } | |
| #endif | |
| // When creating a texture brush from a metafile image, the dstRect | |
| // is used to specify the size that the metafile image should be | |
| // rendered at in the device units of the destination graphics. | |
| // It is NOT used to crop the metafile image, so only the width | |
| // and height values matter for metafiles. | |
| TextureBrush( | |
| IN Image* image, | |
| IN WrapMode wrapMode, | |
| #ifdef DCR_USE_NEW_145138 | |
| const IN Rect &dstRect | |
| #else | |
| IN Rect &dstRect | |
| #endif | |
| ) | |
| { | |
| GpTexture *texture = NULL; | |
| lastResult = DllExports::GdipCreateTexture2I( | |
| image->nativeImage, | |
| wrapMode, | |
| dstRect.X, | |
| dstRect.Y, | |
| dstRect.Width, | |
| dstRect.Height, | |
| &texture); | |
| SetNativeBrush(texture); | |
| } | |
| // When creating a texture brush from a metafile image, the dstRect | |
| // is used to specify the size that the metafile image should be | |
| // rendered at in the device units of the destination graphics. | |
| // It is NOT used to crop the metafile image, so only the width | |
| // and height values matter for metafiles. | |
| TextureBrush(IN Image* image, | |
| IN WrapMode wrapMode, | |
| IN REAL dstX, | |
| IN REAL dstY, | |
| IN REAL dstWidth, | |
| IN REAL dstHeight) | |
| { | |
| GpTexture *texture = NULL; | |
| lastResult = DllExports::GdipCreateTexture2( | |
| image->nativeImage, | |
| wrapMode, | |
| dstX, | |
| dstY, | |
| dstWidth, | |
| dstHeight, | |
| &texture); | |
| SetNativeBrush(texture); | |
| } | |
| // When creating a texture brush from a metafile image, the dstRect | |
| // is used to specify the size that the metafile image should be | |
| // rendered at in the device units of the destination graphics. | |
| // It is NOT used to crop the metafile image, so only the width | |
| // and height values matter for metafiles. | |
| TextureBrush(IN Image* image, | |
| IN WrapMode wrapMode, | |
| IN INT dstX, | |
| IN INT dstY, | |
| IN INT dstWidth, | |
| IN INT dstHeight) | |
| { | |
| GpTexture *texture = NULL; | |
| lastResult = DllExports::GdipCreateTexture2I( | |
| image->nativeImage, | |
| wrapMode, | |
| dstX, | |
| dstY, | |
| dstWidth, | |
| dstHeight, | |
| &texture); | |
| SetNativeBrush(texture); | |
| } | |
| /** | |
| * Set/get brush transform | |
| */ | |
| Status SetTransform(IN const Matrix* matrix) | |
| { | |
| return SetStatus(DllExports::GdipSetTextureTransform((GpTexture*)nativeBrush, | |
| matrix->nativeMatrix)); | |
| } | |
| Status GetTransform(OUT Matrix* matrix) const | |
| { | |
| return SetStatus(DllExports::GdipGetTextureTransform((GpTexture*)nativeBrush, | |
| matrix->nativeMatrix)); | |
| } | |
| Status ResetTransform() | |
| { | |
| return SetStatus(DllExports::GdipResetTextureTransform((GpTexture*)nativeBrush)); | |
| } | |
| Status MultiplyTransform(IN const Matrix* matrix, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipMultiplyTextureTransform((GpTexture*)nativeBrush, | |
| matrix->nativeMatrix, | |
| order)); | |
| } | |
| Status TranslateTransform(IN REAL dx, | |
| IN REAL dy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipTranslateTextureTransform((GpTexture*)nativeBrush, | |
| dx, dy, order)); | |
| } | |
| Status ScaleTransform(IN REAL sx, | |
| IN REAL sy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipScaleTextureTransform((GpTexture*)nativeBrush, | |
| sx, sy, order)); | |
| } | |
| Status RotateTransform(IN REAL angle, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipRotateTextureTransform((GpTexture*)nativeBrush, | |
| angle, order)); | |
| } | |
| /** | |
| * Set/get brush wrapping mode | |
| */ | |
| Status SetWrapMode(IN WrapMode wrapMode) | |
| { | |
| return SetStatus(DllExports::GdipSetTextureWrapMode((GpTexture*)nativeBrush, | |
| wrapMode)); | |
| } | |
| WrapMode GetWrapMode() const | |
| { | |
| WrapMode wrapMode; | |
| SetStatus(DllExports::GdipGetTextureWrapMode((GpTexture*)nativeBrush, | |
| &wrapMode)); | |
| return wrapMode; | |
| } | |
| // Get texture brush attributes | |
| Image *GetImage() const | |
| { | |
| GpImage *image; | |
| SetStatus(DllExports::GdipGetTextureImage((GpTexture *)nativeBrush, | |
| &image)); | |
| Image *retimage = new Image(image, lastResult); | |
| if (retimage == NULL) | |
| { | |
| DllExports::GdipDisposeImage(image); | |
| } | |
| return retimage; | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| TextureBrush(const TextureBrush &); | |
| TextureBrush& operator=(const TextureBrush &); | |
| #endif | |
| protected: | |
| TextureBrush() | |
| { | |
| } | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // Represent line gradient brush object | |
| //-------------------------------------------------------------------------- | |
| class LinearGradientBrush : public Brush | |
| { | |
| public: | |
| friend class Pen; | |
| LinearGradientBrush(IN const PointF& point1, | |
| IN const PointF& point2, | |
| IN const Color& color1, | |
| IN const Color& color2) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrush(&point1, | |
| &point2, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| LinearGradientBrush(IN const Point& point1, | |
| IN const Point& point2, | |
| IN const Color& color1, | |
| IN const Color& color2) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrushI(&point1, | |
| &point2, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| LinearGradientBrush(IN const RectF& rect, | |
| IN const Color& color1, | |
| IN const Color& color2, | |
| IN LinearGradientMode mode) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrushFromRect(&rect, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| mode, | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| LinearGradientBrush(IN const Rect& rect, | |
| IN const Color& color1, | |
| IN const Color& color2, | |
| IN LinearGradientMode mode) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrushFromRectI(&rect, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| mode, | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| LinearGradientBrush(IN const RectF& rect, | |
| IN const Color& color1, | |
| IN const Color& color2, | |
| IN REAL angle, | |
| IN BOOL isAngleScalable = FALSE) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrushFromRectWithAngle(&rect, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| angle, | |
| isAngleScalable, | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| LinearGradientBrush(IN const Rect& rect, | |
| IN const Color& color1, | |
| IN const Color& color2, | |
| IN REAL angle, | |
| IN BOOL isAngleScalable = FALSE) | |
| { | |
| GpLineGradient *brush = NULL; | |
| lastResult = DllExports::GdipCreateLineBrushFromRectWithAngleI(&rect, | |
| color1.GetValue(), | |
| color2.GetValue(), | |
| angle, | |
| isAngleScalable, | |
| WrapModeTile, | |
| &brush); | |
| SetNativeBrush(brush); | |
| } | |
| // Get/set point attributes | |
| Status SetLinearPoints(IN const PointF& point1, | |
| IN const PointF& point2) | |
| { | |
| return SetStatus(DllExports::GdipSetLinePoints((GpLineGradient*)nativeBrush, | |
| &point1, &point2)); | |
| } | |
| Status GetLinearPoints(OUT PointF* points) const | |
| { | |
| return SetStatus(DllExports::GdipGetLinePoints((GpLineGradient*) nativeBrush, | |
| points)); | |
| } | |
| Status SetLinearPoints(IN const Point& point1, | |
| IN const Point& point2) | |
| { | |
| return SetStatus(DllExports::GdipSetLinePointsI((GpLineGradient*)nativeBrush, | |
| &point1, &point2)); | |
| } | |
| Status GetLinearPoints(OUT Point* points) const | |
| { | |
| return SetStatus(DllExports::GdipGetLinePointsI((GpLineGradient*) nativeBrush, | |
| points)); | |
| } | |
| // Get/set color attributes | |
| Status SetLinearColors(IN const Color& color1, | |
| IN const Color& color2) | |
| { | |
| return SetStatus(DllExports::GdipSetLineColors((GpLineGradient*)nativeBrush, | |
| color1.GetValue(), | |
| color2.GetValue())); | |
| } | |
| Status GetLinearColors(OUT Color* colors) const | |
| { | |
| ARGB argb[2]; | |
| if (colors == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| SetStatus(DllExports::GdipGetLineColors((GpLineGradient*) nativeBrush, argb)); | |
| if (lastResult == Ok) | |
| { | |
| // use bitwise copy operator for Color copy | |
| colors[0] = Color(argb[0]); | |
| colors[1] = Color(argb[1]); | |
| } | |
| return lastResult; | |
| } | |
| Status GetRectangle(OUT RectF* rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetLineRect((GpLineGradient*)nativeBrush, rect)); | |
| } | |
| // integer version | |
| Status GetRectangle(OUT Rect* rect) const | |
| { | |
| return SetStatus(DllExports::GdipGetLineRectI((GpLineGradient*)nativeBrush, rect)); | |
| } | |
| // Gamma correction in interporlation. | |
| Status SetGammaCorrection(IN BOOL useGammaCorrection) | |
| { | |
| return SetStatus(DllExports::GdipSetLineGammaCorrection((GpLineGradient*)nativeBrush, | |
| useGammaCorrection)); | |
| } | |
| BOOL GetGammaCorrection() const | |
| { | |
| BOOL 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(IN const REAL* blendFactors, | |
| IN const REAL* blendPositions, | |
| IN INT count) | |
| { | |
| return SetStatus(DllExports::GdipSetLineBlend((GpLineGradient*) | |
| nativeBrush, | |
| blendFactors, | |
| blendPositions, | |
| count)); | |
| } | |
| Status GetBlend(OUT REAL* blendFactors, | |
| OUT REAL* blendPositions, | |
| IN 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(IN const Color* presetColors, | |
| IN const REAL* blendPositions, | |
| IN 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(OUT Color* presetColors, | |
| OUT REAL* blendPositions, | |
| IN 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(IN REAL focus, | |
| IN REAL scale = 1.0) | |
| { | |
| return SetStatus(DllExports::GdipSetLineSigmaBlend((GpLineGradient*)nativeBrush, focus, scale)); | |
| } | |
| #ifdef DCR_USE_NEW_145135 | |
| Status SetBlendTriangularShape( | |
| IN REAL focus, | |
| IN REAL scale = 1.0 | |
| ) | |
| #else | |
| Status SetBlendTrianglarShape(IN REAL focus, | |
| IN REAL scale = 1.0) | |
| #endif | |
| { | |
| return SetStatus(DllExports::GdipSetLineLinearBlend((GpLineGradient*)nativeBrush, focus, scale)); | |
| } | |
| /** | |
| * Set/get brush transform | |
| */ | |
| Status SetTransform(IN const Matrix* matrix) | |
| { | |
| return SetStatus(DllExports::GdipSetLineTransform((GpLineGradient*)nativeBrush, | |
| matrix->nativeMatrix)); | |
| } | |
| Status GetTransform(OUT Matrix *matrix) const | |
| { | |
| return SetStatus(DllExports::GdipGetLineTransform((GpLineGradient*)nativeBrush, | |
| matrix->nativeMatrix)); | |
| } | |
| Status ResetTransform() | |
| { | |
| return SetStatus(DllExports::GdipResetLineTransform((GpLineGradient*)nativeBrush)); | |
| } | |
| Status MultiplyTransform(IN const Matrix* matrix, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipMultiplyLineTransform((GpLineGradient*)nativeBrush, | |
| matrix->nativeMatrix, | |
| order)); | |
| } | |
| Status TranslateTransform(IN REAL dx, | |
| IN REAL dy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipTranslateLineTransform((GpLineGradient*)nativeBrush, | |
| dx, dy, order)); | |
| } | |
| Status ScaleTransform(IN REAL sx, | |
| IN REAL sy, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipScaleLineTransform((GpLineGradient*)nativeBrush, | |
| sx, sy, order)); | |
| } | |
| Status RotateTransform(IN REAL angle, | |
| IN MatrixOrder order = MatrixOrderPrepend) | |
| { | |
| return SetStatus(DllExports::GdipRotateLineTransform((GpLineGradient*)nativeBrush, | |
| angle, order)); | |
| } | |
| /** | |
| * Set/get brush wrapping mode | |
| */ | |
| Status SetWrapMode(IN WrapMode wrapMode) | |
| { | |
| return SetStatus(DllExports::GdipSetLineWrapMode((GpLineGradient*)nativeBrush, | |
| wrapMode)); | |
| } | |
| WrapMode GetWrapMode() const | |
| { | |
| WrapMode wrapMode; | |
| SetStatus(DllExports::GdipGetLineWrapMode((GpLineGradient*) | |
| nativeBrush, | |
| &wrapMode)); | |
| return wrapMode; | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| LinearGradientBrush(const LinearGradientBrush &); | |
| LinearGradientBrush& operator=(const LinearGradientBrush &); | |
| #endif | |
| protected: | |
| LinearGradientBrush() | |
| { | |
| } | |
| }; | |
| //-------------------------------------------------------------------------- | |
| // PathGradientBrush object is defined | |
| // in gdipluspath.h. | |
| //-------------------------------------------------------------------------- | |
| //-------------------------------------------------------------------------- | |
| // Represent hatch brush object | |
| //-------------------------------------------------------------------------- | |
| class HatchBrush : public Brush | |
| { | |
| public: | |
| friend class Pen; | |
| // Constructors | |
| HatchBrush(IN HatchStyle hatchStyle, | |
| IN const Color& foreColor, | |
| IN 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(OUT Color* color) const | |
| { | |
| ARGB argb; | |
| if (color == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| Status status = SetStatus(DllExports::GdipGetHatchForegroundColor( | |
| (GpHatch*)nativeBrush, | |
| &argb)); | |
| color->SetValue(argb); | |
| return status; | |
| } | |
| Status GetBackgroundColor(OUT Color *color) const | |
| { | |
| ARGB argb; | |
| if (color == NULL) | |
| { | |
| return SetStatus(InvalidParameter); | |
| } | |
| Status status = SetStatus(DllExports::GdipGetHatchBackgroundColor( | |
| (GpHatch*)nativeBrush, | |
| &argb)); | |
| color->SetValue(argb); | |
| return status; | |
| } | |
| #ifdef DCR_USE_NEW_250932 | |
| private: | |
| HatchBrush(const HatchBrush &); | |
| HatchBrush& operator=(const HatchBrush &); | |
| #endif | |
| protected: | |
| HatchBrush() | |
| { | |
| } | |
| }; | |
| #endif |