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