interface/wx/gdicmn.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        gdicmn.h
   3 // Purpose:     interface of wxRealPoint
   4 // Author:      wxWidgets team
   5 // RCS-ID:      $Id$
   6 // Licence:     wxWindows licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9
  10 /**
  11     Bitmap type flags. See wxBitmap and wxImage classes.
  12 */
  13 enum wxBitmapType
  14 {
  15     wxBITMAP_TYPE_INVALID,
  16     wxBITMAP_TYPE_BMP,
  17     wxBITMAP_TYPE_BMP_RESOURCE,
  18     wxBITMAP_TYPE_RESOURCE = wxBITMAP_TYPE_BMP_RESOURCE,
  19     wxBITMAP_TYPE_ICO,
  20     wxBITMAP_TYPE_ICO_RESOURCE,
  21     wxBITMAP_TYPE_CUR,
  22     wxBITMAP_TYPE_CUR_RESOURCE,
  23     wxBITMAP_TYPE_XBM,
  24     wxBITMAP_TYPE_XBM_DATA,
  25     wxBITMAP_TYPE_XPM,
  26     wxBITMAP_TYPE_XPM_DATA,
  27     wxBITMAP_TYPE_TIFF,
  28     wxBITMAP_TYPE_TIF = wxBITMAP_TYPE_TIFF,
  29     wxBITMAP_TYPE_TIFF_RESOURCE,
  30     wxBITMAP_TYPE_TIF_RESOURCE = wxBITMAP_TYPE_TIFF_RESOURCE,
  31     wxBITMAP_TYPE_GIF,
  32     wxBITMAP_TYPE_GIF_RESOURCE,
  33     wxBITMAP_TYPE_PNG,
  34     wxBITMAP_TYPE_PNG_RESOURCE,
  35     wxBITMAP_TYPE_JPEG,
  36     wxBITMAP_TYPE_JPEG_RESOURCE,
  37     wxBITMAP_TYPE_PNM,
  38     wxBITMAP_TYPE_PNM_RESOURCE,
  39     wxBITMAP_TYPE_PCX,
  40     wxBITMAP_TYPE_PCX_RESOURCE,
  41     wxBITMAP_TYPE_PICT,
  42     wxBITMAP_TYPE_PICT_RESOURCE,
  43     wxBITMAP_TYPE_ICON,
  44     wxBITMAP_TYPE_ICON_RESOURCE,
  45     wxBITMAP_TYPE_ANI,
  46     wxBITMAP_TYPE_IFF,
  47     wxBITMAP_TYPE_TGA,
  48     wxBITMAP_TYPE_MACCURSOR,
  49     wxBITMAP_TYPE_MACCURSOR_RESOURCE,
  50     wxBITMAP_TYPE_ANY = 50
  51 };
  52
  53 /**
  54     Polygon filling mode. See wxDC::DrawPolygon.
  55 */
  56 enum wxPolygonFillMode
  57 {
  58     wxODDEVEN_RULE = 1,
  59     wxWINDING_RULE
  60 };
  61
  62 /**
  63     Standard cursors.
  64
  65     Notice that under wxMSW some of these cursors are defined in @c wx.rc file
  66     and not by the system itself so you should include this file from your own
  67     resource file (possibly creating a trivial resource file just containing a
  68     single include line if you don't need it otherwise) to be able to use them.
  69
  70     See wxCursor.
  71 */
  72 enum wxStockCursor
  73 {
  74     wxCURSOR_NONE,
  75     wxCURSOR_ARROW,             ///< A standard arrow cursor.
  76     wxCURSOR_RIGHT_ARROW,       ///< A standard arrow cursor pointing to the right.
  77     wxCURSOR_BULLSEYE,          ///< Bullseye cursor.
  78     wxCURSOR_CHAR,              ///< Rectangular character cursor.
  79     wxCURSOR_CROSS,             ///< A cross cursor.
  80     wxCURSOR_HAND,              ///< A hand cursor.
  81     wxCURSOR_IBEAM,             ///< An I-beam cursor (vertical line).
  82     wxCURSOR_LEFT_BUTTON,       ///< Represents a mouse with the left button depressed.
  83     wxCURSOR_MAGNIFIER,         ///< A magnifier icon.
  84     wxCURSOR_MIDDLE_BUTTON,     ///< Represents a mouse with the middle button depressed.
  85     wxCURSOR_NO_ENTRY,          ///< A no-entry sign cursor.
  86     wxCURSOR_PAINT_BRUSH,       ///< A paintbrush cursor.
  87     wxCURSOR_PENCIL,            ///< A pencil cursor.
  88     wxCURSOR_POINT_LEFT,        ///< A cursor that points left.
  89     wxCURSOR_POINT_RIGHT,       ///< A cursor that points right.
  90     wxCURSOR_QUESTION_ARROW,    ///< An arrow and question mark.
  91     wxCURSOR_RIGHT_BUTTON,      ///< Represents a mouse with the right button depressed.
  92     wxCURSOR_SIZENESW,          ///< A sizing cursor pointing NE-SW.
  93     wxCURSOR_SIZENS,            ///< A sizing cursor pointing N-S.
  94     wxCURSOR_SIZENWSE,          ///< A sizing cursor pointing NW-SE.
  95     wxCURSOR_SIZEWE,            ///< A sizing cursor pointing W-E.
  96     wxCURSOR_SIZING,            ///< A general sizing cursor.
  97     wxCURSOR_SPRAYCAN,          ///< A spraycan cursor.
  98     wxCURSOR_WAIT,              ///< A wait cursor.
  99     wxCURSOR_WATCH,             ///< A watch cursor.
 100     wxCURSOR_BLANK,             ///< Transparent cursor.
 101     wxCURSOR_DEFAULT,           ///< Standard X11 cursor (only in wxGTK).
 102     wxCURSOR_COPY_ARROW ,       ///< MacOS Theme Plus arrow (only in wxMac).
 103     wxCURSOR_CROSS_REVERSE,     ///< Only available on wxX11.
 104     wxCURSOR_DOUBLE_ARROW,      ///< Only available on wxX11.
 105     wxCURSOR_BASED_ARROW_UP,    ///< Only available on wxX11.
 106     wxCURSOR_BASED_ARROW_DOWN,  ///< Only available on wxX11.
 107     wxCURSOR_ARROWWAIT,         ///< A wait cursor with a standard arrow.
 108     wxCURSOR_MAX
 109 };
 110
 111
 112
 113 /**
 114     @class wxRealPoint
 115
 116     A wxRealPoint is a useful data structure for graphics operations.
 117
 118     It contains floating point @e x and @e y members.
 119     See wxPoint for an integer version.
 120
 121     Note that the coordinates stored inside a wxRealPoint object may be negative
 122     and that wxRealPoint functions do not perform any check against negative values.
 123
 124     @library{wxcore}
 125     @category{data}
 126
 127     @see wxPoint
 128 */
 129 class wxRealPoint
 130 {
 131 public:
 132     /**
 133         Initializes to zero the x and y members.
 134     */
 135     wxRealPoint();
 136
 137     /**
 138         Initializes the point with the given coordinates.
 139     */
 140     wxRealPoint(double x, double y);
 141
 142     /**
 143         Converts the given wxPoint (with integer coordinates) to a wxRealPoint.
 144     */
 145     wxRealPoint(const wxPoint& pt);
 146
 147     /**
 148         @name Miscellaneous operators
 149
 150         Note that these operators are documented as class members
 151         (to make them easier to find) but, as their prototype shows,
 152         they are implemented as global operators; note that this is
 153         transparent to the user but it helps to understand why the
 154         following functions are documented to take the wxPoint they
 155         operate on as an explicit argument.
 156     */
 157     //@{
 158     wxRealPoint& operator=(const wxRealPoint& pt);
 159
 160     bool operator ==(const wxRealPoint& p1, const wxRealPoint& p2);
 161     bool operator !=(const wxRealPoint& p1, const wxRealPoint& p2);
 162
 163     wxRealPoint operator +(const wxRealPoint& p1, const wxRealPoint& p2);
 164     wxRealPoint operator -(const wxRealPoint& p1, const wxRealPoint& p2);
 165
 166     wxRealPoint& operator +=(const wxRealPoint& pt);
 167     wxRealPoint& operator -=(const wxRealPoint& pt);
 168
 169     wxRealPoint operator +(const wxRealPoint& pt, const wxSize& sz);
 170     wxRealPoint operator -(const wxRealPoint& pt, const wxSize& sz);
 171     wxRealPoint operator +(const wxSize& sz, const wxRealPoint& pt);
 172     wxRealPoint operator -(const wxSize& sz, const wxRealPoint& pt);
 173
 174     wxRealPoint& operator +=(const wxSize& sz);
 175     wxRealPoint& operator -=(const wxSize& sz);
 176
 177     wxSize operator /(const wxRealPoint& sz, int factor);
 178     wxSize operator *(const wxRealPoint& sz, int factor);
 179     wxSize operator *(int factor, const wxSize& sz);
 180     wxSize& operator /=(int factor);
 181     wxSize& operator *=(int factor);
 182     //@}
 183
 184     /**
 185         X coordinate of this point.
 186     */
 187     double x;
 188
 189     /**
 190         Y coordinate of this point.
 191     */
 192     double y;
 193 };
 194
 195
 196
 197 /**
 198     @class wxRect
 199
 200     A class for manipulating rectangles.
 201
 202     Note that the x, y coordinates and the width and height stored inside a wxRect
 203     object may be negative and that wxRect functions do not perform any check against
 204     negative values.
 205
 206     @library{wxcore}
 207     @category{data}
 208
 209     @see wxPoint, wxSize
 210 */
 211 class wxRect
 212 {
 213 public:
 214     /**
 215         Default constructor.
 216         Initializes to zero the internal @a x, @a y, @a width and @a height members.
 217     */
 218     wxRect();
 219     /**
 220         Creates a wxRect object from @a x, @a y, @a width and @a height values.
 221     */
 222     wxRect(int x, int y, int width, int height);
 223     /**
 224         Creates a wxRect object from top-left and bottom-right points.
 225     */
 226     wxRect(const wxPoint& topLeft, const wxPoint& bottomRight);
 227     /**
 228         Creates a wxRect object from position @a pos and @a size values.
 229     */
 230     wxRect(const wxPoint& pos, const wxSize& size);
 231     /**
 232         Creates a wxRect object from @a size values at the origin.
 233     */
 234     wxRect(const wxSize& size);
 235
 236     //@{
 237     /**
 238         Returns the rectangle having the same size as this one but centered
 239         relatively to the given rectangle @a r. By default, rectangle is
 240         centred in both directions but if @a dir includes only @c wxVERTICAL or
 241         only @c wxHORIZONTAL, then it is only centered in this direction while
 242         the other component of its position remains unchanged.
 243     */
 244     wxRect CentreIn(const wxRect& r, int dir = wxBOTH) const;
 245     wxRect CenterIn(const wxRect& r, int dir = wxBOTH) const;
 246     //@}
 247
 248     /**
 249         Returns @true if the given point is inside the rectangle (or on its
 250         boundary) and @false otherwise.
 251     */
 252     bool Contains(int x, int y) const;
 253     /**
 254         Returns @true if the given point is inside the rectangle (or on its
 255         boundary) and @false otherwise.
 256     */
 257     bool Contains(const wxPoint& pt) const;
 258     /**
 259         Returns @true if the given rectangle is completely inside this
 260         rectangle (or touches its boundary) and @false otherwise.
 261     */
 262     bool Contains(const wxRect& rect) const;
 263
 264     //@{
 265     /**
 266         Decrease the rectangle size.
 267
 268         This method is the opposite from Inflate(): Deflate(a, b) is equivalent
 269         to Inflate(-a, -b). Please refer to Inflate() for full description.
 270     */
 271     wxRect& Deflate(wxCoord dx, wxCoord dy);
 272     wxRect& Deflate(const wxSize& diff);
 273     wxRect& Deflate(wxCoord diff);
 274     wxRect  Deflate(wxCoord dx, wxCoord dy) const;
 275     //@}
 276
 277     /**
 278         Gets the bottom point of the rectangle.
 279     */
 280     int GetBottom() const;
 281
 282     /**
 283         Gets the position of the bottom left corner.
 284     */
 285     wxPoint GetBottomLeft() const;
 286
 287     /**
 288         Gets the position of the bottom right corner.
 289     */
 290     wxPoint GetBottomRight() const;
 291
 292     /**
 293         Gets the height member.
 294     */
 295     int GetHeight() const;
 296
 297     /**
 298         Gets the left point of the rectangle (the same as GetX()).
 299     */
 300     int GetLeft() const;
 301
 302     /**
 303         Gets the position.
 304     */
 305     wxPoint GetPosition() const;
 306
 307     /**
 308         Gets the right point of the rectangle.
 309     */
 310     int GetRight() const;
 311
 312     /**
 313         Gets the size.
 314
 315         @see SetSize()
 316     */
 317     wxSize GetSize() const;
 318
 319     /**
 320         Gets the top point of the rectangle (the same as GetY()).
 321     */
 322     int GetTop() const;
 323
 324     /**
 325         Gets the position of the top left corner of the rectangle, same as
 326         GetPosition().
 327     */
 328     wxPoint GetTopLeft() const;
 329
 330     /**
 331         Gets the position of the top right corner.
 332     */
 333     wxPoint GetTopRight() const;
 334
 335     /**
 336         Gets the width member.
 337     */
 338     int GetWidth() const;
 339
 340     /**
 341         Gets the x member.
 342     */
 343     int GetX() const;
 344
 345     /**
 346         Gets the y member.
 347     */
 348     int GetY() const;
 349
 350     //@{
 351     /**
 352         Increases the size of the rectangle.
 353
 354         The left border is moved farther left and the right border is moved
 355         farther right by @a dx. The upper border is moved farther up and the
 356         bottom border is moved farther down by @a dy. (Note that the width and
 357         height of the rectangle thus change by 2*dx and 2*dy, respectively.) If
 358         one or both of @a dx and @a dy are negative, the opposite happens: the
 359         rectangle size decreases in the respective direction.
 360
 361         Inflating and deflating behaves "naturally". Defined more precisely,
 362         that means:
 363         -# "Real" inflates (that is, @a dx and/or @a dy = 0) are not
 364            constrained. Thus inflating a rectangle can cause its upper left
 365            corner to move into the negative numbers. (2.5.4 and older forced
 366            the top left coordinate to not fall below (0, 0), which implied a
 367            forced move of the rectangle.)
 368         -# Deflates are clamped to not reduce the width or height of the
 369            rectangle below zero. In such cases, the top-left corner is
 370            nonetheless handled properly. For example, a rectangle at (10, 10)
 371            with size (20, 40) that is inflated by (-15, -15) will become
 372            located at (20, 25) at size (0, 10). Finally, observe that the width
 373            and height are treated independently. In the above example, the
 374            width is reduced by 20, whereas the height is reduced by the full 30
 375            (rather than also stopping at 20, when the width reached zero).
 376
 377         @see Deflate()
 378     */
 379     wxRect& Inflate(wxCoord dx, wxCoord dy);
 380     wxRect& Inflate(const wxSize& diff);
 381     wxRect& Inflate(wxCoord diff);
 382     wxRect Inflate(wxCoord dx, wxCoord dy) const;
 383     //@}
 384
 385     /**
 386         Modifies this rectangle to contain the overlapping portion of this rectangle
 387         and the one passed in as parameter.
 388
 389         @return This rectangle, modified.
 390     */
 391     wxRect& Intersect(const wxRect& rect);
 392
 393     /**
 394         Returns the overlapping portion of this rectangle and the one passed in as
 395         parameter.
 396     */
 397     wxRect Intersect(const wxRect& rect) const;
 398
 399     /**
 400         Returns @true if this rectangle has a non-empty intersection with the
 401         rectangle @a rect and @false otherwise.
 402     */
 403     bool Intersects(const wxRect& rect) const;
 404
 405     /**
 406         Returns @true if this rectangle has a width or height less than or
 407         equal to 0 and @false otherwise.
 408     */
 409     bool IsEmpty() const;
 410
 411     //@{
 412     /**
 413         Moves the rectangle by the specified offset. If @a dx is positive, the
 414         rectangle is moved to the right, if @a dy is positive, it is moved to the
 415         bottom, otherwise it is moved to the left or top respectively.
 416     */
 417     void Offset(wxCoord dx, wxCoord dy);
 418     void Offset(const wxPoint& pt);
 419     //@}
 420
 421     /**
 422         Sets the height.
 423     */
 424     void SetHeight(int height);
 425
 426     /**
 427         Sets the size.
 428
 429         @see GetSize()
 430     */
 431     void SetSize(const wxSize& s);
 432
 433     /**
 434         Sets the width.
 435     */
 436     void SetWidth(int width);
 437
 438     /**
 439         Sets the x position.
 440     */
 441     void SetX(int x);
 442
 443     /**
 444         Sets the y position.
 445     */
 446     void SetY(int y);
 447
 448     //@{
 449     /**
 450         Modifies the rectangle to contain the bounding box of this rectangle
 451         and the one passed in as parameter.
 452     */
 453     wxRect Union(const wxRect& rect) const;
 454     wxRect& Union(const wxRect& rect);
 455     //@}
 456
 457     /**
 458         Inequality operator.
 459     */
 460     bool operator !=(const wxRect& r1, const wxRect& r2);
 461
 462     //@{
 463     /**
 464         Like Union(), but doesn't treat empty rectangles specially.
 465     */
 466     wxRect operator +(const wxRect& r1, const wxRect& r2);
 467     wxRect& operator +=(const wxRect& r);
 468     //@}
 469
 470     //@{
 471     /**
 472         Returns the intersection of two rectangles (which may be empty).
 473     */
 474     wxRect operator *(const wxRect& r1, const wxRect& r2);
 475     wxRect& operator *=(const wxRect& r);
 476     //@}
 477
 478     /**
 479         Assignment operator.
 480     */
 481     wxRect& operator=(const wxRect& rect);
 482
 483     /**
 484         Equality operator.
 485     */
 486     bool operator ==(const wxRect& r1, const wxRect& r2);
 487
 488     /**
 489         Height member.
 490     */
 491     int height;
 492
 493     /**
 494         Width member.
 495     */
 496     int width;
 497
 498     /**
 499         x coordinate of the top-level corner of the rectangle.
 500     */
 501     int x;
 502
 503     /**
 504         y coordinate of the top-level corner of the rectangle.
 505     */
 506     int y;
 507 };
 508
 509
 510
 511 /**
 512     @class wxPoint
 513
 514     A wxPoint is a useful data structure for graphics operations.
 515
 516     It contains integer @e x and @e y members.
 517     See wxRealPoint for a floating point version.
 518
 519     Note that the width and height stored inside a wxPoint object may be negative
 520     and that wxPoint functions do not perform any check against negative values
 521     (this is used to e.g. store the special -1 value in ::wxDefaultPosition instance).
 522
 523     @library{wxcore}
 524     @category{data}
 525
 526     @stdobjects
 527     ::wxDefaultPosition
 528
 529     @see wxRealPoint
 530 */
 531 class wxPoint
 532 {
 533 public:
 534     /**
 535         Constructs a point.
 536         Initializes the internal x and y coordinates to zero.
 537     */
 538     wxPoint();
 539
 540     /**
 541         Initializes the point object with the given @a x and @a y coordinates.
 542     */
 543     wxPoint(int x, int y);
 544
 545     /**
 546         Converts the given wxRealPoint (with floating point coordinates) to a
 547         wxPoint instance.
 548     */
 549     wxPoint(const wxRealPoint& pt);
 550
 551     /**
 552         @name Miscellaneous operators
 553
 554         Note that these operators are documented as class members
 555         (to make them easier to find) but, as their prototype shows,
 556         they are implemented as global operators; note that this is
 557         transparent to the user but it helps to understand why the
 558         following functions are documented to take the wxPoint they
 559         operate on as an explicit argument.
 560     */
 561     //@{
 562     wxPoint& operator=(const wxPoint& pt);
 563
 564     bool operator ==(const wxPoint& p1, const wxPoint& p2);
 565     bool operator !=(const wxPoint& p1, const wxPoint& p2);
 566
 567     wxPoint operator +(const wxPoint& p1, const wxPoint& p2);
 568     wxPoint operator -(const wxPoint& p1, const wxPoint& p2);
 569
 570     wxPoint& operator +=(const wxPoint& pt);
 571     wxPoint& operator -=(const wxPoint& pt);
 572
 573     wxPoint operator +(const wxPoint& pt, const wxSize& sz);
 574     wxPoint operator -(const wxPoint& pt, const wxSize& sz);
 575     wxPoint operator +(const wxSize& sz, const wxPoint& pt);
 576     wxPoint operator -(const wxSize& sz, const wxPoint& pt);
 577
 578     wxPoint& operator +=(const wxSize& sz);
 579     wxPoint& operator -=(const wxSize& sz);
 580
 581     wxSize operator /(const wxPoint& sz, int factor);
 582     wxSize operator *(const wxPoint& sz, int factor);
 583     wxSize operator *(int factor, const wxSize& sz);
 584     wxSize& operator /=(int factor);
 585     wxSize& operator *=(int factor);
 586     //@}
 587
 588
 589     /**
 590         @name Defaults handling.
 591
 592         Test for and set non-specified wxPoint components.
 593
 594         Although a wxPoint is always initialized to (0, 0), wxWidgets commonly
 595         uses wxDefaultCoord (defined as @c -1) to indicate that a point hasn't
 596         been initialized or specified. In particular, ::wxDefaultPosition is
 597         used in many places with this meaning.
 598      */
 599     //@{
 600
 601     /**
 602         Returns @true if neither of the point components is equal to
 603         wxDefaultCoord.
 604
 605         This method is typically used before calling SetDefaults().
 606
 607         @since 2.9.2
 608     */
 609     bool IsFullySpecified() const;
 610
 611     /**
 612         Combine this object with another one replacing the uninitialized
 613         values.
 614
 615         It is typically used like this:
 616
 617         @code
 618         if ( !pos.IsFullySpecified() )
 619         {
 620             pos.SetDefaults(GetDefaultPosition());
 621         }
 622         @endcode
 623
 624         @see IsFullySpecified()
 625
 626         @since 2.9.2
 627     */
 628     void SetDefaults(const wxPoint& pt);
 629     //@}
 630
 631     /**
 632         x member.
 633     */
 634     int x;
 635
 636     /**
 637         y member.
 638     */
 639     int  y;
 640 };
 641
 642 /**
 643     Global instance of a wxPoint initialized with values (-1,-1).
 644 */
 645 const wxPoint wxDefaultPosition;
 646
 647
 648 /**
 649     @class wxColourDatabase
 650
 651     wxWidgets maintains a database of standard RGB colours for a predefined
 652     set of named colours. The application may add to this set if desired by
 653     using AddColour() and may use it to look up colours by names using Find()
 654     or find the names for the standard colour using FindName().
 655
 656     There is one predefined, global instance of this class called
 657     ::wxTheColourDatabase.
 658
 659     The standard database contains at least the following colours:
 660
 661     @beginTable
 662     <tr><td>
 663        AQUAMARINE
 664     @n BLACK
 665     @n BLUE
 666     @n BLUE VIOLET
 667     @n BROWN
 668     @n CADET BLUE
 669     @n CORAL
 670     @n CORNFLOWER BLUE
 671     @n CYAN
 672     @n DARK GREY
 673     @n DARK GREEN
 674     @n DARK OLIVE GREEN
 675     @n DARK ORCHID
 676     @n DARK SLATE BLUE
 677     @n DARK SLATE GREY
 678     @n DARK TURQUOISE
 679     @n DIM GREY
 680     </td><td>
 681        FIREBRICK
 682     @n FOREST GREEN
 683     @n GOLD
 684     @n GOLDENROD
 685     @n GREY
 686     @n GREEN
 687     @n GREEN YELLOW
 688     @n INDIAN RED
 689     @n KHAKI
 690     @n LIGHT BLUE
 691     @n LIGHT GREY
 692     @n LIGHT STEEL BLUE
 693     @n LIME GREEN
 694     @n MAGENTA
 695     @n MAROON
 696     @n MEDIUM AQUAMARINE
 697     @n MEDIUM BLUE
 698     </td><td>
 699        MEDIUM FOREST GREEN
 700     @n MEDIUM GOLDENROD
 701     @n MEDIUM ORCHID
 702     @n MEDIUM SEA GREEN
 703     @n MEDIUM SLATE BLUE
 704     @n MEDIUM SPRING GREEN
 705     @n MEDIUM TURQUOISE
 706     @n MEDIUM VIOLET RED
 707     @n MIDNIGHT BLUE
 708     @n NAVY
 709     @n ORANGE
 710     @n ORANGE RED
 711     @n ORCHID
 712     @n PALE GREEN
 713     @n PINK
 714     @n PLUM
 715     @n PURPLE
 716     </td><td>
 717        RED
 718     @n SALMON
 719     @n SEA GREEN
 720     @n SIENNA
 721     @n SKY BLUE
 722     @n SLATE BLUE
 723     @n SPRING GREEN
 724     @n STEEL BLUE
 725     @n TAN
 726     @n THISTLE
 727     @n TURQUOISE
 728     @n VIOLET
 729     @n VIOLET RED
 730     @n WHEAT
 731     @n WHITE
 732     @n YELLOW
 733     @n YELLOW GREEN
 734     </td></tr>
 735     @endTable
 736
 737     @library{wxcore}
 738     @category{gdi}
 739
 740     @see wxColour
 741 */
 742 class wxColourDatabase
 743 {
 744 public:
 745     /**
 746         Constructs the colour database. It will be initialized at the first
 747         use.
 748     */
 749     wxColourDatabase();
 750
 751     /**
 752         Adds a colour to the database. If a colour with the same name already
 753         exists, it is replaced.
 754     */
 755     void AddColour(const wxString& colourName, const wxColour& colour);
 756
 757     /**
 758         Finds a colour given the name. Returns an invalid colour object (that
 759         is, wxColour::IsOk() will return @false) if the colour wasn't found in
 760         the database.
 761     */
 762     wxColour Find(const wxString& colourName) const;
 763
 764     /**
 765         Finds a colour name given the colour. Returns an empty string if the
 766         colour is not found in the database.
 767     */
 768     wxString FindName(const wxColour& colour) const;
 769 };
 770
 771
 772 /**
 773     Global instance of a wxColourDatabase.
 774 */
 775 wxColourDatabase* wxTheColourDatabase;
 776
 777
 778 /**
 779     @class wxSize
 780
 781     A wxSize is a useful data structure for graphics operations.
 782     It simply contains integer @e width and @e height members.
 783
 784     Note that the width and height stored inside a wxSize object may be negative
 785     and that wxSize functions do not perform any check against negative values
 786     (this is used to e.g. store the special -1 value in ::wxDefaultSize instance).
 787     See also IsFullySpecified() and SetDefaults() for utility functions regarding
 788     the special -1 value.
 789
 790     wxSize is used throughout wxWidgets as well as wxPoint which, although
 791     almost equivalent to wxSize, has a different meaning: wxPoint represents a
 792     position while wxSize represents the size.
 793
 794     @beginWxPythonOnly
 795     wxPython defines aliases for the @e x and @e y members named @e width and
 796     @e height since it makes much more sense for sizes.
 797     @endWxPythonOnly
 798
 799     @library{wxcore}
 800     @category{data}
 801
 802     @stdobjects
 803     ::wxDefaultSize
 804
 805     @see wxPoint, wxRealPoint
 806 */
 807 class wxSize
 808 {
 809 public:
 810     /**
 811         Initializes this size object with zero width and height.
 812     */
 813     wxSize();
 814
 815     /**
 816         Initializes this size object with the given @a width and @a height.
 817     */
 818     wxSize(int width, int height);
 819
 820     //@{
 821     /**
 822         Decreases the size in both x and y directions.
 823
 824         @see IncBy()
 825     */
 826     void DecBy(const wxPoint& pt);
 827     void DecBy(const wxSize& size);
 828     void DecBy(int dx, int dy);
 829     void DecBy(int d);
 830     //@}
 831
 832     /**
 833         Decrements this object so that both of its dimensions are not greater
 834         than the corresponding dimensions of the @a size.
 835
 836         @see IncTo()
 837     */
 838     void DecTo(const wxSize& size);
 839
 840     /**
 841         Gets the height member.
 842     */
 843     int GetHeight() const;
 844
 845     /**
 846         Gets the width member.
 847     */
 848     int GetWidth() const;
 849
 850     //@{
 851     /**
 852         Increases the size in both x and y directions.
 853
 854         @see DecBy()
 855     */
 856     void IncBy(const wxPoint& pt);
 857     void IncBy(const wxSize& size);
 858     void IncBy(int dx, int dy);
 859     void IncBy(int d);
 860     //@}
 861
 862     /**
 863         Increments this object so that both of its dimensions are not less than
 864         the corresponding dimensions of the @a size.
 865
 866         @see DecTo()
 867     */
 868     void IncTo(const wxSize& size);
 869
 870     /**
 871         Returns @true if neither of the size object components is equal to -1,
 872         which is used as default for the size values in wxWidgets (hence the
 873         predefined ::wxDefaultSize has both of its components equal to -1).
 874
 875         This method is typically used before calling SetDefaults().
 876     */
 877     bool IsFullySpecified() const;
 878
 879     /**
 880         Scales the dimensions of this object by the given factors. If you want
 881         to scale both dimensions by the same factor you can also use
 882         operator*=().
 883
 884         @return A reference to this object (so that you can concatenate other
 885                  operations in the same line).
 886     */
 887     wxSize& Scale(float xscale, float yscale);
 888
 889     /**
 890         Sets the width and height members.
 891     */
 892     void Set(int width, int height);
 893
 894     /**
 895         Combine this size object with another one replacing the default (i.e.
 896         equal to -1) components of this object with those of the other. It is
 897         typically used like this:
 898
 899         @code
 900         if ( !size.IsFullySpecified() )
 901         {
 902             size.SetDefaults(GetDefaultSize());
 903         }
 904         @endcode
 905
 906         @see IsFullySpecified()
 907     */
 908     void SetDefaults(const wxSize& sizeDefault);
 909
 910     /**
 911         Sets the height.
 912     */
 913     void SetHeight(int height);
 914
 915     /**
 916         Sets the width.
 917     */
 918     void SetWidth(int width);
 919
 920
 921     /**
 922         @name Miscellaneous operators
 923
 924         Note that these operators are documented as class members
 925         (to make them easier to find) but, as their prototype shows,
 926         they are implemented as global operators; note that this is
 927         transparent to the user but it helps to understand why the
 928         following functions are documented to take the wxSize they
 929         operate on as an explicit argument.
 930     */
 931     //@{
 932     wxSize& operator=(const wxSize& sz);
 933
 934     bool operator ==(const wxSize& s1, const wxSize& s2);
 935     bool operator !=(const wxSize& s1, const wxSize& s2);
 936
 937     wxSize operator +(const wxSize& s1, const wxSize& s2);
 938     wxSize operator -(const wxSize& s1, const wxSize& s2);
 939     wxSize& operator +=(const wxSize& sz);
 940     wxSize& operator -=(const wxSize& sz);
 941
 942     wxSize operator /(const wxSize& sz, int factor);
 943     wxSize operator *(const wxSize& sz, int factor);
 944     wxSize operator *(int factor, const wxSize& sz);
 945     wxSize& operator /=(int factor);
 946     wxSize& operator *=(int factor);
 947     //@}
 948 };
 949
 950 /**
 951     Global instance of a wxSize object initialized to (-1,-1).
 952 */
 953 const wxSize wxDefaultSize;
 954
 955
 956
 957
 958 // ============================================================================
 959 // Global functions/macros
 960 // ============================================================================
 961
 962 /** @addtogroup group_funcmacro_gdi */
 963 //@{
 964
 965 /**
 966     This macro loads a bitmap from either application resources (on the
 967     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
 968     This can help to avoid using @ifdef_ when creating bitmaps.
 969
 970     @see @ref overview_bitmap, wxICON()
 971
 972     @header{wx/gdicmn.h}
 973 */
 974 #define wxBITMAP(bitmapName)
 975
 976 /**
 977     This macro loads an icon from either application resources (on the
 978     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
 979     This can help to avoid using @ifdef_ when creating icons.
 980
 981     @see @ref overview_bitmap, wxBITMAP()
 982
 983     @header{wx/gdicmn.h}
 984 */
 985 #define wxICON(iconName)
 986
 987 /**
 988     Returns @true if the display is colour, @false otherwise.
 989
 990     @header{wx/gdicmn.h}
 991 */
 992 bool wxColourDisplay();
 993
 994 /**
 995     Returns the depth of the display (a value of 1 denotes a monochrome
 996     display).
 997
 998     @header{wx/gdicmn.h}
 999 */
