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