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         Decrements this object to be not bigger than the given size ignoring
 878         non-specified components.
 879
 880         This is similar to DecTo() but doesn't do anything for x or y
 881         component if the same component of @a size is not specified, i.e. set
 882         to ::wxDefaultCoord.
 883
 884         @since 2.9.5
 885      */
 886     void DecToIfSpecified(const wxSize& size);
 887
 888     /**
 889         Gets the height member.
 890     */
 891     int GetHeight() const;
 892
 893     /**
 894         Gets the width member.
 895     */
 896     int GetWidth() const;
 897
 898     //@{
 899     /**
 900         Increases the size in both x and y directions.
 901
 902         @see DecBy()
 903     */
 904     void IncBy(const wxPoint& pt);
 905     void IncBy(const wxSize& size);
 906     void IncBy(int dx, int dy);
 907     void IncBy(int d);
 908     //@}
 909
 910     /**
 911         Increments this object so that both of its dimensions are not less than
 912         the corresponding dimensions of the @a size.
 913
 914         @see DecTo()
 915     */
 916     void IncTo(const wxSize& size);
 917
 918     /**
 919         Returns @true if neither of the size object components is equal to -1,
 920         which is used as default for the size values in wxWidgets (hence the
 921         predefined ::wxDefaultSize has both of its components equal to -1).
 922
 923         This method is typically used before calling SetDefaults().
 924     */
 925     bool IsFullySpecified() const;
 926
 927     /**
 928         Scales the dimensions of this object by the given factors. If you want
 929         to scale both dimensions by the same factor you can also use
 930         operator*=().
 931
 932         @return A reference to this object (so that you can concatenate other
 933                  operations in the same line).
 934     */
 935     wxSize& Scale(float xscale, float yscale);
 936
 937     /**
 938         Sets the width and height members.
 939     */
 940     void Set(int width, int height);
 941
 942     /**
 943         Combine this size object with another one replacing the default (i.e.
 944         equal to -1) components of this object with those of the other. It is
 945         typically used like this:
 946
 947         @code
 948         if ( !size.IsFullySpecified() )
 949         {
 950             size.SetDefaults(GetDefaultSize());
 951         }
 952         @endcode
 953
 954         @see IsFullySpecified()
 955     */
 956     void SetDefaults(const wxSize& sizeDefault);
 957
 958     /**
 959         Sets the height.
 960     */
 961     void SetHeight(int height);
 962
 963     /**
 964         Sets the width.
 965     */
 966     void SetWidth(int width);
 967
 968
 969     /**
 970         @name Miscellaneous operators
 971
 972         Note that these operators are documented as class members
 973         (to make them easier to find) but, as their prototype shows,
 974         they are implemented as global operators; note that this is
 975         transparent to the user but it helps to understand why the
 976         following functions are documented to take the wxSize they
 977         operate on as an explicit argument.
 978     */
 979     //@{
 980     wxSize& operator=(const wxSize& sz);
 981
 982     bool operator ==(const wxSize& s1, const wxSize& s2);
 983     bool operator !=(const wxSize& s1, const wxSize& s2);
 984
 985     wxSize operator +(const wxSize& s1, const wxSize& s2);
 986     wxSize operator -(const wxSize& s1, const wxSize& s2);
 987     wxSize& operator +=(const wxSize& sz);
 988     wxSize& operator -=(const wxSize& sz);
 989
 990     wxSize operator /(const wxSize& sz, int factor);
 991     wxSize operator *(const wxSize& sz, int factor);
 992     wxSize operator *(int factor, const wxSize& sz);
 993     wxSize& operator /=(int factor);
 994     wxSize& operator *=(int factor);
 995     //@}
 996 };
 997
 998 /**
 999     Global instance of a wxSize object initialized to (-1,-1).
1000 */
1001 const wxSize wxDefaultSize;
1002
1003
1004
1005
1006 // ============================================================================
1007 // Global functions/macros
1008 // ============================================================================
1009
1010 /** @addtogroup group_funcmacro_gdi */
1011 //@{
1012
1013 /**
1014     This macro loads a bitmap from either application resources (on the
1015     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
1016     This can help to avoid using @ifdef_ when creating bitmaps.
1017
1018     @see @ref overview_bitmap, wxICON()
1019
1020     @header{wx/gdicmn.h}
1021 */
1022 #define wxBITMAP(bitmapName)
1023
1024 /**
1025     Creates a bitmap from either application resources or embedded image data
1026     in PNG format.
1027
1028     This macro is similar to wxBITMAP() but works with bitmap data in PNG
1029     format and not BMP or XPM.
1030
1031     Under Windows the given @a bitmapName must be present in the application
1032     resource file with the type @c RCDATA and refer to a PNG image. I.e. you
1033     should have a definition similar to the following in your @c .rc file:
1034     @code
1035         mybitmap    RCDATA  "mybitmap.png"
1036     @endcode
1037     to be able to use @c wxBITMAP_PNG(mybitmap) in the code.
1038
1039     Under OS X the file with the specified name and "png" extension must be
1040     present in the "Resources" subdirectory of the application bundle.
1041
1042     Under the other platforms, this is equivalent to wxBITMAP_PNG_FROM_DATA()
1043     and so loads the image data from the array called @c bitmapName_png that
1044     must exist. Notice that it @e must be an array and not a pointer as the
1045     macro needs to be able to determine its size. Such an array can be produced
1046     by a number of conversion programs. A very simple one is included in
1047     wxWidgets distribution as @c misc/scripts/png2c.py.
1048
1049     Finally notice that you must register PNG image handler to be able to
1050     load bitmaps from PNG data. This can be done either by calling
1051     wxInitAllImageHandlers() which also registers all the other image formats
1052     or including the necessary header:
1053     @code
1054         #include <wx/imagpng.h>
1055     @endcode
1056     and calling
1057     @code
1058         wxImage::AddHandler(new wxPNGHandler);
1059     @endcode
1060     in your application startup code.
1061
1062     @see wxBITMAP_PNG_FROM_DATA()
1063
1064     @header{wx/gdicmn.h}
1065
1066     @since 2.9.5
1067  */
1068 #define wxBITMAP_PNG(bitmapName)
1069
1070 /**
1071     Creates a bitmap from embedded image data in PNG format.
1072
1073     This macro is a thin wrapper around wxBitmap::NewFromPNGData() and takes
1074     just the base name of the array containing the image data and computes its
1075     size internally. In other words, the array called @c bitmapName_png must
1076     exist. Notice that it @e must be an array and not a pointer as the macro
1077     needs to be able to determine its size. Such an array can be produced by a
1078     number of conversion programs. A very simple one is included in wxWidgets
1079     distribution as @c misc/scripts/png2c.py.
1080
1081     You can use wxBITMAP_PNG() to load the PNG bitmaps from resources on the
1082     platforms that support this and only fall back to loading them from data
1083     under the other ones (i.e. not Windows and not OS X).
1084
1085     @header{wx/gdicmn.h}
1086
1087     @since 2.9.5
1088  */
1089 #define wxBITMAP_PNG_FROM_DATA(bitmapName)
1090
1091 /**
1092     This macro loads an icon from either application resources (on the
1093     platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
1094     This can help to avoid using @ifdef_ when creating icons.
1095
1096     @see @ref overview_bitmap, wxBITMAP()
1097
1098     @header{wx/gdicmn.h}
1099 */
1100 #define wxICON(iconName)
1101
1102 /**
1103     Returns @true if the display is colour, @false otherwise.
1104
1105     @header{wx/gdicmn.h}
1106 */
1107 bool wxColourDisplay();
1108
1109 /**
1110     Returns the depth of the display (a value of 1 denotes a monochrome
1111     display).
1112
1113     @header{wx/gdicmn.h}
1114 */
1115 int wxDisplayDepth();
1116
1117 /**
1118     Globally sets the cursor; only has an effect on Windows, Mac and GTK+. You
1119     should call this function with wxNullCursor to restore the system cursor.
1120
1121     @see wxCursor, wxWindow::SetCursor()
1122
1123     @header{wx/gdicmn.h}
1124 */
1125 void wxSetCursor(const wxCursor& cursor);
1126
1127 //@}
1128
1129 /** @addtogroup group_funcmacro_gdi */
1130 //@{
1131 /**
1132     Returns the dimensions of the work area on the display. On Windows this
1133     means the area not covered by the taskbar, etc. Other platforms are
1134     currently defaulting to the whole display until a way is found to provide
1135     this info for all window managers, etc.
1136
1137     @header{wx/gdicmn.h}
1138 */
1139 void wxClientDisplayRect(int* x, int* y, int* width, int* height);
1140 wxRect wxGetClientDisplayRect();
1141 //@}
1142
1143 /** @addtogroup group_funcmacro_gdi */
1144 //@{
1145 /**
1146     Returns the display resolution in pixels per inch.
1147
1148     The @c x component of the returned wxSize object contains the horizontal
1149     resolution and the @c y one -- the vertical resolution.
1150
1151     @header{wx/gdicmn.h}
1152
1153     @since 2.9.0
1154 */
1155 wxSize wxGetDisplayPPI();
1156 //@}
1157
1158 /** @addtogroup group_funcmacro_gdi */
1159 //@{
1160 /**
1161     Returns the display size in pixels.
1162
1163     For the version taking @a width and @a header arguments, either of them
1164     can be @NULL if the caller is not interested in the returned value.
1165
1166     @header{wx/gdicmn.h}
1167 */
1168 void wxDisplaySize(int* width, int* height);
1169 wxSize wxGetDisplaySize();
1170 //@}
1171
1172 /** @addtogroup group_funcmacro_gdi */
1173 //@{
1174 /**
1175     Returns the display size in millimeters.
1176
1177     For the version taking @a width and @a header arguments, either of them
1178     can be @NULL if the caller is not interested in the returned value.
1179
1180     @see wxGetDisplayPPI()
1181
1182     @header{wx/gdicmn.h}
1183 */
1184 void wxDisplaySizeMM(int* width, int* height);
1185 wxSize wxGetDisplaySizeMM();
1186 //@}
1187