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        Set the left side of the rectangle.
 450     */
 451     void SetLeft(int left);
 452
 453     /**
 454        Set the right side of the rectangle.
 455      */
 456     void SetRight(int right);
 457
 458     /**
 459        Set the top edge of the rectangle.
 460      */
 461     void SetTop(int top);
 462
 463     /**
 464        Set the bottome edge of th rectangle.
 465      */
 466     void SetBottom(int bottom);
 467
 468     /**
 469        Set the top-left point of the rectangle.
 470      */
 471     void SetTopLeft(const wxPoint &p);
 472
 473     /**
 474        Set the bottom-right point of the rectangle.
 475      */
 476     void SetBottomRight(const wxPoint &p);
 477
 478     /**
 479        Set the top-right point of the rectangle.
 480      */
 481     void SetTopRight(const wxPoint &p);
 482
 483     /**
 484        Set the bottom-left point of the rectangle.
 485      */
 486     void SetBottomLeft(const wxPoint &p);
 487
 488
 489     //@{
 490     /**
 491         Modifies the rectangle to contain the bounding box of this rectangle
 492         and the one passed in as parameter.
 493     */
 494     wxRect Union(const wxRect& rect) const;
 495     wxRect& Union(const wxRect& rect);
 496     //@}
 497
 498     /**
 499         Inequality operator.
 500     */
 501     bool operator !=(const wxRect& r1, const wxRect& r2);
 502
 503     //@{
 504     /**
 505         Like Union(), but doesn't treat empty rectangles specially.
 506     */
 507     wxRect operator +(const wxRect& r1, const wxRect& r2);
 508     wxRect& operator +=(const wxRect& r);
 509     //@}
 510
 511     //@{
 512     /**
 513         Returns the intersection of two rectangles (which may be empty).
 514     */
 515     wxRect operator *(const wxRect& r1, const wxRect& r2);
 516     wxRect& operator *=(const wxRect& r);
 517     //@}
 518
 519     /**
 520         Assignment operator.
 521     */
 522     wxRect& operator=(const wxRect& rect);
 523
 524     /**
 525         Equality operator.
 526     */
 527     bool operator ==(const wxRect& r1, const wxRect& r2);
 528
 529     /**
 530         Height member.
 531     */
 532     int height;
 533
 534     /**
 535         Width member.
 536     */
 537     int width;
 538
 539     /**
 540         x coordinate of the top-level corner of the rectangle.
 541     */
 542     int x;
 543
 544     /**
 545         y coordinate of the top-level corner of the rectangle.
 546     */
 547     int y;
 548 };
 549
 550
 551
 552 /**
 553     @class wxPoint
 554
 555     A wxPoint is a useful data structure for graphics operations.
 556
 557     It contains integer @e x and @e y members.
 558     See wxRealPoint for a floating point version.
 559
 560     Note that the width and height stored inside a wxPoint object may be negative
 561     and that wxPoint functions do not perform any check against negative values
 562     (this is used to e.g. store the special -1 value in ::wxDefaultPosition instance).
 563
 564     @library{wxcore}
 565     @category{data}
 566
 567     @stdobjects
 568     ::wxDefaultPosition
 569
 570     @see wxRealPoint
 571 */
 572 class wxPoint
 573 {
 574 public:
 575     /**
 576         Constructs a point.
 577         Initializes the internal x and y coordinates to zero.
 578     */
 579     wxPoint();
 580
 581     /**
 582         Initializes the point object with the given @a x and @a y coordinates.
 583     */
 584     wxPoint(int x, int y);
 585
 586     /**
 587         Converts the given wxRealPoint (with floating point coordinates) to a
 588         wxPoint instance.
 589     */
 590     wxPoint(const wxRealPoint& pt);
 591
 592     /**
 593         @name Miscellaneous operators
 594
 595         Note that these operators are documented as class members
 596         (to make them easier to find) but, as their prototype shows,
 597         they are implemented as global operators; note that this is
 598         transparent to the user but it helps to understand why the
 599         following functions are documented to take the wxPoint they
 600         operate on as an explicit argument.
 601     */
 602     //@{
 603     wxPoint& operator=(const wxPoint& pt);
 604
 605     bool operator ==(const wxPoint& p1, const wxPoint& p2);
 606     bool operator !=(const wxPoint& p1, const wxPoint& p2);
 607
 608     wxPoint operator +(const wxPoint& p1, const wxPoint& p2);
 609     wxPoint operator -(const wxPoint& p1, const wxPoint& p2);
 610
 611     wxPoint& operator +=(const wxPoint& pt);
 612     wxPoint& operator -=(const wxPoint& pt);
 613
 614     wxPoint operator +(const wxPoint& pt, const wxSize& sz);
 615     wxPoint operator -(const wxPoint& pt, const wxSize& sz);
 616     wxPoint operator +(const wxSize& sz, const wxPoint& pt);
 617     wxPoint operator -(const wxSize& sz, const wxPoint& pt);
 618
 619     wxPoint& operator +=(const wxSize& sz);
 620     wxPoint& operator -=(const wxSize& sz);
 621
 622     wxSize operator /(const wxPoint& sz, int factor);
 623     wxSize operator *(const wxPoint& sz, int factor);
 624     wxSize operator *(int factor, const wxSize& sz);
 625     wxSize& operator /=(int factor);
 626     wxSize& operator *=(int factor);
 627     //@}
 628
 629
 630     /**
 631         @name Defaults handling.
 632
 633         Test for and set non-specified wxPoint components.
 634
 635         Although a wxPoint is always initialized to (0, 0), wxWidgets commonly
 636         uses wxDefaultCoord (defined as @c -1) to indicate that a point hasn't
 637         been initialized or specified. In particular, ::wxDefaultPosition is
 638         used in many places with this meaning.
 639      */
 640     //@{
 641
 642     /**
 643         Returns @true if neither of the point components is equal to
 644         wxDefaultCoord.
 645
 646         This method is typically used before calling SetDefaults().
 647
 648         @since 2.9.2
 649     */
 650     bool IsFullySpecified() const;
 651
 652     /**
 653         Combine this object with another one replacing the uninitialized
 654         values.
 655
 656         It is typically used like this:
 657
 658         @code
 659         if ( !pos.IsFullySpecified() )
 660         {
 661             pos.SetDefaults(GetDefaultPosition());
 662         }
 663         @endcode
 664
 665         @see IsFullySpecified()
 666
 667         @since 2.9.2
 668     */
 669     void SetDefaults(const wxPoint& pt);
 670     //@}
 671
 672     /**
 673         x member.
 674     */
 675     int x;
 676
 677     /**
 678         y member.
 679     */
 680     int  y;
 681 };
 682
 683 /**
 684     Global instance of a wxPoint initialized with values (-1,-1).
 685 */
 686 const wxPoint wxDefaultPosition;
 687
 688
 689 /**
 690     @class wxColourDatabase
 691
 692     wxWidgets maintains a database of standard RGB colours for a predefined
 693     set of named colours. The application may add to this set if desired by
 694     using AddColour() and may use it to look up colours by names using Find()
 695     or find the names for the standard colour using FindName().
 696
 697     There is one predefined, global instance of this class called
 698     ::wxTheColourDatabase.
 699
 700     The standard database contains at least the following colours:
 701
 702     @beginTable
 703     <tr><td>
 704        AQUAMARINE
 705     @n BLACK
 706     @n BLUE
 707     @n BLUE VIOLET
 708     @n BROWN
 709     @n CADET BLUE
 710     @n CORAL
 711     @n CORNFLOWER BLUE
 712     @n CYAN
 713     @n DARK GREY
 714     @n DARK GREEN
 715     @n DARK OLIVE GREEN
 716     @n DARK ORCHID
 717     @n DARK SLATE BLUE
 718     @n DARK SLATE GREY
 719     @n DARK TURQUOISE
 720     @n DIM GREY
 721     </td><td>
 722        FIREBRICK
 723     @n FOREST GREEN
 724     @n GOLD
 725     @n GOLDENROD
 726     @n GREY
 727     @n GREEN
 728     @n GREEN YELLOW
 729     @n INDIAN RED
 730     @n KHAKI
 731     @n LIGHT BLUE
 732     @n LIGHT GREY
 733     @n LIGHT STEEL BLUE
 734     @n LIME GREEN
 735     @n MAGENTA
 736     @n MAROON
 737     @n MEDIUM AQUAMARINE
 738     @n MEDIUM BLUE
 739     </td><td>
 740        MEDIUM FOREST GREEN
 741     @n MEDIUM GOLDENROD
 742     @n MEDIUM ORCHID
 743     @n MEDIUM SEA GREEN
 744     @n MEDIUM SLATE BLUE
 745     @n MEDIUM SPRING GREEN
 746     @n MEDIUM TURQUOISE
 747     @n MEDIUM VIOLET RED
 748     @n MIDNIGHT BLUE
 749     @n NAVY
 750     @n ORANGE
 751     @n ORANGE RED
 752     @n ORCHID
 753     @n PALE GREEN
 754     @n PINK
 755     @n PLUM
 756     @n PURPLE
 757     </td><td>
 758        RED
 759     @n SALMON
 760     @n SEA GREEN
 761     @n SIENNA
 762     @n SKY BLUE
 763     @n SLATE BLUE
 764     @n SPRING GREEN
 765     @n STEEL BLUE
 766     @n TAN
 767     @n THISTLE
 768     @n TURQUOISE
 769     @n VIOLET
 770     @n VIOLET RED
 771     @n WHEAT
 772     @n WHITE
 773     @n YELLOW
 774     @n YELLOW GREEN
 775     </td></tr>
 776     @endTable
 777
 778     @library{wxcore}
 779     @category{gdi}
 780
 781     @see wxColour
 782 */
 783 class wxColourDatabase
 784 {
 785 public:
 786     /**
 787         Constructs the colour database. It will be initialized at the first
 788         use.
 789     */
 790     wxColourDatabase();
 791
 792     /**
 793         Adds a colour to the database. If a colour with the same name already
 794         exists, it is replaced.
 795     */
 796     void AddColour(const wxString& colourName, const wxColour& colour);
 797
 798     /**
 799         Finds a colour given the name. Returns an invalid colour object (that
 800         is, wxColour::IsOk() will return @false) if the colour wasn't found in
 801         the database.
 802     */
 803     wxColour Find(const wxString& colourName) const;
 804
 805     /**
 806         Finds a colour name given the colour. Returns an empty string if the
 807         colour is not found in the database.
 808     */
 809     wxString FindName(const wxColour& colour) const;
 810 };
 811
 812
 813 /**
 814     Global instance of a wxColourDatabase.
 815 */
 816 wxColourDatabase* wxTheColourDatabase;
 817
 818
 819 /**
 820     @class wxSize
 821
 822     A wxSize is a useful data structure for graphics operations.
 823     It simply contains integer @e width and @e height members.
 824
 825     Note that the width and height stored inside a wxSize object may be negative
 826     and that wxSize functions do not perform any check against negative values
 827     (this is used to e.g. store the special -1 value in ::wxDefaultSize instance).
 828     See also IsFullySpecified() and SetDefaults() for utility functions regarding
 829     the special -1 value.
 830
 831     wxSize is used throughout wxWidgets as well as wxPoint which, although
 832     almost equivalent to wxSize, has a different meaning: wxPoint represents a
 833     position while wxSize represents the size.
 834
 835     @library{wxcore}
 836     @category{data}
 837
 838     @stdobjects
 839     ::wxDefaultSize
 840
 841     @see wxPoint, wxRealPoint
 842 */
 843 class wxSize
 844 {
 845 public:
 846     /**
 847         Initializes this size object with zero width and height.
 848     */
 849     wxSize();
 850
 851     /**
 852         Initializes this size object with the given @a width and @a height.
 853     */
 854     wxSize(int width, int height);
 855
 856     //@{
 857     /**
 858         Decreases the size in both x and y directions.
 859
 860         @see IncBy()
 861     */
 862     void DecBy(const wxPoint& pt);
 863     void DecBy(const wxSize& size);
 864     void DecBy(int dx, int dy);
 865     void DecBy(int d);
 866     //@}
 867
 868     /**
 869         Decrements this object so that both of its dimensions are not greater
 870         than the corresponding dimensions of the @a size.
 871
 872         @see IncTo()
 873     */
 874     void DecTo(const wxSize& size);
 875
 876     /**
 877         Gets the height member.
 878     */
 879     int GetHeight() const;
 880
 881     /**
 882         Gets the width member.
 883     */
 884     int GetWidth() const;
 885
 886     //@{
 887     /**
 888         Increases the size in both x and y directions.
 889
 890         @see DecBy()
 891     */
 892     void IncBy(const wxPoint& pt);
 893     void IncBy(const wxSize& size);
 894     void IncBy(int dx, int dy);
 895     void IncBy(int d);
 896     //@}
 897
 898     /**
 899         Increments this object so that both of its dimensions are not less than
 900         the corresponding dimensions of the @a size.
 901
 902         @see DecTo()
 903     */
 904     void IncTo(const wxSize& size);
 905
 906     /**
 907         Returns @true if neither of the size object components is equal to -1,
 908         which is used as default for the size values in wxWidgets (hence the
 909         predefined ::wxDefaultSize has both of its components equal to -1).
 910
 911         This method is typically used before calling SetDefaults().
 912     */
 913     bool IsFullySpecified() const;
 914
 915     /**
 916         Scales the dimensions of this object by the given factors. If you want
 917         to scale both dimensions by the same factor you can also use
 918         operator*=().
 919
 920         @return A reference to this object (so that you can concatenate other
 921                  operations in the same line).
 922     */
 923     wxSize& Scale(float xscale, float yscale);
 924
 925     /**
 926         Sets the width and height members.
 927     */
 928     void Set(int width, int height);
 929
 930     /**
 931         Combine this size object with another one replacing the default (i.e.
 932         equal to -1) components of this object with those of the other. It is
 933         typically used like this:
 934
 935         @code
 936         if ( !size.IsFullySpecified() )
 937         {
 938             size.SetDefaults(GetDefaultSize());
 939         }
 940         @endcode
 941
 942         @see IsFullySpecified()
 943     */
 944     void SetDefaults(const wxSize& sizeDefault);
 945
 946     /**
 947         Sets the height.
 948     */
 949     void SetHeight(int height);
 950
 951     /**
 952         Sets the width.
 953     */
 954     void SetWidth(int width);
 955
 956
 957     /**
 958         @name Miscellaneous operators
 959
 960         Note that these operators are documented as class members
 961         (to make them easier to find) but, as their prototype shows,
 962         they are implemented as global operators; note that this is
 963         transparent to the user but it helps to understand why the
 964         following functions are documented to take the wxSize they
 965         operate on as an explicit argument.
 966     */
 967     //@{
 968     wxSize& operator=(const wxSize& sz);
 969
 970     bool operator ==(const wxSize& s1, const wxSize& s2);
 971     bool operator !=(const wxSize& s1, const wxSize& s2);
 972
 973     wxSize operator +(const wxSize& s1, const wxSize& s2);
 974     wxSize operator -(const wxSize& s1, const wxSize& s2);
 975     wxSize& operator +=(const wxSize& sz);
 976     wxSize& operator -=(const wxSize& sz);
 977
 978     wxSize operator /(const wxSize& sz, int factor);
 979     wxSize operator *(const wxSize& sz, int factor);
 980     wxSize operator *(int factor, const wxSize& sz);
 981     wxSize& operator /=(int factor);
 982     wxSize& operator *=(int factor);
 983     //@}
 984 };
 985
 986 /**
 987     Global instance of a wxSize object initialized to (-1,-1).
 988 */
 989 const wxSize wxDefaultSize;
 990
 991
 992
 993
 994 // ============================================================================
 995 // Global functions/macros
 996 // ============================================================================
 997
 998 /** @addtogroup group_funcmacro_gdi */
 999 //@{
