]>
Commit | Line | Data |
---|---|---|
f03fc89f | 1 | /////////////////////////////////////////////////////////////////////////////// |
23895080 | 2 | // Name: wx/window.h |
789295bf | 3 | // Purpose: wxWindowBase class - the interface of wxWindow |
f03fc89f | 4 | // Author: Vadim Zeitlin |
566d84a7 | 5 | // Modified by: Ron Lee |
f03fc89f VZ |
6 | // Created: 01/02/97 |
7 | // RCS-ID: $Id$ | |
99d80019 | 8 | // Copyright: (c) Vadim Zeitlin |
65571936 | 9 | // Licence: wxWindows licence |
f03fc89f VZ |
10 | /////////////////////////////////////////////////////////////////////////////// |
11 | ||
34138703 JS |
12 | #ifndef _WX_WINDOW_H_BASE_ |
13 | #define _WX_WINDOW_H_BASE_ | |
c801d85f | 14 | |
f03fc89f VZ |
15 | // ---------------------------------------------------------------------------- |
16 | // headers which we must include here | |
17 | // ---------------------------------------------------------------------------- | |
18 | ||
19 | #include "wx/event.h" // the base class | |
20 | ||
21 | #include "wx/list.h" // defines wxWindowList | |
22 | ||
23 | #include "wx/cursor.h" // we have member variables of these classes | |
24 | #include "wx/font.h" // so we can't do without them | |
25 | #include "wx/colour.h" | |
26 | #include "wx/region.h" | |
5e4ff78a | 27 | #include "wx/utils.h" |
978af864 | 28 | #include "wx/intl.h" |
88ac883a | 29 | |
674ac8b9 | 30 | #include "wx/validate.h" // for wxDefaultValidator (always include it) |
8d99be5f | 31 | |
574c939e | 32 | #if wxUSE_PALETTE |
d577d610 | 33 | #include "wx/palette.h" |
574c939e KB |
34 | #endif // wxUSE_PALETTE |
35 | ||
88ac883a VZ |
36 | #if wxUSE_ACCEL |
37 | #include "wx/accel.h" | |
38 | #endif // wxUSE_ACCEL | |
f03fc89f | 39 | |
45a959a3 JS |
40 | #if wxUSE_ACCESSIBILITY |
41 | #include "wx/access.h" | |
42 | #endif | |
43 | ||
6522713c VZ |
44 | // when building wxUniv/Foo we don't want the code for native menu use to be |
45 | // compiled in - it should only be used when building real wxFoo | |
46 | #ifdef __WXUNIVERSAL__ | |
47 | #define wxUSE_MENUS_NATIVE 0 | |
22dd3847 | 48 | #else // !__WXUNIVERSAL__ |
6522713c | 49 | #define wxUSE_MENUS_NATIVE wxUSE_MENUS |
22dd3847 | 50 | #endif // __WXUNIVERSAL__/!__WXUNIVERSAL__ |
6522713c | 51 | |
47a8a4d5 VZ |
52 | |
53 | // Define this macro if the corresponding operating system handles the state | |
54 | // of children windows automatically when the parent is enabled/disabled. | |
55 | // Otherwise wx itself must ensure that when the parent is disabled its | |
56 | // children are disabled too, and their initial state is restored when the | |
57 | // parent is enabled back. | |
58 | #if defined(__WXMSW__) || defined(__WXPM__) | |
59 | // must do everything ourselves | |
60 | #undef wxHAS_NATIVE_ENABLED_MANAGEMENT | |
61 | #else | |
62 | #define wxHAS_NATIVE_ENABLED_MANAGEMENT | |
63 | #endif | |
64 | ||
f03fc89f VZ |
65 | // ---------------------------------------------------------------------------- |
66 | // forward declarations | |
67 | // ---------------------------------------------------------------------------- | |
68 | ||
b5dbe15d VS |
69 | class WXDLLIMPEXP_FWD_CORE wxCaret; |
70 | class WXDLLIMPEXP_FWD_CORE wxControl; | |
71 | class WXDLLIMPEXP_FWD_CORE wxCursor; | |
72 | class WXDLLIMPEXP_FWD_CORE wxDC; | |
73 | class WXDLLIMPEXP_FWD_CORE wxDropTarget; | |
b5dbe15d | 74 | class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints; |
b5dbe15d VS |
75 | class WXDLLIMPEXP_FWD_CORE wxSizer; |
76 | class WXDLLIMPEXP_FWD_CORE wxToolTip; | |
77 | class WXDLLIMPEXP_FWD_CORE wxWindowBase; | |
78 | class WXDLLIMPEXP_FWD_CORE wxWindow; | |
79 | class WXDLLIMPEXP_FWD_CORE wxScrollHelper; | |
f03fc89f | 80 | |
45a959a3 | 81 | #if wxUSE_ACCESSIBILITY |
b5dbe15d | 82 | class WXDLLIMPEXP_FWD_CORE wxAccessible; |
45a959a3 JS |
83 | #endif |
84 | ||
1b69c815 VZ |
85 | // ---------------------------------------------------------------------------- |
86 | // helper stuff used by wxWindow | |
87 | // ---------------------------------------------------------------------------- | |
88 | ||
89 | // struct containing all the visual attributes of a control | |
53a2db12 | 90 | struct WXDLLIMPEXP_CORE wxVisualAttributes |
1b69c815 VZ |
91 | { |
92 | // the font used for control label/text inside it | |
93 | wxFont font; | |
94 | ||
95 | // the foreground colour | |
96 | wxColour colFg; | |
97 | ||
98 | // the background colour, may be wxNullColour if the controls background | |
99 | // colour is not solid | |
100 | wxColour colBg; | |
101 | }; | |
102 | ||
103 | // different window variants, on platforms like eg mac uses different | |
104 | // rendering sizes | |
400a9e41 | 105 | enum wxWindowVariant |
1b69c815 VZ |
106 | { |
107 | wxWINDOW_VARIANT_NORMAL, // Normal size | |
108 | wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal) | |
109 | wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal) | |
110 | wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal) | |
111 | wxWINDOW_VARIANT_MAX | |
112 | }; | |
113 | ||
ff9f7a12 SC |
114 | #if wxUSE_SYSTEM_OPTIONS |
115 | #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant") | |
116 | #endif | |
117 | ||
376d7d97 VZ |
118 | // valid values for Show/HideWithEffect() |
119 | enum wxShowEffect | |
120 | { | |
eed04c99 VS |
121 | wxSHOW_EFFECT_ROLL_TO_LEFT, |
122 | wxSHOW_EFFECT_ROLL_TO_RIGHT, | |
123 | wxSHOW_EFFECT_ROLL_TO_TOP, | |
124 | wxSHOW_EFFECT_ROLL_TO_BOTTOM, | |
125 | wxSHOW_EFFECT_SLIDE_TO_LEFT, | |
126 | wxSHOW_EFFECT_SLIDE_TO_RIGHT, | |
127 | wxSHOW_EFFECT_SLIDE_TO_TOP, | |
128 | wxSHOW_EFFECT_SLIDE_TO_BOTTOM, | |
376d7d97 VZ |
129 | wxSHOW_EFFECT_BLEND, |
130 | wxSHOW_EFFECT_EXPAND, | |
131 | wxSHOW_EFFECT_MAX | |
132 | }; | |
133 | ||
ecdc1183 VZ |
134 | // flags for SendSizeEvent() |
135 | enum | |
136 | { | |
137 | wxSEND_EVENT_POST = 1 | |
138 | }; | |
139 | ||
f03fc89f VZ |
140 | // ---------------------------------------------------------------------------- |
141 | // (pseudo)template list classes | |
142 | // ---------------------------------------------------------------------------- | |
143 | ||
53a2db12 | 144 | WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLIMPEXP_CORE); |
f03fc89f VZ |
145 | |
146 | // ---------------------------------------------------------------------------- | |
147 | // global variables | |
148 | // ---------------------------------------------------------------------------- | |
149 | ||
53a2db12 | 150 | extern WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows; |
e7445ff8 | 151 | extern WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete; |
f03fc89f | 152 | |
f03fc89f VZ |
153 | // ---------------------------------------------------------------------------- |
154 | // wxWindowBase is the base class for all GUI controls/widgets, this is the public | |
155 | // interface of this class. | |
156 | // | |
157 | // Event handler: windows have themselves as their event handlers by default, | |
158 | // but their event handlers could be set to another object entirely. This | |
159 | // separation can reduce the amount of derivation required, and allow | |
160 | // alteration of a window's functionality (e.g. by a resource editor that | |
161 | // temporarily switches event handlers). | |
162 | // ---------------------------------------------------------------------------- | |
163 | ||
53a2db12 | 164 | class WXDLLIMPEXP_CORE wxWindowBase : public wxEvtHandler |
f03fc89f | 165 | { |
f03fc89f VZ |
166 | public: |
167 | // creating the window | |
168 | // ------------------- | |
169 | ||
06f6df7d VZ |
170 | // default ctor, initializes everything which can be initialized before |
171 | // Create() | |
6463b9f5 | 172 | wxWindowBase() ; |
f03fc89f VZ |
173 | |
174 | // pseudo ctor (can't be virtual, called from ctor) | |
175 | bool CreateBase(wxWindowBase *parent, | |
d9e2e4c2 | 176 | wxWindowID winid, |
f03fc89f VZ |
177 | const wxPoint& pos = wxDefaultPosition, |
178 | const wxSize& size = wxDefaultSize, | |
179 | long style = 0, | |
8d99be5f | 180 | const wxValidator& validator = wxDefaultValidator, |
f03fc89f VZ |
181 | const wxString& name = wxPanelNameStr); |
182 | ||
183 | virtual ~wxWindowBase(); | |
184 | ||
f03fc89f VZ |
185 | // deleting the window |
186 | // ------------------- | |
187 | ||
d4864e97 | 188 | // ask the window to close itself, return true if the event handler |
f03fc89f | 189 | // honoured our request |
d4864e97 | 190 | bool Close( bool force = false ); |
f03fc89f VZ |
191 | |
192 | // the following functions delete the C++ objects (the window itself | |
193 | // or its children) as well as the GUI windows and normally should | |
194 | // never be used directly | |
195 | ||
d4864e97 | 196 | // delete window unconditionally (dangerous!), returns true if ok |
f03fc89f | 197 | virtual bool Destroy(); |
d4864e97 | 198 | // delete all children of this window, returns true if ok |
f03fc89f VZ |
199 | bool DestroyChildren(); |
200 | ||
201 | // is the window being deleted? | |
a3ac93e3 | 202 | bool IsBeingDeleted() const; |
f03fc89f VZ |
203 | |
204 | // window attributes | |
205 | // ----------------- | |
206 | ||
ffd84c94 WS |
207 | // label is just the same as the title (but for, e.g., buttons it |
208 | // makes more sense to speak about labels), title access | |
209 | // is available from wxTLW classes only (frames, dialogs) | |
faa49bfd WS |
210 | virtual void SetLabel(const wxString& label) = 0; |
211 | virtual wxString GetLabel() const = 0; | |
f03fc89f VZ |
212 | |
213 | // the window name is used for ressource setting in X, it is not the | |
214 | // same as the window title/label | |
215 | virtual void SetName( const wxString &name ) { m_windowName = name; } | |
216 | virtual wxString GetName() const { return m_windowName; } | |
217 | ||
978af864 VZ |
218 | // sets the window variant, calls internally DoSetVariant if variant |
219 | // has changed | |
220 | void SetWindowVariant(wxWindowVariant variant); | |
221 | wxWindowVariant GetWindowVariant() const { return m_windowVariant; } | |
400a9e41 | 222 | |
69d90995 | 223 | |
978af864 VZ |
224 | // get or change the layout direction (LTR or RTL) for this window, |
225 | // wxLayout_Default is returned if layout direction is not supported | |
226 | virtual wxLayoutDirection GetLayoutDirection() const | |
227 | { return wxLayout_Default; } | |
228 | virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) | |
229 | { } | |
230 | ||
231 | // mirror coordinates for RTL layout if this window uses it and if the | |
232 | // mirroring is not done automatically like Win32 | |
233 | virtual wxCoord AdjustForLayoutDirection(wxCoord x, | |
234 | wxCoord width, | |
235 | wxCoord widthTotal) const; | |
f03fc89f | 236 | |
f35fdf7e VZ |
237 | |
238 | // window id uniquely identifies the window among its siblings unless | |
239 | // it is wxID_ANY which means "don't care" | |
240 | void SetId( wxWindowID winid ) { m_windowId = winid; } | |
241 | wxWindowID GetId() const { return m_windowId; } | |
242 | ||
f35fdf7e | 243 | // generate a unique id (or count of them consecutively), returns a |
cf2810aa VZ |
244 | // valid id in the auto-id range or wxID_NONE if failed. If using |
245 | // autoid management, it will mark the id as reserved until it is | |
246 | // used (by assigning it to a wxWindowIDRef) or unreserved. | |
247 | static wxWindowID NewControlId(int count = 1) | |
248 | { | |
249 | return wxIdManager::ReserveId(count); | |
250 | } | |
f35fdf7e | 251 | |
cf2810aa VZ |
252 | // If an ID generated from NewControlId is not assigned to a wxWindowIDRef, |
253 | // it must be unreserved | |
254 | static void UnreserveControlId(wxWindowID id, int count = 1) | |
255 | { | |
256 | wxIdManager::UnreserveId(id, count); | |
257 | } | |
f35fdf7e | 258 | |
f03fc89f VZ |
259 | |
260 | // moving/resizing | |
261 | // --------------- | |
262 | ||
263 | // set the window size and/or position | |
264 | void SetSize( int x, int y, int width, int height, | |
265 | int sizeFlags = wxSIZE_AUTO ) | |
266 | { DoSetSize(x, y, width, height, sizeFlags); } | |
267 | ||
268 | void SetSize( int width, int height ) | |
a0d9c6cb | 269 | { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); } |
f03fc89f VZ |
270 | |
271 | void SetSize( const wxSize& size ) | |
272 | { SetSize( size.x, size.y); } | |
273 | ||
274 | void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO) | |
275 | { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); } | |
276 | ||
1e6feb95 | 277 | void Move(int x, int y, int flags = wxSIZE_USE_EXISTING) |
a0d9c6cb | 278 | { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); } |
f03fc89f | 279 | |
1e6feb95 VZ |
280 | void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING) |
281 | { Move(pt.x, pt.y, flags); } | |
f03fc89f | 282 | |
3c81c9aa VZ |
283 | void SetPosition(const wxPoint& pt) { Move(pt); } |
284 | ||
f03fc89f VZ |
285 | // Z-order |
286 | virtual void Raise() = 0; | |
287 | virtual void Lower() = 0; | |
288 | ||
289 | // client size is the size of area available for subwindows | |
290 | void SetClientSize( int width, int height ) | |
291 | { DoSetClientSize(width, height); } | |
292 | ||
293 | void SetClientSize( const wxSize& size ) | |
294 | { DoSetClientSize(size.x, size.y); } | |
295 | ||
296 | void SetClientSize(const wxRect& rect) | |
297 | { SetClientSize( rect.width, rect.height ); } | |
298 | ||
3c81c9aa VZ |
299 | // get the window position (pointers may be NULL): notice that it is in |
300 | // client coordinates for child windows and screen coordinates for the | |
301 | // top level ones, use GetScreenPosition() if you need screen | |
302 | // coordinates for all kinds of windows | |
f03fc89f VZ |
303 | void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); } |
304 | wxPoint GetPosition() const | |
305 | { | |
3c81c9aa VZ |
306 | int x, y; |
307 | DoGetPosition(&x, &y); | |
f03fc89f | 308 | |
3c81c9aa | 309 | return wxPoint(x, y); |
f03fc89f VZ |
310 | } |
311 | ||
3c81c9aa VZ |
312 | // get the window position in screen coordinates |
313 | void GetScreenPosition(int *x, int *y) const { DoGetScreenPosition(x, y); } | |
314 | wxPoint GetScreenPosition() const | |
315 | { | |
316 | int x, y; | |
317 | DoGetScreenPosition(&x, &y); | |
38759b67 | 318 | |
3c81c9aa VZ |
319 | return wxPoint(x, y); |
320 | } | |
321 | ||
322 | // get the window size (pointers may be NULL) | |
f03fc89f VZ |
323 | void GetSize( int *w, int *h ) const { DoGetSize(w, h); } |
324 | wxSize GetSize() const | |
325 | { | |
326 | int w, h; | |
327 | DoGetSize(& w, & h); | |
328 | return wxSize(w, h); | |
329 | } | |
330 | ||
3c81c9aa VZ |
331 | void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); } |
332 | wxSize GetClientSize() const | |
333 | { | |
334 | int w, h; | |
335 | DoGetClientSize(&w, &h); | |
336 | ||
337 | return wxSize(w, h); | |
338 | } | |
339 | ||
340 | // get the position and size at once | |
f03fc89f VZ |
341 | wxRect GetRect() const |
342 | { | |
343 | int x, y, w, h; | |
3c81c9aa VZ |
344 | GetPosition(&x, &y); |
345 | GetSize(&w, &h); | |
f03fc89f VZ |
346 | |
347 | return wxRect(x, y, w, h); | |
348 | } | |
349 | ||
3c81c9aa | 350 | wxRect GetScreenRect() const |
f03fc89f | 351 | { |
3c81c9aa VZ |
352 | int x, y, w, h; |
353 | GetScreenPosition(&x, &y); | |
354 | GetSize(&w, &h); | |
f03fc89f | 355 | |
3c81c9aa | 356 | return wxRect(x, y, w, h); |
f03fc89f VZ |
357 | } |
358 | ||
1e6feb95 VZ |
359 | // get the origin of the client area of the window relative to the |
360 | // window top left corner (the client area may be shifted because of | |
361 | // the borders, scrollbars, other decorations...) | |
362 | virtual wxPoint GetClientAreaOrigin() const; | |
363 | ||
364 | // get the client rectangle in window (i.e. client) coordinates | |
365 | wxRect GetClientRect() const | |
366 | { | |
367 | return wxRect(GetClientAreaOrigin(), GetClientSize()); | |
368 | } | |
369 | ||
301d7a0d VS |
370 | // client<->window size conversion |
371 | virtual wxSize ClientToWindowSize(const wxSize& size) const; | |
372 | virtual wxSize WindowToClientSize(const wxSize& size) const; | |
373 | ||
f68586e5 | 374 | // get the size best suited for the window (in fact, minimal |
9f884528 RD |
375 | // acceptable size using which it will still look "nice" in |
376 | // most situations) | |
26f7724c RR |
377 | wxSize GetBestSize() const; |
378 | ||
f68586e5 VZ |
379 | void GetBestSize(int *w, int *h) const |
380 | { | |
9f884528 | 381 | wxSize s = GetBestSize(); |
f68586e5 VZ |
382 | if ( w ) |
383 | *w = s.x; | |
384 | if ( h ) | |
385 | *h = s.y; | |
386 | } | |
387 | ||
f4fe2f20 RR |
388 | void SetScrollHelper( wxScrollHelper *sh ) { m_scrollHelper = sh; } |
389 | wxScrollHelper *GetScrollHelper() { return m_scrollHelper; } | |
390 | ||
9f884528 RD |
391 | // reset the cached best size value so it will be recalculated the |
392 | // next time it is needed. | |
992b2ec4 | 393 | void InvalidateBestSize(); |
9f884528 RD |
394 | void CacheBestSize(const wxSize& size) const |
395 | { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; } | |
a0d9c6cb | 396 | |
2b5f62a0 | 397 | |
9f884528 RD |
398 | // This function will merge the window's best size into the window's |
399 | // minimum size, giving priority to the min size components, and | |
400 | // returns the results. | |
a20a357d | 401 | virtual wxSize GetEffectiveMinSize() const; |
170acdc9 | 402 | wxDEPRECATED( wxSize GetBestFittingSize() const ); // replaced by GetEffectiveMinSize |
d6f582e7 | 403 | wxDEPRECATED( wxSize GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize |
a0d9c6cb | 404 | |
9f884528 RD |
405 | // A 'Smart' SetSize that will fill in default size values with 'best' |
406 | // size. Sets the minsize to what was passed in. | |
170acdc9 RD |
407 | void SetInitialSize(const wxSize& size=wxDefaultSize); |
408 | wxDEPRECATED( void SetBestFittingSize(const wxSize& size=wxDefaultSize) ); // replaced by SetInitialSize | |
9f884528 | 409 | |
47a8a4d5 | 410 | |
2b5f62a0 | 411 | // the generic centre function - centers the window on parent by` |
7eb4e9cc VZ |
412 | // default or on screen if it doesn't have parent or |
413 | // wxCENTER_ON_SCREEN flag is given | |
1f464296 VZ |
414 | void Centre(int dir = wxBOTH) { DoCentre(dir); } |
415 | void Center(int dir = wxBOTH) { DoCentre(dir); } | |
7eb4e9cc VZ |
416 | |
417 | // centre with respect to the the parent window | |
1f464296 | 418 | void CentreOnParent(int dir = wxBOTH) { DoCentre(dir); } |
7eb4e9cc | 419 | void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); } |
f03fc89f VZ |
420 | |
421 | // set window size to wrap around its children | |
422 | virtual void Fit(); | |
423 | ||
2b5f62a0 VZ |
424 | // set virtual size to satisfy children |
425 | virtual void FitInside(); | |
426 | ||
9379c0d7 | 427 | |
b21f4960 RR |
428 | // SetSizeHints is actually for setting the size hints |
429 | // for the wxTLW for a Window Manager - hence the name - | |
430 | // and it is therefore overridden in wxTLW to do that. | |
431 | // In wxWindow(Base), it has (unfortunately) been abused | |
432 | // to mean the same as SetMinSize() and SetMaxSize(). | |
47a8a4d5 | 433 | |
f03fc89f | 434 | virtual void SetSizeHints( int minW, int minH, |
a0d9c6cb | 435 | int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, |
571f6981 | 436 | int incW = wxDefaultCoord, int incH = wxDefaultCoord ) |
9379c0d7 | 437 | { DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); } |
6fb99eb3 | 438 | |
1ec25e8f RD |
439 | void SetSizeHints( const wxSize& minSize, |
440 | const wxSize& maxSize=wxDefaultSize, | |
441 | const wxSize& incSize=wxDefaultSize) | |
9379c0d7 RR |
442 | { DoSetSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y, incSize.x, incSize.y); } |
443 | ||
f03fc89f | 444 | |
f944aec0 VS |
445 | #if WXWIN_COMPATIBILITY_2_8 |
446 | // these are useless and do nothing since wxWidgets 2.9 | |
447 | wxDEPRECATED( virtual void SetVirtualSizeHints( int minW, int minH, | |
448 | int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ) ); | |
449 | wxDEPRECATED( void SetVirtualSizeHints( const wxSize& minSize, | |
450 | const wxSize& maxSize=wxDefaultSize) ); | |
451 | #endif // WXWIN_COMPATIBILITY_2_8 | |
566d84a7 | 452 | |
57c4d796 | 453 | |
47a8a4d5 | 454 | // Call these to override what GetBestSize() returns. This |
a1b05a60 RR |
455 | // method is only virtual because it is overriden in wxTLW |
456 | // as a different API for SetSizeHints(). | |
e81c7155 RR |
457 | virtual void SetMinSize(const wxSize& minSize); |
458 | virtual void SetMaxSize(const wxSize& maxSize); | |
a1b05a60 | 459 | |
3b96ea1a VS |
460 | // Like Set*Size, but for client, not window, size |
461 | virtual void SetMinClientSize(const wxSize& size) | |
462 | { SetMinSize(ClientToWindowSize(size)); } | |
463 | virtual void SetMaxClientSize(const wxSize& size) | |
464 | { SetMaxSize(ClientToWindowSize(size)); } | |
465 | ||
a1b05a60 | 466 | // Override these methods to impose restrictions on min/max size. |
47a8a4d5 | 467 | // The easier way is to call SetMinSize() and SetMaxSize() which |
a1b05a60 | 468 | // will have the same effect. Doing both is non-sense. |
b4350341 VZ |
469 | virtual wxSize GetMinSize() const { return wxSize(m_minWidth, m_minHeight); } |
470 | virtual wxSize GetMaxSize() const { return wxSize(m_maxWidth, m_maxHeight); } | |
400a9e41 | 471 | |
3b96ea1a VS |
472 | // Like Get*Size, but for client, not window, size |
473 | virtual wxSize GetMinClientSize() const | |
474 | { return WindowToClientSize(GetMinSize()); } | |
475 | virtual wxSize GetMaxClientSize() const | |
476 | { return WindowToClientSize(GetMaxSize()); } | |
477 | ||
a1b05a60 RR |
478 | // Get the min and max values one by one |
479 | int GetMinWidth() const { return GetMinSize().x; } | |
480 | int GetMinHeight() const { return GetMinSize().y; } | |
481 | int GetMaxWidth() const { return GetMaxSize().x; } | |
482 | int GetMaxHeight() const { return GetMaxSize().y; } | |
9379c0d7 | 483 | |
a0d9c6cb | 484 | |
566d84a7 RL |
485 | // Methods for accessing the virtual size of a window. For most |
486 | // windows this is just the client area of the window, but for | |
487 | // some like scrolled windows it is more or less independent of | |
488 | // the screen window size. You may override the DoXXXVirtual | |
489 | // methods below for classes where that is is the case. | |
490 | ||
491 | void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); } | |
492 | void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); } | |
493 | ||
494 | wxSize GetVirtualSize() const { return DoGetVirtualSize(); } | |
495 | void GetVirtualSize( int *x, int *y ) const | |
496 | { | |
497 | wxSize s( DoGetVirtualSize() ); | |
498 | ||
499 | if( x ) | |
500 | *x = s.GetWidth(); | |
501 | if( y ) | |
502 | *y = s.GetHeight(); | |
503 | } | |
504 | ||
505 | // Override these methods for windows that have a virtual size | |
506 | // independent of their client size. eg. the virtual area of a | |
e5ecf1fc | 507 | // wxScrolledWindow. |
566d84a7 RL |
508 | |
509 | virtual void DoSetVirtualSize( int x, int y ); | |
85b38e0b | 510 | virtual wxSize DoGetVirtualSize() const; |
e5ecf1fc | 511 | |
2b5f62a0 VZ |
512 | // Return the largest of ClientSize and BestSize (as determined |
513 | // by a sizer, interior children, or other means) | |
514 | ||
515 | virtual wxSize GetBestVirtualSize() const | |
516 | { | |
517 | wxSize client( GetClientSize() ); | |
518 | wxSize best( GetBestSize() ); | |
519 | ||
520 | return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) ); | |
521 | } | |
522 | ||
333d7052 VZ |
523 | // return the size of the left/right and top/bottom borders in x and y |
524 | // components of the result respectively | |
525 | virtual wxSize GetWindowBorderSize() const; | |
526 | ||
15f7c305 | 527 | // wxSizer and friends use this to give a chance to a component to recalc |
53a2db12 FM |
528 | // its min size once one of the final size components is known. Override |
529 | // this function when that is useful (such as for wxStaticText which can | |
15f7c305 | 530 | // stretch over several lines). Parameter availableOtherDir |
53a2db12 | 531 | // tells the item how much more space there is available in the opposite |
15f7c305 | 532 | // direction (-1 if unknown). |
0dba08dd VZ |
533 | virtual bool |
534 | InformFirstDirection(int WXUNUSED(direction), | |
535 | int WXUNUSED(size), | |
536 | int WXUNUSED(availableOtherDir)) | |
537 | { | |
538 | return false; | |
539 | } | |
540 | ||
541 | // sends a size event to the window using its current size -- this has an | |
542 | // effect of refreshing the window layout | |
ecdc1183 VZ |
543 | // |
544 | // by default the event is sent, i.e. processed immediately, but if flags | |
545 | // value includes wxSEND_EVENT_POST then it's posted, i.e. only schedule | |
546 | // for later processing | |
547 | virtual void SendSizeEvent(int flags = 0); | |
0dba08dd VZ |
548 | |
549 | // this is a safe wrapper for GetParent()->SendSizeEvent(): it checks that | |
550 | // we have a parent window and it's not in process of being deleted | |
551 | // | |
552 | // this is used by controls such as tool/status bars changes to which must | |
553 | // also result in parent re-layout | |
ecdc1183 VZ |
554 | void SendSizeEventToParent(int flags = 0); |
555 | ||
556 | // this is a more readable synonym for SendSizeEvent(wxSEND_EVENT_POST) | |
557 | void PostSizeEvent() { SendSizeEvent(wxSEND_EVENT_POST); } | |
558 | ||
559 | // this is the same as SendSizeEventToParent() but using PostSizeEvent() | |
560 | void PostSizeEventToParent() { SendSizeEventToParent(wxSEND_EVENT_POST); } | |
0dba08dd | 561 | |
333d7052 | 562 | |
f03fc89f VZ |
563 | // window state |
564 | // ------------ | |
565 | ||
d4864e97 | 566 | // returns true if window was shown/hidden, false if the nothing was |
f03fc89f | 567 | // done (window was already shown/hidden) |
d4864e97 VZ |
568 | virtual bool Show( bool show = true ); |
569 | bool Hide() { return Show(false); } | |
f03fc89f | 570 | |
376d7d97 VZ |
571 | // show or hide the window with a special effect, not implemented on |
572 | // most platforms (where it is the same as Show()/Hide() respectively) | |
573 | // | |
574 | // timeout specifies how long the animation should take, in ms, the | |
575 | // default value of 0 means to use the default (system-dependent) value | |
eed04c99 VS |
576 | virtual bool ShowWithEffect(wxShowEffect WXUNUSED(effect), |
577 | unsigned WXUNUSED(timeout) = 0) | |
376d7d97 | 578 | { |
376d7d97 VZ |
579 | return Show(); |
580 | } | |
581 | ||
eed04c99 VS |
582 | virtual bool HideWithEffect(wxShowEffect WXUNUSED(effect), |
583 | unsigned WXUNUSED(timeout) = 0) | |
376d7d97 | 584 | { |
376d7d97 VZ |
585 | return Hide(); |
586 | } | |
587 | ||
d4864e97 VZ |
588 | // returns true if window was enabled/disabled, false if nothing done |
589 | virtual bool Enable( bool enable = true ); | |
590 | bool Disable() { return Enable(false); } | |
f03fc89f | 591 | |
b08cd3bf | 592 | virtual bool IsShown() const { return m_isShown; } |
47a8a4d5 VZ |
593 | // returns true if the window is really enabled and false otherwise, |
594 | // whether because it had been explicitly disabled itself or because | |
595 | // its parent is currently disabled -- then this method returns false | |
596 | // whatever is the intrinsic state of this window, use IsThisEnabled(0 | |
597 | // to retrieve it. In other words, this relation always holds: | |
598 | // | |
599 | // IsEnabled() == IsThisEnabled() && parent.IsEnabled() | |
600 | // | |
601 | bool IsEnabled() const; | |
602 | ||
603 | // returns the internal window state independently of the parent(s) | |
604 | // state, i.e. the state in which the window would be if all its | |
605 | // parents were enabled (use IsEnabled() above to get the effective | |
606 | // window state) | |
607 | bool IsThisEnabled() const { return m_isEnabled; } | |
f03fc89f | 608 | |
9c72cf76 VS |
609 | // returns true if the window is visible, i.e. IsShown() returns true |
610 | // if called on it and all its parents up to the first TLW | |
865a74c7 | 611 | virtual bool IsShownOnScreen() const; |
9c72cf76 | 612 | |
f03fc89f VZ |
613 | // get/set window style (setting style won't update the window and so |
614 | // is only useful for internal usage) | |
615 | virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; } | |
616 | virtual long GetWindowStyleFlag() const { return m_windowStyle; } | |
617 | ||
618 | // just some (somewhat shorter) synonims | |
619 | void SetWindowStyle( long style ) { SetWindowStyleFlag(style); } | |
620 | long GetWindowStyle() const { return GetWindowStyleFlag(); } | |
621 | ||
d63312a9 | 622 | // check if the flag is set |
f03fc89f | 623 | bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; } |
d80cd92a | 624 | virtual bool IsRetained() const { return HasFlag(wxRETAINED); } |
f03fc89f | 625 | |
d63312a9 VZ |
626 | // turn the flag on if it had been turned off before and vice versa, |
627 | // return true if the flag is currently turned on | |
628 | bool ToggleWindowStyle(int flag); | |
629 | ||
d80cd92a VZ |
630 | // extra style: the less often used style bits which can't be set with |
631 | // SetWindowStyleFlag() | |
b2d5a7ee | 632 | virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; } |
d80cd92a | 633 | long GetExtraStyle() const { return m_exStyle; } |
f03fc89f | 634 | |
a2979ead VZ |
635 | bool HasExtraStyle(int exFlag) const { return (m_exStyle & exFlag) != 0; } |
636 | ||
f03fc89f | 637 | // make the window modal (all other windows unresponsive) |
d4864e97 | 638 | virtual void MakeModal(bool modal = true); |
f03fc89f | 639 | |
b8e7b673 VZ |
640 | |
641 | // (primitive) theming support | |
642 | // --------------------------- | |
643 | ||
a2d93e73 JS |
644 | virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; } |
645 | virtual bool GetThemeEnabled() const { return m_themeEnabled; } | |
646 | ||
d4864e97 | 647 | |
456bc6d9 VZ |
648 | // focus and keyboard handling |
649 | // --------------------------- | |
f03fc89f VZ |
650 | |
651 | // set focus to this window | |
652 | virtual void SetFocus() = 0; | |
653 | ||
d577d610 VZ |
654 | // set focus to this window as the result of a keyboard action |
655 | virtual void SetFocusFromKbd() { SetFocus(); } | |
656 | ||
f03fc89f | 657 | // return the window which currently has the focus or NULL |
0fe02759 | 658 | static wxWindow *FindFocus(); |
6fb99eb3 | 659 | |
0fe02759 | 660 | static wxWindow *DoFindFocus() /* = 0: implement in derived classes */; |
f03fc89f | 661 | |
3358af0f VS |
662 | // return true if the window has focus (handles composite windows |
663 | // correctly - returns true if GetMainWindowOfCompositeControl() | |
664 | // has focus) | |
665 | virtual bool HasFocus() const; | |
666 | ||
ad02525d VZ |
667 | // can this window have focus in principle? |
668 | // | |
669 | // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus | |
670 | // [FromKeyboard]() is that the former functions are meant to be | |
671 | // overridden in the derived classes to simply return false if the | |
672 | // control can't have focus, while the latter are meant to be used by | |
673 | // this class clients and take into account the current window state | |
674 | virtual bool AcceptsFocus() const { return true; } | |
675 | ||
edc09871 VZ |
676 | // can this window or one of its children accept focus? |
677 | // | |
678 | // usually it's the same as AcceptsFocus() but is overridden for | |
679 | // container windows | |
680 | virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); } | |
f03fc89f | 681 | |
1e6feb95 VZ |
682 | // can this window be given focus by keyboard navigation? if not, the |
683 | // only way to give it focus (provided it accepts it at all) is to | |
684 | // click it | |
685 | virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); } | |
686 | ||
edc09871 VZ |
687 | |
688 | // this is mostly a helper for the various functions using it below | |
689 | bool CanBeFocused() const { return IsShown() && IsEnabled(); } | |
690 | ||
691 | // can this window itself have focus? | |
692 | bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); } | |
693 | ||
694 | // can this window have focus right now? | |
695 | // | |
696 | // if this method returns true, it means that calling SetFocus() will | |
697 | // put focus either to this window or one of its children, if you need | |
698 | // to know whether this window accepts focus itself, use IsFocusable() | |
699 | bool CanAcceptFocus() const | |
700 | { return AcceptsFocusRecursively() && CanBeFocused(); } | |
701 | ||
ad02525d VZ |
702 | // can this window be assigned focus from keyboard right now? |
703 | bool CanAcceptFocusFromKeyboard() const | |
edc09871 | 704 | { return AcceptsFocusFromKeyboard() && CanBeFocused(); } |
ad02525d | 705 | |
80332672 VZ |
706 | // call this when the return value of AcceptsFocus() changes |
707 | virtual void SetCanFocus(bool WXUNUSED(canFocus)) { } | |
708 | ||
5644933f VZ |
709 | // navigates inside this window |
710 | bool NavigateIn(int flags = wxNavigationKeyEvent::IsForward) | |
711 | { return DoNavigateIn(flags); } | |
712 | ||
713 | // navigates in the specified direction from this window, this is | |
714 | // equivalent to GetParent()->NavigateIn() | |
715 | bool Navigate(int flags = wxNavigationKeyEvent::IsForward) | |
716 | { return m_parent && ((wxWindowBase *)m_parent)->DoNavigateIn(flags); } | |
5f6cfda7 | 717 | |
f029f1d1 VS |
718 | // this function will generate the appropriate call to Navigate() if the |
719 | // key event is one normally used for keyboard navigation and return true | |
720 | // in this case | |
721 | bool HandleAsNavigationKey(const wxKeyEvent& event); | |
722 | ||
a24de76b VZ |
723 | // move this window just before/after the specified one in tab order |
724 | // (the other window must be our sibling!) | |
725 | void MoveBeforeInTabOrder(wxWindow *win) | |
c944775f | 726 | { DoMoveInTabOrder(win, OrderBefore); } |
a24de76b | 727 | void MoveAfterInTabOrder(wxWindow *win) |
c944775f | 728 | { DoMoveInTabOrder(win, OrderAfter); } |
a24de76b VZ |
729 | |
730 | ||
f03fc89f VZ |
731 | // parent/children relations |
732 | // ------------------------- | |
733 | ||
734 | // get the list of children | |
735 | const wxWindowList& GetChildren() const { return m_children; } | |
736 | wxWindowList& GetChildren() { return m_children; } | |
737 | ||
1978421a SC |
738 | // needed just for extended runtime |
739 | const wxWindowList& GetWindowChildren() const { return GetChildren() ; } | |
740 | ||
c944775f VZ |
741 | // get the window before/after this one in the parents children list, |
742 | // returns NULL if this is the first/last window | |
743 | wxWindow *GetPrevSibling() const { return DoGetSibling(OrderBefore); } | |
744 | wxWindow *GetNextSibling() const { return DoGetSibling(OrderAfter); } | |
745 | ||
f03fc89f VZ |
746 | // get the parent or the parent of the parent |
747 | wxWindow *GetParent() const { return m_parent; } | |
748 | inline wxWindow *GetGrandParent() const; | |
749 | ||
750 | // is this window a top level one? | |
8487f887 | 751 | virtual bool IsTopLevel() const; |
f03fc89f | 752 | |
87b6002d | 753 | // it doesn't really change parent, use Reparent() instead |
f03fc89f | 754 | void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; } |
d4864e97 VZ |
755 | // change the real parent of this window, return true if the parent |
756 | // was changed, false otherwise (error or newParent == oldParent) | |
f03fc89f VZ |
757 | virtual bool Reparent( wxWindowBase *newParent ); |
758 | ||
146ba0fe VZ |
759 | // implementation mostly |
760 | virtual void AddChild( wxWindowBase *child ); | |
761 | virtual void RemoveChild( wxWindowBase *child ); | |
762 | ||
049908c5 VS |
763 | // returns true if the child is in the client area of the window, i.e. is |
764 | // not scrollbar, toolbar etc. | |
765 | virtual bool IsClientAreaChild(const wxWindow *WXUNUSED(child)) const | |
766 | { return true; } | |
767 | ||
146ba0fe VZ |
768 | // looking for windows |
769 | // ------------------- | |
770 | ||
f03fc89f VZ |
771 | // find window among the descendants of this one either by id or by |
772 | // name (return NULL if not found) | |
6b73af79 VZ |
773 | wxWindow *FindWindow(long winid) const; |
774 | wxWindow *FindWindow(const wxString& name) const; | |
f03fc89f | 775 | |
146ba0fe | 776 | // Find a window among any window (all return NULL if not found) |
d9e2e4c2 | 777 | static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL ); |
146ba0fe VZ |
778 | static wxWindow *FindWindowByName( const wxString& name, |
779 | const wxWindow *parent = NULL ); | |
780 | static wxWindow *FindWindowByLabel( const wxString& label, | |
781 | const wxWindow *parent = NULL ); | |
f03fc89f VZ |
782 | |
783 | // event handler stuff | |
784 | // ------------------- | |
785 | ||
786 | // get the current event handler | |
787 | wxEvtHandler *GetEventHandler() const { return m_eventHandler; } | |
788 | ||
789 | // replace the event handler (allows to completely subclass the | |
790 | // window) | |
7f853dd0 | 791 | void SetEventHandler( wxEvtHandler *handler ); |
f03fc89f VZ |
792 | |
793 | // push/pop event handler: allows to chain a custom event handler to | |
794 | // alreasy existing ones | |
795 | void PushEventHandler( wxEvtHandler *handler ); | |
d4864e97 | 796 | wxEvtHandler *PopEventHandler( bool deleteHandler = false ); |
f03fc89f | 797 | |
2e36d5cf | 798 | // find the given handler in the event handler chain and remove (but |
d4864e97 VZ |
799 | // not delete) it from the event handler chain, return true if it was |
800 | // found and false otherwise (this also results in an assert failure so | |
2e36d5cf VZ |
801 | // this function should only be called when the handler is supposed to |
802 | // be there) | |
803 | bool RemoveEventHandler(wxEvtHandler *handler); | |
804 | ||
3b7fa206 VZ |
805 | // Process an event by calling GetEventHandler()->ProcessEvent(): this |
806 | // is a straightforward replacement for ProcessEvent() itself which | |
807 | // shouldn't be used directly with windows as it doesn't take into | |
808 | // account any event handlers associated with the window | |
809 | bool ProcessWindowEvent(wxEvent& event) | |
810 | { return GetEventHandler()->ProcessEvent(event); } | |
811 | ||
7f853dd0 FM |
812 | // Process an event by calling GetEventHandler()->ProcessEvent() and |
813 | // handling any exceptions thrown by event handlers. It's mostly useful | |
814 | // when processing wx events when called from C code (e.g. in GTK+ | |
815 | // callback) when the exception wouldn't correctly propagate to | |
816 | // wxEventLoop. | |
937013e0 VS |
817 | bool HandleWindowEvent(wxEvent& event) const; |
818 | ||
7f853dd0 FM |
819 | // disable wxEvtHandler double-linked list mechanism: |
820 | virtual void SetNextHandler(wxEvtHandler *handler); | |
821 | virtual void SetPreviousHandler(wxEvtHandler *handler); | |
822 | ||
f27683e7 VZ |
823 | |
824 | // Watcom doesn't allow reducing access with using access declaration, see | |
825 | // #10749 | |
826 | #ifndef __WATCOMC__ | |
004867db FM |
827 | protected: |
828 | ||
829 | // NOTE: we change the access specifier of the following wxEvtHandler functions | |
830 | // so that the user won't be able to call them directly. | |
831 | // Calling wxWindow::ProcessEvent in fact only works when there are NO | |
832 | // event handlers pushed on the window. | |
833 | // To ensure correct operation, instead of wxWindow::ProcessEvent | |
834 | // you must always call wxWindow::GetEventHandler()->ProcessEvent() | |
835 | // or HandleWindowEvent(). | |
836 | // The same holds for all other wxEvtHandler functions. | |
837 | ||
d571cf14 | 838 | using wxEvtHandler::ProcessEvent; |
5079735c | 839 | #if wxUSE_THREADS |
d571cf14 | 840 | using wxEvtHandler::ProcessThreadEvent; |
5079735c | 841 | #endif |
d571cf14 VZ |
842 | using wxEvtHandler::SafelyProcessEvent; |
843 | using wxEvtHandler::ProcessPendingEvents; | |
844 | using wxEvtHandler::AddPendingEvent; | |
845 | using wxEvtHandler::QueueEvent; | |
f27683e7 | 846 | #endif // __WATCOMC__ |
004867db FM |
847 | |
848 | public: | |
849 | ||
1e6feb95 VZ |
850 | // validators |
851 | // ---------- | |
f03fc89f | 852 | |
88ac883a | 853 | #if wxUSE_VALIDATORS |
f03fc89f VZ |
854 | // a window may have an associated validator which is used to control |
855 | // user input | |
856 | virtual void SetValidator( const wxValidator &validator ); | |
857 | virtual wxValidator *GetValidator() { return m_windowValidator; } | |
88ac883a | 858 | #endif // wxUSE_VALIDATORS |
f03fc89f | 859 | |
f03fc89f VZ |
860 | |
861 | // dialog oriented functions | |
862 | // ------------------------- | |
863 | ||
d4864e97 | 864 | // validate the correctness of input, return true if ok |
f03fc89f VZ |
865 | virtual bool Validate(); |
866 | ||
867 | // transfer data between internal and GUI representations | |
868 | virtual bool TransferDataToWindow(); | |
869 | virtual bool TransferDataFromWindow(); | |
870 | ||
871 | virtual void InitDialog(); | |
872 | ||
88ac883a | 873 | #if wxUSE_ACCEL |
f03fc89f VZ |
874 | // accelerators |
875 | // ------------ | |
876 | virtual void SetAcceleratorTable( const wxAcceleratorTable& accel ) | |
877 | { m_acceleratorTable = accel; } | |
878 | wxAcceleratorTable *GetAcceleratorTable() | |
879 | { return &m_acceleratorTable; } | |
5048c832 | 880 | |
540b6b09 VZ |
881 | #endif // wxUSE_ACCEL |
882 | ||
883 | #if wxUSE_HOTKEY | |
884 | // hot keys (system wide accelerators) | |
885 | // ----------------------------------- | |
886 | ||
887 | virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode); | |
5048c832 | 888 | virtual bool UnregisterHotKey(int hotkeyId); |
540b6b09 | 889 | #endif // wxUSE_HOTKEY |
5048c832 | 890 | |
f03fc89f VZ |
891 | |
892 | // dialog units translations | |
893 | // ------------------------- | |
894 | ||
895 | wxPoint ConvertPixelsToDialog( const wxPoint& pt ); | |
896 | wxPoint ConvertDialogToPixels( const wxPoint& pt ); | |
897 | wxSize ConvertPixelsToDialog( const wxSize& sz ) | |
898 | { | |
899 | wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); | |
900 | ||
901 | return wxSize(pt.x, pt.y); | |
902 | } | |
903 | ||
904 | wxSize ConvertDialogToPixels( const wxSize& sz ) | |
905 | { | |
906 | wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); | |
907 | ||
908 | return wxSize(pt.x, pt.y); | |
909 | } | |
910 | ||
911 | // mouse functions | |
912 | // --------------- | |
913 | ||
914 | // move the mouse to the specified position | |
915 | virtual void WarpPointer(int x, int y) = 0; | |
916 | ||
94633ad9 VZ |
917 | // start or end mouse capture, these functions maintain the stack of |
918 | // windows having captured the mouse and after calling ReleaseMouse() | |
919 | // the mouse is not released but returns to the window which had had | |
920 | // captured it previously (if any) | |
921 | void CaptureMouse(); | |
922 | void ReleaseMouse(); | |
f03fc89f | 923 | |
1e6feb95 VZ |
924 | // get the window which currently captures the mouse or NULL |
925 | static wxWindow *GetCapture(); | |
926 | ||
927 | // does this window have the capture? | |
928 | virtual bool HasCapture() const | |
929 | { return (wxWindow *)this == GetCapture(); } | |
930 | ||
f03fc89f VZ |
931 | // painting the window |
932 | // ------------------- | |
933 | ||
934 | // mark the specified rectangle (or the whole window) as "dirty" so it | |
935 | // will be repainted | |
d4864e97 | 936 | virtual void Refresh( bool eraseBackground = true, |
f03fc89f | 937 | const wxRect *rect = (const wxRect *) NULL ) = 0; |
1e6feb95 VZ |
938 | |
939 | // a less awkward wrapper for Refresh | |
8cfa09bd VZ |
940 | void RefreshRect(const wxRect& rect, bool eraseBackground = true) |
941 | { | |
942 | Refresh(eraseBackground, &rect); | |
943 | } | |
1e6feb95 VZ |
944 | |
945 | // repaint all invalid areas of the window immediately | |
946 | virtual void Update() { } | |
947 | ||
5da0803c VZ |
948 | // clear the window background |
949 | virtual void ClearBackground(); | |
f03fc89f | 950 | |
0cc7251e | 951 | // freeze the window: don't redraw it until it is thawed |
1c8e5c51 | 952 | void Freeze(); |
0cc7251e VZ |
953 | |
954 | // thaw the window: redraw it after it had been frozen | |
1c8e5c51 | 955 | void Thaw(); |
0cc7251e | 956 | |
d4a1433f | 957 | // return true if window had been frozen and not unthawed yet |
17808a75 | 958 | bool IsFrozen() const { return m_freezeCount != 0; } |
d4a1433f | 959 | |
f03fc89f | 960 | // adjust DC for drawing on this window |
f6147cfc | 961 | virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { } |
f03fc89f | 962 | |
2e992e06 VZ |
963 | // return true if the window contents is double buffered by the system |
964 | virtual bool IsDoubleBuffered() const { return false; } | |
965 | ||
f03fc89f VZ |
966 | // the update region of the window contains the areas which must be |
967 | // repainted by the program | |
968 | const wxRegion& GetUpdateRegion() const { return m_updateRegion; } | |
969 | wxRegion& GetUpdateRegion() { return m_updateRegion; } | |
970 | ||
1e6feb95 VZ |
971 | // get the update rectangleregion bounding box in client coords |
972 | wxRect GetUpdateClientRect() const; | |
973 | ||
f03fc89f VZ |
974 | // these functions verify whether the given point/rectangle belongs to |
975 | // (or at least intersects with) the update region | |
657b4fd4 RD |
976 | virtual bool DoIsExposed( int x, int y ) const; |
977 | virtual bool DoIsExposed( int x, int y, int w, int h ) const; | |
f03fc89f | 978 | |
657b4fd4 RD |
979 | bool IsExposed( int x, int y ) const |
980 | { return DoIsExposed(x, y); } | |
981 | bool IsExposed( int x, int y, int w, int h ) const | |
982 | { return DoIsExposed(x, y, w, h); } | |
f03fc89f | 983 | bool IsExposed( const wxPoint& pt ) const |
657b4fd4 | 984 | { return DoIsExposed(pt.x, pt.y); } |
f03fc89f | 985 | bool IsExposed( const wxRect& rect ) const |
657b4fd4 | 986 | { return DoIsExposed(rect.x, rect.y, rect.width, rect.height); } |
f03fc89f VZ |
987 | |
988 | // colours, fonts and cursors | |
989 | // -------------------------- | |
990 | ||
1b69c815 VZ |
991 | // get the default attributes for the controls of this class: we |
992 | // provide a virtual function which can be used to query the default | |
993 | // attributes of an existing control and a static function which can | |
994 | // be used even when no existing object of the given class is | |
995 | // available, but which won't return any styles specific to this | |
996 | // particular control, of course (e.g. "Ok" button might have | |
997 | // different -- bold for example -- font) | |
998 | virtual wxVisualAttributes GetDefaultAttributes() const | |
999 | { | |
1000 | return GetClassDefaultAttributes(GetWindowVariant()); | |
1001 | } | |
1002 | ||
1003 | static wxVisualAttributes | |
1004 | GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL); | |
1005 | ||
f03fc89f | 1006 | // set/retrieve the window colours (system defaults are used by |
b8e7b673 | 1007 | // default): SetXXX() functions return true if colour was changed, |
f8ff87ed VS |
1008 | // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the |
1009 | // value to prevent it from being inherited by our children | |
b8e7b673 | 1010 | virtual bool SetBackgroundColour(const wxColour& colour); |
fa47d7a7 | 1011 | void SetOwnBackgroundColour(const wxColour& colour) |
b8e7b673 VZ |
1012 | { |
1013 | if ( SetBackgroundColour(colour) ) | |
f8ff87ed | 1014 | m_inheritBgCol = false; |
b8e7b673 | 1015 | } |
1b69c815 | 1016 | wxColour GetBackgroundColour() const; |
e5ecf1fc WS |
1017 | bool InheritsBackgroundColour() const |
1018 | { | |
1019 | return m_inheritBgCol; | |
1020 | } | |
1021 | bool UseBgCol() const | |
1022 | { | |
1023 | return m_hasBgCol; | |
1024 | } | |
b8e7b673 VZ |
1025 | |
1026 | virtual bool SetForegroundColour(const wxColour& colour); | |
fa47d7a7 | 1027 | void SetOwnForegroundColour(const wxColour& colour) |
b8e7b673 VZ |
1028 | { |
1029 | if ( SetForegroundColour(colour) ) | |
f8ff87ed | 1030 | m_inheritFgCol = false; |
b8e7b673 | 1031 | } |
1b69c815 | 1032 | wxColour GetForegroundColour() const; |
f03fc89f | 1033 | |
50c53860 JS |
1034 | // Set/get the background style. |
1035 | // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM | |
1036 | virtual bool SetBackgroundStyle(wxBackgroundStyle style) { m_backgroundStyle = style; return true; } | |
1037 | virtual wxBackgroundStyle GetBackgroundStyle() const { return m_backgroundStyle; } | |
1038 | ||
7c7a653b VZ |
1039 | // returns true if the control has "transparent" areas such as a |
1040 | // wxStaticText and wxCheckBox and the background should be adapted | |
1041 | // from a parent window | |
1042 | virtual bool HasTransparentBackground() { return false; } | |
1043 | ||
b8e7b673 VZ |
1044 | // set/retrieve the font for the window (SetFont() returns true if the |
1045 | // font really changed) | |
1046 | virtual bool SetFont(const wxFont& font) = 0; | |
fa47d7a7 | 1047 | void SetOwnFont(const wxFont& font) |
b8e7b673 VZ |
1048 | { |
1049 | if ( SetFont(font) ) | |
f8ff87ed | 1050 | m_inheritFont = false; |
b8e7b673 | 1051 | } |
29094af0 | 1052 | wxFont GetFont() const; |
b8e7b673 | 1053 | |
d4864e97 | 1054 | // set/retrieve the cursor for this window (SetCursor() returns true |
f03fc89f VZ |
1055 | // if the cursor was really changed) |
1056 | virtual bool SetCursor( const wxCursor &cursor ); | |
1057 | const wxCursor& GetCursor() const { return m_cursor; } | |
f03fc89f | 1058 | |
789295bf VZ |
1059 | #if wxUSE_CARET |
1060 | // associate a caret with the window | |
1061 | void SetCaret(wxCaret *caret); | |
1062 | // get the current caret (may be NULL) | |
1063 | wxCaret *GetCaret() const { return m_caret; } | |
1064 | #endif // wxUSE_CARET | |
1065 | ||
f03fc89f VZ |
1066 | // get the (average) character size for the current font |
1067 | virtual int GetCharHeight() const = 0; | |
1068 | virtual int GetCharWidth() const = 0; | |
1069 | ||
1070 | // get the width/height/... of the text using current or specified | |
1071 | // font | |
6de70470 VZ |
1072 | void GetTextExtent(const wxString& string, |
1073 | int *x, int *y, | |
1074 | int *descent = NULL, | |
1075 | int *externalLeading = NULL, | |
1076 | const wxFont *font = NULL) const | |
1077 | { | |
1078 | DoGetTextExtent(string, x, y, descent, externalLeading, font); | |
1079 | } | |
f03fc89f | 1080 | |
6b062263 VZ |
1081 | wxSize GetTextExtent(const wxString& string) const |
1082 | { | |
1083 | wxCoord w, h; | |
1084 | GetTextExtent(string, &w, &h); | |
1085 | return wxSize(w, h); | |
1086 | } | |
1087 | ||
1e6feb95 VZ |
1088 | // client <-> screen coords |
1089 | // ------------------------ | |
1090 | ||
f03fc89f | 1091 | // translate to/from screen/client coordinates (pointers may be NULL) |
dabc0cd5 VZ |
1092 | void ClientToScreen( int *x, int *y ) const |
1093 | { DoClientToScreen(x, y); } | |
1094 | void ScreenToClient( int *x, int *y ) const | |
1095 | { DoScreenToClient(x, y); } | |
1e6feb95 VZ |
1096 | |
1097 | // wxPoint interface to do the same thing | |
dabc0cd5 VZ |
1098 | wxPoint ClientToScreen(const wxPoint& pt) const |
1099 | { | |
1100 | int x = pt.x, y = pt.y; | |
1101 | DoClientToScreen(&x, &y); | |
1102 | ||
1103 | return wxPoint(x, y); | |
1104 | } | |
1105 | ||
1106 | wxPoint ScreenToClient(const wxPoint& pt) const | |
1107 | { | |
1108 | int x = pt.x, y = pt.y; | |
1109 | DoScreenToClient(&x, &y); | |
1110 | ||
1111 | return wxPoint(x, y); | |
1112 | } | |
f03fc89f | 1113 | |
1e6feb95 VZ |
1114 | // test where the given (in client coords) point lies |
1115 | wxHitTest HitTest(wxCoord x, wxCoord y) const | |
1116 | { return DoHitTest(x, y); } | |
1117 | ||
1118 | wxHitTest HitTest(const wxPoint& pt) const | |
1119 | { return DoHitTest(pt.x, pt.y); } | |
1120 | ||
f03fc89f VZ |
1121 | // misc |
1122 | // ---- | |
1123 | ||
aede4ebb VZ |
1124 | // get the window border style from the given flags: this is different from |
1125 | // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to | |
1126 | // translate wxBORDER_DEFAULT to something reasonable | |
1127 | wxBorder GetBorder(long flags) const; | |
1128 | ||
1129 | // get border for the flags of this window | |
1130 | wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); } | |
1e6feb95 | 1131 | |
d4864e97 | 1132 | // send wxUpdateUIEvents to this window, and children if recurse is true |
e39af974 JS |
1133 | virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE); |
1134 | ||
1135 | // do the window-specific processing after processing the update event | |
1136 | virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; | |
f03fc89f | 1137 | |
1e6feb95 | 1138 | #if wxUSE_MENUS |
00a77b7c VZ |
1139 | // show popup menu at the given position, generate events for the items |
1140 | // selected in it | |
45b8a256 | 1141 | bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition) |
eeb0bee1 VZ |
1142 | { return PopupMenu(menu, pos.x, pos.y); } |
1143 | bool PopupMenu(wxMenu *menu, int x, int y); | |
00a77b7c VZ |
1144 | |
1145 | // simply return the id of the selected item or wxID_NONE without | |
1146 | // generating any events | |
1147 | int GetPopupMenuSelectionFromUser(wxMenu& menu, const wxPoint& pos) | |
1148 | { return DoGetPopupMenuSelectionFromUser(menu, pos.x, pos.y); } | |
1149 | int GetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y) | |
1150 | { return DoGetPopupMenuSelectionFromUser(menu, x, y); } | |
1e6feb95 | 1151 | #endif // wxUSE_MENUS |
f03fc89f | 1152 | |
e71c530e VZ |
1153 | // override this method to return true for controls having multiple pages |
1154 | virtual bool HasMultiplePages() const { return false; } | |
1155 | ||
1156 | ||
f03fc89f VZ |
1157 | // scrollbars |
1158 | // ---------- | |
1159 | ||
1e6feb95 VZ |
1160 | // does the window have the scrollbar for this orientation? |
1161 | bool HasScrollbar(int orient) const | |
1162 | { | |
1163 | return (m_windowStyle & | |
1164 | (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0; | |
1165 | } | |
1166 | ||
f03fc89f VZ |
1167 | // configure the window scrollbars |
1168 | virtual void SetScrollbar( int orient, | |
1169 | int pos, | |
1e6feb95 | 1170 | int thumbvisible, |
f03fc89f | 1171 | int range, |
d4864e97 VZ |
1172 | bool refresh = true ) = 0; |
1173 | virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0; | |
f03fc89f VZ |
1174 | virtual int GetScrollPos( int orient ) const = 0; |
1175 | virtual int GetScrollThumb( int orient ) const = 0; | |
1176 | virtual int GetScrollRange( int orient ) const = 0; | |
1177 | ||
1178 | // scroll window to the specified position | |
1179 | virtual void ScrollWindow( int dx, int dy, | |
d3b9f782 | 1180 | const wxRect* rect = NULL ) = 0; |
f03fc89f | 1181 | |
b9b3393e | 1182 | // scrolls window by line/page: note that not all controls support this |
9cd6d737 | 1183 | // |
d4864e97 VZ |
1184 | // return true if the position changed, false otherwise |
1185 | virtual bool ScrollLines(int WXUNUSED(lines)) { return false; } | |
1186 | virtual bool ScrollPages(int WXUNUSED(pages)) { return false; } | |
9cd6d737 VZ |
1187 | |
1188 | // convenient wrappers for ScrollLines/Pages | |
1189 | bool LineUp() { return ScrollLines(-1); } | |
1190 | bool LineDown() { return ScrollLines(1); } | |
1191 | bool PageUp() { return ScrollPages(-1); } | |
1192 | bool PageDown() { return ScrollPages(1); } | |
b9b3393e | 1193 | |
c1142003 VZ |
1194 | // call this to always show one or both scrollbars, even if the window |
1195 | // is big enough to not require them | |
1196 | virtual void AlwaysShowScrollbars(bool WXUNUSED(horz) = true, | |
1197 | bool WXUNUSED(vert) = true) | |
1198 | { | |
1199 | } | |
1200 | ||
1201 | // return true if AlwaysShowScrollbars() had been called before for the | |
1202 | // corresponding orientation | |
1203 | virtual bool IsScrollbarAlwaysShown(int WXUNUSED(orient)) const | |
1204 | { | |
1205 | return false; | |
1206 | } | |
1207 | ||
bd83cb56 VZ |
1208 | // context-sensitive help |
1209 | // ---------------------- | |
1210 | ||
1211 | // these are the convenience functions wrapping wxHelpProvider methods | |
1212 | ||
1213 | #if wxUSE_HELP | |
1214 | // associate this help text with this window | |
1215 | void SetHelpText(const wxString& text); | |
520746ac VS |
1216 | |
1217 | #if WXWIN_COMPATIBILITY_2_8 | |
1218 | // Associate this help text with all windows with the same id as this one. | |
1219 | // Don't use this, do wxHelpProvider::Get()->AddHelp(id, text); | |
1220 | wxDEPRECATED( void SetHelpTextForId(const wxString& text) ); | |
1221 | #endif // WXWIN_COMPATIBILITY_2_8 | |
1222 | ||
dc6588e7 VZ |
1223 | // get the help string associated with the given position in this window |
1224 | // | |
1225 | // notice that pt may be invalid if event origin is keyboard or unknown | |
1226 | // and this method should return the global window help text then | |
1227 | virtual wxString GetHelpTextAtPoint(const wxPoint& pt, | |
1228 | wxHelpEvent::Origin origin) const; | |
1229 | // returns the position-independent help text | |
1230 | wxString GetHelpText() const | |
1231 | { | |
1232 | return GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Unknown); | |
1233 | } | |
1234 | ||
1235 | #else // !wxUSE_HELP | |
6c3c55cf VZ |
1236 | // silently ignore SetHelpText() calls |
1237 | void SetHelpText(const wxString& WXUNUSED(text)) { } | |
1238 | void SetHelpTextForId(const wxString& WXUNUSED(text)) { } | |
bd83cb56 VZ |
1239 | #endif // wxUSE_HELP |
1240 | ||
f03fc89f VZ |
1241 | // tooltips |
1242 | // -------- | |
bd83cb56 | 1243 | |
f03fc89f VZ |
1244 | #if wxUSE_TOOLTIPS |
1245 | // the easiest way to set a tooltip for a window is to use this method | |
1246 | void SetToolTip( const wxString &tip ); | |
410201d9 VZ |
1247 | // attach a tooltip to the window, pointer can be NULL to remove |
1248 | // existing tooltip | |
f03fc89f | 1249 | void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); } |
410201d9 VZ |
1250 | // more readable synonym for SetToolTip(NULL) |
1251 | void UnsetToolTip() { SetToolTip(NULL); } | |
f03fc89f VZ |
1252 | // get the associated tooltip or NULL if none |
1253 | wxToolTip* GetToolTip() const { return m_tooltip; } | |
410201d9 VZ |
1254 | wxString GetToolTipText() const; |
1255 | #else // !wxUSE_TOOLTIPS | |
7649d8fc JS |
1256 | // make it much easier to compile apps in an environment |
1257 | // that doesn't support tooltips, such as PocketPC | |
410201d9 VZ |
1258 | void SetToolTip(const wxString & WXUNUSED(tip)) { } |
1259 | void UnsetToolTip() { } | |
1260 | #endif // wxUSE_TOOLTIPS/!wxUSE_TOOLTIPS | |
f03fc89f VZ |
1261 | |
1262 | // drag and drop | |
1263 | // ------------- | |
1264 | #if wxUSE_DRAG_AND_DROP | |
1265 | // set/retrieve the drop target associated with this window (may be | |
1266 | // NULL; it's owned by the window and will be deleted by it) | |
1267 | virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0; | |
1268 | virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; } | |
4f24cbbd VS |
1269 | |
1270 | // Accept files for dragging | |
1271 | virtual void DragAcceptFiles(bool accept) | |
1272 | #ifdef __WXMSW__ | |
1273 | // it does have common implementation but not for MSW which has its own | |
1274 | // native version of it | |
1275 | = 0 | |
1276 | #endif // __WXMSW__ | |
1277 | ; | |
1278 | ||
f03fc89f VZ |
1279 | #endif // wxUSE_DRAG_AND_DROP |
1280 | ||
1281 | // constraints and sizers | |
1282 | // ---------------------- | |
1283 | #if wxUSE_CONSTRAINTS | |
1284 | // set the constraints for this window or retrieve them (may be NULL) | |
1285 | void SetConstraints( wxLayoutConstraints *constraints ); | |
1286 | wxLayoutConstraints *GetConstraints() const { return m_constraints; } | |
1287 | ||
f03fc89f VZ |
1288 | // implementation only |
1289 | void UnsetConstraints(wxLayoutConstraints *c); | |
1290 | wxWindowList *GetConstraintsInvolvedIn() const | |
1291 | { return m_constraintsInvolvedIn; } | |
1292 | void AddConstraintReference(wxWindowBase *otherWin); | |
1293 | void RemoveConstraintReference(wxWindowBase *otherWin); | |
1294 | void DeleteRelatedConstraints(); | |
1295 | void ResetConstraints(); | |
1296 | ||
90e572f1 | 1297 | // these methods may be overridden for special layout algorithms |
d4864e97 | 1298 | virtual void SetConstraintSizes(bool recurse = true); |
f03fc89f VZ |
1299 | virtual bool LayoutPhase1(int *noChanges); |
1300 | virtual bool LayoutPhase2(int *noChanges); | |
4b7f2165 | 1301 | virtual bool DoPhase(int phase); |
f03fc89f VZ |
1302 | |
1303 | // these methods are virtual but normally won't be overridden | |
f03fc89f VZ |
1304 | virtual void SetSizeConstraint(int x, int y, int w, int h); |
1305 | virtual void MoveConstraint(int x, int y); | |
1306 | virtual void GetSizeConstraint(int *w, int *h) const ; | |
1307 | virtual void GetClientSizeConstraint(int *w, int *h) const ; | |
1308 | virtual void GetPositionConstraint(int *x, int *y) const ; | |
1309 | ||
461e93f9 JS |
1310 | #endif // wxUSE_CONSTRAINTS |
1311 | ||
1312 | // when using constraints or sizers, it makes sense to update | |
1313 | // children positions automatically whenever the window is resized | |
1314 | // - this is done if autoLayout is on | |
1315 | void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; } | |
1316 | bool GetAutoLayout() const { return m_autoLayout; } | |
1317 | ||
1318 | // lay out the window and its children | |
1319 | virtual bool Layout(); | |
1320 | ||
f03fc89f | 1321 | // sizers |
d4864e97 VZ |
1322 | void SetSizer(wxSizer *sizer, bool deleteOld = true ); |
1323 | void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true ); | |
566d84a7 | 1324 | |
f03fc89f | 1325 | wxSizer *GetSizer() const { return m_windowSizer; } |
be90c029 RD |
1326 | |
1327 | // Track if this window is a member of a sizer | |
1ebfafde | 1328 | void SetContainingSizer(wxSizer* sizer); |
be90c029 RD |
1329 | wxSizer *GetContainingSizer() const { return m_containingSizer; } |
1330 | ||
45a959a3 JS |
1331 | // accessibility |
1332 | // ---------------------- | |
1333 | #if wxUSE_ACCESSIBILITY | |
1334 | // Override to create a specific accessible object. | |
1335 | virtual wxAccessible* CreateAccessible(); | |
1336 | ||
1337 | // Sets the accessible object. | |
1338 | void SetAccessible(wxAccessible* accessible) ; | |
1339 | ||
1340 | // Returns the accessible object. | |
47b378bd | 1341 | wxAccessible* GetAccessible() { return m_accessible; } |
45a959a3 JS |
1342 | |
1343 | // Returns the accessible object, creating if necessary. | |
1344 | wxAccessible* GetOrCreateAccessible() ; | |
1345 | #endif | |
1346 | ||
b137e493 | 1347 | |
b58d5e2d RD |
1348 | // Set window transparency if the platform supports it |
1349 | virtual bool SetTransparent(wxByte WXUNUSED(alpha)) { return false; } | |
1350 | virtual bool CanSetTransparent() { return false; } | |
1351 | ||
1352 | ||
f03fc89f VZ |
1353 | // implementation |
1354 | // -------------- | |
1355 | ||
1356 | // event handlers | |
1357 | void OnSysColourChanged( wxSysColourChangedEvent& event ); | |
1358 | void OnInitDialog( wxInitDialogEvent &event ); | |
72fc5caf | 1359 | void OnMiddleClick( wxMouseEvent& event ); |
bd83cb56 VZ |
1360 | #if wxUSE_HELP |
1361 | void OnHelp(wxHelpEvent& event); | |
1362 | #endif // wxUSE_HELP | |
f03fc89f | 1363 | |
e39af974 JS |
1364 | // virtual function for implementing internal idle |
1365 | // behaviour | |
1366 | virtual void OnInternalIdle() {} | |
1367 | ||
1368 | // call internal idle recursively | |
5109ae5d | 1369 | // void ProcessInternalIdle() ; |
e39af974 JS |
1370 | |
1371 | // get the handle of the window for the underlying window system: this | |
d7c24517 VZ |
1372 | // is only used for wxWin itself or for user code which wants to call |
1373 | // platform-specific APIs | |
d22699b5 | 1374 | virtual WXWidget GetHandle() const = 0; |
ed4780ea VZ |
1375 | // associate the window with a new native handle |
1376 | virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { } | |
1377 | // dissociate the current native handle from the window | |
1378 | virtual void DissociateHandle() { } | |
cc2b7472 | 1379 | |
574c939e KB |
1380 | #if wxUSE_PALETTE |
1381 | // Store the palette used by DCs in wxWindow so that the dcs can share | |
1382 | // a palette. And we can respond to palette messages. | |
1383 | wxPalette GetPalette() const { return m_palette; } | |
b95edd47 | 1384 | |
574c939e KB |
1385 | // When palette is changed tell the DC to set the system palette to the |
1386 | // new one. | |
b95edd47 VZ |
1387 | void SetPalette(const wxPalette& pal); |
1388 | ||
1389 | // return true if we have a specific palette | |
1390 | bool HasCustomPalette() const { return m_hasCustomPalette; } | |
1391 | ||
1392 | // return the first parent window with a custom palette or NULL | |
1393 | wxWindow *GetAncestorWithCustomPalette() const; | |
574c939e KB |
1394 | #endif // wxUSE_PALETTE |
1395 | ||
b8e7b673 VZ |
1396 | // inherit the parents visual attributes if they had been explicitly set |
1397 | // by the user (i.e. we don't inherit default attributes) and if we don't | |
1398 | // have our own explicitly set | |
1399 | virtual void InheritAttributes(); | |
1400 | ||
1401 | // returns false from here if this window doesn't want to inherit the | |
1402 | // parents colours even if InheritAttributes() would normally do it | |
1403 | // | |
1404 | // this just provides a simple way to customize InheritAttributes() | |
1405 | // behaviour in the most common case | |
1406 | virtual bool ShouldInheritColours() const { return false; } | |
1407 | ||
c04c7a3d VS |
1408 | // returns true if the window can be positioned outside of parent's client |
1409 | // area (normal windows can't, but e.g. menubar or statusbar can): | |
1410 | virtual bool CanBeOutsideClientArea() const { return false; } | |
1411 | ||
dc797d8e JS |
1412 | // returns true if the platform should explicitly apply a theme border. Currently |
1413 | // used only by Windows | |
a047aff2 JS |
1414 | virtual bool CanApplyThemeBorder() const { return true; } |
1415 | ||
245c5d2e RD |
1416 | protected: |
1417 | // event handling specific to wxWindow | |
8cc208e3 VZ |
1418 | virtual bool TryBefore(wxEvent& event); |
1419 | virtual bool TryAfter(wxEvent& event); | |
245c5d2e | 1420 | |
c944775f | 1421 | enum WindowOrder |
a24de76b | 1422 | { |
c944775f VZ |
1423 | OrderBefore, // insert before the given window |
1424 | OrderAfter // insert after the given window | |
a24de76b | 1425 | }; |
c944775f VZ |
1426 | |
1427 | // common part of GetPrev/NextSibling() | |
1428 | wxWindow *DoGetSibling(WindowOrder order) const; | |
1429 | ||
1430 | // common part of MoveBefore/AfterInTabOrder() | |
1431 | virtual void DoMoveInTabOrder(wxWindow *win, WindowOrder move); | |
4caf847c | 1432 | |
5644933f VZ |
1433 | // implementation of Navigate() and NavigateIn() |
1434 | virtual bool DoNavigateIn(int flags); | |
1435 | ||
ec5bb70d VZ |
1436 | #if wxUSE_CONSTRAINTS |
1437 | // satisfy the constraints for the windows but don't set the window sizes | |
1438 | void SatisfyConstraints(); | |
1439 | #endif // wxUSE_CONSTRAINTS | |
566d84a7 | 1440 | |
c6212a0c VZ |
1441 | // Send the wxWindowDestroyEvent if not done yet and sets m_isBeingDeleted |
1442 | // to true | |
7de59551 RD |
1443 | void SendDestroyEvent(); |
1444 | ||
0fe02759 VS |
1445 | // returns the main window of composite control; this is the window |
1446 | // that FindFocus returns if the focus is in one of composite control's | |
1447 | // windows | |
6fb99eb3 | 1448 | virtual wxWindow *GetMainWindowOfCompositeControl() |
0fe02759 VS |
1449 | { return (wxWindow*)this; } |
1450 | ||
47a8a4d5 VZ |
1451 | // this method should be implemented to use operating system specific code |
1452 | // to really enable/disable the widget, it will only be called when we | |
1453 | // really need to enable/disable window and so no additional checks on the | |
1454 | // widgets state are necessary | |
1455 | virtual void DoEnable(bool WXUNUSED(enable)) { } | |
1456 | ||
1457 | // called when the on-screen widget state changes and provides an | |
1458 | // an opportunity for the widget to update its visual state (colours, | |
1459 | // fonts, anything else) as necessary | |
1460 | virtual void OnEnabled(bool WXUNUSED(enabled)) { } | |
1461 | ||
1462 | ||
7af6f327 | 1463 | // the window id - a number which uniquely identifies a window among |
a0d9c6cb | 1464 | // its siblings unless it is wxID_ANY |
cf2810aa | 1465 | wxWindowIDRef m_windowId; |
456bc6d9 | 1466 | |
f03fc89f VZ |
1467 | // the parent window of this window (or NULL) and the list of the children |
1468 | // of this window | |
1469 | wxWindow *m_parent; | |
1470 | wxWindowList m_children; | |
1471 | ||
1472 | // the minimal allowed size for the window (no minimal size if variable(s) | |
a0d9c6cb | 1473 | // contain(s) wxDefaultCoord) |
ec5bb70d VZ |
1474 | int m_minWidth, |
1475 | m_minHeight, | |
1476 | m_maxWidth, | |
1477 | m_maxHeight; | |
f03fc89f VZ |
1478 | |
1479 | // event handler for this window: usually is just 'this' but may be | |
1480 | // changed with SetEventHandler() | |
1481 | wxEvtHandler *m_eventHandler; | |
1482 | ||
88ac883a | 1483 | #if wxUSE_VALIDATORS |
f03fc89f VZ |
1484 | // associated validator or NULL if none |
1485 | wxValidator *m_windowValidator; | |
88ac883a | 1486 | #endif // wxUSE_VALIDATORS |
f03fc89f VZ |
1487 | |
1488 | #if wxUSE_DRAG_AND_DROP | |
1489 | wxDropTarget *m_dropTarget; | |
1490 | #endif // wxUSE_DRAG_AND_DROP | |
1491 | ||
1492 | // visual window attributes | |
1493 | wxCursor m_cursor; | |
1b69c815 VZ |
1494 | wxFont m_font; // see m_hasFont |
1495 | wxColour m_backgroundColour, // m_hasBgCol | |
1496 | m_foregroundColour; // m_hasFgCol | |
f03fc89f | 1497 | |
789295bf VZ |
1498 | #if wxUSE_CARET |
1499 | wxCaret *m_caret; | |
1500 | #endif // wxUSE_CARET | |
1501 | ||
f03fc89f VZ |
1502 | // the region which should be repainted in response to paint event |
1503 | wxRegion m_updateRegion; | |
1504 | ||
88ac883a | 1505 | #if wxUSE_ACCEL |
f03fc89f VZ |
1506 | // the accelerator table for the window which translates key strokes into |
1507 | // command events | |
1508 | wxAcceleratorTable m_acceleratorTable; | |
88ac883a | 1509 | #endif // wxUSE_ACCEL |
f03fc89f | 1510 | |
f03fc89f VZ |
1511 | // the tooltip for this window (may be NULL) |
1512 | #if wxUSE_TOOLTIPS | |
1513 | wxToolTip *m_tooltip; | |
1514 | #endif // wxUSE_TOOLTIPS | |
1515 | ||
1516 | // constraints and sizers | |
1517 | #if wxUSE_CONSTRAINTS | |
1518 | // the constraints for this window or NULL | |
1519 | wxLayoutConstraints *m_constraints; | |
1520 | ||
1521 | // constraints this window is involved in | |
1522 | wxWindowList *m_constraintsInvolvedIn; | |
461e93f9 | 1523 | #endif // wxUSE_CONSTRAINTS |
f03fc89f | 1524 | |
be90c029 | 1525 | // this window's sizer |
f03fc89f | 1526 | wxSizer *m_windowSizer; |
be90c029 RD |
1527 | |
1528 | // The sizer this window is a member of, if any | |
1529 | wxSizer *m_containingSizer; | |
f03fc89f VZ |
1530 | |
1531 | // Layout() window automatically when its size changes? | |
1532 | bool m_autoLayout:1; | |
f03fc89f VZ |
1533 | |
1534 | // window state | |
1535 | bool m_isShown:1; | |
1536 | bool m_isEnabled:1; | |
1537 | bool m_isBeingDeleted:1; | |
1538 | ||
23895080 VZ |
1539 | // was the window colours/font explicitly changed by user? |
1540 | bool m_hasBgCol:1; | |
1541 | bool m_hasFgCol:1; | |
1542 | bool m_hasFont:1; | |
a0d9c6cb | 1543 | |
f8ff87ed VS |
1544 | // and should it be inherited by children? |
1545 | bool m_inheritBgCol:1; | |
1546 | bool m_inheritFgCol:1; | |
1547 | bool m_inheritFont:1; | |
23895080 | 1548 | |
f03fc89f | 1549 | // window attributes |
d80cd92a VZ |
1550 | long m_windowStyle, |
1551 | m_exStyle; | |
f03fc89f | 1552 | wxString m_windowName; |
a2d93e73 | 1553 | bool m_themeEnabled; |
50c53860 | 1554 | wxBackgroundStyle m_backgroundStyle; |
071e5fd9 | 1555 | #if wxUSE_PALETTE |
574c939e | 1556 | wxPalette m_palette; |
b95edd47 VZ |
1557 | bool m_hasCustomPalette; |
1558 | #endif // wxUSE_PALETTE | |
574c939e | 1559 | |
45a959a3 JS |
1560 | #if wxUSE_ACCESSIBILITY |
1561 | wxAccessible* m_accessible; | |
1562 | #endif | |
2654f7e4 | 1563 | |
566d84a7 RL |
1564 | // Virtual size (scrolling) |
1565 | wxSize m_virtualSize; | |
1566 | ||
f4fe2f20 RR |
1567 | wxScrollHelper *m_scrollHelper; |
1568 | ||
69d90995 | 1569 | wxWindowVariant m_windowVariant ; |
45e0dc94 | 1570 | |
1e6feb95 VZ |
1571 | // override this to change the default (i.e. used when no style is |
1572 | // specified) border for the window class | |
1573 | virtual wxBorder GetDefaultBorder() const; | |
1574 | ||
a047aff2 JS |
1575 | // this allows you to implement standard control borders without |
1576 | // repeating the code in different classes that are not derived from | |
1577 | // wxControl | |
dc797d8e | 1578 | virtual wxBorder GetDefaultBorderForControl() const { return wxBORDER_THEME; } |
a047aff2 | 1579 | |
5c2be659 RD |
1580 | // Get the default size for the new window if no explicit size given. TLWs |
1581 | // have their own default size so this is just for non top-level windows. | |
a0d9c6cb WS |
1582 | static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; } |
1583 | static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; } | |
f03fc89f | 1584 | |
9f884528 RD |
1585 | |
1586 | // Used to save the results of DoGetBestSize so it doesn't need to be | |
1587 | // recalculated each time the value is needed. | |
1588 | wxSize m_bestSizeCache; | |
1589 | ||
170acdc9 RD |
1590 | wxDEPRECATED( void SetBestSize(const wxSize& size) ); // use SetInitialSize |
1591 | wxDEPRECATED( virtual void SetInitialBestSize(const wxSize& size) ); // use SetInitialSize | |
d3b5db4b | 1592 | |
a0d9c6cb | 1593 | |
d3b5db4b | 1594 | |
f03fc89f VZ |
1595 | // more pure virtual functions |
1596 | // --------------------------- | |
1597 | ||
1598 | // NB: we must have DoSomething() function when Something() is an overloaded | |
1599 | // method: indeed, we can't just have "virtual Something()" in case when | |
1600 | // the function is overloaded because then we'd have to make virtual all | |
1601 | // the variants (otherwise only the virtual function may be called on a | |
1602 | // pointer to derived class according to C++ rules) which is, in | |
1603 | // general, absolutely not needed. So instead we implement all | |
1604 | // overloaded Something()s in terms of DoSomething() which will be the | |
1605 | // only one to be virtual. | |
1606 | ||
6de70470 VZ |
1607 | // text extent |
1608 | virtual void DoGetTextExtent(const wxString& string, | |
1609 | int *x, int *y, | |
1610 | int *descent = NULL, | |
1611 | int *externalLeading = NULL, | |
1612 | const wxFont *font = NULL) const = 0; | |
1613 | ||
dabc0cd5 VZ |
1614 | // coordinates translation |
1615 | virtual void DoClientToScreen( int *x, int *y ) const = 0; | |
1616 | virtual void DoScreenToClient( int *x, int *y ) const = 0; | |
1617 | ||
1e6feb95 VZ |
1618 | virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const; |
1619 | ||
94633ad9 | 1620 | // capture/release the mouse, used by Capture/ReleaseMouse() |
a83e1475 VZ |
1621 | virtual void DoCaptureMouse() = 0; |
1622 | virtual void DoReleaseMouse() = 0; | |
be90c029 | 1623 | |
f03fc89f | 1624 | // retrieve the position/size of the window |
3c81c9aa VZ |
1625 | virtual void DoGetPosition(int *x, int *y) const = 0; |
1626 | virtual void DoGetScreenPosition(int *x, int *y) const; | |
1627 | virtual void DoGetSize(int *width, int *height) const = 0; | |
1628 | virtual void DoGetClientSize(int *width, int *height) const = 0; | |
f03fc89f | 1629 | |
f68586e5 VZ |
1630 | // get the size which best suits the window: for a control, it would be |
1631 | // the minimal size which doesn't truncate the control, for a panel - the | |
1632 | // same size as it would have after a call to Fit() | |
1633 | virtual wxSize DoGetBestSize() const; | |
1634 | ||
f03fc89f VZ |
1635 | // this is the virtual function to be overriden in any derived class which |
1636 | // wants to change how SetSize() or Move() works - it is called by all | |
1637 | // versions of these functions in the base class | |
1638 | virtual void DoSetSize(int x, int y, | |
1639 | int width, int height, | |
1640 | int sizeFlags = wxSIZE_AUTO) = 0; | |
1641 | ||
1642 | // same as DoSetSize() for the client size | |
1643 | virtual void DoSetClientSize(int width, int height) = 0; | |
1644 | ||
b2e10dac PC |
1645 | virtual void DoSetSizeHints( int minW, int minH, |
1646 | int maxW, int maxH, | |
1647 | int incW, int incH ); | |
1648 | ||
9d9b7755 VZ |
1649 | // move the window to the specified location and resize it: this is called |
1650 | // from both DoSetSize() and DoSetClientSize() and would usually just | |
1651 | // reposition this window except for composite controls which will want to | |
1652 | // arrange themselves inside the given rectangle | |
69deca26 VS |
1653 | // |
1654 | // Important note: the coordinates passed to this method are in parent's | |
1655 | // *window* coordinates and not parent's client coordinates (as the values | |
1656 | // passed to DoSetSize and returned by DoGetPosition are)! | |
9d9b7755 VZ |
1657 | virtual void DoMoveWindow(int x, int y, int width, int height) = 0; |
1658 | ||
1f464296 VZ |
1659 | // centre the window in the specified direction on parent, note that |
1660 | // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for | |
1661 | // TLWs | |
1662 | virtual void DoCentre(int dir); | |
1663 | ||
f03fc89f VZ |
1664 | #if wxUSE_TOOLTIPS |
1665 | virtual void DoSetToolTip( wxToolTip *tip ); | |
1666 | #endif // wxUSE_TOOLTIPS | |
1667 | ||
1e6feb95 | 1668 | #if wxUSE_MENUS |
971562cb | 1669 | virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0; |
1e6feb95 | 1670 | #endif // wxUSE_MENUS |
a1665b22 | 1671 | |
716e96df VZ |
1672 | // Makes an adjustment to the window position to make it relative to the |
1673 | // parents client area, e.g. if the parent is a frame with a toolbar, its | |
1674 | // (0, 0) is just below the toolbar | |
1675 | virtual void AdjustForParentClientOrigin(int& x, int& y, | |
1676 | int sizeFlags = 0) const; | |
8d99be5f | 1677 | |
69d90995 SC |
1678 | // implements the window variants |
1679 | virtual void DoSetWindowVariant( wxWindowVariant variant ) ; | |
45e0dc94 | 1680 | |
17808a75 VZ |
1681 | |
1682 | // really freeze/thaw the window (should have port-specific implementation) | |
1683 | virtual void DoFreeze() { } | |
1684 | virtual void DoThaw() { } | |
1685 | ||
1686 | ||
63e819f2 | 1687 | // Must be called when mouse capture is lost to send |
72f8c792 VS |
1688 | // wxMouseCaptureLostEvent to windows on capture stack. |
1689 | static void NotifyCaptureLost(); | |
63e819f2 | 1690 | |
f03fc89f | 1691 | private: |
47a8a4d5 VZ |
1692 | // recursively call our own and our children OnEnabled() when the |
1693 | // enabled/disabled status changed because a parent window had been | |
1694 | // enabled/disabled | |
1695 | void NotifyWindowOnEnableChange(bool enabled); | |
1696 | ||
00a77b7c | 1697 | #if wxUSE_MENUS |
565382de | 1698 | // temporary event handlers used by GetPopupMenuSelectionFromUser() |
00a77b7c | 1699 | void InternalOnPopupMenu(wxCommandEvent& event); |
565382de | 1700 | void InternalOnPopupMenuUpdate(wxUpdateUIEvent& event); |
00a77b7c VZ |
1701 | |
1702 | // implementation of the public GetPopupMenuSelectionFromUser() method | |
1703 | int DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y); | |
1704 | #endif // wxUSE_MENUS | |
47a8a4d5 | 1705 | |
6528a7f1 VZ |
1706 | // layout the window children when its size changes unless this was |
1707 | // explicitly disabled with SetAutoLayout(false) | |
1708 | void InternalOnSize(wxSizeEvent& event); | |
1709 | ||
1710 | ||
a83e1475 | 1711 | // the stack of windows which have captured the mouse |
b5dbe15d | 1712 | static struct WXDLLIMPEXP_FWD_CORE wxWindowNext *ms_winCaptureNext; |
17808a75 | 1713 | |
63e819f2 VS |
1714 | // the window that currently has mouse capture |
1715 | static wxWindow *ms_winCaptureCurrent; | |
17808a75 | 1716 | |
63e819f2 VS |
1717 | // indicates if execution is inside CaptureMouse/ReleaseMouse |
1718 | static bool ms_winCaptureChanging; | |
a83e1475 | 1719 | |
17808a75 VZ |
1720 | |
1721 | // number of Freeze() calls minus the number of Thaw() calls: we're frozen | |
1722 | // (i.e. not being updated) if it is positive | |
1723 | unsigned int m_freezeCount; | |
1724 | ||
1725 | ||
1e6feb95 | 1726 | DECLARE_ABSTRACT_CLASS(wxWindowBase) |
c0c133e1 | 1727 | wxDECLARE_NO_COPY_CLASS(wxWindowBase); |
f03fc89f VZ |
1728 | DECLARE_EVENT_TABLE() |
1729 | }; | |
1730 | ||
170acdc9 RD |
1731 | |
1732 | ||
1733 | // Inlines for some deprecated methods | |
1734 | inline wxSize wxWindowBase::GetBestFittingSize() const | |
1735 | { | |
1736 | return GetEffectiveMinSize(); | |
1737 | } | |
1738 | ||
1739 | inline void wxWindowBase::SetBestFittingSize(const wxSize& size) | |
1740 | { | |
1741 | SetInitialSize(size); | |
1742 | } | |
1743 | ||
1744 | inline void wxWindowBase::SetBestSize(const wxSize& size) | |
1745 | { | |
1746 | SetInitialSize(size); | |
1747 | } | |
1748 | ||
1749 | inline void wxWindowBase::SetInitialBestSize(const wxSize& size) | |
1750 | { | |
1751 | SetInitialSize(size); | |
1752 | } | |
1753 | ||
1754 | ||
f03fc89f VZ |
1755 | // ---------------------------------------------------------------------------- |
1756 | // now include the declaration of wxWindow class | |
1757 | // ---------------------------------------------------------------------------- | |
1758 | ||
1e6feb95 | 1759 | // include the declaration of the platform-specific class |
4055ed82 | 1760 | #if defined(__WXPALMOS__) |
ffecfa5a JS |
1761 | #ifdef __WXUNIVERSAL__ |
1762 | #define wxWindowNative wxWindowPalm | |
1763 | #else // !wxUniv | |
1764 | #define wxWindowPalm wxWindow | |
1765 | #endif // wxUniv/!wxUniv | |
1766 | #include "wx/palmos/window.h" | |
1767 | #elif defined(__WXMSW__) | |
a5b3669d VZ |
1768 | #ifdef __WXUNIVERSAL__ |
1769 | #define wxWindowNative wxWindowMSW | |
1770 | #else // !wxUniv | |
1e6feb95 | 1771 | #define wxWindowMSW wxWindow |
a5b3669d | 1772 | #endif // wxUniv/!wxUniv |
f03fc89f | 1773 | #include "wx/msw/window.h" |
2049ba38 | 1774 | #elif defined(__WXMOTIF__) |
f03fc89f | 1775 | #include "wx/motif/window.h" |
1be7a35c | 1776 | #elif defined(__WXGTK20__) |
a5b3669d VZ |
1777 | #ifdef __WXUNIVERSAL__ |
1778 | #define wxWindowNative wxWindowGTK | |
1779 | #else // !wxUniv | |
1e6feb95 | 1780 | #define wxWindowGTK wxWindow |
1e6feb95 | 1781 | #endif // wxUniv |
f03fc89f | 1782 | #include "wx/gtk/window.h" |
1be7a35c MR |
1783 | #elif defined(__WXGTK__) |
1784 | #ifdef __WXUNIVERSAL__ | |
1785 | #define wxWindowNative wxWindowGTK | |
1786 | #else // !wxUniv | |
1787 | #define wxWindowGTK wxWindow | |
1788 | #endif // wxUniv | |
1789 | #include "wx/gtk1/window.h" | |
83df96d6 JS |
1790 | #elif defined(__WXX11__) |
1791 | #ifdef __WXUNIVERSAL__ | |
1792 | #define wxWindowNative wxWindowX11 | |
1793 | #else // !wxUniv | |
1794 | #define wxWindowX11 wxWindow | |
83df96d6 JS |
1795 | #endif // wxUniv |
1796 | #include "wx/x11/window.h" | |
711c76db | 1797 | #elif defined(__WXMGL__) |
b3c86150 | 1798 | #define wxWindowNative wxWindowMGL |
386c7058 | 1799 | #include "wx/mgl/window.h" |
b3c86150 VS |
1800 | #elif defined(__WXDFB__) |
1801 | #define wxWindowNative wxWindowDFB | |
1802 | #include "wx/dfb/window.h" | |
34138703 | 1803 | #elif defined(__WXMAC__) |
e766c8a9 SC |
1804 | #ifdef __WXUNIVERSAL__ |
1805 | #define wxWindowNative wxWindowMac | |
1806 | #else // !wxUniv | |
1807 | #define wxWindowMac wxWindow | |
e766c8a9 | 1808 | #endif // wxUniv |
ef0e9220 | 1809 | #include "wx/osx/window.h" |
e64df9bc DE |
1810 | #elif defined(__WXCOCOA__) |
1811 | #ifdef __WXUNIVERSAL__ | |
1812 | #define wxWindowNative wxWindowCocoa | |
1813 | #else // !wxUniv | |
1814 | #define wxWindowCocoa wxWindow | |
e64df9bc DE |
1815 | #endif // wxUniv |
1816 | #include "wx/cocoa/window.h" | |
1777b9bb | 1817 | #elif defined(__WXPM__) |
210a651b DW |
1818 | #ifdef __WXUNIVERSAL__ |
1819 | #define wxWindowNative wxWindowOS2 | |
1820 | #else // !wxUniv | |
1821 | #define wxWindowOS2 wxWindow | |
210a651b | 1822 | #endif // wxUniv/!wxUniv |
1777b9bb | 1823 | #include "wx/os2/window.h" |
c801d85f KB |
1824 | #endif |
1825 | ||
1e6feb95 VZ |
1826 | // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>, |
1827 | // for the native ports we already have defined it above | |
1828 | #if defined(__WXUNIVERSAL__) | |
a5b3669d VZ |
1829 | #ifndef wxWindowNative |
1830 | #error "wxWindowNative must be defined above!" | |
1831 | #endif | |
1832 | ||
1e6feb95 VZ |
1833 | #include "wx/univ/window.h" |
1834 | #endif // wxUniv | |
1835 | ||
f03fc89f VZ |
1836 | // ---------------------------------------------------------------------------- |
1837 | // inline functions which couldn't be declared in the class body because of | |
1838 | // forward dependencies | |
1839 | // ---------------------------------------------------------------------------- | |
1840 | ||
bacd69f9 | 1841 | inline wxWindow *wxWindowBase::GetGrandParent() const |
f03fc89f | 1842 | { |
d3b9f782 | 1843 | return m_parent ? m_parent->GetParent() : NULL; |
f03fc89f VZ |
1844 | } |
1845 | ||
1846 | // ---------------------------------------------------------------------------- | |
3723b7b1 | 1847 | // global functions |
f03fc89f VZ |
1848 | // ---------------------------------------------------------------------------- |
1849 | ||
3723b7b1 JS |
1850 | // Find the wxWindow at the current mouse position, also returning the mouse |
1851 | // position. | |
53a2db12 | 1852 | extern WXDLLIMPEXP_CORE wxWindow* wxFindWindowAtPointer(wxPoint& pt); |
3723b7b1 JS |
1853 | |
1854 | // Get the current mouse position. | |
53a2db12 | 1855 | extern WXDLLIMPEXP_CORE wxPoint wxGetMousePosition(); |
3723b7b1 | 1856 | |
1e6feb95 | 1857 | // get the currently active window of this application or NULL |
53a2db12 | 1858 | extern WXDLLIMPEXP_CORE wxWindow *wxGetActiveWindow(); |
1e6feb95 | 1859 | |
33b494d6 | 1860 | // get the (first) top level parent window |
53a2db12 | 1861 | WXDLLIMPEXP_CORE wxWindow* wxGetTopLevelParent(wxWindow *win); |
33b494d6 | 1862 | |
40ff126a WS |
1863 | #if WXWIN_COMPATIBILITY_2_6 |
1864 | // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() | |
cf2810aa VZ |
1865 | wxDEPRECATED( wxWindowID NewControlId() ); |
1866 | inline wxWindowID NewControlId() { return wxWindowBase::NewControlId(); } | |
40ff126a | 1867 | #endif // WXWIN_COMPATIBILITY_2_6 |
f03fc89f | 1868 | |
45a959a3 JS |
1869 | #if wxUSE_ACCESSIBILITY |
1870 | // ---------------------------------------------------------------------------- | |
1871 | // accessible object for windows | |
1872 | // ---------------------------------------------------------------------------- | |
1873 | ||
53a2db12 | 1874 | class WXDLLIMPEXP_CORE wxWindowAccessible: public wxAccessible |
45a959a3 JS |
1875 | { |
1876 | public: | |
f81387bd | 1877 | wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); } |
6fb99eb3 | 1878 | virtual ~wxWindowAccessible() {} |
45a959a3 JS |
1879 | |
1880 | // Overridables | |
1881 | ||
1882 | // Can return either a child object, or an integer | |
1883 | // representing the child element, starting from 1. | |
1884 | virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject); | |
1885 | ||
1886 | // Returns the rectangle for this object (id = 0) or a child element (id > 0). | |
1887 | virtual wxAccStatus GetLocation(wxRect& rect, int elementId); | |
1888 | ||
1889 | // Navigates from fromId to toId/toObject. | |
1890 | virtual wxAccStatus Navigate(wxNavDir navDir, int fromId, | |
1891 | int* toId, wxAccessible** toObject); | |
1892 | ||
1893 | // Gets the name of the specified object. | |
1894 | virtual wxAccStatus GetName(int childId, wxString* name); | |
1895 | ||
1896 | // Gets the number of children. | |
a37e4a07 | 1897 | virtual wxAccStatus GetChildCount(int* childCount); |
45a959a3 JS |
1898 | |
1899 | // Gets the specified child (starting from 1). | |
1900 | // If *child is NULL and return value is wxACC_OK, | |
1901 | // this means that the child is a simple element and | |
1902 | // not an accessible object. | |
1903 | virtual wxAccStatus GetChild(int childId, wxAccessible** child); | |
1904 | ||
1905 | // Gets the parent, or NULL. | |
1906 | virtual wxAccStatus GetParent(wxAccessible** parent); | |
1907 | ||
1908 | // Performs the default action. childId is 0 (the action for this object) | |
1909 | // or > 0 (the action for a child). | |
1910 | // Return wxACC_NOT_SUPPORTED if there is no default action for this | |
1911 | // window (e.g. an edit control). | |
1912 | virtual wxAccStatus DoDefaultAction(int childId); | |
1913 | ||
1914 | // Gets the default action for this object (0) or > 0 (the action for a child). | |
1915 | // Return wxACC_OK even if there is no action. actionName is the action, or the empty | |
1916 | // string if there is no action. | |
1917 | // The retrieved string describes the action that is performed on an object, | |
1918 | // not what the object does as a result. For example, a toolbar button that prints | |
1919 | // a document has a default action of "Press" rather than "Prints the current document." | |
1920 | virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName); | |
1921 | ||
1922 | // Returns the description for this object or a child. | |
1923 | virtual wxAccStatus GetDescription(int childId, wxString* description); | |
1924 | ||
1925 | // Returns help text for this object or a child, similar to tooltip text. | |
1926 | virtual wxAccStatus GetHelpText(int childId, wxString* helpText); | |
1927 | ||
1928 | // Returns the keyboard shortcut for this object or child. | |
1929 | // Return e.g. ALT+K | |
1930 | virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut); | |
1931 | ||
1932 | // Returns a role constant. | |
1933 | virtual wxAccStatus GetRole(int childId, wxAccRole* role); | |
1934 | ||
1935 | // Returns a state constant. | |
1936 | virtual wxAccStatus GetState(int childId, long* state); | |
1937 | ||
1938 | // Returns a localized string representing the value for the object | |
1939 | // or child. | |
1940 | virtual wxAccStatus GetValue(int childId, wxString* strValue); | |
1941 | ||
1942 | // Selects the object or child. | |
1943 | virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags); | |
1944 | ||
1945 | // Gets the window with the keyboard focus. | |
1946 | // If childId is 0 and child is NULL, no object in | |
1947 | // this subhierarchy has the focus. | |
1948 | // If this object has the focus, child should be 'this'. | |
1949 | virtual wxAccStatus GetFocus(int* childId, wxAccessible** child); | |
1950 | ||
ca5c6ac3 | 1951 | #if wxUSE_VARIANT |
45a959a3 JS |
1952 | // Gets a variant representing the selected children |
1953 | // of this object. | |
1954 | // Acceptable values: | |
d4864e97 | 1955 | // - a null variant (IsNull() returns true) |
45a959a3 JS |
1956 | // - a list variant (GetType() == wxT("list") |
1957 | // - an integer representing the selected child element, | |
1958 | // or 0 if this object is selected (GetType() == wxT("long") | |
1959 | // - a "void*" pointer to a wxAccessible child object | |
1960 | virtual wxAccStatus GetSelections(wxVariant* selections); | |
ca5c6ac3 | 1961 | #endif // wxUSE_VARIANT |
45a959a3 JS |
1962 | }; |
1963 | ||
1964 | #endif // wxUSE_ACCESSIBILITY | |
1965 | ||
1966 | ||
faa49bfd | 1967 | #endif // _WX_WINDOW_H_BASE_ |