/**************************************************************************\ | |
* | |
* 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 |