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