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