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