Embed:
(wiki syntax)
Show/hide line numbers
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 */
Generated on Tue Jul 12 2022 19:59:54 by
1.7.2