]> git.saurik.com Git - wxWidgets.git/blob - include/wx/region.h
Remove wxRTTI macro for wxComboBox from Motif port.
[wxWidgets.git] / include / wx / region.h
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: wx/region.h
3 // Purpose: Base header for wxRegion
4 // Author: Julian Smart
5 // Modified by:
6 // Created:
7 // RCS-ID: $Id$
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows Licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #ifndef _WX_REGION_H_BASE_
13 #define _WX_REGION_H_BASE_
14
15 #include "wx/gdiobj.h"
16 #include "wx/gdicmn.h"
17
18 class WXDLLIMPEXP_FWD_CORE wxBitmap;
19 class WXDLLIMPEXP_FWD_CORE wxColour;
20 class WXDLLIMPEXP_FWD_CORE wxRegion;
21
22 // ----------------------------------------------------------------------------
23 // constants
24 // ----------------------------------------------------------------------------
25
26 // result of wxRegion::Contains() call
27 enum wxRegionContain
28 {
29 wxOutRegion = 0,
30 wxPartRegion = 1,
31 wxInRegion = 2
32 };
33
34 // these constants are used with wxRegion::Combine() in the ports which have
35 // this method
36 enum wxRegionOp
37 {
38 // Creates the intersection of the two combined regions.
39 wxRGN_AND,
40
41 // Creates a copy of the region
42 wxRGN_COPY,
43
44 // Combines the parts of first region that are not in the second one
45 wxRGN_DIFF,
46
47 // Creates the union of two combined regions.
48 wxRGN_OR,
49
50 // Creates the union of two regions except for any overlapping areas.
51 wxRGN_XOR
52 };
53
54 // ----------------------------------------------------------------------------
55 // wxRegionBase defines wxRegion API
56 // ----------------------------------------------------------------------------
57
58 class WXDLLIMPEXP_CORE wxRegionBase : public wxGDIObject
59 {
60 public:
61 // ctors
62 // -----
63
64 // none are defined here but the following should be available:
65 #if 0
66 wxRegion();
67 wxRegion(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
68 wxRegion(const wxPoint& topLeft, const wxPoint& bottomRight);
69 wxRegion(const wxRect& rect);
70 wxRegion(size_t n, const wxPoint *points, wxPolygonFillMode fillStyle = wxODDEVEN_RULE);
71 wxRegion(const wxBitmap& bmp);
72 wxRegion(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
73 #endif // 0
74
75 // operators
76 // ---------
77
78 bool operator==(const wxRegion& region) const { return IsEqual(region); }
79 bool operator!=(const wxRegion& region) const { return !(*this == region); }
80
81
82 // accessors
83 // ---------
84
85 // Is region empty?
86 virtual bool IsEmpty() const = 0;
87 bool Empty() const { return IsEmpty(); }
88
89 // Is region equal (i.e. covers the same area as another one)?
90 bool IsEqual(const wxRegion& region) const;
91
92 // Get the bounding box
93 bool GetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const
94 { return DoGetBox(x, y, w, h); }
95 wxRect GetBox() const
96 {
97 wxCoord x, y, w, h;
98 return DoGetBox(x, y, w, h) ? wxRect(x, y, w, h) : wxRect();
99 }
100
101 // Test if the given point or rectangle is inside this region
102 wxRegionContain Contains(wxCoord x, wxCoord y) const
103 { return DoContainsPoint(x, y); }
104 wxRegionContain Contains(const wxPoint& pt) const
105 { return DoContainsPoint(pt.x, pt.y); }
106 wxRegionContain Contains(wxCoord x, wxCoord y, wxCoord w, wxCoord h) const
107 { return DoContainsRect(wxRect(x, y, w, h)); }
108 wxRegionContain Contains(const wxRect& rect) const
109 { return DoContainsRect(rect); }
110
111
112 // operations
113 // ----------
114
115 virtual void Clear() = 0;
116
117 // Move the region
118 bool Offset(wxCoord x, wxCoord y)
119 { return DoOffset(x, y); }
120 bool Offset(const wxPoint& pt)
121 { return DoOffset(pt.x, pt.y); }
122
123 // Union rectangle or region with this region.
124 bool Union(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
125 { return DoUnionWithRect(wxRect(x, y, w, h)); }
126 bool Union(const wxRect& rect)
127 { return DoUnionWithRect(rect); }
128 bool Union(const wxRegion& region)
129 { return DoUnionWithRegion(region); }
130
131 #if wxUSE_IMAGE
132 // Use the non-transparent pixels of a wxBitmap for the region to combine
133 // with this region. First version takes transparency from bitmap's mask,
134 // second lets the user specify the colour to be treated as transparent
135 // along with an optional tolerance value.
136 // NOTE: implemented in common/rgncmn.cpp
137 bool Union(const wxBitmap& bmp);
138 bool Union(const wxBitmap& bmp, const wxColour& transp, int tolerance = 0);
139 #endif // wxUSE_IMAGE
140
141 // Intersect rectangle or region with this one.
142 bool Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
143 bool Intersect(const wxRect& rect);
144 bool Intersect(const wxRegion& region)
145 { return DoIntersect(region); }
146
147 // Subtract rectangle or region from this:
148 // Combines the parts of 'this' that are not part of the second region.
149 bool Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
150 bool Subtract(const wxRect& rect);
151 bool Subtract(const wxRegion& region)
152 { return DoSubtract(region); }
153
154 // XOR: the union of two combined regions except for any overlapping areas.
155 bool Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h);
156 bool Xor(const wxRect& rect);
157 bool Xor(const wxRegion& region)
158 { return DoXor(region); }
159
160
161 // Convert the region to a B&W bitmap with the white pixels being inside
162 // the region.
163 wxBitmap ConvertToBitmap() const;
164
165 protected:
166 virtual bool DoIsEqual(const wxRegion& region) const = 0;
167 virtual bool DoGetBox(wxCoord& x, wxCoord& y, wxCoord& w, wxCoord& h) const = 0;
168 virtual wxRegionContain DoContainsPoint(wxCoord x, wxCoord y) const = 0;
169 virtual wxRegionContain DoContainsRect(const wxRect& rect) const = 0;
170
171 virtual bool DoOffset(wxCoord x, wxCoord y) = 0;
172
173 virtual bool DoUnionWithRect(const wxRect& rect) = 0;
174 virtual bool DoUnionWithRegion(const wxRegion& region) = 0;
175
176 virtual bool DoIntersect(const wxRegion& region) = 0;
177 virtual bool DoSubtract(const wxRegion& region) = 0;
178 virtual bool DoXor(const wxRegion& region) = 0;
179 };
180
181 // some ports implement a generic Combine() function while others only
182 // implement individual wxRegion operations, factor out the common code for the
183 // ports with Combine() in this class
184 #if defined(__WXMSW__) || \
185 ( defined(__WXMAC__) && wxOSX_USE_COCOA_OR_CARBON ) || \
186 defined(__WXPM__)
187
188 #define wxHAS_REGION_COMBINE
189
190 class WXDLLIMPEXP_CORE wxRegionWithCombine : public wxRegionBase
191 {
192 public:
193 // these methods are not part of public API as they're not implemented on
194 // all ports
195 bool Combine(wxCoord x, wxCoord y, wxCoord w, wxCoord h, wxRegionOp op);
196 bool Combine(const wxRect& rect, wxRegionOp op);
197 bool Combine(const wxRegion& region, wxRegionOp op)
198 { return DoCombine(region, op); }
199
200
201 protected:
202 // the real Combine() method, to be defined in the derived class
203 virtual bool DoCombine(const wxRegion& region, wxRegionOp op) = 0;
204
205 // implement some wxRegionBase pure virtuals in terms of Combine()
206 virtual bool DoUnionWithRect(const wxRect& rect);
207 virtual bool DoUnionWithRegion(const wxRegion& region);
208 virtual bool DoIntersect(const wxRegion& region);
209 virtual bool DoSubtract(const wxRegion& region);
210 virtual bool DoXor(const wxRegion& region);
211 };
212
213 #endif // ports with wxRegion::Combine()
214
215 #if defined(__WXMSW__)
216 #include "wx/msw/region.h"
217 #elif defined(__WXGTK20__)
218 #include "wx/gtk/region.h"
219 #elif defined(__WXGTK__)
220 #include "wx/gtk1/region.h"
221 #elif defined(__WXMOTIF__) || defined(__WXX11__)
222 #include "wx/x11/region.h"
223 #elif defined(__WXDFB__)
224 #include "wx/dfb/region.h"
225 #elif defined(__WXMAC__)
226 #include "wx/osx/region.h"
227 #elif defined(__WXCOCOA__)
228 #include "wx/cocoa/region.h"
229 #elif defined(__WXPM__)
230 #include "wx/os2/region.h"
231 #endif
232
233 // ----------------------------------------------------------------------------
234 // inline functions implementation
235 // ----------------------------------------------------------------------------
236
237 // NB: these functions couldn't be defined in the class declaration as they use
238 // wxRegion and so can be only defined after including the header declaring
239 // the real class
240
241 inline bool wxRegionBase::Intersect(const wxRect& rect)
242 {
243 return DoIntersect(wxRegion(rect));
244 }
245
246 inline bool wxRegionBase::Subtract(const wxRect& rect)
247 {
248 return DoSubtract(wxRegion(rect));
249 }
250
251 inline bool wxRegionBase::Xor(const wxRect& rect)
252 {
253 return DoXor(wxRegion(rect));
254 }
255
256 // ...and these functions are here because they call the ones above, and its
257 // not really proper to call an inline function before its defined inline.
258
259 inline bool wxRegionBase::Intersect(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
260 {
261 return Intersect(wxRect(x, y, w, h));
262 }
263
264 inline bool wxRegionBase::Subtract(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
265 {
266 return Subtract(wxRect(x, y, w, h));
267 }
268
269 inline bool wxRegionBase::Xor(wxCoord x, wxCoord y, wxCoord w, wxCoord h)
270 {
271 return Xor(wxRect(x, y, w, h));
272 }
273
274 #ifdef wxHAS_REGION_COMBINE
275
276 inline bool wxRegionWithCombine::Combine(wxCoord x,
277 wxCoord y,
278 wxCoord w,
279 wxCoord h,
280 wxRegionOp op)
281 {
282 return DoCombine(wxRegion(x, y, w, h), op);
283 }
284
285 inline bool wxRegionWithCombine::Combine(const wxRect& rect, wxRegionOp op)
286 {
287 return DoCombine(wxRegion(rect), op);
288 }
289
290 #endif // wxHAS_REGION_COMBINE
291
292 #endif // _WX_REGION_H_BASE_