1 /////////////////////////////////////////////////////////////////////////////
3 // Purpose: Common GDI classes, types and declarations
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
15 // ---------------------------------------------------------------------------
17 // ---------------------------------------------------------------------------
21 #include "wx/string.h"
22 #include "wx/fontenc.h"
23 #include "wx/hashmap.h"
26 // ---------------------------------------------------------------------------
27 // forward declarations
28 // ---------------------------------------------------------------------------
30 class WXDLLIMPEXP_FWD_CORE wxBitmap
;
31 class WXDLLIMPEXP_FWD_CORE wxBrush
;
32 class WXDLLIMPEXP_FWD_CORE wxColour
;
33 class WXDLLIMPEXP_FWD_CORE wxCursor
;
34 class WXDLLIMPEXP_FWD_CORE wxFont
;
35 class WXDLLIMPEXP_FWD_CORE wxIcon
;
36 class WXDLLIMPEXP_FWD_CORE wxPalette
;
37 class WXDLLIMPEXP_FWD_CORE wxPen
;
38 class WXDLLIMPEXP_FWD_CORE wxRegion
;
39 class WXDLLIMPEXP_FWD_BASE wxString
;
40 class WXDLLIMPEXP_FWD_CORE wxIconBundle
;
41 class WXDLLIMPEXP_FWD_CORE wxPoint
;
43 // ---------------------------------------------------------------------------
45 // ---------------------------------------------------------------------------
50 wxBITMAP_TYPE_INVALID
, // should be == 0 for compatibility!
52 wxBITMAP_TYPE_BMP_RESOURCE
,
53 wxBITMAP_TYPE_RESOURCE
= wxBITMAP_TYPE_BMP_RESOURCE
,
55 wxBITMAP_TYPE_ICO_RESOURCE
,
57 wxBITMAP_TYPE_CUR_RESOURCE
,
59 wxBITMAP_TYPE_XBM_DATA
,
61 wxBITMAP_TYPE_XPM_DATA
,
63 wxBITMAP_TYPE_TIF
= wxBITMAP_TYPE_TIFF
,
64 wxBITMAP_TYPE_TIFF_RESOURCE
,
65 wxBITMAP_TYPE_TIF_RESOURCE
= wxBITMAP_TYPE_TIFF_RESOURCE
,
67 wxBITMAP_TYPE_GIF_RESOURCE
,
69 wxBITMAP_TYPE_PNG_RESOURCE
,
71 wxBITMAP_TYPE_JPEG_RESOURCE
,
73 wxBITMAP_TYPE_PNM_RESOURCE
,
75 wxBITMAP_TYPE_PCX_RESOURCE
,
77 wxBITMAP_TYPE_PICT_RESOURCE
,
79 wxBITMAP_TYPE_ICON_RESOURCE
,
83 wxBITMAP_TYPE_MACCURSOR
,
84 wxBITMAP_TYPE_MACCURSOR_RESOURCE
,
87 wxBITMAP_TYPE_ANY
= 50
90 // Polygon filling mode
91 enum wxPolygonFillMode
100 wxCURSOR_NONE
, // should be 0
102 wxCURSOR_RIGHT_ARROW
,
108 wxCURSOR_LEFT_BUTTON
,
110 wxCURSOR_MIDDLE_BUTTON
,
112 wxCURSOR_PAINT_BRUSH
,
115 wxCURSOR_POINT_RIGHT
,
116 wxCURSOR_QUESTION_ARROW
,
117 wxCURSOR_RIGHT_BUTTON
,
128 wxCURSOR_DEFAULT
, // standard X11 cursor
131 wxCURSOR_COPY_ARROW
, // MacOS Theme Plus arrow
134 // Not yet implemented for Windows
135 wxCURSOR_CROSS_REVERSE
,
136 wxCURSOR_DOUBLE_ARROW
,
137 wxCURSOR_BASED_ARROW_UP
,
138 wxCURSOR_BASED_ARROW_DOWN
,
143 wxCURSOR_CLOSED_HAND
,
150 #define wxCURSOR_DEFAULT wxCURSOR_ARROW
154 // TODO CS supply openhand and closedhand cursors
155 #define wxCURSOR_OPEN_HAND wxCURSOR_HAND
156 #define wxCURSOR_CLOSED_HAND wxCURSOR_HAND
159 // ---------------------------------------------------------------------------
161 // ---------------------------------------------------------------------------
163 #if defined(__WINDOWS__) || defined(__WXPM__)
164 #define wxHAS_IMAGES_IN_RESOURCES
167 /* Useful macro for creating icons portably, for example:
169 wxIcon *icon = new wxICON(sample);
173 wxIcon *icon = new wxIcon("sample"); // On Windows
174 wxIcon *icon = new wxIcon(sample_xpm); // On wxGTK/Linux
178 // Load from a resource
179 #define wxICON(X) wxIcon(wxT(#X))
180 #elif defined(__WXPM__)
181 // Load from a resource
182 #define wxICON(X) wxIcon(wxT(#X))
183 #elif defined(__WXDFB__)
184 // Initialize from an included XPM
185 #define wxICON(X) wxIcon( X##_xpm )
186 #elif defined(__WXGTK__)
187 // Initialize from an included XPM
188 #define wxICON(X) wxIcon( X##_xpm )
189 #elif defined(__WXMAC__)
190 // Initialize from an included XPM
191 #define wxICON(X) wxIcon( X##_xpm )
192 #elif defined(__WXMOTIF__)
193 // Initialize from an included XPM
194 #define wxICON(X) wxIcon( X##_xpm )
195 #elif defined(__WXX11__)
196 // Initialize from an included XPM
197 #define wxICON(X) wxIcon( X##_xpm )
199 // This will usually mean something on any platform
200 #define wxICON(X) wxIcon(wxT(#X))
203 /* Another macro: this one is for portable creation of bitmaps. We assume that
204 under Unix bitmaps live in XPMs and under Windows they're in ressources.
207 #if defined(__WINDOWS__) || defined(__WXPM__)
208 #define wxBITMAP(name) wxBitmap(wxT(#name), wxBITMAP_TYPE_BMP_RESOURCE)
209 #elif defined(__WXGTK__) || \
210 defined(__WXMOTIF__) || \
211 defined(__WXX11__) || \
212 defined(__WXMAC__) || \
213 defined(__WXDFB__) || \
215 // Initialize from an included XPM
216 #define wxBITMAP(name) wxBitmap(name##_xpm)
217 #else // other platforms
218 #define wxBITMAP(name) wxBitmap(name##_xpm, wxBITMAP_TYPE_XPM)
221 // ===========================================================================
223 // ===========================================================================
225 // ---------------------------------------------------------------------------
227 // ---------------------------------------------------------------------------
229 class WXDLLIMPEXP_CORE wxSize
232 // members are public for compatibility, don't use them directly.
236 wxSize() : x(0), y(0) { }
237 wxSize(int xx
, int yy
) : x(xx
), y(yy
) { }
239 // no copy ctor or assignment operator - the defaults are ok
241 wxSize
& operator+=(const wxSize
& sz
) { x
+= sz
.x
; y
+= sz
.y
; return *this; }
242 wxSize
& operator-=(const wxSize
& sz
) { x
-= sz
.x
; y
-= sz
.y
; return *this; }
243 wxSize
& operator/=(int i
) { x
/= i
; y
/= i
; return *this; }
244 wxSize
& operator*=(int i
) { x
*= i
; y
*= i
; return *this; }
245 wxSize
& operator/=(unsigned int i
) { x
/= i
; y
/= i
; return *this; }
246 wxSize
& operator*=(unsigned int i
) { x
*= i
; y
*= i
; return *this; }
247 wxSize
& operator/=(long i
) { x
/= i
; y
/= i
; return *this; }
248 wxSize
& operator*=(long i
) { x
*= i
; y
*= i
; return *this; }
249 wxSize
& operator/=(unsigned long i
) { x
/= i
; y
/= i
; return *this; }
250 wxSize
& operator*=(unsigned long i
) { x
*= i
; y
*= i
; return *this; }
251 wxSize
& operator/=(double i
) { x
= int(x
/i
); y
= int(y
/i
); return *this; }
252 wxSize
& operator*=(double i
) { x
= int(x
*i
); y
= int(y
*i
); return *this; }
254 void IncTo(const wxSize
& sz
)
255 { if ( sz
.x
> x
) x
= sz
.x
; if ( sz
.y
> y
) y
= sz
.y
; }
256 void DecTo(const wxSize
& sz
)
257 { if ( sz
.x
< x
) x
= sz
.x
; if ( sz
.y
< y
) y
= sz
.y
; }
258 void DecToIfSpecified(const wxSize
& sz
)
260 if ( sz
.x
!= wxDefaultCoord
&& sz
.x
< x
)
262 if ( sz
.y
!= wxDefaultCoord
&& sz
.y
< y
)
266 void IncBy(int dx
, int dy
) { x
+= dx
; y
+= dy
; }
267 void IncBy(const wxPoint
& pt
);
268 void IncBy(const wxSize
& sz
) { IncBy(sz
.x
, sz
.y
); }
269 void IncBy(int d
) { IncBy(d
, d
); }
271 void DecBy(int dx
, int dy
) { IncBy(-dx
, -dy
); }
272 void DecBy(const wxPoint
& pt
);
273 void DecBy(const wxSize
& sz
) { DecBy(sz
.x
, sz
.y
); }
274 void DecBy(int d
) { DecBy(d
, d
); }
277 wxSize
& Scale(float xscale
, float yscale
)
278 { x
= (int)(x
*xscale
); y
= (int)(y
*yscale
); return *this; }
281 void Set(int xx
, int yy
) { x
= xx
; y
= yy
; }
282 void SetWidth(int w
) { x
= w
; }
283 void SetHeight(int h
) { y
= h
; }
285 int GetWidth() const { return x
; }
286 int GetHeight() const { return y
; }
288 bool IsFullySpecified() const { return x
!= wxDefaultCoord
&& y
!= wxDefaultCoord
; }
290 // combine this size with the other one replacing the default (i.e. equal
291 // to wxDefaultCoord) components of this object with those of the other
292 void SetDefaults(const wxSize
& size
)
294 if ( x
== wxDefaultCoord
)
296 if ( y
== wxDefaultCoord
)
301 int GetX() const { return x
; }
302 int GetY() const { return y
; }
305 inline bool operator==(const wxSize
& s1
, const wxSize
& s2
)
307 return s1
.x
== s2
.x
&& s1
.y
== s2
.y
;
310 inline bool operator!=(const wxSize
& s1
, const wxSize
& s2
)
312 return s1
.x
!= s2
.x
|| s1
.y
!= s2
.y
;
315 inline wxSize
operator+(const wxSize
& s1
, const wxSize
& s2
)
317 return wxSize(s1
.x
+ s2
.x
, s1
.y
+ s2
.y
);
320 inline wxSize
operator-(const wxSize
& s1
, const wxSize
& s2
)
322 return wxSize(s1
.x
- s2
.x
, s1
.y
- s2
.y
);
325 inline wxSize
operator/(const wxSize
& s
, int i
)
327 return wxSize(s
.x
/ i
, s
.y
/ i
);
330 inline wxSize
operator*(const wxSize
& s
, int i
)
332 return wxSize(s
.x
* i
, s
.y
* i
);
335 inline wxSize
operator*(int i
, const wxSize
& s
)
337 return wxSize(s
.x
* i
, s
.y
* i
);
340 inline wxSize
operator/(const wxSize
& s
, unsigned int i
)
342 return wxSize(s
.x
/ i
, s
.y
/ i
);
345 inline wxSize
operator*(const wxSize
& s
, unsigned int i
)
347 return wxSize(s
.x
* i
, s
.y
* i
);
350 inline wxSize
operator*(unsigned int i
, const wxSize
& s
)
352 return wxSize(s
.x
* i
, s
.y
* i
);
355 inline wxSize
operator/(const wxSize
& s
, long i
)
357 return wxSize(s
.x
/ i
, s
.y
/ i
);
360 inline wxSize
operator*(const wxSize
& s
, long i
)
362 return wxSize(s
.x
* i
, s
.y
* i
);
365 inline wxSize
operator*(long i
, const wxSize
& s
)
367 return wxSize(s
.x
* i
, s
.y
* i
);
370 inline wxSize
operator/(const wxSize
& s
, unsigned long i
)
372 return wxSize(s
.x
/ i
, s
.y
/ i
);
375 inline wxSize
operator*(const wxSize
& s
, unsigned long i
)
377 return wxSize(s
.x
* i
, s
.y
* i
);
380 inline wxSize
operator*(unsigned long i
, const wxSize
& s
)
382 return wxSize(s
.x
* i
, s
.y
* i
);
385 inline wxSize
operator*(const wxSize
& s
, double i
)
387 return wxSize(int(s
.x
* i
), int(s
.y
* i
));
390 inline wxSize
operator*(double i
, const wxSize
& s
)
392 return wxSize(int(s
.x
* i
), int(s
.y
* i
));
397 // ---------------------------------------------------------------------------
398 // Point classes: with real or integer coordinates
399 // ---------------------------------------------------------------------------
401 class WXDLLIMPEXP_CORE wxRealPoint
407 wxRealPoint() : x(0.0), y(0.0) { }
408 wxRealPoint(double xx
, double yy
) : x(xx
), y(yy
) { }
409 wxRealPoint(const wxPoint
& pt
);
411 // no copy ctor or assignment operator - the defaults are ok
413 //assignment operators
414 wxRealPoint
& operator+=(const wxRealPoint
& p
) { x
+= p
.x
; y
+= p
.y
; return *this; }
415 wxRealPoint
& operator-=(const wxRealPoint
& p
) { x
-= p
.x
; y
-= p
.y
; return *this; }
417 wxRealPoint
& operator+=(const wxSize
& s
) { x
+= s
.GetWidth(); y
+= s
.GetHeight(); return *this; }
418 wxRealPoint
& operator-=(const wxSize
& s
) { x
-= s
.GetWidth(); y
-= s
.GetHeight(); return *this; }
422 inline bool operator==(const wxRealPoint
& p1
, const wxRealPoint
& p2
)
424 return wxIsSameDouble(p1
.x
, p2
.x
) && wxIsSameDouble(p1
.y
, p2
.y
);
427 inline bool operator!=(const wxRealPoint
& p1
, const wxRealPoint
& p2
)
432 inline wxRealPoint
operator+(const wxRealPoint
& p1
, const wxRealPoint
& p2
)
434 return wxRealPoint(p1
.x
+ p2
.x
, p1
.y
+ p2
.y
);
438 inline wxRealPoint
operator-(const wxRealPoint
& p1
, const wxRealPoint
& p2
)
440 return wxRealPoint(p1
.x
- p2
.x
, p1
.y
- p2
.y
);
444 inline wxRealPoint
operator/(const wxRealPoint
& s
, int i
)
446 return wxRealPoint(s
.x
/ i
, s
.y
/ i
);
449 inline wxRealPoint
operator*(const wxRealPoint
& s
, int i
)
451 return wxRealPoint(s
.x
* i
, s
.y
* i
);
454 inline wxRealPoint
operator*(int i
, const wxRealPoint
& s
)
456 return wxRealPoint(s
.x
* i
, s
.y
* i
);
459 inline wxRealPoint
operator/(const wxRealPoint
& s
, unsigned int i
)
461 return wxRealPoint(s
.x
/ i
, s
.y
/ i
);
464 inline wxRealPoint
operator*(const wxRealPoint
& s
, unsigned int i
)
466 return wxRealPoint(s
.x
* i
, s
.y
* i
);
469 inline wxRealPoint
operator*(unsigned int i
, const wxRealPoint
& s
)
471 return wxRealPoint(s
.x
* i
, s
.y
* i
);
474 inline wxRealPoint
operator/(const wxRealPoint
& s
, long i
)
476 return wxRealPoint(s
.x
/ i
, s
.y
/ i
);
479 inline wxRealPoint
operator*(const wxRealPoint
& s
, long i
)
481 return wxRealPoint(s
.x
* i
, s
.y
* i
);
484 inline wxRealPoint
operator*(long i
, const wxRealPoint
& s
)
486 return wxRealPoint(s
.x
* i
, s
.y
* i
);
489 inline wxRealPoint
operator/(const wxRealPoint
& s
, unsigned long i
)
491 return wxRealPoint(s
.x
/ i
, s
.y
/ i
);
494 inline wxRealPoint
operator*(const wxRealPoint
& s
, unsigned long i
)
496 return wxRealPoint(s
.x
* i
, s
.y
* i
);
499 inline wxRealPoint
operator*(unsigned long i
, const wxRealPoint
& s
)
501 return wxRealPoint(s
.x
* i
, s
.y
* i
);
504 inline wxRealPoint
operator*(const wxRealPoint
& s
, double i
)
506 return wxRealPoint(int(s
.x
* i
), int(s
.y
* i
));
509 inline wxRealPoint
operator*(double i
, const wxRealPoint
& s
)
511 return wxRealPoint(int(s
.x
* i
), int(s
.y
* i
));
515 // ----------------------------------------------------------------------------
516 // wxPoint: 2D point with integer coordinates
517 // ----------------------------------------------------------------------------
519 class WXDLLIMPEXP_CORE wxPoint
524 wxPoint() : x(0), y(0) { }
525 wxPoint(int xx
, int yy
) : x(xx
), y(yy
) { }
526 wxPoint(const wxRealPoint
& pt
) : x(int(pt
.x
)), y(int(pt
.y
)) { }
528 // no copy ctor or assignment operator - the defaults are ok
530 //assignment operators
531 wxPoint
& operator+=(const wxPoint
& p
) { x
+= p
.x
; y
+= p
.y
; return *this; }
532 wxPoint
& operator-=(const wxPoint
& p
) { x
-= p
.x
; y
-= p
.y
; return *this; }
534 wxPoint
& operator+=(const wxSize
& s
) { x
+= s
.GetWidth(); y
+= s
.GetHeight(); return *this; }
535 wxPoint
& operator-=(const wxSize
& s
) { x
-= s
.GetWidth(); y
-= s
.GetHeight(); return *this; }
537 // check if both components are set/initialized
538 bool IsFullySpecified() const { return x
!= wxDefaultCoord
&& y
!= wxDefaultCoord
; }
540 // fill in the unset components with the values from the other point
541 void SetDefaults(const wxPoint
& pt
)
543 if ( x
== wxDefaultCoord
)
545 if ( y
== wxDefaultCoord
)
552 inline bool operator==(const wxPoint
& p1
, const wxPoint
& p2
)
554 return p1
.x
== p2
.x
&& p1
.y
== p2
.y
;
557 inline bool operator!=(const wxPoint
& p1
, const wxPoint
& p2
)
563 // arithmetic operations (component wise)
564 inline wxPoint
operator+(const wxPoint
& p1
, const wxPoint
& p2
)
566 return wxPoint(p1
.x
+ p2
.x
, p1
.y
+ p2
.y
);
569 inline wxPoint
operator-(const wxPoint
& p1
, const wxPoint
& p2
)
571 return wxPoint(p1
.x
- p2
.x
, p1
.y
- p2
.y
);
574 inline wxPoint
operator+(const wxPoint
& p
, const wxSize
& s
)
576 return wxPoint(p
.x
+ s
.x
, p
.y
+ s
.y
);
579 inline wxPoint
operator-(const wxPoint
& p
, const wxSize
& s
)
581 return wxPoint(p
.x
- s
.x
, p
.y
- s
.y
);
584 inline wxPoint
operator+(const wxSize
& s
, const wxPoint
& p
)
586 return wxPoint(p
.x
+ s
.x
, p
.y
+ s
.y
);
589 inline wxPoint
operator-(const wxSize
& s
, const wxPoint
& p
)
591 return wxPoint(s
.x
- p
.x
, s
.y
- p
.y
);
594 inline wxPoint
operator-(const wxPoint
& p
)
596 return wxPoint(-p
.x
, -p
.y
);
599 inline wxPoint
operator/(const wxPoint
& s
, int i
)
601 return wxPoint(s
.x
/ i
, s
.y
/ i
);
604 inline wxPoint
operator*(const wxPoint
& s
, int i
)
606 return wxPoint(s
.x
* i
, s
.y
* i
);
609 inline wxPoint
operator*(int i
, const wxPoint
& s
)
611 return wxPoint(s
.x
* i
, s
.y
* i
);
614 inline wxPoint
operator/(const wxPoint
& s
, unsigned int i
)
616 return wxPoint(s
.x
/ i
, s
.y
/ i
);
619 inline wxPoint
operator*(const wxPoint
& s
, unsigned int i
)
621 return wxPoint(s
.x
* i
, s
.y
* i
);
624 inline wxPoint
operator*(unsigned int i
, const wxPoint
& s
)
626 return wxPoint(s
.x
* i
, s
.y
* i
);
629 inline wxPoint
operator/(const wxPoint
& s
, long i
)
631 return wxPoint(s
.x
/ i
, s
.y
/ i
);
634 inline wxPoint
operator*(const wxPoint
& s
, long i
)
636 return wxPoint(s
.x
* i
, s
.y
* i
);
639 inline wxPoint
operator*(long i
, const wxPoint
& s
)
641 return wxPoint(s
.x
* i
, s
.y
* i
);
644 inline wxPoint
operator/(const wxPoint
& s
, unsigned long i
)
646 return wxPoint(s
.x
/ i
, s
.y
/ i
);
649 inline wxPoint
operator*(const wxPoint
& s
, unsigned long i
)
651 return wxPoint(s
.x
* i
, s
.y
* i
);
654 inline wxPoint
operator*(unsigned long i
, const wxPoint
& s
)
656 return wxPoint(s
.x
* i
, s
.y
* i
);
659 inline wxPoint
operator*(const wxPoint
& s
, double i
)
661 return wxPoint(int(s
.x
* i
), int(s
.y
* i
));
664 inline wxPoint
operator*(double i
, const wxPoint
& s
)
666 return wxPoint(int(s
.x
* i
), int(s
.y
* i
));
669 WX_DECLARE_LIST_WITH_DECL(wxPoint
, wxPointList
, class WXDLLIMPEXP_CORE
);
671 // ---------------------------------------------------------------------------
673 // ---------------------------------------------------------------------------
675 class WXDLLIMPEXP_CORE wxRect
679 : x(0), y(0), width(0), height(0)
681 wxRect(int xx
, int yy
, int ww
, int hh
)
682 : x(xx
), y(yy
), width(ww
), height(hh
)
684 wxRect(const wxPoint
& topLeft
, const wxPoint
& bottomRight
);
685 wxRect(const wxPoint
& pt
, const wxSize
& size
)
686 : x(pt
.x
), y(pt
.y
), width(size
.x
), height(size
.y
)
688 wxRect(const wxSize
& size
)
689 : x(0), y(0), width(size
.x
), height(size
.y
)
692 // default copy ctor and assignment operators ok
694 int GetX() const { return x
; }
695 void SetX(int xx
) { x
= xx
; }
697 int GetY() const { return y
; }
698 void SetY(int yy
) { y
= yy
; }
700 int GetWidth() const { return width
; }
701 void SetWidth(int w
) { width
= w
; }
703 int GetHeight() const { return height
; }
704 void SetHeight(int h
) { height
= h
; }
706 wxPoint
GetPosition() const { return wxPoint(x
, y
); }
707 void SetPosition( const wxPoint
&p
) { x
= p
.x
; y
= p
.y
; }
709 wxSize
GetSize() const { return wxSize(width
, height
); }
710 void SetSize( const wxSize
&s
) { width
= s
.GetWidth(); height
= s
.GetHeight(); }
712 bool IsEmpty() const { return (width
<= 0) || (height
<= 0); }
714 int GetLeft() const { return x
; }
715 int GetTop() const { return y
; }
716 int GetBottom() const { return y
+ height
- 1; }
717 int GetRight() const { return x
+ width
- 1; }
719 void SetLeft(int left
) { x
= left
; }
720 void SetRight(int right
) { width
= right
- x
+ 1; }
721 void SetTop(int top
) { y
= top
; }
722 void SetBottom(int bottom
) { height
= bottom
- y
+ 1; }
724 wxPoint
GetTopLeft() const { return GetPosition(); }
725 wxPoint
GetLeftTop() const { return GetTopLeft(); }
726 void SetTopLeft(const wxPoint
&p
) { SetPosition(p
); }
727 void SetLeftTop(const wxPoint
&p
) { SetTopLeft(p
); }
729 wxPoint
GetBottomRight() const { return wxPoint(GetRight(), GetBottom()); }
730 wxPoint
GetRightBottom() const { return GetBottomRight(); }
731 void SetBottomRight(const wxPoint
&p
) { SetRight(p
.x
); SetBottom(p
.y
); }
732 void SetRightBottom(const wxPoint
&p
) { SetBottomRight(p
); }
734 wxPoint
GetTopRight() const { return wxPoint(GetRight(), GetTop()); }
735 wxPoint
GetRightTop() const { return GetTopRight(); }
736 void SetTopRight(const wxPoint
&p
) { SetRight(p
.x
); SetTop(p
.y
); }
737 void SetRightTop(const wxPoint
&p
) { SetTopRight(p
); }
739 wxPoint
GetBottomLeft() const { return wxPoint(GetLeft(), GetBottom()); }
740 wxPoint
GetLeftBottom() const { return GetBottomLeft(); }
741 void SetBottomLeft(const wxPoint
&p
) { SetLeft(p
.x
); SetBottom(p
.y
); }
742 void SetLeftBottom(const wxPoint
&p
) { SetBottomLeft(p
); }
744 // operations with rect
745 wxRect
& Inflate(wxCoord dx
, wxCoord dy
);
746 wxRect
& Inflate(const wxSize
& d
) { return Inflate(d
.x
, d
.y
); }
747 wxRect
& Inflate(wxCoord d
) { return Inflate(d
, d
); }
748 wxRect
Inflate(wxCoord dx
, wxCoord dy
) const
755 wxRect
& Deflate(wxCoord dx
, wxCoord dy
) { return Inflate(-dx
, -dy
); }
756 wxRect
& Deflate(const wxSize
& d
) { return Inflate(-d
.x
, -d
.y
); }
757 wxRect
& Deflate(wxCoord d
) { return Inflate(-d
); }
758 wxRect
Deflate(wxCoord dx
, wxCoord dy
) const
765 void Offset(wxCoord dx
, wxCoord dy
) { x
+= dx
; y
+= dy
; }
766 void Offset(const wxPoint
& pt
) { Offset(pt
.x
, pt
.y
); }
768 wxRect
& Intersect(const wxRect
& rect
);
769 wxRect
Intersect(const wxRect
& rect
) const
776 wxRect
& Union(const wxRect
& rect
);
777 wxRect
Union(const wxRect
& rect
) const
784 // return true if the point is (not strcitly) inside the rect
785 bool Contains(int x
, int y
) const;
786 bool Contains(const wxPoint
& pt
) const { return Contains(pt
.x
, pt
.y
); }
787 // return true if the rectangle 'rect' is (not strictly) inside this rect
788 bool Contains(const wxRect
& rect
) const;
790 #if WXWIN_COMPATIBILITY_2_6
791 // use Contains() instead
792 wxDEPRECATED( bool Inside(int x
, int y
) const );
793 wxDEPRECATED( bool Inside(const wxPoint
& pt
) const );
794 wxDEPRECATED( bool Inside(const wxRect
& rect
) const );
795 #endif // WXWIN_COMPATIBILITY_2_6
797 // return true if the rectangles have a non empty intersection
798 bool Intersects(const wxRect
& rect
) const;
800 // like Union() but don't ignore empty rectangles
801 wxRect
& operator+=(const wxRect
& rect
);
803 // intersections of two rectrangles not testing for empty rectangles
804 wxRect
& operator*=(const wxRect
& rect
);
806 // centre this rectangle in the given (usually, but not necessarily,
808 wxRect
CentreIn(const wxRect
& r
, int dir
= wxBOTH
) const
810 return wxRect(dir
& wxHORIZONTAL
? r
.x
+ (r
.width
- width
)/2 : x
,
811 dir
& wxVERTICAL
? r
.y
+ (r
.height
- height
)/2 : y
,
815 wxRect
CenterIn(const wxRect
& r
, int dir
= wxBOTH
) const
817 return CentreIn(r
, dir
);
821 int x
, y
, width
, height
;
825 // compare rectangles
826 inline bool operator==(const wxRect
& r1
, const wxRect
& r2
)
828 return (r1
.x
== r2
.x
) && (r1
.y
== r2
.y
) &&
829 (r1
.width
== r2
.width
) && (r1
.height
== r2
.height
);
832 inline bool operator!=(const wxRect
& r1
, const wxRect
& r2
)
837 // like Union() but don't treat empty rectangles specially
838 WXDLLIMPEXP_CORE wxRect
operator+(const wxRect
& r1
, const wxRect
& r2
);
840 // intersections of two rectangles
841 WXDLLIMPEXP_CORE wxRect
operator*(const wxRect
& r1
, const wxRect
& r2
);
846 #if WXWIN_COMPATIBILITY_2_6
847 inline bool wxRect::Inside(int cx
, int cy
) const { return Contains(cx
, cy
); }
848 inline bool wxRect::Inside(const wxPoint
& pt
) const { return Contains(pt
); }
849 inline bool wxRect::Inside(const wxRect
& rect
) const { return Contains(rect
); }
850 #endif // WXWIN_COMPATIBILITY_2_6
853 // define functions which couldn't be defined above because of declarations
855 inline void wxSize::IncBy(const wxPoint
& pt
) { IncBy(pt
.x
, pt
.y
); }
856 inline void wxSize::DecBy(const wxPoint
& pt
) { DecBy(pt
.x
, pt
.y
); }
858 // ---------------------------------------------------------------------------
859 // Management of pens, brushes and fonts
860 // ---------------------------------------------------------------------------
862 typedef wxInt8 wxDash
;
864 class WXDLLIMPEXP_CORE wxGDIObjListBase
{
873 WX_DECLARE_STRING_HASH_MAP(wxColour
*, wxStringToColourHashMap
);
875 class WXDLLIMPEXP_CORE wxColourDatabase
881 // find colour by name or name for the given colour
882 wxColour
Find(const wxString
& name
) const;
883 wxString
FindName(const wxColour
& colour
) const;
885 // add a new colour to the database
886 void AddColour(const wxString
& name
, const wxColour
& colour
);
888 #if WXWIN_COMPATIBILITY_2_6
889 // deprecated, use Find() instead
890 wxDEPRECATED( wxColour
*FindColour(const wxString
& name
) );
891 #endif // WXWIN_COMPATIBILITY_2_6
895 // PM keeps its own type of colour table
901 // load the database with the built in colour values when called for the
902 // first time, do nothing after this
905 wxStringToColourHashMap
*m_map
;
908 class WXDLLIMPEXP_CORE wxResourceCache
: public wxList
911 wxResourceCache() { }
912 #if !wxUSE_STD_CONTAINERS
913 wxResourceCache(const unsigned int keyType
) : wxList(keyType
) { }
915 virtual ~wxResourceCache();
918 // ---------------------------------------------------------------------------
920 // ---------------------------------------------------------------------------
925 wxStockGDI creates the stock GDI objects on demand. Pointers to the
926 created objects are stored in the ms_stockObject array, which is indexed
927 by the Item enum values. Platorm-specific fonts can be created by
928 implementing a derived class with an override for the GetFont function.
929 wxStockGDI operates as a singleton, accessed through the ms_instance
930 pointer. By default this pointer is set to an instance of wxStockGDI.
931 A derived class must arrange to set this pointer to an instance of itself.
933 class WXDLLIMPEXP_CORE wxStockGDI
979 virtual ~wxStockGDI();
980 static void DeleteAll();
982 static wxStockGDI
& instance() { return *ms_instance
; }
984 static const wxBrush
* GetBrush(Item item
);
985 static const wxColour
* GetColour(Item item
);
986 static const wxCursor
* GetCursor(Item item
);
987 // Can be overridden by platform-specific derived classes
988 virtual const wxFont
* GetFont(Item item
);
989 static const wxPen
* GetPen(Item item
);
992 static wxStockGDI
* ms_instance
;
994 static wxObject
* ms_stockObject
[ITEMCOUNT
];
996 wxDECLARE_NO_COPY_CLASS(wxStockGDI
);
999 #define wxITALIC_FONT wxStockGDI::instance().GetFont(wxStockGDI::FONT_ITALIC)
1000 #define wxNORMAL_FONT wxStockGDI::instance().GetFont(wxStockGDI::FONT_NORMAL)
1001 #define wxSMALL_FONT wxStockGDI::instance().GetFont(wxStockGDI::FONT_SMALL)
1002 #define wxSWISS_FONT wxStockGDI::instance().GetFont(wxStockGDI::FONT_SWISS)
1004 #define wxBLACK_DASHED_PEN wxStockGDI::GetPen(wxStockGDI::PEN_BLACKDASHED)
1005 #define wxBLACK_PEN wxStockGDI::GetPen(wxStockGDI::PEN_BLACK)
1006 #define wxBLUE_PEN wxStockGDI::GetPen(wxStockGDI::PEN_BLUE)
1007 #define wxCYAN_PEN wxStockGDI::GetPen(wxStockGDI::PEN_CYAN)
1008 #define wxGREEN_PEN wxStockGDI::GetPen(wxStockGDI::PEN_GREEN)
1009 #define wxYELLOW_PEN wxStockGDI::GetPen(wxStockGDI::PEN_YELLOW)
1010 #define wxGREY_PEN wxStockGDI::GetPen(wxStockGDI::PEN_GREY)
1011 #define wxLIGHT_GREY_PEN wxStockGDI::GetPen(wxStockGDI::PEN_LIGHTGREY)
1012 #define wxMEDIUM_GREY_PEN wxStockGDI::GetPen(wxStockGDI::PEN_MEDIUMGREY)
1013 #define wxRED_PEN wxStockGDI::GetPen(wxStockGDI::PEN_RED)
1014 #define wxTRANSPARENT_PEN wxStockGDI::GetPen(wxStockGDI::PEN_TRANSPARENT)
1015 #define wxWHITE_PEN wxStockGDI::GetPen(wxStockGDI::PEN_WHITE)
1017 #define wxBLACK_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_BLACK)
1018 #define wxBLUE_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_BLUE)
1019 #define wxCYAN_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_CYAN)
1020 #define wxGREEN_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_GREEN)
1021 #define wxYELLOW_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_YELLOW)
1022 #define wxGREY_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_GREY)
1023 #define wxLIGHT_GREY_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_LIGHTGREY)
1024 #define wxMEDIUM_GREY_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_MEDIUMGREY)
1025 #define wxRED_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_RED)
1026 #define wxTRANSPARENT_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_TRANSPARENT)
1027 #define wxWHITE_BRUSH wxStockGDI::GetBrush(wxStockGDI::BRUSH_WHITE)
1029 #define wxBLACK wxStockGDI::GetColour(wxStockGDI::COLOUR_BLACK)
1030 #define wxBLUE wxStockGDI::GetColour(wxStockGDI::COLOUR_BLUE)
1031 #define wxCYAN wxStockGDI::GetColour(wxStockGDI::COLOUR_CYAN)
1032 #define wxGREEN wxStockGDI::GetColour(wxStockGDI::COLOUR_GREEN)
1033 #define wxYELLOW wxStockGDI::GetColour(wxStockGDI::COLOUR_YELLOW)
1034 #define wxLIGHT_GREY wxStockGDI::GetColour(wxStockGDI::COLOUR_LIGHTGREY)
1035 #define wxRED wxStockGDI::GetColour(wxStockGDI::COLOUR_RED)
1036 #define wxWHITE wxStockGDI::GetColour(wxStockGDI::COLOUR_WHITE)
1038 #define wxCROSS_CURSOR wxStockGDI::GetCursor(wxStockGDI::CURSOR_CROSS)
1039 #define wxHOURGLASS_CURSOR wxStockGDI::GetCursor(wxStockGDI::CURSOR_HOURGLASS)
1040 #define wxSTANDARD_CURSOR wxStockGDI::GetCursor(wxStockGDI::CURSOR_STANDARD)
1043 extern WXDLLIMPEXP_DATA_CORE(wxBitmap
) wxNullBitmap
;
1044 extern WXDLLIMPEXP_DATA_CORE(wxIcon
) wxNullIcon
;
1045 extern WXDLLIMPEXP_DATA_CORE(wxCursor
) wxNullCursor
;
1046 extern WXDLLIMPEXP_DATA_CORE(wxPen
) wxNullPen
;
1047 extern WXDLLIMPEXP_DATA_CORE(wxBrush
) wxNullBrush
;
1048 extern WXDLLIMPEXP_DATA_CORE(wxPalette
) wxNullPalette
;
1049 extern WXDLLIMPEXP_DATA_CORE(wxFont
) wxNullFont
;
1050 extern WXDLLIMPEXP_DATA_CORE(wxColour
) wxNullColour
;
1051 extern WXDLLIMPEXP_DATA_CORE(wxIconBundle
) wxNullIconBundle
;
1053 extern WXDLLIMPEXP_DATA_CORE(wxColourDatabase
*) wxTheColourDatabase
;
1055 extern WXDLLIMPEXP_DATA_CORE(const char) wxPanelNameStr
[];
1057 extern WXDLLIMPEXP_DATA_CORE(const wxSize
) wxDefaultSize
;
1058 extern WXDLLIMPEXP_DATA_CORE(const wxPoint
) wxDefaultPosition
;
1060 // ---------------------------------------------------------------------------
1062 // ---------------------------------------------------------------------------
1064 // resource management
1065 extern void WXDLLIMPEXP_CORE
wxInitializeStockLists();
1066 extern void WXDLLIMPEXP_CORE
wxDeleteStockLists();
1068 // is the display colour (or monochrome)?
1069 extern bool WXDLLIMPEXP_CORE
wxColourDisplay();
1071 // Returns depth of screen
1072 extern int WXDLLIMPEXP_CORE
wxDisplayDepth();
1073 #define wxGetDisplayDepth wxDisplayDepth
1075 // get the display size
1076 extern void WXDLLIMPEXP_CORE
wxDisplaySize(int *width
, int *height
);
1077 extern wxSize WXDLLIMPEXP_CORE
wxGetDisplaySize();
1078 extern void WXDLLIMPEXP_CORE
wxDisplaySizeMM(int *width
, int *height
);
1079 extern wxSize WXDLLIMPEXP_CORE
wxGetDisplaySizeMM();
1080 extern wxSize WXDLLIMPEXP_CORE
wxGetDisplayPPI();
1082 // Get position and size of the display workarea
1083 extern void WXDLLIMPEXP_CORE
wxClientDisplayRect(int *x
, int *y
, int *width
, int *height
);
1084 extern wxRect WXDLLIMPEXP_CORE
wxGetClientDisplayRect();
1086 // set global cursor
1087 extern void WXDLLIMPEXP_CORE
wxSetCursor(const wxCursor
& cursor
);