gdiplusbrush.h

00001 /*
00002  * gdiplusbrush.h
00003  *
00004  * GDI+ brush classes
00005  *
00006  * This file is part of the w32api package.
00007  *
00008  * Contributors:
00009  *   Created by Markus Koenig <markus@stber-koenig.de>
00010  *
00011  * THIS SOFTWARE IS NOT COPYRIGHTED
00012  *
00013  * This source code is offered for use in the public domain. You may
00014  * use, modify or distribute it freely.
00015  *
00016  * This code is distributed in the hope that it will be useful but
00017  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
00018  * DISCLAIMED. This includes but is not limited to warranties of
00019  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00020  *
00021  */
00022 
00023 #ifndef __GDIPLUS_BRUSH_H
00024 #define __GDIPLUS_BRUSH_H
00025 #if __GNUC__ >=3
00026 #pragma GCC system_header
00027 #endif
00028 
00029 #ifndef __cplusplus
00030 #error "A C++ compiler is required to include gdiplusbrush.h."
00031 #endif
00032 
00033 class Brush: public GdiplusBase
00034 {
00035     friend class HatchBrush;
00036     friend class LinearGradientBrush;
00037     friend class PathGradientBrush;
00038     friend class SolidBrush;
00039     friend class TextureBrush;
00040     friend class Graphics;
00041     friend class Pen;
00042 
00043 public:
00044     virtual ~Brush()
00045     {
00046         DllExports::GdipDeleteBrush(nativeBrush);
00047     }
00048     virtual Brush* Clone() const  // each subclass must implement this
00049     {
00050         lastStatus = NotImplemented;
00051         return NULL;
00052     }
00053 
00054     Status GetLastStatus() const
00055     {
00056         Status result = lastStatus;
00057         lastStatus = Ok;
00058         return result;
00059     }
00060     BrushType GetType() const
00061     {
00062         BrushType result = BrushTypeSolidColor;
00063         updateStatus(DllExports::GdipGetBrushType(nativeBrush, &result));
00064         return result;  
00065     }
00066 
00067 private:
00068     Brush(): nativeBrush(NULL), lastStatus(Ok) {}
00069     Brush(GpBrush *brush, Status status):
00070         nativeBrush(brush), lastStatus(status) {}
00071     Brush(const Brush& brush);
00072     Brush& operator=(const Brush&);
00073 
00074     Status updateStatus(Status newStatus) const
00075     {
00076         if (newStatus != Ok) lastStatus = newStatus;
00077         return newStatus;
00078     }
00079 
00080     GpBrush *nativeBrush;
00081     mutable Status lastStatus;
00082 };
00083 
00084 class HatchBrush: public Brush
00085 {
00086 public:
00087     HatchBrush(HatchStyle hatchStyle,
00088             const Color& foreColor,
00089             const Color& backColor = Color())
00090     {
00091         GpHatch *nativeHatch = NULL;
00092         lastStatus = DllExports::GdipCreateHatchBrush(hatchStyle,
00093                 foreColor.GetValue(), backColor.GetValue(),
00094                 &nativeHatch);
00095         nativeBrush = nativeHatch; 
00096     }
00097     virtual HatchBrush* Clone() const
00098     {
00099         GpBrush *cloneBrush = NULL;
00100         Status status = updateStatus(DllExports::GdipCloneBrush(
00101                 nativeBrush, &cloneBrush));
00102         if (status == Ok) {
00103             HatchBrush *result =
00104                 new HatchBrush(cloneBrush, lastStatus);
00105             if (!result) {
00106                 DllExports::GdipDeleteBrush(cloneBrush);
00107                 updateStatus(OutOfMemory);
00108             }
00109             return result;
00110         } else {
00111             return NULL;
00112         }
00113     }
00114 
00115     Status GetBackgroundColor(Color *color) const
00116     {
00117         return updateStatus(DllExports::GdipGetHatchBackgroundColor(
00118                 (GpHatch*) nativeBrush,
00119                 color ? &color->Value : NULL));
00120     }
00121     Status GetForegroundColor(Color *color) const
00122     {
00123         return updateStatus(DllExports::GdipGetHatchForegroundColor(
00124                 (GpHatch*) nativeBrush,
00125                 color ? &color->Value : NULL));
00126     }
00127     HatchStyle GetHatchStyle() const
00128     {
00129         HatchStyle result;
00130         updateStatus(DllExports::GdipGetHatchStyle(
00131                 (GpHatch*) nativeBrush, &result));
00132         return result;
00133     }
00134 
00135 private:
00136     HatchBrush(GpBrush *brush, Status status): Brush(brush, status) {}
00137     HatchBrush(const HatchBrush& brush);
00138     HatchBrush& operator=(const HatchBrush&);
00139 };
00140 
00141 class LinearGradientBrush: public Brush
00142 {
00143 public:
00144     LinearGradientBrush(const PointF& point1, const PointF& point2,
00145             const Color& color1, const Color& color2)
00146     {
00147         GpLineGradient *nativeLineGradient = NULL;
00148         lastStatus = DllExports::GdipCreateLineBrush(
00149                 &point1, &point2,
00150                 color1.GetValue(), color2.GetValue(),
00151                 WrapModeTile, &nativeLineGradient);
00152         nativeBrush = nativeLineGradient;
00153     }
00154     LinearGradientBrush(const Point& point1, const Point& point2,
00155             const Color& color1, const Color& color2)
00156     {
00157         GpLineGradient *nativeLineGradient = NULL;
00158         lastStatus = DllExports::GdipCreateLineBrushI(
00159                 &point1, &point2,
00160                 color1.GetValue(), color2.GetValue(),
00161                 WrapModeTile, &nativeLineGradient);
00162         nativeBrush = nativeLineGradient;
00163     }
00164     LinearGradientBrush(const RectF& rect, const Color& color1,
00165             const Color& color2, LinearGradientMode mode)
00166     {
00167         GpLineGradient *nativeLineGradient = NULL;
00168         lastStatus = DllExports::GdipCreateLineBrushFromRect(
00169                 &rect, color1.GetValue(), color2.GetValue(),
00170                 mode, WrapModeTile, &nativeLineGradient);
00171         nativeBrush = nativeLineGradient;
00172     }
00173     LinearGradientBrush(const Rect& rect, const Color& color1,
00174             const Color& color2, LinearGradientMode mode)
00175     {
00176         GpLineGradient *nativeLineGradient = NULL;
00177         lastStatus = DllExports::GdipCreateLineBrushFromRectI(
00178                 &rect, color1.GetValue(), color2.GetValue(),
00179                 mode, WrapModeTile, &nativeLineGradient);
00180         nativeBrush = nativeLineGradient;
00181     }
00182     LinearGradientBrush(const RectF& rect, const Color& color1,
00183             const Color& color2, REAL angle,
00184             BOOL isAngleScalable = FALSE)
00185     {
00186         GpLineGradient *nativeLineGradient = NULL;
00187         lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngle(
00188                 &rect, color1.GetValue(), color2.GetValue(),
00189                 angle, isAngleScalable, WrapModeTile,
00190                 &nativeLineGradient);
00191         nativeBrush = nativeLineGradient;
00192     }
00193     LinearGradientBrush(const Rect& rect, const Color& color1,
00194             const Color& color2, REAL angle,
00195             BOOL isAngleScalable = FALSE)
00196     {
00197         GpLineGradient *nativeLineGradient = NULL;
00198         lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngleI(
00199                 &rect, color1.GetValue(), color2.GetValue(),
00200                 angle, isAngleScalable, WrapModeTile,
00201                 &nativeLineGradient);
00202         nativeBrush = nativeLineGradient;
00203     }
00204     virtual LinearGradientBrush* Clone() const
00205     {
00206         GpBrush *cloneBrush = NULL;
00207         Status status = updateStatus(DllExports::GdipCloneBrush(
00208                 nativeBrush, &cloneBrush));
00209         if (status == Ok) {
00210             LinearGradientBrush *result =
00211                 new LinearGradientBrush(cloneBrush, lastStatus);
00212             if (!result) {
00213                 DllExports::GdipDeleteBrush(cloneBrush);
00214                 updateStatus(OutOfMemory);
00215             }
00216             return result;
00217         } else {
00218             return NULL;
00219         }
00220     }
00221 
00222     Status GetBlend(REAL *blendFactors, REAL *blendPositions,
00223             INT count) const
00224     {
00225         return updateStatus(DllExports::GdipGetLineBlend(
00226                 (GpLineGradient*) nativeBrush,
00227                 blendFactors, blendPositions, count));
00228     }
00229     INT GetBlendCount() const
00230     {
00231         INT result = 0;
00232         updateStatus(DllExports::GdipGetLineBlendCount(
00233                 (GpLineGradient*) nativeBrush, &result));
00234         return result;
00235     }
00236     BOOL GetGammaCorrection() const
00237     {
00238         BOOL result = FALSE;
00239         updateStatus(DllExports::GdipGetLineGammaCorrection(
00240                 (GpLineGradient*) nativeBrush, &result));
00241         return result;
00242     }
00243     INT GetInterpolationColorCount() const
00244     {
00245         INT result = 0;
00246         updateStatus(DllExports::GdipGetLinePresetBlendCount(
00247                 (GpLineGradient*) nativeBrush, &result));
00248         return result;
00249     }
00250     Status GetInterpolationColors(Color *presetColors,
00251             REAL *blendPositions, INT count) const
00252     {
00253         if (!presetColors || count <= 0)
00254             return lastStatus = InvalidParameter;
00255 
00256         ARGB *presetArgb =
00257             (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
00258         if (!presetArgb)
00259             return lastStatus = OutOfMemory;
00260 
00261         Status status = updateStatus(DllExports::GdipGetLinePresetBlend(
00262                 (GpLineGradient*) nativeBrush, presetArgb,
00263                 blendPositions, count));
00264         for (INT i = 0; i < count; ++i) {
00265             presetColors[i].SetValue(presetArgb[i]);
00266         }
00267         DllExports::GdipFree((void*) presetArgb);
00268         return status;
00269     }
00270     Status GetLinearColors(Color *colors) const
00271     {
00272         if (!colors) return lastStatus = InvalidParameter;
00273 
00274         ARGB colorsArgb[2];
00275         Status status = updateStatus(DllExports::GdipGetLineColors(
00276                 (GpLineGradient*) nativeBrush, colorsArgb));
00277         colors[0].SetValue(colorsArgb[0]);
00278         colors[1].SetValue(colorsArgb[1]);
00279         return status;
00280     }
00281     Status GetRectangle(RectF *rect) const
00282     {
00283         return updateStatus(DllExports::GdipGetLineRect(
00284                 (GpLineGradient*) nativeBrush, rect));
00285     }
00286     Status GetRectangle(Rect *rect) const
00287     {
00288         return updateStatus(DllExports::GdipGetLineRectI(
00289                 (GpLineGradient*) nativeBrush, rect));
00290     }
00291     Status GetTransform(Matrix *matrix) const
00292     {
00293         return updateStatus(DllExports::GdipGetLineTransform(
00294                 (GpLineGradient*) nativeBrush,
00295                 matrix ? matrix->nativeMatrix : NULL));
00296     }
00297     WrapMode GetWrapMode() const
00298     {
00299         WrapMode wrapMode = WrapModeTile;
00300         updateStatus(DllExports::GdipGetLineWrapMode(
00301                 (GpLineGradient*) nativeBrush, &wrapMode));
00302         return wrapMode;
00303     }
00304     Status MultiplyTransform(const Matrix *matrix,
00305             MatrixOrder order = MatrixOrderPrepend)
00306     {
00307         return updateStatus(DllExports::GdipMultiplyLineTransform(
00308                 (GpLineGradient*) nativeBrush,
00309                 matrix ? matrix->nativeMatrix : NULL, order));
00310     }
00311     Status ResetTransform()
00312     {
00313         return updateStatus(DllExports::GdipResetLineTransform(
00314                 (GpLineGradient*) nativeBrush));
00315     }
00316     Status RotateTranform(REAL angle, MatrixOrder order = MatrixOrderPrepend)
00317     {
00318         return updateStatus(DllExports::GdipRotateLineTransform(
00319                 (GpLineGradient*) nativeBrush, angle, order));
00320     }
00321     Status ScaleTransform(REAL sx, REAL sy,
00322             MatrixOrder order = MatrixOrderPrepend)
00323     {
00324         return updateStatus(DllExports::GdipScaleLineTransform(
00325                 (GpLineGradient*) nativeBrush, sx, sy, order));
00326     }
00327     Status SetBlend(const REAL *blendFactors,
00328             const REAL *blendPositions, INT count)
00329     {
00330         return updateStatus(DllExports::GdipSetLineBlend(
00331                 (GpLineGradient*) nativeBrush,
00332                 blendFactors, blendPositions, count));
00333     }
00334     Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)
00335     {
00336         return updateStatus(DllExports::GdipSetLineSigmaBlend(
00337                 (GpLineGradient*) nativeBrush,
00338                 focus, scale));
00339     }
00340     Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)
00341     {
00342         return updateStatus(DllExports::GdipSetLineLinearBlend(
00343                 (GpLineGradient*) nativeBrush,
00344                 focus, scale));
00345     }
00346     Status SetGammaCorrection(BOOL useGammaCorrection)
00347     {
00348         return updateStatus(DllExports::GdipSetLineGammaCorrection(
00349                 (GpLineGradient*) nativeBrush,
00350                 useGammaCorrection));
00351     }
00352     Status SetInterpolationColors(const Color *presetColors,
00353             const REAL *blendPositions, INT count)
00354     {
00355         if (!presetColors || count < 0)
00356             return lastStatus = InvalidParameter;
00357 
00358         ARGB *presetArgb =
00359             (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));
00360         if (!presetArgb)
00361             return lastStatus = OutOfMemory;
00362         for (INT i = 0; i < count; ++i) {
00363             presetArgb[i] = presetColors[i].GetValue();
00364         }
00365 
00366         Status status = updateStatus(DllExports::GdipSetLinePresetBlend(
00367                 (GpLineGradient*) nativeBrush,
00368                 presetArgb, blendPositions, count));
00369         DllExports::GdipFree((void*) presetArgb);
00370         return status;
00371     }
00372     Status SetLinearColors(const Color& color1, const Color& color2)
00373     {
00374         return updateStatus(DllExports::GdipSetLineColors(
00375                 (GpLineGradient*) nativeBrush,
00376                 color1.GetValue(), color2.GetValue()));
00377     }
00378     Status SetTransform(const Matrix *matrix)
00379     {
00380         return updateStatus(DllExports::GdipSetLineTransform(
00381                 (GpLineGradient*) nativeBrush,
00382                 matrix ? matrix->nativeMatrix : NULL));
00383     }
00384     Status SetWrapMode(WrapMode wrapMode)
00385     {
00386         return updateStatus(DllExports::GdipSetLineWrapMode(
00387                 (GpLineGradient*) nativeBrush, wrapMode));
00388     }
00389     Status TranslateTransform(REAL dx, REAL dy,
00390             MatrixOrder order = MatrixOrderPrepend)
00391     {
00392         return updateStatus(DllExports::GdipTranslateLineTransform(
00393                 (GpLineGradient*) nativeBrush, dx, dy, order));
00394     }
00395 
00396 private:
00397     LinearGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}
00398     LinearGradientBrush(const LinearGradientBrush& brush);
00399     LinearGradientBrush& operator=(const LinearGradientBrush&);
00400 };
00401 
00402 class SolidBrush: public Brush
00403 {
00404 public:
00405     SolidBrush(const Color& color)
00406     {
00407         GpSolidFill *nativeSolidFill = NULL;
00408         lastStatus = DllExports::GdipCreateSolidFill(
00409                 color.GetValue(), &nativeSolidFill);
00410         nativeBrush = nativeSolidFill; 
00411     }
00412     virtual SolidBrush* Clone() const
00413     {
00414         GpBrush *cloneBrush = NULL;
00415         Status status = updateStatus(DllExports::GdipCloneBrush(
00416                 nativeBrush, &cloneBrush));
00417         if (status == Ok) {
00418             SolidBrush *result =
00419                 new SolidBrush(cloneBrush, lastStatus);
00420             if (!result) {
00421                 DllExports::GdipDeleteBrush(cloneBrush);
00422                 updateStatus(OutOfMemory);
00423             }
00424             return result;
00425         } else {
00426             return NULL;
00427         }
00428     }
00429 
00430     Status GetColor(Color *color) const
00431     {
00432         return updateStatus(DllExports::GdipGetSolidFillColor(
00433                 (GpSolidFill*) nativeBrush,
00434                 color ? &color->Value : NULL));
00435     }
00436     Status SetColor(const Color& color)
00437     {
00438         return updateStatus(DllExports::GdipSetSolidFillColor(
00439                 (GpSolidFill*) nativeBrush, color.GetValue()));
00440     }
00441 
00442 private:
00443     SolidBrush(GpBrush *brush, Status status): Brush(brush, status) {}
00444     SolidBrush(const SolidBrush&);
00445     SolidBrush& operator=(const SolidBrush&);
00446 };
00447 
00448 class TextureBrush: public Brush
00449 {
00450 public:
00451     TextureBrush(Image *image, WrapMode wrapMode = WrapModeTile)
00452     {
00453         GpTexture *nativeTexture = NULL;
00454         lastStatus = DllExports::GdipCreateTexture(
00455                 image ? image->nativeImage : NULL,
00456                 wrapMode, &nativeTexture);
00457         nativeBrush = nativeTexture;
00458     }
00459     TextureBrush(Image *image, WrapMode wrapMode,
00460             REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
00461     {
00462         GpTexture *nativeTexture = NULL;
00463         lastStatus = DllExports::GdipCreateTexture2(
00464                 image ? image->nativeImage : NULL,
00465                 wrapMode, dstX, dstY, dstWidth, dstHeight,
00466                 &nativeTexture);
00467         nativeBrush = nativeTexture;
00468     }
00469     TextureBrush(Image *image, WrapMode wrapMode,
00470             INT dstX, INT dstY, INT dstWidth, INT dstHeight)
00471     {
00472         GpTexture *nativeTexture = NULL;
00473         lastStatus = DllExports::GdipCreateTexture2I(
00474                 image ? image->nativeImage : NULL,
00475                 wrapMode, dstX, dstY, dstWidth, dstHeight,
00476                 &nativeTexture);
00477         nativeBrush = nativeTexture;
00478     }
00479     TextureBrush(Image *image, WrapMode wrapMode, const RectF& dstRect)
00480     {
00481         GpTexture *nativeTexture = NULL;
00482         lastStatus = DllExports::GdipCreateTexture2(
00483                 image ? image->nativeImage : NULL, wrapMode,
00484                 dstRect.X, dstRect.Y,
00485                 dstRect.Width, dstRect.Height, &nativeTexture);
00486         nativeBrush = nativeTexture;
00487     }
00488     TextureBrush(Image *image, WrapMode wrapMode, const Rect& dstRect)
00489     {
00490         GpTexture *nativeTexture = NULL;
00491         lastStatus = DllExports::GdipCreateTexture2I(
00492                 image ? image->nativeImage : NULL, wrapMode,
00493                 dstRect.X, dstRect.Y,
00494                 dstRect.Width, dstRect.Height, &nativeTexture);
00495         nativeBrush = nativeTexture;
00496     }
00497     TextureBrush(Image *image, const RectF& dstRect,
00498             ImageAttributes *imageAttributes = NULL)
00499     {
00500         GpTexture *nativeTexture = NULL;
00501         lastStatus = DllExports::GdipCreateTextureIA(
00502                 image ? image->nativeImage : NULL,
00503                 imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
00504                 dstRect.X, dstRect.Y,
00505                 dstRect.Width, dstRect.Height, &nativeTexture);
00506         nativeBrush = nativeTexture;
00507     }
00508     TextureBrush(Image *image, const Rect& dstRect,
00509             ImageAttributes *imageAttributes = NULL)
00510     {
00511         GpTexture *nativeTexture = NULL;
00512         lastStatus = DllExports::GdipCreateTextureIAI(
00513                 image ? image->nativeImage : NULL,
00514                 imageAttributes ? imageAttributes->nativeImageAttributes : NULL,
00515                 dstRect.X, dstRect.Y,
00516                 dstRect.Width, dstRect.Height, &nativeTexture);
00517         nativeBrush = nativeTexture;
00518     }
00519     virtual TextureBrush* Clone() const
00520     {
00521         GpBrush *cloneBrush = NULL;
00522         Status status = updateStatus(DllExports::GdipCloneBrush(
00523                 nativeBrush, &cloneBrush));
00524         if (status == Ok) {
00525             TextureBrush *result =
00526                 new TextureBrush(cloneBrush, lastStatus);
00527             if (!result) {
00528                 DllExports::GdipDeleteBrush(cloneBrush);
00529                 updateStatus(OutOfMemory);
00530             }
00531             return result;
00532         } else {
00533             return NULL;
00534         }
00535     }
00536 
00537     //TODO: implement TextureBrush::GetImage()
00538     //Image *GetImage() const
00539     //{
00540     //  // where is the Image allocated (static,member,new,other)?
00541     //  // GdipGetTextureImage just returns a GpImage*
00542     //  updateStatus(NotImplemented);
00543     //  return NULL;
00544     //}
00545     Status GetTransfrom(Matrix *matrix) const
00546     {
00547         return updateStatus(DllExports::GdipGetTextureTransform(
00548                 (GpTexture*) nativeBrush,
00549                 matrix ? matrix->nativeMatrix : NULL));
00550     }
00551     WrapMode GetWrapMode() const
00552     {
00553         WrapMode result = WrapModeTile;
00554         updateStatus(DllExports::GdipGetTextureWrapMode(
00555                 (GpTexture*) nativeBrush, &result));
00556         return result;
00557     }
00558     Status MultiplyTransform(const Matrix *matrix,
00559             MatrixOrder order = MatrixOrderPrepend)
00560     {
00561         return updateStatus(DllExports::GdipMultiplyTextureTransform(
00562                 (GpTexture*) nativeBrush,
00563                 matrix ? matrix->nativeMatrix : NULL, order));
00564     }
00565     Status ResetTransform()
00566     {
00567         return updateStatus(DllExports::GdipResetTextureTransform(
00568                 (GpTexture*) nativeBrush));
00569     }
00570     Status RotateTransform(REAL angle,
00571             MatrixOrder order = MatrixOrderPrepend)
00572     {
00573         return updateStatus(DllExports::GdipRotateTextureTransform(
00574                 (GpTexture*) nativeBrush, angle, order));
00575     }
00576     Status ScaleTransform(REAL sx, REAL sy,
00577             MatrixOrder order = MatrixOrderPrepend)
00578     {
00579         return updateStatus(DllExports::GdipScaleTextureTransform(
00580                 (GpTexture*) nativeBrush, sx, sy, order));
00581     }
00582     Status SetTransform(const Matrix *matrix)
00583     {
00584         return updateStatus(DllExports::GdipSetTextureTransform(
00585                 (GpTexture*) nativeBrush,
00586                 matrix ? matrix->nativeMatrix : NULL));
00587     }
00588     Status SetWrapMode(WrapMode wrapMode)
00589     {
00590         return updateStatus(DllExports::GdipSetTextureWrapMode(
00591                 (GpTexture*) nativeBrush, wrapMode));
00592     }
00593     Status TranslateTransform(REAL dx, REAL dy,
00594             MatrixOrder order = MatrixOrderPrepend)
00595     {
00596         return updateStatus(DllExports::GdipTranslateTextureTransform(
00597                 (GpTexture*) nativeBrush, dx, dy, order));
00598     }
00599 
00600 private:
00601     TextureBrush(GpBrush *brush, Status status): Brush(brush, status) {}
00602     TextureBrush(const TextureBrush&);
00603     TextureBrush& operator=(const TextureBrush&);
00604 };
00605 
00606 #endif /* __GDIPLUS_BRUSH_H */