reactos/include/psdk/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 class Brush : public GdiplusBase
  23 {
  24 public:
  25   Brush *Clone(VOID) const
  26   {
  27     return NULL;
  28   }
  29
  30   Status GetLastStatus(VOID)
  31   {
  32     return NotImplemented;
  33   }
  34
  35   BrushType GetType(VOID)
  36   {
  37     return BrushTypeSolidColor;
  38   }
  39 };
  40
  41
  42 class HatchBrush : public Brush
  43 {
  44 public:
  45   HatchBrush(HatchStyle hatchStyle, const Color &foreColor, const Color &backColor)
  46   {
  47   }
  48
  49   Status GetBackgroundColor(Color *color) const
  50   {
  51     return NotImplemented;
  52   }
  53
  54   Status GetForegroundColor(Color *color) const
  55   {
  56     return NotImplemented;
  57   }
  58
  59   HatchStyle GetHatchStyle(VOID) const
  60   {
  61     return HatchStyleHorizontal;
  62   }
  63 };
  64
  65
  66 class LinearGradientBrush : public Brush
  67 {
  68 public:
  69   LinearGradientBrush(const PointF &point1, const PointF &point2, const Color &color1, const Color &color2)
  70   {
  71   }
  72
  73   LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
  74   {
  75   }
  76
  77   LinearGradientBrush(const Rect &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
  78   {
  79   }
  80
  81   LinearGradientBrush(const Point &point1, const Point &point2, const Color &color1, const Color &color2)
  82   {
  83   }
  84
  85   LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, REAL angle, BOOL isAngleScalable)
  86   {
  87   }
  88
  89   LinearGradientBrush(const RectF &rect, const Color &color1, const Color &color2, LinearGradientMode mode)
  90   {
  91   }
  92
  93   Status GetBlend(REAL *blendFactors, REAL *blendPositions, INT count)
  94   {
  95     return NotImplemented;
  96   }
  97
  98   INT GetBlendCount(VOID) const
  99   {
 100     return 0;
 101   }
 102
 103   BOOL GetGammaCorrection(VOID) const
 104   {
 105     return FALSE;
 106   }
 107
 108   INT GetInterpolationColorCount(VOID) const
 109   {
 110     return 0;
 111   }
 112
 113   Status GetInterpolationColors(Color *presetColors, REAL *blendPositions, INT count) const
 114   {
 115     return NotImplemented;
 116   }
 117
 118   Status GetLinearColors(Color* colors) const
 119   {
 120     return NotImplemented;
 121   }
 122
 123   Status GetRectangle(Rect *rect) const
 124   {
 125     return NotImplemented;
 126   }
 127
 128   Status GetRectangle(RectF* rect) const
 129   {
 130     return NotImplemented;
 131   }
 132
 133   Status GetTransform(Matrix* matrix) const
 134   {
 135     return NotImplemented;
 136   }
 137
 138   WrapMode GetWrapMode(VOID) const
 139   {
 140     return WrapModeTile;
 141   }
 142
 143   Status MultiplyTransform(const Matrix *matrix, MatrixOrder order)
 144   {
 145     return NotImplemented;
 146   }
 147
 148   Status ResetTransform(VOID)
 149   {
 150     return NotImplemented;
 151   }
 152
 153   Status RotateTransform(REAL angle, MatrixOrder order)
 154   {
 155     return NotImplemented;
 156   }
 157
 158   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
 159   {
 160     return NotImplemented;
 161   }
 162
 163   Status SetBlend(const REAL *blendFactors, const REAL *blendPositions, INT count)
 164   {
 165     return NotImplemented;
 166   }
 167
 168   Status SetBlendBellShape(REAL focus, REAL scale)
 169   {
 170     return NotImplemented;
 171   }
 172
 173   Status SetBlendTriangularShape(REAL focus, REAL scale)
 174   {
 175     return NotImplemented;
 176   }
 177
 178   Status SetGammaCorrection(BOOL useGammaCorrection)
 179   {
 180     return NotImplemented;
 181   }
 182
 183   Status SetInterpolationColors(const Color *presetColors, const REAL *blendPositions, INT count)
 184   {
 185     return NotImplemented;
 186   }
 187
 188   Status SetLinearColors(const Color& color1, const Color& color2)
 189   {
 190     return NotImplemented;
 191   }
 192
 193   Status SetTransform(const Matrix* matrix)
 194   {
 195     return NotImplemented;
 196   }
 197
 198   Status SetWrapMode(WrapMode wrapMode)
 199   {
 200     return NotImplemented;
 201   }
 202
 203   Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
 204   {
 205     return NotImplemented;
 206   }
 207 };
 208
 209
 210 class SolidBrush : Brush
 211 {
 212 public:
 213   SolidBrush(const Color &color)
 214   {
 215   }
 216
 217   Status GetColor(Color *color) const
 218   {
 219     return NotImplemented;
 220   }
 221
 222   Status SetColor(const Color &color)
 223   {
 224     return NotImplemented;
 225   }
 226 };
 227
 228
 229 class TextureBrush : Brush
 230 {
 231 public:
 232   TextureBrush(Image *image, WrapMode wrapMode, const RectF &dstRect)
 233   {
 234   }
 235
 236   TextureBrush(Image *image, Rect &dstRect, ImageAttributes *imageAttributes)
 237   {
 238   }
 239
 240   TextureBrush(Image *image, WrapMode wrapMode, INT dstX, INT dstY, INT dstWidth, INT dstHeight)
 241   {
 242   }
 243
 244   TextureBrush(Image *image, WrapMode wrapMode, REAL dstX, REAL dstY, REAL dstWidth, REAL dstHeight)
 245   {
 246   }
 247
 248   TextureBrush(Image *image, RectF &dstRect, ImageAttributes *imageAttributes)
 249   {
 250   }
 251
 252   TextureBrush(Image *image, WrapMode wrapMode)
 253   {
 254   }
 255
 256   TextureBrush(Image *image, WrapMode wrapMode, const Rect &dstRect)
 257   {
 258   }
 259
 260   Image *GetImage(VOID) const
 261   {
 262     return NULL;
 263   }
 264
 265   Status GetTransform(Matrix *matrix) const
 266   {
 267     return NotImplemented;
 268   }
 269
 270   WrapMode GetWrapMode(VOID) const
 271   {
 272     return WrapModeTile;
 273   }
 274
 275   Status MultiplyTransform(Matrix *matrix, MatrixOrder order)
 276   {
 277     return NotImplemented;
 278   }
 279
 280   Status ResetTransform(VOID)
 281   {
 282     return NotImplemented;
 283   }
 284
 285   Status RotateTransform(REAL angle, MatrixOrder order)
 286   {
 287     return NotImplemented;
 288   }
 289
 290   Status ScaleTransform(REAL sx, REAL sy, MatrixOrder order)
 291   {
 292     return NotImplemented;
 293   }
 294
 295   Status SetTransform(const Matrix *matrix)
 296   {
 297     return NotImplemented;
 298   }
 299
 300   Status SetWrapMode(WrapMode wrapMode)
 301   {
 302     return NotImplemented;
 303   }
 304
 305   Status TranslateTransform(REAL dx, REAL dy, MatrixOrder order)
 306   {
 307     return NotImplemented;
 308   }
 309 };
 310
 311 #endif /* _GDIPLUSBRUSH_H */