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