reactos/w32api/include/GdiPlusBrush.h

   1 /*
   2  * GdiPlusBrush.h
   3  *
   4  * Windows GDI+
   5  *
   6  * This file is part of the w32api package.
   7  *
   8  * THIS SOFTWARE IS NOT COPYRIGHTED
   9  *
  10  * This source code is offered for use in the public domain. You may
  11  * use, modify or distribute it freely.
  12  *
  13  * This code is distributed in the hope that it will be useful but
  14  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
  15  * DISCLAIMED. This includes but is not limited to warranties of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17  */
  18
  19 #ifndef _GDIPLUSBRUSH_H
  20 #define _GDIPLUSBRUSH_H
  21
  22 #if __GNUC__ >= 3
  23 #pragma GCC system_header
  24 #endif
  25
  26 class Brush : public GdiplusBase
  27 {
  28 public:
  29   Brush *Clone(VOID) const
  30   {
  31     return NULL;
  32   }
  33
  34   Status GetLastStatus(VOID)
  35   {
  36     return NotImplemented;
  37   }
  38
  39   BrushType GetType(VOID)
  40   {
  41     return BrushTypeSolidColor;
  42   }
  43 };
  44
  45
  46 class HatchBrush : public Brush
  47 {
  48 public:
  49   HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
  50   {
  51   }
  52
  53   Status GetBackgroundColor(Color *color) const
  54   {
  55     return NotImplemented;
  56   }
  57
  58   Status GetForegroundColor(Color *color) const
  59   {
  60     return NotImplemented;
  61   }
  62
  63   HatchStyle GetHatchStyle(VOID) const
  64   {
  65     return HatchStyleHorizontal;
  66   }
  67 };
  68
  69
  70 class LinearGradientBrush : public Brush
  71 {
  72 public:
  73   LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2)
  74   {
  75   }
  76
  77   LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
  78   {
  79   }
  80
  81   LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
  82   {
  83   }
  84
  85   LinearGradientBrush(const Point &point1, const Point &point2, const Color &color1, const Color &color2)
  86   {
  87   }
  88
  89   LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
  90   {
  91   }
  92
  93   LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
  94   {
  95   }
  96
  97   Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
  98   {
  99     return NotImplemented;
 100   }
 101
 102   INT GetBlendCount(VOID) const
 103   {
 104     return 0;
 105   }
 106
 107   BOOL GetGammaCorrection(VOID) const
 108   {
 109     return FALSE;
 110   }
 111
 112   INT GetInterpolationColorCount(VOID) const
 113   {
 114     return 0;
 115   }
 116
 117   Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
 118   {
 119     return NotImplemented;
 120   }
 121
 122   Status GetLinearColors(Color* colors) const
 123   {
 124     return NotImplemented;
 125   }
 126
 127   Status GetRectangle(Rect *rect) const
 128   {
 129     return NotImplemented;
 130   }
 131
 132   Status GetRectangle(RectF* rect) const
 133   {
 134     return NotImplemented;
 135   }
 136
 137   Status GetTransform(Matrix* matrix) const
 138   {
 139     return NotImplemented;
 140   }
 141
 142   WrapMode GetWrapMode(VOID) const
 143   {
 144     return WrapModeTile;
 145   }
 146
 147   Status MultiplyTransform(const Matrix *matrix, MatrixOrder order)
 148   {
 149     return NotImplemented;
 150   }
 151
 152   Status ResetTransform(VOID)
 153   {
 154     return NotImplemented;
 155   }
 156
 157   Status RotateTransform(REAL angle, MatrixOrder order)
 158   {
 159     return NotImplemented;
 160   }
 161
 162   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
 163   {
 164     return NotImplemented;
 165   }
 166
 167   Status SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
 168   {
 169     return NotImplemented;
 170   }
 171
 172   Status SetBlendBellShape(REAL focus, REAL scale)
 173   {
 174     return NotImplemented;
 175   }
 176
 177   Status SetBlendTriangularShape(REAL focus, REAL scale)
 178   {
 179     return NotImplemented;
 180   }
 181
 182   Status SetGammaCorrection(BOOL useGammaCorrection)
 183   {
 184     return NotImplemented;
 185   }
 186
 187   Status SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
 188   {
 189     return NotImplemented;
 190   }
 191
 192   Status SetLinearColors(const Color& color1, const Color& color2)
 193   {
 194     return NotImplemented;
 195   }
 196
 197   Status SetTransform(const Matrix* matrix)
 198   {
 199     return NotImplemented;
 200   }
 201
 202   Status SetWrapMode(WrapMode wrapMode)
 203   {
 204     return NotImplemented;
 205   }
 206
 207   Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
 208   {
 209     return NotImplemented;
 210   }
 211 };
 212
 213
 214 class SolidBrush : Brush
 215 {
 216 public:
 217   SolidBrush(const Color &color)
 218   {
 219   }
 220
 221   Status GetColor(Color *color) const
 222   {
 223     return NotImplemented;
 224   }
 225
 226   Status SetColor(const Color &color)
 227   {
 228     return NotImplemented;
 229   }
 230 };
 231
 232
 233 class TextureBrush : Brush
 234 {
 235 public:
 236   TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
 237   {
 238   }
 239
 240   TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes)
 241   {
 242   }
 243
 244   TextureBrush(Image *image, WrapMode wrapMode, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
 245   {
 246   }
 247
 248   TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
 249   {
 250   }
 251
 252   TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
 253   {
 254   }
 255
 256   TextureBrush(Image *image, WrapMode wrapMode)
 257   {
 258   }
 259
 260   TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
 261   {
 262   }
 263
 264   Image *GetImage(VOID) const
 265   {
 266     return NULL;
 267   }
 268
 269   Status GetTransform(Matrix *matrix) const
 270   {
 271     return NotImplemented;
 272   }
 273
 274   WrapMode GetWrapMode(VOID) const
 275   {
 276     return WrapModeTile;
 277   }
 278
 279   Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
 280   {
 281     return NotImplemented;
 282   }
 283
 284   Status ResetTransform(VOID)
 285   {
 286     return NotImplemented;
 287   }
 288
 289   Status RotateTransform(REAL angle, MatrixOrder order)
 290   {
 291     return NotImplemented;
 292   }
 293
 294   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
 295   {
 296     return NotImplemented;
 297   }
 298
 299   Status SetTransform(const Matrix *matrix)
 300   {
 301     return NotImplemented;
 302   }
 303
 304   Status SetWrapMode(WrapMode wrapMode)
 305   {
 306     return NotImplemented;
 307   }
 308
 309   Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
 310   {
 311     return NotImplemented;
 312   }
 313 };
 314
 315 #endif /* _GDIPLUSBRUSH_H */