1000 int wxDisplayDepth();
1001
1002 /**
1003     Globally sets the cursor; only has an effect on Windows, Mac and GTK+. You
1004     should call this function with wxNullCursor to restore the system cursor.
1005
1006     @see wxCursor, wxWindow::SetCursor()
1007
1008     @header{wx/gdicmn.h}
1009 */
1010 void wxSetCursor(const wxCursor& cursor);
1011
1012 //@}
1013
1014 /** @addtogroup group_funcmacro_gdi */
1015 //@{
1016 /**
1017     Returns the dimensions of the work area on the display. On Windows this
1018     means the area not covered by the taskbar, etc. Other platforms are
1019     currently defaulting to the whole display until a way is found to provide
1020     this info for all window managers, etc.
1021
1022     @header{wx/gdicmn.h}
1023 */
1024 void wxClientDisplayRect(int* x, int* y, int* width, int* height);
1025 wxRect wxGetClientDisplayRect();
1026 //@}
1027
1028 /** @addtogroup group_funcmacro_gdi */
1029 //@{
1030 /**
1031     Returns the display resolution in pixels per inch.
1032
1033     The @c x component of the returned wxSize object contains the horizontal
1034     resolution and the @c y one -- the vertical resolution.
1035
1036     @header{wx/gdicmn.h}
1037
1038     @since 2.9.0
1039 */
1040 wxSize wxGetDisplayPPI();
1041 //@}
1042
1043 /** @addtogroup group_funcmacro_gdi */
1044 //@{
1045 /**
1046     Returns the display size in pixels.
1047
1048     For the version taking @a width and @a header arguments, either of them
1049     can be @NULL if the caller is not interested in the returned value.
1050
1051     @header{wx/gdicmn.h}
1052 */
1053 void wxDisplaySize(int* width, int* height);
1054 wxSize wxGetDisplaySize();
1055 //@}
1056
1057 /** @addtogroup group_funcmacro_gdi */
1058 //@{
1059 /**
1060     Returns the display size in millimeters.
1061
1062     For the version taking @a width and @a header arguments, either of them
1063     can be @NULL if the caller is not interested in the returned value.
1064
1065     @see wxGetDisplayPPI()
1066
1067     @header{wx/gdicmn.h}
1068 */
1069 void wxDisplaySizeMM(int* width, int* height);
1070 wxSize wxGetDisplaySizeMM();
1071 //@}
1072