wslapi/include/gdiplus/gdiplusbrush.h

   1 /*\r
   2  * gdiplusbrush.h\r
   3  *\r
   4  * GDI+ brush classes\r
   5  *\r
   6  * This file is part of the w32api package.\r
   7  *\r
   8  * Contributors:\r
   9  *   Created by Markus Koenig <markus@stber-koenig.de>\r
  10  *\r
  11  * THIS SOFTWARE IS NOT COPYRIGHTED\r
  12  *\r
  13  * This source code is offered for use in the public domain. You may\r
  14  * use, modify or distribute it freely.\r
  15  *\r
  16  * This code is distributed in the hope that it will be useful but\r
  17  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY\r
  18  * DISCLAIMED. This includes but is not limited to warranties of\r
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\r
  20  *\r
  21  */\r
  22 \r
  23 #ifndef __GDIPLUS_BRUSH_H\r
  24 #define __GDIPLUS_BRUSH_H\r
  25 #if __GNUC__ >=3\r
  26 #pragma GCC system_header\r
  27 #endif\r
  28 \r
  29 #ifndef __cplusplus\r
  30 #error "A C++ compiler is required to include gdiplusbrush.h."\r
  31 #endif\r
  32 \r
  33 class Brush: public GdiplusBase\r
  34 {\r
  35         friend class HatchBrush;\r
  36         friend class LinearGradientBrush;\r
  37         friend class PathGradientBrush;\r
  38         friend class SolidBrush;\r
  39         friend class TextureBrush;\r
  40         friend class Graphics;\r
  41         friend class Pen;\r
  42 \r
  43 public:\r
  44         virtual ~Brush()\r
  45         {\r
  46                 DllExports::GdipDeleteBrush(nativeBrush);\r
  47         }\r
  48         virtual Brush* Clone() const  // each subclass must implement this\r
  49         {\r
  50                 lastStatus = NotImplemented;\r
  51                 return NULL;\r
  52         }\r
  53 \r
  54         Status GetLastStatus() const\r
  55         {\r
  56                 Status result = lastStatus;\r
  57                 lastStatus = Ok;\r
  58                 return result;\r
  59         }\r
  60         BrushType GetType() const\r
  61         {\r
  62                 BrushType result = BrushTypeSolidColor;\r
  63                 updateStatus(DllExports::GdipGetBrushType(nativeBrush, &result));\r
  64                 return result;  \r
  65         }\r
  66 \r
  67 private:\r
  68         Brush(): nativeBrush(NULL), lastStatus(Ok) {}\r
  69         Brush(GpBrush *brush, Status status):\r
  70                 nativeBrush(brush), lastStatus(status) {}\r
  71         Brush(const Brush& brush);\r
  72         Brush& operator=(const Brush&);\r
  73 \r
  74         Status updateStatus(Status newStatus) const\r
  75         {\r
  76                 if (newStatus != Ok) lastStatus = newStatus;\r
  77                 return newStatus;\r
  78         }\r
  79 \r
  80         GpBrush *nativeBrush;\r
  81         mutable Status lastStatus;\r
  82 };\r
  83 \r
  84 class HatchBrush: public Brush\r
  85 {\r
  86 public:\r
  87         HatchBrush(HatchStyle hatchStyle,\r
  88                         const Color& foreColor,\r
  89                         const Color& backColor = Color())\r
  90         {\r
  91                 GpHatch *nativeHatch = NULL;\r
  92                 lastStatus = DllExports::GdipCreateHatchBrush(hatchStyle,\r
  93                                 foreColor.GetValue(), backColor.GetValue(),\r
  94                                 &nativeHatch);\r
  95                 nativeBrush = nativeHatch; \r
  96         }\r
  97         virtual HatchBrush* Clone() const\r
  98         {\r
  99                 GpBrush *cloneBrush = NULL;\r
 100                 Status status = updateStatus(DllExports::GdipCloneBrush(\r
 101                                 nativeBrush, &cloneBrush));\r
 102                 if (status == Ok) {\r
 103                         HatchBrush *result =\r
 104                                 new HatchBrush(cloneBrush, lastStatus);\r
 105                         if (!result) {\r
 106                                 DllExports::GdipDeleteBrush(cloneBrush);\r
 107                                 updateStatus(OutOfMemory);\r
 108                         }\r
 109                         return result;\r
 110                 } else {\r
 111                         return NULL;\r
 112                 }\r
 113         }\r
 114 \r
 115         Status GetBackgroundColor(Color *color) const\r
 116         {\r
 117                 return updateStatus(DllExports::GdipGetHatchBackgroundColor(\r
 118                                 (GpHatch*) nativeBrush,\r
 119                                 color ? &color->Value : NULL));\r
 120         }\r
 121         Status GetForegroundColor(Color *color) const\r
 122         {\r
 123                 return updateStatus(DllExports::GdipGetHatchForegroundColor(\r
 124                                 (GpHatch*) nativeBrush,\r
 125                                 color ? &color->Value : NULL));\r
 126         }\r
 127         HatchStyle GetHatchStyle() const\r
 128         {\r
 129                 HatchStyle result;\r
 130                 updateStatus(DllExports::GdipGetHatchStyle(\r
 131                                 (GpHatch*) nativeBrush, &result));\r
 132                 return result;\r
 133         }\r
 134 \r
 135 private:\r
 136         HatchBrush(GpBrush *brush, Status status): Brush(brush, status) {}\r
 137         HatchBrush(const HatchBrush& brush);\r
 138         HatchBrush& operator=(const HatchBrush&);\r
 139 };\r
 140 \r
 141 class LinearGradientBrush: public Brush\r
 142 {\r
 143 public:\r
 144         LinearGradientBrush(const PointF& point1, const PointF& point2,\r
 145                         const Color& color1, const Color& color2)\r
 146         {\r
 147                 GpLineGradient *nativeLineGradient = NULL;\r
 148                 lastStatus = DllExports::GdipCreateLineBrush(\r
 149                                 &point1, &point2,\r
 150                                 color1.GetValue(), color2.GetValue(),\r
 151                                 WrapModeTile, &nativeLineGradient);\r
 152                 nativeBrush = nativeLineGradient;\r
 153         }\r
 154         LinearGradientBrush(const Point& point1, const Point& point2,\r
 155                         const Color& color1, const Color& color2)\r
 156         {\r
 157                 GpLineGradient *nativeLineGradient = NULL;\r
 158                 lastStatus = DllExports::GdipCreateLineBrushI(\r
 159                                 &point1, &point2,\r
 160                                 color1.GetValue(), color2.GetValue(),\r
 161                                 WrapModeTile, &nativeLineGradient);\r
 162                 nativeBrush = nativeLineGradient;\r
 163         }\r
 164         LinearGradientBrush(const RectF& rect, const Color& color1,\r
 165                         const Color& color2, LinearGradientMode mode)\r
 166         {\r
 167                 GpLineGradient *nativeLineGradient = NULL;\r
 168                 lastStatus = DllExports::GdipCreateLineBrushFromRect(\r
 169                                 &rect, color1.GetValue(), color2.GetValue(),\r
 170                                 mode, WrapModeTile, &nativeLineGradient);\r
 171                 nativeBrush = nativeLineGradient;\r
 172         }\r
 173         LinearGradientBrush(const Rect& rect, const Color& color1,\r
 174                         const Color& color2, LinearGradientMode mode)\r
 175         {\r
 176                 GpLineGradient *nativeLineGradient = NULL;\r
 177                 lastStatus = DllExports::GdipCreateLineBrushFromRectI(\r
 178                                 &rect, color1.GetValue(), color2.GetValue(),\r
 179                                 mode, WrapModeTile, &nativeLineGradient);\r
 180                 nativeBrush = nativeLineGradient;\r
 181         }\r
 182         LinearGradientBrush(const RectF& rect, const Color& color1,\r
 183                         const Color& color2, REAL angle,\r
 184                         BOOL isAngleScalable = FALSE)\r
 185         {\r
 186                 GpLineGradient *nativeLineGradient = NULL;\r
 187                 lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngle(\r
 188                                 &rect, color1.GetValue(), color2.GetValue(),\r
 189                                 angle, isAngleScalable, WrapModeTile,\r
 190                                 &nativeLineGradient);\r
 191                 nativeBrush = nativeLineGradient;\r
 192         }\r
 193         LinearGradientBrush(const Rect& rect, const Color& color1,\r
 194                         const Color& color2, REAL angle,\r
 195                         BOOL isAngleScalable = FALSE)\r
 196         {\r
 197                 GpLineGradient *nativeLineGradient = NULL;\r
 198                 lastStatus = DllExports::GdipCreateLineBrushFromRectWithAngleI(\r
 199                                 &rect, color1.GetValue(), color2.GetValue(),\r
 200                                 angle, isAngleScalable, WrapModeTile,\r
 201                                 &nativeLineGradient);\r
 202                 nativeBrush = nativeLineGradient;\r
 203         }\r
 204         virtual LinearGradientBrush* Clone() const\r
 205         {\r
 206                 GpBrush *cloneBrush = NULL;\r
 207                 Status status = updateStatus(DllExports::GdipCloneBrush(\r
 208                                 nativeBrush, &cloneBrush));\r
 209                 if (status == Ok) {\r
 210                         LinearGradientBrush *result =\r
 211                                 new LinearGradientBrush(cloneBrush, lastStatus);\r
 212                         if (!result) {\r
 213                                 DllExports::GdipDeleteBrush(cloneBrush);\r
 214                                 updateStatus(OutOfMemory);\r
 215                         }\r
 216                         return result;\r
 217                 } else {\r
 218                         return NULL;\r
 219                 }\r
 220         }\r
 221 \r
 222         Status GetBlend(REAL *blendFactors, REAL *blendPositions,\r
 223                         INT count) const\r
 224         {\r
 225                 return updateStatus(DllExports::GdipGetLineBlend(\r
 226                                 (GpLineGradient*) nativeBrush,\r
 227                                 blendFactors, blendPositions, count));\r
 228         }\r
 229         INT GetBlendCount() const\r
 230         {\r
 231                 INT result = 0;\r
 232                 updateStatus(DllExports::GdipGetLineBlendCount(\r
 233                                 (GpLineGradient*) nativeBrush, &result));\r
 234                 return result;\r
 235         }\r
 236         BOOL GetGammaCorrection() const\r
 237         {\r
 238                 BOOL result = FALSE;\r
 239                 updateStatus(DllExports::GdipGetLineGammaCorrection(\r
 240                                 (GpLineGradient*) nativeBrush, &result));\r
 241                 return result;\r
 242         }\r
 243         INT GetInterpolationColorCount() const\r
 244         {\r
 245                 INT result = 0;\r
 246                 updateStatus(DllExports::GdipGetLinePresetBlendCount(\r
 247                                 (GpLineGradient*) nativeBrush, &result));\r
 248                 return result;\r
 249         }\r
 250         Status GetInterpolationColors(Color *presetColors,\r
 251                         REAL *blendPositions, INT count) const\r
 252         {\r
 253                 if (!presetColors || count <= 0)\r
 254                         return lastStatus = InvalidParameter;\r
 255 \r
 256                 ARGB *presetArgb =\r
 257                         (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));\r
 258                 if (!presetArgb)\r
 259                         return lastStatus = OutOfMemory;\r
 260 \r
 261                 Status status = updateStatus(DllExports::GdipGetLinePresetBlend(\r
 262                                 (GpLineGradient*) nativeBrush, presetArgb,\r
 263                                 blendPositions, count));\r
 264                 for (INT i = 0; i < count; ++i) {\r
 265                         presetColors[i].SetValue(presetArgb[i]);\r
 266                 }\r
 267                 DllExports::GdipFree((void*) presetArgb);\r
 268                 return status;\r
 269         }\r
 270         Status GetLinearColors(Color *colors) const\r
 271         {\r
 272                 if (!colors) return lastStatus = InvalidParameter;\r
 273 \r
 274                 ARGB colorsArgb[2];\r
 275                 Status status = updateStatus(DllExports::GdipGetLineColors(\r
 276                                 (GpLineGradient*) nativeBrush, colorsArgb));\r
 277                 colors[0].SetValue(colorsArgb[0]);\r
 278                 colors[1].SetValue(colorsArgb[1]);\r
 279                 return status;\r
 280         }\r
 281         Status GetRectangle(RectF *rect) const\r
 282         {\r
 283                 return updateStatus(DllExports::GdipGetLineRect(\r
 284                                 (GpLineGradient*) nativeBrush, rect));\r
 285         }\r
 286         Status GetRectangle(Rect *rect) const\r
 287         {\r
 288                 return updateStatus(DllExports::GdipGetLineRectI(\r
 289                                 (GpLineGradient*) nativeBrush, rect));\r
 290         }\r
 291         Status GetTransform(Matrix *matrix) const\r
 292         {\r
 293                 return updateStatus(DllExports::GdipGetLineTransform(\r
 294                                 (GpLineGradient*) nativeBrush,\r
 295                                 matrix ? matrix->nativeMatrix : NULL));\r
 296         }\r
 297         WrapMode GetWrapMode() const\r
 298         {\r
 299                 WrapMode wrapMode = WrapModeTile;\r
 300                 updateStatus(DllExports::GdipGetLineWrapMode(\r
 301                                 (GpLineGradient*) nativeBrush, &wrapMode));\r
 302                 return wrapMode;\r
 303         }\r
 304         Status MultiplyTransform(const Matrix *matrix,\r
 305                         MatrixOrder order = MatrixOrderPrepend)\r
 306         {\r
 307                 return updateStatus(DllExports::GdipMultiplyLineTransform(\r
 308                                 (GpLineGradient*) nativeBrush,\r
 309                                 matrix ? matrix->nativeMatrix : NULL, order));\r
 310         }\r
 311         Status ResetTransform()\r
 312         {\r
 313                 return updateStatus(DllExports::GdipResetLineTransform(\r
 314                                 (GpLineGradient*) nativeBrush));\r
 315         }\r
 316         Status RotateTranform(REAL angle, MatrixOrder order = MatrixOrderPrepend)\r
 317         {\r
 318                 return updateStatus(DllExports::GdipRotateLineTransform(\r
 319                                 (GpLineGradient*) nativeBrush, angle, order));\r
 320         }\r
 321         Status ScaleTransform(REAL sx, REAL sy,\r
 322                         MatrixOrder order = MatrixOrderPrepend)\r
 323         {\r
 324                 return updateStatus(DllExports::GdipScaleLineTransform(\r
 325                                 (GpLineGradient*) nativeBrush, sx, sy, order));\r
 326         }\r
 327         Status SetBlend(const REAL *blendFactors,\r
 328                         const REAL *blendPositions, INT count)\r
 329         {\r
 330                 return updateStatus(DllExports::GdipSetLineBlend(\r
 331                                 (GpLineGradient*) nativeBrush,\r
 332                                 blendFactors, blendPositions, count));\r
 333         }\r
 334         Status SetBlendBellShape(REAL focus, REAL scale = 1.0f)\r
 335         {\r
 336                 return updateStatus(DllExports::GdipSetLineSigmaBlend(\r
 337                                 (GpLineGradient*) nativeBrush,\r
 338                                 focus, scale));\r
 339         }\r
 340         Status SetBlendTriangularShape(REAL focus, REAL scale = 1.0f)\r
 341         {\r
 342                 return updateStatus(DllExports::GdipSetLineLinearBlend(\r
 343                                 (GpLineGradient*) nativeBrush,\r
 344                                 focus, scale));\r
 345         }\r
 346         Status SetGammaCorrection(BOOL useGammaCorrection)\r
 347         {\r
 348                 return updateStatus(DllExports::GdipSetLineGammaCorrection(\r
 349                                 (GpLineGradient*) nativeBrush,\r
 350                                 useGammaCorrection));\r
 351         }\r
 352         Status SetInterpolationColors(const Color *presetColors,\r
 353                         const REAL *blendPositions, INT count)\r
 354         {\r
 355                 if (!presetColors || count < 0)\r
 356                         return lastStatus = InvalidParameter;\r
 357 \r
 358                 ARGB *presetArgb =\r
 359                         (ARGB*) DllExports::GdipAlloc(count * sizeof(ARGB));\r
 360                 if (!presetArgb)\r
 361                         return lastStatus = OutOfMemory;\r
 362                 for (INT i = 0; i < count; ++i) {\r
 363                         presetArgb[i] = presetColors[i].GetValue();\r
 364                 }\r
 365 \r
 366                 Status status = updateStatus(DllExports::GdipSetLinePresetBlend(\r
 367                                 (GpLineGradient*) nativeBrush,\r
 368                                 presetArgb, blendPositions, count));\r
 369                 DllExports::GdipFree((void*) presetArgb);\r
 370                 return status;\r
 371         }\r
 372         Status SetLinearColors(const Color& color1, const Color& color2)\r
 373         {\r
 374                 return updateStatus(DllExports::GdipSetLineColors(\r
 375                                 (GpLineGradient*) nativeBrush,\r
 376                                 color1.GetValue(), color2.GetValue()));\r
 377         }\r
 378         Status SetTransform(const Matrix *matrix)\r
 379         {\r
 380                 return updateStatus(DllExports::GdipSetLineTransform(\r
 381                                 (GpLineGradient*) nativeBrush,\r
 382                                 matrix ? matrix->nativeMatrix : NULL));\r
 383         }\r
 384         Status SetWrapMode(WrapMode wrapMode)\r
 385         {\r
 386                 return updateStatus(DllExports::GdipSetLineWrapMode(\r
 387                                 (GpLineGradient*) nativeBrush, wrapMode));\r
 388         }\r
 389         Status TranslateTransform(REAL dx, REAL dy,\r
 390                         MatrixOrder order = MatrixOrderPrepend)\r
 391         {\r
 392                 return updateStatus(DllExports::GdipTranslateLineTransform(\r
 393                                 (GpLineGradient*) nativeBrush, dx, dy, order));\r
 394         }\r
 395 \r
 396 private:\r
 397         LinearGradientBrush(GpBrush *brush, Status status): Brush(brush, status) {}\r
 398         LinearGradientBrush(const LinearGradientBrush& brush);\r
 399         LinearGradientBrush& operator=(const LinearGradientBrush&);\r
 400 };\r
 401 \r
 402 class SolidBrush: public Brush\r
 403 {\r
 404 public:\r
 405         SolidBrush(const Color& color)\r
 406         {\r
 407                 GpSolidFill *nativeSolidFill = NULL;\r
 408                 lastStatus = DllExports::GdipCreateSolidFill(\r
 409                                 color.GetValue(), &nativeSolidFill);\r
 410                 nativeBrush = nativeSolidFill; \r
 411         }\r
 412         virtual SolidBrush* Clone() const\r
 413         {\r
 414                 GpBrush *cloneBrush = NULL;\r
 415                 Status status = updateStatus(DllExports::GdipCloneBrush(\r
 416                                 nativeBrush, &cloneBrush));\r
 417                 if (status == Ok) {\r
 418                         SolidBrush *result =\r
 419                                 new SolidBrush(cloneBrush, lastStatus);\r
 420                         if (!result) {\r
 421                                 DllExports::GdipDeleteBrush(cloneBrush);\r
 422                                 updateStatus(OutOfMemory);\r
 423                         }\r
 424                         return result;\r
 425                 } else {\r
 426                         return NULL;\r
 427                 }\r
 428         }\r
 429 \r
 430         Status GetColor(Color *color) const\r
 431         {\r
 432                 return updateStatus(DllExports::GdipGetSolidFillColor(\r
 433                                 (GpSolidFill*) nativeBrush,\r
 434                                 color ? &color->Value : NULL));\r
 435         }\r
 436         Status SetColor(const Color& color)\r
 437         {\r
 438                 return updateStatus(DllExports::GdipSetSolidFillColor(\r
 439                                 (GpSolidFill*) nativeBrush, color.GetValue()));\r
 440         }\r
 441 \r
 442 private:\r
 443         SolidBrush(GpBrush *brush, Status status): Brush(brush, status) {}\r
 444         SolidBrush(const SolidBrush&);\r
 445         SolidBrush& operator=(const SolidBrush&);\r
 446 };\r
 447 \r
 448 class TextureBrush: public Brush\r
 449 {\r
 450 public:\r
 451         TextureBrush(Image *image, WrapMode wrapMode = WrapModeTile)\r
 452         {\r
 453                 GpTexture *nativeTexture = NULL;\r
 454                 lastStatus = DllExports::GdipCreateTexture(\r
 455                                 image ? image->nativeImage : NULL,\r
 456                                 wrapMode, &nativeTexture);\r
 457                 nativeBrush = nativeTexture;\r
 458         }\r
 459         TextureBrush(Image *image, WrapMode wrapMode,\r
 460                         REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)\r
 461         {\r
 462                 GpTexture *nativeTexture = NULL;\r
 463                 lastStatus = DllExports::GdipCreateTexture2(\r
 464                                 image ? image->nativeImage : NULL,\r
 465                                 wrapMode, dstX, dstY, dstWidth, dstHeight,\r
 466                                 &nativeTexture);\r
 467                 nativeBrush = nativeTexture;\r
 468         }\r
 469         TextureBrush(Image *image, WrapMode wrapMode,\r
 470                         INT dstX, INT dstY, INT dstWidth, INT dstHeight)\r
 471         {\r
 472                 GpTexture *nativeTexture = NULL;\r
 473                 lastStatus = DllExports::GdipCreateTexture2I(\r
 474                                 image ? image->nativeImage : NULL,\r
 475                                 wrapMode, dstX, dstY, dstWidth, dstHeight,\r
 476                                 &nativeTexture);\r
 477                 nativeBrush = nativeTexture;\r
 478         }\r
 479         TextureBrush(Image *image, WrapMode wrapMode, const RectF& dstRect)\r
 480         {\r
 481                 GpTexture *nativeTexture = NULL;\r
 482                 lastStatus = DllExports::GdipCreateTexture2(\r
 483                                 image ? image->nativeImage : NULL, wrapMode,\r
 484                                 dstRect.X, dstRect.Y,\r
 485                                 dstRect.Width, dstRect.Height, &nativeTexture);\r
 486                 nativeBrush = nativeTexture;\r
 487         }\r
 488         TextureBrush(Image *image, WrapMode wrapMode, const Rect& dstRect)\r
 489         {\r
 490                 GpTexture *nativeTexture = NULL;\r
 491                 lastStatus = DllExports::GdipCreateTexture2I(\r
 492                                 image ? image->nativeImage : NULL, wrapMode,\r
 493                                 dstRect.X, dstRect.Y,\r
 494                                 dstRect.Width, dstRect.Height, &nativeTexture);\r
 495                 nativeBrush = nativeTexture;\r
 496         }\r
 497         TextureBrush(Image *image, const RectF& dstRect,\r
 498                         ImageAttributes *imageAttributes = NULL)\r
 499         {\r
 500                 GpTexture *nativeTexture = NULL;\r
 501                 lastStatus = DllExports::GdipCreateTextureIA(\r
 502                                 image ? image->nativeImage : NULL,\r
 503                                 imageAttributes ? imageAttributes->nativeImageAttributes : NULL,\r
 504                                 dstRect.X, dstRect.Y,\r
 505                                 dstRect.Width, dstRect.Height, &nativeTexture);\r
 506                 nativeBrush = nativeTexture;\r
 507         }\r
 508         TextureBrush(Image *image, const Rect& dstRect,\r
 509                         ImageAttributes *imageAttributes = NULL)\r
 510         {\r
 511                 GpTexture *nativeTexture = NULL;\r
 512                 lastStatus = DllExports::GdipCreateTextureIAI(\r
 513                                 image ? image->nativeImage : NULL,\r
 514                                 imageAttributes ? imageAttributes->nativeImageAttributes : NULL,\r
 515                                 dstRect.X, dstRect.Y,\r
 516                                 dstRect.Width, dstRect.Height, &nativeTexture);\r
 517                 nativeBrush = nativeTexture;\r
 518         }\r
 519         virtual TextureBrush* Clone() const\r
 520         {\r
 521                 GpBrush *cloneBrush = NULL;\r
 522                 Status status = updateStatus(DllExports::GdipCloneBrush(\r
 523                                 nativeBrush, &cloneBrush));\r
 524                 if (status == Ok) {\r
 525                         TextureBrush *result =\r
 526                                 new TextureBrush(cloneBrush, lastStatus);\r
 527                         if (!result) {\r
 528                                 DllExports::GdipDeleteBrush(cloneBrush);\r
 529                                 updateStatus(OutOfMemory);\r
 530                         }\r
 531                         return result;\r
 532                 } else {\r
 533                         return NULL;\r
 534                 }\r
 535         }\r
 536 \r
 537         //TODO: implement TextureBrush::GetImage()\r
 538         //Image *GetImage() const\r
 539         //{\r
 540         //      // where is the Image allocated (static,member,new,other)?\r
 541         //      // GdipGetTextureImage just returns a GpImage*\r
 542         //      updateStatus(NotImplemented);\r
 543         //      return NULL;\r
 544         //}\r
 545         Status GetTransfrom(Matrix *matrix) const\r
 546         {\r
 547                 return updateStatus(DllExports::GdipGetTextureTransform(\r
 548                                 (GpTexture*) nativeBrush,\r
 549                                 matrix ? matrix->nativeMatrix : NULL));\r
 550         }\r
 551         WrapMode GetWrapMode() const\r
 552         {\r
 553                 WrapMode result = WrapModeTile;\r
 554                 updateStatus(DllExports::GdipGetTextureWrapMode(\r
 555                                 (GpTexture*) nativeBrush, &result));\r
 556                 return result;\r
 557         }\r
 558         Status MultiplyTransform(const Matrix *matrix,\r
 559                         MatrixOrder order = MatrixOrderPrepend)\r
 560         {\r
 561                 return updateStatus(DllExports::GdipMultiplyTextureTransform(\r
 562                                 (GpTexture*) nativeBrush,\r
 563                                 matrix ? matrix->nativeMatrix : NULL, order));\r
 564         }\r
 565         Status ResetTransform()\r
 566         {\r
 567                 return updateStatus(DllExports::GdipResetTextureTransform(\r
 568                                 (GpTexture*) nativeBrush));\r
 569         }\r
 570         Status RotateTransform(REAL angle,\r
 571                         MatrixOrder order = MatrixOrderPrepend)\r
 572         {\r
 573                 return updateStatus(DllExports::GdipRotateTextureTransform(\r
 574                                 (GpTexture*) nativeBrush, angle, order));\r
 575         }\r
 576         Status ScaleTransform(REAL sx, REAL sy,\r
 577                         MatrixOrder order = MatrixOrderPrepend)\r
 578         {\r
 579                 return updateStatus(DllExports::GdipScaleTextureTransform(\r
 580                                 (GpTexture*) nativeBrush, sx, sy, order));\r
 581         }\r
 582         Status SetTransform(const Matrix *matrix)\r
 583         {\r
 584                 return updateStatus(DllExports::GdipSetTextureTransform(\r
 585                                 (GpTexture*) nativeBrush,\r
 586                                 matrix ? matrix->nativeMatrix : NULL));\r
 587         }\r
 588         Status SetWrapMode(WrapMode wrapMode)\r
 589         {\r
 590                 return updateStatus(DllExports::GdipSetTextureWrapMode(\r
 591                                 (GpTexture*) nativeBrush, wrapMode));\r
 592         }\r
 593         Status TranslateTransform(REAL dx, REAL dy,\r
 594                         MatrixOrder order = MatrixOrderPrepend)\r
 595         {\r
 596                 return updateStatus(DllExports::GdipTranslateTextureTransform(\r
 597                                 (GpTexture*) nativeBrush, dx, dy, order));\r
 598         }\r
 599 \r
 600 private:\r
 601         TextureBrush(GpBrush *brush, Status status): Brush(brush, status) {}\r
 602         TextureBrush(const TextureBrush&);\r
 603         TextureBrush& operator=(const TextureBrush&);\r
 604 };\r
 605 \r
 606 #endif /* __GDIPLUS_BRUSH_H */\r