reactos/w32api/include/gdiplustypes.h

   1 /*
   2  * GdiPlusTypes.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 _GDIPLUSTYPES_H
  20 #define _GDIPLUSTYPES_H
  21
  22 #if __GNUC__ >= 3
  23 #pragma GCC system_header
  24 #endif
  25
  26 typedef float REAL;
  27
  28 extern "C" {
  29   typedef BOOL (CALLBACK * ImageAbort)(VOID *);
  30   typedef ImageAbort DrawImageAbort;
  31   typedef ImageAbort GetThumbnailImageAbort;
  32   typedef BOOL (CALLBACK * EnumerateMetafileProc)(EmfPlusRecordType, UINT, UINT, const BYTE*, VOID*);
  33 }
  34
  35 typedef enum {
  36   Ok = 0,
  37   GenericError = 1,
  38   InvalidParameter = 2,
  39   OutOfMemory = 3,
  40   ObjectBusy = 4,
  41   InsufficientBuffer = 5,
  42   NotImplemented = 6,
  43   Win32Error = 7,
  44   WrongState = 8,
  45   Aborted = 9,
  46   FileNotFound = 10,
  47   ValueOverflow = 11,
  48   AccessDenied = 12,
  49   UnknownImageFormat = 13,
  50   FontFamilyNotFound = 14,
  51   FontStyleNotFound = 15,
  52   NotTrueTypeFont = 16,
  53   UnsupportedGdiplusVersion = 17,
  54   GdiplusNotInitialized = 18,
  55   PropertyNotFound = 19,
  56   PropertyNotSupported = 20,
  57   ProfileNotFound = 21
  58 } Status;
  59
  60
  61 class CharacterRange
  62 {
  63 public:
  64   CharacterRange(VOID)
  65   {
  66   }
  67
  68   CharacterRange(INT first, INT length)
  69   {
  70   }
  71
  72   CharacterRange &operator=(const CharacterRange &rhs)
  73   {
  74     First  = rhs.First;
  75     Length = rhs.Length;
  76     return *this;
  77   }
  78
  79 public:
  80   INT First;
  81   INT Length;
  82 };
  83
  84
  85 class SizeF
  86 {
  87 public:
  88   SizeF(VOID)
  89   {
  90   }
  91
  92   SizeF(FLOAT width, FLOAT height)
  93   {
  94   }
  95
  96   SizeF(const SizeF &size)
  97   {
  98   }
  99
 100   BOOL Empty(VOID)
 101   {
 102     return FALSE;
 103   }
 104
 105   BOOL Equals(const SizeF &sz)
 106   {
 107     return FALSE;
 108   }
 109
 110   SizeF operator+(const SizeF &sz)
 111   {
 112     return SizeF(Width + sz.Width,
 113       Height + sz.Height);
 114   }
 115
 116   SizeF operator-(const SizeF &sz)
 117   {
 118     return SizeF(Width - sz.Width,
 119       Height - sz.Height);
 120   }
 121
 122 public:
 123   FLOAT Height;
 124   FLOAT Width;
 125 };
 126
 127
 128 class PointF
 129 {
 130 public:
 131   PointF(REAL x, REAL y)
 132   {
 133   }
 134
 135   PointF(const SizeF &size)
 136   {
 137   }
 138
 139   PointF(VOID)
 140   {
 141   }
 142
 143   PointF(const PointF &point)
 144   {
 145   }
 146
 147   BOOL Equals(const PointF& point)
 148   {
 149     return FALSE;
 150   }
 151
 152   PointF operator+(const PointF &point)
 153   {
 154     return PointF(X + point.X,
 155       Y + point.Y);
 156   }
 157
 158   PointF operator-(const PointF &point)
 159   {
 160     return PointF(X - point.X,
 161       Y - point.Y);
 162   }
 163
 164 public:
 165   REAL X;
 166   REAL Y;
 167 };
 168
 169
 170 class PathData
 171 {
 172 public:
 173   PathData(VOID)
 174   {
 175   }
 176
 177 public:
 178   INT Count;
 179   PointF *Points;
 180   BYTE *Types;
 181 };
 182
 183
 184 class Size
 185 {
 186 public:
 187   Size(VOID)
 188   {
 189   }
 190
 191   Size(INT width, INT height)
 192   {
 193   }
 194
 195   Size(const Size &size)
 196   {
 197   }
 198
 199   BOOL Empty(VOID)
 200   {
 201     return FALSE;
 202   }
 203
 204   BOOL Equals(const Size &sz)
 205   {
 206     return FALSE;
 207   }
 208
 209   Size operator+(const Size &sz)
 210   {
 211     return Size(Width + sz.Width,
 212       Height + sz.Height);
 213   }
 214
 215   Size operator-(const Size &sz)
 216   {
 217     return Size(Width - sz.Width,
 218       Height - sz.Height);
 219   }
 220
 221 public:
 222   INT Height;
 223   INT Width;
 224 };
 225
 226
 227 class Point
 228 {
 229 public:
 230   Point(VOID)
 231   {
 232   }
 233
 234   Point(INT x, INT y)
 235   {
 236   }
 237
 238   Point(const Point &point)
 239   {
 240   }
 241
 242   Point(const Size &size)
 243   {
 244   }
 245
 246   BOOL Equals(const Point& point)
 247   {
 248     return FALSE;
 249   }
 250
 251   Point operator+(const Point &point)
 252   {
 253     return Point(X + point.X,
 254       Y + point.Y);
 255   }
 256
 257   Point operator-(const Point &point)
 258   {
 259     return Point(X - point.X,
 260       Y - point.Y);
 261   }
 262
 263 public:
 264   INT X;
 265   INT Y;
 266 };
 267
 268
 269 class Rect
 270 {
 271 public:
 272   Rect(VOID)
 273   {
 274   }
 275
 276   Rect(const Point &location, const Size &size)
 277   {
 278   }
 279
 280   Rect(INT x, INT y, INT width, INT height)
 281   {
 282   }
 283
 284   Rect *Clone(VOID) const
 285   {
 286     return NULL;
 287   }
 288
 289   BOOL Contains(const Point& pt)
 290   {
 291     return FALSE;
 292   }
 293
 294   BOOL Contains(Rect& rect)
 295   {
 296     return FALSE;
 297   }
 298
 299   BOOL Contains(INT x, INT y)
 300   {
 301     return FALSE;
 302   }
 303
 304   BOOL Equals(const Rect& rect) const
 305   {
 306     return FALSE;
 307   }
 308
 309   INT GetBottom(VOID) const
 310   {
 311     return 0;
 312   }
 313
 314   VOID GetBounds(Rect* rect) const
 315   {
 316   }
 317
 318   INT GetLeft(VOID) const
 319   {
 320     return 0;
 321   }
 322
 323   VOID GetLocation(Point* point) const
 324   {
 325   }
 326
 327   INT GetRight(VOID) const
 328   {
 329     return 0;
 330   }
 331
 332   VOID GetSize(Size* size) const
 333   {
 334   }
 335
 336   INT GetTop(VOID) const
 337   {
 338     return 0;
 339   }
 340
 341   VOID Inflate(INT dx, INT dy)
 342   {
 343   }
 344
 345   VOID Inflate(const Point& point)
 346   {
 347   }
 348
 349   BOOL Intersect(Rect& c, const Rect& a, const Rect& b)
 350   {
 351     return FALSE;
 352   }
 353
 354   BOOL Intersect(const Rect& rect)
 355   {
 356     return FALSE;
 357   }
 358
 359   BOOL IntersectsWith(const Rect& rect) const
 360   {
 361     return FALSE;
 362   }
 363
 364   BOOL IsEmptyArea(VOID) const
 365   {
 366     return FALSE;
 367   }
 368
 369   VOID Offset(INT dx, INT dy)
 370   {
 371   }
 372
 373   VOID Offset(const Point& point)
 374   {
 375   }
 376
 377   BOOL Union(Rect& c, const Rect& a, const Rect& b)
 378   {
 379     return FALSE;
 380   }
 381 public:
 382   INT X;
 383   INT Y;
 384   INT Width;
 385   INT Height;
 386 };
 387
 388
 389 class RectF
 390 {
 391 public:
 392   RectF(const PointF &location, const SizeF &size)
 393   {
 394   }
 395
 396   RectF(VOID)
 397   {
 398   }
 399
 400   RectF(REAL x, REAL y, REAL width, REAL height)
 401   {
 402   }
 403
 404   RectF *Clone(VOID) const
 405   {
 406     return NULL;
 407   }
 408
 409   BOOL Contains(const RectF& rect)
 410   {
 411     return FALSE;
 412   }
 413
 414   BOOL Contains(const PointF& pt) const
 415   {
 416     return FALSE;
 417   }
 418
 419   BOOL Contains(REAL x, REAL y)
 420   {
 421     return FALSE;
 422   }
 423
 424   BOOL Equals(const RectF& rect) const
 425   {
 426     return FALSE;
 427   }
 428
 429   REAL GetBottom(VOID) const
 430   {
 431     return 0;
 432   }
 433
 434   VOID GetBounds(RectF* rect) const
 435   {
 436   }
 437
 438   REAL GetLeft(VOID) const
 439   {
 440     return 0;
 441   }
 442
 443   VOID GetLocation(PointF* point) const
 444   {
 445   }
 446
 447   REAL GetRight(VOID) const
 448   {
 449     return 0;
 450   }
 451
 452   VOID GetSize(SizeF* size) const
 453   {
 454   }
 455
 456   REAL GetTop(VOID) const
 457   {
 458     return 0;
 459   }
 460
 461   VOID Inflate(const PointF& point)
 462   {
 463   }
 464
 465   VOID Inflate(REAL dx, REAL dy)
 466   {
 467   }
 468
 469   BOOL Intersect(Rect& c, const Rect& a, const Rect& b)
 470   {
 471     return FALSE;
 472   }
 473
 474   BOOL Intersect(const Rect& rect)
 475   {
 476     return FALSE;
 477   }
 478
 479   BOOL IntersectsWith(const RectF& rect) const
 480   {
 481     return FALSE;
 482   }
 483
 484   BOOL IsEmptyArea(VOID) const
 485   {
 486     return FALSE;
 487   }
 488
 489   VOID Offset(INT dx, INT dy)
 490   {
 491   }
 492
 493   VOID Offset(const Point& point)
 494   {
 495   }
 496
 497   BOOL Union(RectF& c, const RectF& a, const RectF& b)
 498   {
 499     return FALSE;
 500   }
 501
 502 public:
 503   REAL X;
 504   REAL Y;
 505   REAL Width;
 506   REAL Height;
 507 };
 508
 509 #endif /* _GDIPLUSTYPES_H */