]> git.saurik.com Git - wxWidgets.git/blob - interface/wx/gdicmn.h
Added wxPGProperty::Enable() for conveniency. Refactored related code and improved...
[wxWidgets.git] / 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 void Deflate(wxCoord dx, wxCoord dy);
270 void Deflate(const wxSize& diff);
271 void 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 the 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 void Inflate(wxCoord dx, wxCoord dy);
378 void Inflate(const wxSize& diff);
379 void 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 x member.
588 */
589 int x;
590
591 /**
592 y member.
593 */
594 int y;
595 };
596
597 /**
598 Global istance of a wxPoint initialized with values (-1,-1).
599 */
600 wxPoint wxDefaultPosition;
601
602
603 /**
604 @class wxColourDatabase
605
606 wxWidgets maintains a database of standard RGB colours for a predefined
607 set of named colours. The application may add to this set if desired by
608 using AddColour() and may use it to look up colours by names using Find()
609 or find the names for the standard colour using FindName().
610
611 There is one predefined, global instance of this class called
612 ::wxTheColourDatabase.
613
614 The standard database contains at least the following colours:
615
616 @beginTable
617 <tr><td>
618 AQUAMARINE
619 @n BLACK
620 @n BLUE
621 @n BLUE VIOLET
622 @n BROWN
623 @n CADET BLUE
624 @n CORAL
625 @n CORNFLOWER BLUE
626 @n CYAN
627 @n DARK GREY
628 @n DARK GREEN
629 @n DARK OLIVE GREEN
630 @n DARK ORCHID
631 @n DARK SLATE BLUE
632 @n DARK SLATE GREY
633 @n DARK TURQUOISE
634 @n DIM GREY
635 </td><td>
636 FIREBRICK
637 @n FOREST GREEN
638 @n GOLD
639 @n GOLDENROD
640 @n GREY
641 @n GREEN
642 @n GREEN YELLOW
643 @n INDIAN RED
644 @n KHAKI
645 @n LIGHT BLUE
646 @n LIGHT GREY
647 @n LIGHT STEEL BLUE
648 @n LIME GREEN
649 @n MAGENTA
650 @n MAROON
651 @n MEDIUM AQUAMARINE
652 @n MEDIUM BLUE
653 </td><td>
654 MEDIUM FOREST GREEN
655 @n MEDIUM GOLDENROD
656 @n MEDIUM ORCHID
657 @n MEDIUM SEA GREEN
658 @n MEDIUM SLATE BLUE
659 @n MEDIUM SPRING GREEN
660 @n MEDIUM TURQUOISE
661 @n MEDIUM VIOLET RED
662 @n MIDNIGHT BLUE
663 @n NAVY
664 @n ORANGE
665 @n ORANGE RED
666 @n ORCHID
667 @n PALE GREEN
668 @n PINK
669 @n PLUM
670 @n PURPLE
671 </td><td>
672 RED
673 @n SALMON
674 @n SEA GREEN
675 @n SIENNA
676 @n SKY BLUE
677 @n SLATE BLUE
678 @n SPRING GREEN
679 @n STEEL BLUE
680 @n TAN
681 @n THISTLE
682 @n TURQUOISE
683 @n VIOLET
684 @n VIOLET RED
685 @n WHEAT
686 @n WHITE
687 @n YELLOW
688 @n YELLOW GREEN
689 </td></tr>
690 @endTable
691
692 @library{wxcore}
693 @category{gdi}
694
695 @see wxColour
696 */
697 class wxColourDatabase
698 {
699 public:
700 /**
701 Constructs the colour database. It will be initialized at the first
702 use.
703 */
704 wxColourDatabase();
705
706 /**
707 Adds a colour to the database. If a colour with the same name already
708 exists, it is replaced.
709 */
710 void AddColour(const wxString& colourName, const wxColour& colour);
711
712 /**
713 Finds a colour given the name. Returns an invalid colour object (that
714 is, wxColour::IsOk() will return @false) if the colour wasn't found in
715 the database.
716 */
717 wxColour Find(const wxString& colourName) const;
718
719 /**
720 Finds a colour name given the colour. Returns an empty string if the
721 colour is not found in the database.
722 */
723 wxString FindName(const wxColour& colour) const;
724 };
725
726
727 /**
728 Global istance of a wxColourDatabase.
729 */
730 wxColourDatabase* wxTheColourDatabase;
731
732
733 /**
734 @class wxSize
735
736 A wxSize is a useful data structure for graphics operations.
737 It simply contains integer @e width and @e height members.
738
739 Note that the width and height stored inside a wxSize object may be negative
740 and that wxSize functions do not perform any check against negative values
741 (this is used to e.g. store the special -1 value in ::wxDefaultSize instance).
742 See also IsFullySpecified() and SetDefaults() for utility functions regarding
743 the special -1 value.
744
745 wxSize is used throughout wxWidgets as well as wxPoint which, although
746 almost equivalent to wxSize, has a different meaning: wxPoint represents a
747 position while wxSize represents the size.
748
749 @beginWxPythonOnly
750 wxPython defines aliases for the @e x and @e y members named @e width and
751 @e height since it makes much more sense for sizes.
752 @endWxPythonOnly
753
754 @library{wxcore}
755 @category{data}
756
757 @stdobjects
758 ::wxDefaultSize
759
760 @see wxPoint, wxRealPoint
761 */
762 class wxSize
763 {
764 public:
765 /**
766 Initializes this size object with zero width and height.
767 */
768 wxSize();
769
770 /**
771 Initializes this size object with the given @a width and @a height.
772 */
773 wxSize(int width, int height);
774
775 //@{
776 /**
777 Decreases the size in both x and y directions.
778
779 @see IncBy()
780 */
781 void DecBy(const wxPoint& pt);
782 void DecBy(const wxSize& size);
783 void DecBy(int dx, int dy);
784 void DecBy(int d);
785 //@}
786
787 /**
788 Decrements this object so that both of its dimensions are not greater
789 than the corresponding dimensions of the @a size.
790
791 @see IncTo()
792 */
793 void DecTo(const wxSize& size);
794
795 /**
796 Gets the height member.
797 */
798 int GetHeight() const;
799
800 /**
801 Gets the width member.
802 */
803 int GetWidth() const;
804
805 //@{
806 /**
807 Increases the size in both x and y directions.
808
809 @see DecBy()
810 */
811 void IncBy(const wxPoint& pt);
812 void IncBy(const wxSize& size);
813 void IncBy(int dx, int dy);
814 void IncBy(int d);
815 //@}
816
817 /**
818 Increments this object so that both of its dimensions are not less than
819 the corresponding dimensions of the @a size.
820
821 @see DecTo()
822 */
823 void IncTo(const wxSize& size);
824
825 /**
826 Returns @true if neither of the size object components is equal to -1,
827 which is used as default for the size values in wxWidgets (hence the
828 predefined ::wxDefaultSize has both of its components equal to -1).
829
830 This method is typically used before calling SetDefaults().
831 */
832 bool IsFullySpecified() const;
833
834 /**
835 Scales the dimensions of this object by the given factors. If you want
836 to scale both dimensions by the same factor you can also use
837 operator*=().
838
839 @return A reference to this object (so that you can concatenate other
840 operations in the same line).
841 */
842 wxSize& Scale(float xscale, float yscale);
843
844 /**
845 Sets the width and height members.
846 */
847 void Set(int width, int height);
848
849 /**
850 Combine this size object with another one replacing the default (i.e.
851 equal to -1) components of this object with those of the other. It is
852 typically used like this:
853
854 @code
855 if ( !size.IsFullySpecified() )
856 {
857 size.SetDefaults(GetDefaultSize());
858 }
859 @endcode
860
861 @see IsFullySpecified()
862 */
863 void SetDefaults(const wxSize& sizeDefault);
864
865 /**
866 Sets the height.
867 */
868 void SetHeight(int height);
869
870 /**
871 Sets the width.
872 */
873 void SetWidth(int width);
874
875
876 /**
877 @name Miscellaneous operators
878
879 Note that these operators are documented as class members
880 (to make them easier to find) but, as their prototype shows,
881 they are implemented as global operators; note that this is
882 transparent to the user but it helps to understand why the
883 following functions are documented to take the wxSize they
884 operate on as an explicit argument.
885 */
886 //@{
887 wxSize& operator=(const wxSize& sz);
888
889 bool operator ==(const wxSize& s1, const wxSize& s2);
890 bool operator !=(const wxSize& s1, const wxSize& s2);
891
892 wxSize operator +(const wxSize& s1, const wxSize& s2);
893 wxSize operator -(const wxSize& s1, const wxSize& s2);
894 wxSize& operator +=(const wxSize& sz);
895 wxSize& operator -=(const wxSize& sz);
896
897 wxSize operator /(const wxSize& sz, int factor);
898 wxSize operator *(const wxSize& sz, int factor);
899 wxSize operator *(int factor, const wxSize& sz);
900 wxSize& operator /=(int factor);
901 wxSize& operator *=(int factor);
902 //@}
903 };
904
905 /**
906 Global instance of a wxSize object initialized to (-1,-1).
907 */
908 wxSize wxDefaultSize;
909
910
911
912
913 // ============================================================================
914 // Global functions/macros
915 // ============================================================================
916
917 /** @addtogroup group_funcmacro_gdi */
918 //@{
919
920 /**
921 This macro loads a bitmap from either application resources (on the
922 platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
923 This can help to avoid using @ifdef_ when creating bitmaps.
924
925 @see @ref overview_bitmap, wxICON()
926
927 @header{wx/gdicmn.h}
928 */
929 #define wxBITMAP(bitmapName)
930
931 /**
932 This macro loads an icon from either application resources (on the
933 platforms for which they exist, i.e. Windows and OS2) or from an XPM file.
934 This can help to avoid using @ifdef_ when creating icons.
935
936 @see @ref overview_bitmap, wxBITMAP()
937
938 @header{wx/gdicmn.h}
939 */
940 #define wxICON(iconName)
941
942 /**
943 Returns @true if the display is colour, @false otherwise.
944
945 @header{wx/gdicmn.h}
946 */
947 bool wxColourDisplay();
948
949 /**
950 Returns the depth of the display (a value of 1 denotes a monochrome
951 display).
952
953 @header{wx/gdicmn.h}
954 */
955 int wxDisplayDepth();
956
957 /**
958 Globally sets the cursor; only has an effect on Windows, Mac and GTK+. You
959 should call this function with wxNullCursor to restore the system cursor.
960
961 @see wxCursor, wxWindow::SetCursor()
962
963 @header{wx/gdicmn.h}
964 */
965 void wxSetCursor(const wxCursor& cursor);
966
967 //@}
968
969 /** @addtogroup group_funcmacro_gdi */
970 //@{
971 /**
972 Returns the dimensions of the work area on the display. On Windows this
973 means the area not covered by the taskbar, etc. Other platforms are
974 currently defaulting to the whole display until a way is found to provide
975 this info for all window managers, etc.
976
977 @header{wx/gdicmn.h}
978 */
979 void wxClientDisplayRect(int* x, int* y, int* width, int* height);
980 wxRect wxGetClientDisplayRect();
981 //@}
982
983 /** @addtogroup group_funcmacro_gdi */
984 //@{
985 /**
986 Returns the display resolution in pixels per inch.
987
988 The @c x component of the returned wxSize object contains the horizontal
989 resolution and the @c y one -- the vertical resolution.
990
991 @header{wx/gdicmn.h}
992
993 @since 2.9.0
994 */
995 wxSize wxGetDisplayPPI();
996 //@}
997
998 /** @addtogroup group_funcmacro_gdi */
999 //@{
1000 /**
1001 Returns the display size in pixels.
1002
1003 For the version taking @a width and @a header arguments, either of them
1004 can be @NULL if the caller is not interested in the returned value.
1005
1006 @header{wx/gdicmn.h}
1007 */
1008 void wxDisplaySize(int* width, int* height);
1009 wxSize wxGetDisplaySize();
1010 //@}
1011
1012 /** @addtogroup group_funcmacro_gdi */
1013 //@{
1014 /**
1015 Returns the display size in millimeters.
1016
1017 For the version taking @a width and @a header arguments, either of them
1018 can be @NULL if the caller is not interested in the returned value.
1019
1020 @see wxGetDisplayPPI()
1021
1022 @header{wx/gdicmn.h}
1023 */
1024 void wxDisplaySizeMM(int* width, int* height);
1025 wxSize wxGetDisplaySizeMM();
1026 //@}
1027