1000
1001 /**
1002     This macro loads a bitmap from either application resources (on the
1003     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
1004     This can help to avoid using @ifdef_ when creating bitmaps.
1005
1006     @see @ref overview_bitmap, wxICON()
1007
1008     @header{wx/gdicmn.h}
1009 */
1010 #define wxBITMAP(bitmapName)
1011
1012 /**
1013     This macro loads an icon from either application resources (on the
1014     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
1015     This can help to avoid using @ifdef_ when creating icons.
1016
1017     @see @ref overview_bitmap, wxBITMAP()
1018
1019     @header{wx/gdicmn.h}
1020 */
1021 #define wxICON(iconName)
1022
1023 /**
1024     Returns @true if the display is colour, @false otherwise.
1025
1026     @header{wx/gdicmn.h}
1027 */
1028 bool wxColourDisplay();
1029
1030 /**
1031     Returns the depth of the display (a value of 1 denotes a monochrome
1032     display).
1033
1034     @header{wx/gdicmn.h}
1035 */
1036 int wxDisplayDepth();
1037
1038 /**
1039     Globally sets the cursor; only has an effect on Windows, Mac and GTK+. You
1040     should call this function with wxNullCursor to restore the system cursor.
1041
1042     @see wxCursor, wxWindow::SetCursor()
1043
1044     @header{wx/gdicmn.h}
1045 */
1046 void wxSetCursor(const wxCursor& cursor);
1047
1048 //@}
1049
1050 /** @addtogroup group_funcmacro_gdi */
1051 //@{
1052 /**
1053     Returns the dimensions of the work area on the display. On Windows this
1054     means the area not covered by the taskbar, etc. Other platforms are
1055     currently defaulting to the whole display until a way is found to provide
1056     this info for all window managers, etc.
1057
1058     @header{wx/gdicmn.h}
1059 */
1060 void wxClientDisplayRect(int* x, int* y, int* width, int* height);
1061 wxRect wxGetClientDisplayRect();
1062 //@}
1063
1064 /** @addtogroup group_funcmacro_gdi */
1065 //@{
1066 /**
1067     Returns the display resolution in pixels per inch.
1068
1069     The @c x component of the returned wxSize object contains the horizontal
1070     resolution and the @c y one -- the vertical resolution.
1071
1072     @header{wx/gdicmn.h}
1073
1074     @since 2.9.0
1075 */
1076 wxSize wxGetDisplayPPI();
1077 //@}
1078
1079 /** @addtogroup group_funcmacro_gdi */
1080 //@{
1081 /**
1082     Returns the display size in pixels.
1083
1084     For the version taking @a width and @a header arguments, either of them
1085     can be @NULL if the caller is not interested in the returned value.
1086
1087     @header{wx/gdicmn.h}
1088 */
1089 void wxDisplaySize(int* width, int* height);
1090 wxSize wxGetDisplaySize();
1091 //@}
1092
1093 /** @addtogroup group_funcmacro_gdi */
1094 //@{
1095 /**
1096     Returns the display size in millimeters.
1097
1098     For the version taking @a width and @a header arguments, either of them
1099     can be @NULL if the caller is not interested in the returned value.
1100
1101     @see wxGetDisplayPPI()
1102
1103     @header{wx/gdicmn.h}
1104 */
1105 void wxDisplaySizeMM(int* width, int* height);
1106 wxSize wxGetDisplaySizeMM();
1107 //@}
1108