]>
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 | |
f03fc89f VZ |
52 | // ---------------------------------------------------------------------------- |
53 | // forward declarations | |
54 | // ---------------------------------------------------------------------------- | |
55 | ||
789295bf | 56 | class WXDLLEXPORT wxCaret; |
f03fc89f VZ |
57 | class WXDLLEXPORT wxControl; |
58 | class WXDLLEXPORT wxCursor; | |
eb082a08 | 59 | class WXDLLEXPORT wxDC; |
f03fc89f VZ |
60 | class WXDLLEXPORT wxDropTarget; |
61 | class WXDLLEXPORT wxItemResource; | |
62 | class WXDLLEXPORT wxLayoutConstraints; | |
63 | class WXDLLEXPORT wxResourceTable; | |
64 | class WXDLLEXPORT wxSizer; | |
65 | class WXDLLEXPORT wxToolTip; | |
f03fc89f VZ |
66 | class WXDLLEXPORT wxWindowBase; |
67 | class WXDLLEXPORT wxWindow; | |
f4fe2f20 | 68 | class WXDLLEXPORT wxScrollHelper; |
f03fc89f | 69 | |
45a959a3 JS |
70 | #if wxUSE_ACCESSIBILITY |
71 | class WXDLLEXPORT wxAccessible; | |
72 | #endif | |
73 | ||
1b69c815 VZ |
74 | // ---------------------------------------------------------------------------- |
75 | // helper stuff used by wxWindow | |
76 | // ---------------------------------------------------------------------------- | |
77 | ||
78 | // struct containing all the visual attributes of a control | |
79 | struct WXDLLEXPORT wxVisualAttributes | |
80 | { | |
81 | // the font used for control label/text inside it | |
82 | wxFont font; | |
83 | ||
84 | // the foreground colour | |
85 | wxColour colFg; | |
86 | ||
87 | // the background colour, may be wxNullColour if the controls background | |
88 | // colour is not solid | |
89 | wxColour colBg; | |
90 | }; | |
91 | ||
92 | // different window variants, on platforms like eg mac uses different | |
93 | // rendering sizes | |
400a9e41 | 94 | enum wxWindowVariant |
1b69c815 VZ |
95 | { |
96 | wxWINDOW_VARIANT_NORMAL, // Normal size | |
97 | wxWINDOW_VARIANT_SMALL, // Smaller size (about 25 % smaller than normal) | |
98 | wxWINDOW_VARIANT_MINI, // Mini size (about 33 % smaller than normal) | |
99 | wxWINDOW_VARIANT_LARGE, // Large size (about 25 % larger than normal) | |
100 | wxWINDOW_VARIANT_MAX | |
101 | }; | |
102 | ||
ff9f7a12 SC |
103 | #if wxUSE_SYSTEM_OPTIONS |
104 | #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant") | |
105 | #endif | |
106 | ||
f03fc89f VZ |
107 | // ---------------------------------------------------------------------------- |
108 | // (pseudo)template list classes | |
109 | // ---------------------------------------------------------------------------- | |
110 | ||
f6bcfd97 | 111 | WX_DECLARE_LIST_3(wxWindow, wxWindowBase, wxWindowList, wxWindowListNode, class WXDLLEXPORT); |
f03fc89f VZ |
112 | |
113 | // ---------------------------------------------------------------------------- | |
114 | // global variables | |
115 | // ---------------------------------------------------------------------------- | |
116 | ||
16cba29d | 117 | extern WXDLLEXPORT_DATA(wxWindowList) wxTopLevelWindows; |
e7445ff8 | 118 | extern WXDLLIMPEXP_DATA_CORE(wxList) wxPendingDelete; |
f03fc89f | 119 | |
f03fc89f VZ |
120 | // ---------------------------------------------------------------------------- |
121 | // wxWindowBase is the base class for all GUI controls/widgets, this is the public | |
122 | // interface of this class. | |
123 | // | |
124 | // Event handler: windows have themselves as their event handlers by default, | |
125 | // but their event handlers could be set to another object entirely. This | |
126 | // separation can reduce the amount of derivation required, and allow | |
127 | // alteration of a window's functionality (e.g. by a resource editor that | |
128 | // temporarily switches event handlers). | |
129 | // ---------------------------------------------------------------------------- | |
130 | ||
131 | class WXDLLEXPORT wxWindowBase : public wxEvtHandler | |
132 | { | |
f03fc89f VZ |
133 | public: |
134 | // creating the window | |
135 | // ------------------- | |
136 | ||
06f6df7d VZ |
137 | // default ctor, initializes everything which can be initialized before |
138 | // Create() | |
6463b9f5 | 139 | wxWindowBase() ; |
f03fc89f VZ |
140 | |
141 | // pseudo ctor (can't be virtual, called from ctor) | |
142 | bool CreateBase(wxWindowBase *parent, | |
d9e2e4c2 | 143 | wxWindowID winid, |
f03fc89f VZ |
144 | const wxPoint& pos = wxDefaultPosition, |
145 | const wxSize& size = wxDefaultSize, | |
146 | long style = 0, | |
8d99be5f | 147 | const wxValidator& validator = wxDefaultValidator, |
f03fc89f VZ |
148 | const wxString& name = wxPanelNameStr); |
149 | ||
150 | virtual ~wxWindowBase(); | |
151 | ||
f03fc89f VZ |
152 | // deleting the window |
153 | // ------------------- | |
154 | ||
d4864e97 | 155 | // ask the window to close itself, return true if the event handler |
f03fc89f | 156 | // honoured our request |
d4864e97 | 157 | bool Close( bool force = false ); |
f03fc89f VZ |
158 | |
159 | // the following functions delete the C++ objects (the window itself | |
160 | // or its children) as well as the GUI windows and normally should | |
161 | // never be used directly | |
162 | ||
d4864e97 | 163 | // delete window unconditionally (dangerous!), returns true if ok |
f03fc89f | 164 | virtual bool Destroy(); |
d4864e97 | 165 | // delete all children of this window, returns true if ok |
f03fc89f VZ |
166 | bool DestroyChildren(); |
167 | ||
168 | // is the window being deleted? | |
169 | bool IsBeingDeleted() const { return m_isBeingDeleted; } | |
170 | ||
171 | // window attributes | |
172 | // ----------------- | |
173 | ||
ffd84c94 WS |
174 | // label is just the same as the title (but for, e.g., buttons it |
175 | // makes more sense to speak about labels), title access | |
176 | // is available from wxTLW classes only (frames, dialogs) | |
faa49bfd WS |
177 | virtual void SetLabel(const wxString& label) = 0; |
178 | virtual wxString GetLabel() const = 0; | |
f03fc89f VZ |
179 | |
180 | // the window name is used for ressource setting in X, it is not the | |
181 | // same as the window title/label | |
182 | virtual void SetName( const wxString &name ) { m_windowName = name; } | |
183 | virtual wxString GetName() const { return m_windowName; } | |
184 | ||
978af864 VZ |
185 | // sets the window variant, calls internally DoSetVariant if variant |
186 | // has changed | |
187 | void SetWindowVariant(wxWindowVariant variant); | |
188 | wxWindowVariant GetWindowVariant() const { return m_windowVariant; } | |
400a9e41 | 189 | |
69d90995 | 190 | |
f03fc89f | 191 | // window id uniquely identifies the window among its siblings unless |
a0d9c6cb | 192 | // it is wxID_ANY which means "don't care" |
d9e2e4c2 | 193 | void SetId( wxWindowID winid ) { m_windowId = winid; } |
f03fc89f | 194 | wxWindowID GetId() const { return m_windowId; } |
b137e493 | 195 | |
978af864 VZ |
196 | // get or change the layout direction (LTR or RTL) for this window, |
197 | // wxLayout_Default is returned if layout direction is not supported | |
198 | virtual wxLayoutDirection GetLayoutDirection() const | |
199 | { return wxLayout_Default; } | |
200 | virtual void SetLayoutDirection(wxLayoutDirection WXUNUSED(dir)) | |
201 | { } | |
202 | ||
203 | // mirror coordinates for RTL layout if this window uses it and if the | |
204 | // mirroring is not done automatically like Win32 | |
205 | virtual wxCoord AdjustForLayoutDirection(wxCoord x, | |
206 | wxCoord width, | |
207 | wxCoord widthTotal) const; | |
f03fc89f VZ |
208 | |
209 | // generate a control id for the controls which were not given one by | |
210 | // user | |
69418a8e | 211 | static int NewControlId() { return --ms_lastControlId; } |
c539ab55 VZ |
212 | // get the id of the control following the one with the given |
213 | // (autogenerated) id | |
d9e2e4c2 | 214 | static int NextControlId(int winid) { return winid - 1; } |
c539ab55 VZ |
215 | // get the id of the control preceding the one with the given |
216 | // (autogenerated) id | |
d9e2e4c2 | 217 | static int PrevControlId(int winid) { return winid + 1; } |
f03fc89f VZ |
218 | |
219 | // moving/resizing | |
220 | // --------------- | |
221 | ||
222 | // set the window size and/or position | |
223 | void SetSize( int x, int y, int width, int height, | |
224 | int sizeFlags = wxSIZE_AUTO ) | |
225 | { DoSetSize(x, y, width, height, sizeFlags); } | |
226 | ||
227 | void SetSize( int width, int height ) | |
a0d9c6cb | 228 | { DoSetSize( wxDefaultCoord, wxDefaultCoord, width, height, wxSIZE_USE_EXISTING ); } |
f03fc89f VZ |
229 | |
230 | void SetSize( const wxSize& size ) | |
231 | { SetSize( size.x, size.y); } | |
232 | ||
233 | void SetSize(const wxRect& rect, int sizeFlags = wxSIZE_AUTO) | |
234 | { DoSetSize(rect.x, rect.y, rect.width, rect.height, sizeFlags); } | |
235 | ||
1e6feb95 | 236 | void Move(int x, int y, int flags = wxSIZE_USE_EXISTING) |
a0d9c6cb | 237 | { DoSetSize(x, y, wxDefaultCoord, wxDefaultCoord, flags); } |
f03fc89f | 238 | |
1e6feb95 VZ |
239 | void Move(const wxPoint& pt, int flags = wxSIZE_USE_EXISTING) |
240 | { Move(pt.x, pt.y, flags); } | |
f03fc89f | 241 | |
3c81c9aa VZ |
242 | void SetPosition(const wxPoint& pt) { Move(pt); } |
243 | ||
f03fc89f VZ |
244 | // Z-order |
245 | virtual void Raise() = 0; | |
246 | virtual void Lower() = 0; | |
247 | ||
248 | // client size is the size of area available for subwindows | |
249 | void SetClientSize( int width, int height ) | |
250 | { DoSetClientSize(width, height); } | |
251 | ||
252 | void SetClientSize( const wxSize& size ) | |
253 | { DoSetClientSize(size.x, size.y); } | |
254 | ||
255 | void SetClientSize(const wxRect& rect) | |
256 | { SetClientSize( rect.width, rect.height ); } | |
257 | ||
3c81c9aa VZ |
258 | // get the window position (pointers may be NULL): notice that it is in |
259 | // client coordinates for child windows and screen coordinates for the | |
260 | // top level ones, use GetScreenPosition() if you need screen | |
261 | // coordinates for all kinds of windows | |
f03fc89f VZ |
262 | void GetPosition( int *x, int *y ) const { DoGetPosition(x, y); } |
263 | wxPoint GetPosition() const | |
264 | { | |
3c81c9aa VZ |
265 | int x, y; |
266 | DoGetPosition(&x, &y); | |
f03fc89f | 267 | |
3c81c9aa | 268 | return wxPoint(x, y); |
f03fc89f VZ |
269 | } |
270 | ||
3c81c9aa VZ |
271 | // get the window position in screen coordinates |
272 | void GetScreenPosition(int *x, int *y) const { DoGetScreenPosition(x, y); } | |
273 | wxPoint GetScreenPosition() const | |
274 | { | |
275 | int x, y; | |
276 | DoGetScreenPosition(&x, &y); | |
38759b67 | 277 | |
3c81c9aa VZ |
278 | return wxPoint(x, y); |
279 | } | |
280 | ||
281 | // get the window size (pointers may be NULL) | |
f03fc89f VZ |
282 | void GetSize( int *w, int *h ) const { DoGetSize(w, h); } |
283 | wxSize GetSize() const | |
284 | { | |
285 | int w, h; | |
286 | DoGetSize(& w, & h); | |
287 | return wxSize(w, h); | |
288 | } | |
289 | ||
3c81c9aa VZ |
290 | void GetClientSize( int *w, int *h ) const { DoGetClientSize(w, h); } |
291 | wxSize GetClientSize() const | |
292 | { | |
293 | int w, h; | |
294 | DoGetClientSize(&w, &h); | |
295 | ||
296 | return wxSize(w, h); | |
297 | } | |
298 | ||
299 | // get the position and size at once | |
f03fc89f VZ |
300 | wxRect GetRect() const |
301 | { | |
302 | int x, y, w, h; | |
3c81c9aa VZ |
303 | GetPosition(&x, &y); |
304 | GetSize(&w, &h); | |
f03fc89f VZ |
305 | |
306 | return wxRect(x, y, w, h); | |
307 | } | |
308 | ||
3c81c9aa | 309 | wxRect GetScreenRect() const |
f03fc89f | 310 | { |
3c81c9aa VZ |
311 | int x, y, w, h; |
312 | GetScreenPosition(&x, &y); | |
313 | GetSize(&w, &h); | |
f03fc89f | 314 | |
3c81c9aa | 315 | return wxRect(x, y, w, h); |
f03fc89f VZ |
316 | } |
317 | ||
1e6feb95 VZ |
318 | // get the origin of the client area of the window relative to the |
319 | // window top left corner (the client area may be shifted because of | |
320 | // the borders, scrollbars, other decorations...) | |
321 | virtual wxPoint GetClientAreaOrigin() const; | |
322 | ||
323 | // get the client rectangle in window (i.e. client) coordinates | |
324 | wxRect GetClientRect() const | |
325 | { | |
326 | return wxRect(GetClientAreaOrigin(), GetClientSize()); | |
327 | } | |
328 | ||
f68586e5 | 329 | // get the size best suited for the window (in fact, minimal |
9f884528 RD |
330 | // acceptable size using which it will still look "nice" in |
331 | // most situations) | |
332 | wxSize GetBestSize() const | |
333 | { | |
334 | if (m_bestSizeCache.IsFullySpecified()) | |
335 | return m_bestSizeCache; | |
336 | return DoGetBestSize(); | |
337 | } | |
f68586e5 VZ |
338 | void GetBestSize(int *w, int *h) const |
339 | { | |
9f884528 | 340 | wxSize s = GetBestSize(); |
f68586e5 VZ |
341 | if ( w ) |
342 | *w = s.x; | |
343 | if ( h ) | |
344 | *h = s.y; | |
345 | } | |
346 | ||
f4fe2f20 RR |
347 | void SetScrollHelper( wxScrollHelper *sh ) { m_scrollHelper = sh; } |
348 | wxScrollHelper *GetScrollHelper() { return m_scrollHelper; } | |
349 | ||
9f884528 RD |
350 | // reset the cached best size value so it will be recalculated the |
351 | // next time it is needed. | |
992b2ec4 | 352 | void InvalidateBestSize(); |
9f884528 RD |
353 | void CacheBestSize(const wxSize& size) const |
354 | { wxConstCast(this, wxWindowBase)->m_bestSizeCache = size; } | |
a0d9c6cb | 355 | |
2b5f62a0 VZ |
356 | // There are times (and windows) where 'Best' size and 'Min' size |
357 | // are vastly out of sync. This should be remedied somehow, but in | |
358 | // the meantime, this method will return the larger of BestSize | |
359 | // (the window's smallest legible size), and any user specified | |
360 | // MinSize hint. | |
361 | wxSize GetAdjustedBestSize() const | |
362 | { | |
9f884528 | 363 | wxSize s( GetBestSize() ); |
2b5f62a0 VZ |
364 | return wxSize( wxMax( s.x, GetMinWidth() ), wxMax( s.y, GetMinHeight() ) ); |
365 | } | |
366 | ||
9f884528 RD |
367 | // This function will merge the window's best size into the window's |
368 | // minimum size, giving priority to the min size components, and | |
369 | // returns the results. | |
370 | wxSize GetBestFittingSize() const; | |
a0d9c6cb | 371 | |
9f884528 RD |
372 | // A 'Smart' SetSize that will fill in default size values with 'best' |
373 | // size. Sets the minsize to what was passed in. | |
374 | void SetBestFittingSize(const wxSize& size=wxDefaultSize); | |
375 | ||
2b5f62a0 | 376 | // the generic centre function - centers the window on parent by` |
7eb4e9cc VZ |
377 | // default or on screen if it doesn't have parent or |
378 | // wxCENTER_ON_SCREEN flag is given | |
1f464296 VZ |
379 | void Centre(int dir = wxBOTH) { DoCentre(dir); } |
380 | void Center(int dir = wxBOTH) { DoCentre(dir); } | |
7eb4e9cc VZ |
381 | |
382 | // centre with respect to the the parent window | |
1f464296 | 383 | void CentreOnParent(int dir = wxBOTH) { DoCentre(dir); } |
7eb4e9cc | 384 | void CenterOnParent(int dir = wxBOTH) { CentreOnParent(dir); } |
f03fc89f VZ |
385 | |
386 | // set window size to wrap around its children | |
387 | virtual void Fit(); | |
388 | ||
2b5f62a0 VZ |
389 | // set virtual size to satisfy children |
390 | virtual void FitInside(); | |
391 | ||
f03fc89f VZ |
392 | // set min/max size of the window |
393 | virtual void SetSizeHints( int minW, int minH, | |
a0d9c6cb | 394 | int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, |
571f6981 VS |
395 | int incW = wxDefaultCoord, int incH = wxDefaultCoord ) |
396 | { | |
397 | DoSetSizeHints(minW, minH, maxW, maxH, incW, incH); | |
398 | } | |
6fb99eb3 | 399 | |
1ec25e8f RD |
400 | void SetSizeHints( const wxSize& minSize, |
401 | const wxSize& maxSize=wxDefaultSize, | |
402 | const wxSize& incSize=wxDefaultSize) | |
403 | { | |
571f6981 VS |
404 | DoSetSizeHints(minSize.x, minSize.y, |
405 | maxSize.x, maxSize.y, | |
406 | incSize.x, incSize.y); | |
1ec25e8f | 407 | } |
6fb99eb3 | 408 | |
571f6981 VS |
409 | virtual void DoSetSizeHints(int minW, int minH, |
410 | int maxW = wxDefaultCoord, int maxH = wxDefaultCoord, | |
411 | int incW = wxDefaultCoord, int incH = wxDefaultCoord ); | |
f03fc89f | 412 | |
566d84a7 | 413 | virtual void SetVirtualSizeHints( int minW, int minH, |
a0d9c6cb | 414 | int maxW = wxDefaultCoord, int maxH = wxDefaultCoord ); |
1ec25e8f RD |
415 | void SetVirtualSizeHints( const wxSize& minSize, |
416 | const wxSize& maxSize=wxDefaultSize) | |
417 | { | |
418 | SetVirtualSizeHints(minSize.x, minSize.y, maxSize.x, maxSize.y); | |
419 | } | |
566d84a7 | 420 | |
e7dda1ff VS |
421 | virtual int GetMinWidth() const { return m_minWidth; } |
422 | virtual int GetMinHeight() const { return m_minHeight; } | |
738f9e5a RR |
423 | int GetMaxWidth() const { return m_maxWidth; } |
424 | int GetMaxHeight() const { return m_maxHeight; } | |
57c4d796 | 425 | |
34c3ffca RL |
426 | // Override this method to control the values given to Sizers etc. |
427 | virtual wxSize GetMaxSize() const { return wxSize( m_maxWidth, m_maxHeight ); } | |
1ec25e8f | 428 | virtual wxSize GetMinSize() const { return wxSize( m_minWidth, m_minHeight ); } |
400a9e41 | 429 | |
49f1dc5e RD |
430 | void SetMinSize(const wxSize& minSize) { SetSizeHints(minSize); } |
431 | void SetMaxSize(const wxSize& maxSize) { SetSizeHints(GetMinSize(), maxSize); } | |
a0d9c6cb | 432 | |
566d84a7 RL |
433 | // Methods for accessing the virtual size of a window. For most |
434 | // windows this is just the client area of the window, but for | |
435 | // some like scrolled windows it is more or less independent of | |
436 | // the screen window size. You may override the DoXXXVirtual | |
437 | // methods below for classes where that is is the case. | |
438 | ||
439 | void SetVirtualSize( const wxSize &size ) { DoSetVirtualSize( size.x, size.y ); } | |
440 | void SetVirtualSize( int x, int y ) { DoSetVirtualSize( x, y ); } | |
441 | ||
442 | wxSize GetVirtualSize() const { return DoGetVirtualSize(); } | |
443 | void GetVirtualSize( int *x, int *y ) const | |
444 | { | |
445 | wxSize s( DoGetVirtualSize() ); | |
446 | ||
447 | if( x ) | |
448 | *x = s.GetWidth(); | |
449 | if( y ) | |
450 | *y = s.GetHeight(); | |
451 | } | |
452 | ||
453 | // Override these methods for windows that have a virtual size | |
454 | // independent of their client size. eg. the virtual area of a | |
e5ecf1fc | 455 | // wxScrolledWindow. |
566d84a7 RL |
456 | |
457 | virtual void DoSetVirtualSize( int x, int y ); | |
85b38e0b | 458 | virtual wxSize DoGetVirtualSize() const; |
e5ecf1fc | 459 | |
2b5f62a0 VZ |
460 | // Return the largest of ClientSize and BestSize (as determined |
461 | // by a sizer, interior children, or other means) | |
462 | ||
463 | virtual wxSize GetBestVirtualSize() const | |
464 | { | |
465 | wxSize client( GetClientSize() ); | |
466 | wxSize best( GetBestSize() ); | |
467 | ||
468 | return wxSize( wxMax( client.x, best.x ), wxMax( client.y, best.y ) ); | |
469 | } | |
470 | ||
f03fc89f VZ |
471 | // window state |
472 | // ------------ | |
473 | ||
d4864e97 | 474 | // returns true if window was shown/hidden, false if the nothing was |
f03fc89f | 475 | // done (window was already shown/hidden) |
d4864e97 VZ |
476 | virtual bool Show( bool show = true ); |
477 | bool Hide() { return Show(false); } | |
f03fc89f | 478 | |
d4864e97 VZ |
479 | // returns true if window was enabled/disabled, false if nothing done |
480 | virtual bool Enable( bool enable = true ); | |
481 | bool Disable() { return Enable(false); } | |
f03fc89f | 482 | |
b08cd3bf | 483 | virtual bool IsShown() const { return m_isShown; } |
db101bd3 | 484 | virtual bool IsEnabled() const { return m_isEnabled; } |
f03fc89f | 485 | |
9c72cf76 VS |
486 | // returns true if the window is visible, i.e. IsShown() returns true |
487 | // if called on it and all its parents up to the first TLW | |
865a74c7 | 488 | virtual bool IsShownOnScreen() const; |
9c72cf76 | 489 | |
f03fc89f VZ |
490 | // get/set window style (setting style won't update the window and so |
491 | // is only useful for internal usage) | |
492 | virtual void SetWindowStyleFlag( long style ) { m_windowStyle = style; } | |
493 | virtual long GetWindowStyleFlag() const { return m_windowStyle; } | |
494 | ||
495 | // just some (somewhat shorter) synonims | |
496 | void SetWindowStyle( long style ) { SetWindowStyleFlag(style); } | |
497 | long GetWindowStyle() const { return GetWindowStyleFlag(); } | |
498 | ||
499 | bool HasFlag(int flag) const { return (m_windowStyle & flag) != 0; } | |
d80cd92a | 500 | virtual bool IsRetained() const { return HasFlag(wxRETAINED); } |
f03fc89f | 501 | |
d80cd92a VZ |
502 | // extra style: the less often used style bits which can't be set with |
503 | // SetWindowStyleFlag() | |
b2d5a7ee | 504 | virtual void SetExtraStyle(long exStyle) { m_exStyle = exStyle; } |
d80cd92a | 505 | long GetExtraStyle() const { return m_exStyle; } |
f03fc89f VZ |
506 | |
507 | // make the window modal (all other windows unresponsive) | |
d4864e97 | 508 | virtual void MakeModal(bool modal = true); |
f03fc89f | 509 | |
b8e7b673 VZ |
510 | |
511 | // (primitive) theming support | |
512 | // --------------------------- | |
513 | ||
a2d93e73 JS |
514 | virtual void SetThemeEnabled(bool enableTheme) { m_themeEnabled = enableTheme; } |
515 | virtual bool GetThemeEnabled() const { return m_themeEnabled; } | |
516 | ||
d4864e97 | 517 | |
456bc6d9 VZ |
518 | // focus and keyboard handling |
519 | // --------------------------- | |
f03fc89f VZ |
520 | |
521 | // set focus to this window | |
522 | virtual void SetFocus() = 0; | |
523 | ||
d577d610 VZ |
524 | // set focus to this window as the result of a keyboard action |
525 | virtual void SetFocusFromKbd() { SetFocus(); } | |
526 | ||
f03fc89f | 527 | // return the window which currently has the focus or NULL |
0fe02759 | 528 | static wxWindow *FindFocus(); |
6fb99eb3 | 529 | |
0fe02759 | 530 | static wxWindow *DoFindFocus() /* = 0: implement in derived classes */; |
f03fc89f VZ |
531 | |
532 | // can this window have focus? | |
533 | virtual bool AcceptsFocus() const { return IsShown() && IsEnabled(); } | |
534 | ||
1e6feb95 VZ |
535 | // can this window be given focus by keyboard navigation? if not, the |
536 | // only way to give it focus (provided it accepts it at all) is to | |
537 | // click it | |
538 | virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); } | |
539 | ||
a24de76b | 540 | // navigates in the specified direction by sending a wxNavigationKeyEvent |
eedc82f4 | 541 | virtual bool Navigate(int flags = wxNavigationKeyEvent::IsForward); |
5f6cfda7 | 542 | |
a24de76b VZ |
543 | // move this window just before/after the specified one in tab order |
544 | // (the other window must be our sibling!) | |
545 | void MoveBeforeInTabOrder(wxWindow *win) | |
546 | { DoMoveInTabOrder(win, MoveBefore); } | |
547 | void MoveAfterInTabOrder(wxWindow *win) | |
548 | { DoMoveInTabOrder(win, MoveAfter); } | |
549 | ||
550 | ||
f03fc89f VZ |
551 | // parent/children relations |
552 | // ------------------------- | |
553 | ||
554 | // get the list of children | |
555 | const wxWindowList& GetChildren() const { return m_children; } | |
556 | wxWindowList& GetChildren() { return m_children; } | |
557 | ||
1978421a SC |
558 | // needed just for extended runtime |
559 | const wxWindowList& GetWindowChildren() const { return GetChildren() ; } | |
560 | ||
f03fc89f VZ |
561 | // get the parent or the parent of the parent |
562 | wxWindow *GetParent() const { return m_parent; } | |
563 | inline wxWindow *GetGrandParent() const; | |
564 | ||
565 | // is this window a top level one? | |
8487f887 | 566 | virtual bool IsTopLevel() const; |
f03fc89f | 567 | |
87b6002d | 568 | // it doesn't really change parent, use Reparent() instead |
f03fc89f | 569 | void SetParent( wxWindowBase *parent ) { m_parent = (wxWindow *)parent; } |
d4864e97 VZ |
570 | // change the real parent of this window, return true if the parent |
571 | // was changed, false otherwise (error or newParent == oldParent) | |
f03fc89f VZ |
572 | virtual bool Reparent( wxWindowBase *newParent ); |
573 | ||
146ba0fe VZ |
574 | // implementation mostly |
575 | virtual void AddChild( wxWindowBase *child ); | |
576 | virtual void RemoveChild( wxWindowBase *child ); | |
577 | ||
578 | // looking for windows | |
579 | // ------------------- | |
580 | ||
f03fc89f VZ |
581 | // find window among the descendants of this one either by id or by |
582 | // name (return NULL if not found) | |
6b73af79 VZ |
583 | wxWindow *FindWindow(long winid) const; |
584 | wxWindow *FindWindow(const wxString& name) const; | |
f03fc89f | 585 | |
146ba0fe | 586 | // Find a window among any window (all return NULL if not found) |
d9e2e4c2 | 587 | static wxWindow *FindWindowById( long winid, const wxWindow *parent = NULL ); |
146ba0fe VZ |
588 | static wxWindow *FindWindowByName( const wxString& name, |
589 | const wxWindow *parent = NULL ); | |
590 | static wxWindow *FindWindowByLabel( const wxString& label, | |
591 | const wxWindow *parent = NULL ); | |
f03fc89f VZ |
592 | |
593 | // event handler stuff | |
594 | // ------------------- | |
595 | ||
596 | // get the current event handler | |
597 | wxEvtHandler *GetEventHandler() const { return m_eventHandler; } | |
598 | ||
599 | // replace the event handler (allows to completely subclass the | |
600 | // window) | |
601 | void SetEventHandler( wxEvtHandler *handler ) { m_eventHandler = handler; } | |
602 | ||
603 | // push/pop event handler: allows to chain a custom event handler to | |
604 | // alreasy existing ones | |
605 | void PushEventHandler( wxEvtHandler *handler ); | |
d4864e97 | 606 | wxEvtHandler *PopEventHandler( bool deleteHandler = false ); |
f03fc89f | 607 | |
2e36d5cf | 608 | // find the given handler in the event handler chain and remove (but |
d4864e97 VZ |
609 | // not delete) it from the event handler chain, return true if it was |
610 | // found and false otherwise (this also results in an assert failure so | |
2e36d5cf VZ |
611 | // this function should only be called when the handler is supposed to |
612 | // be there) | |
613 | bool RemoveEventHandler(wxEvtHandler *handler); | |
614 | ||
1e6feb95 VZ |
615 | // validators |
616 | // ---------- | |
f03fc89f | 617 | |
88ac883a | 618 | #if wxUSE_VALIDATORS |
f03fc89f VZ |
619 | // a window may have an associated validator which is used to control |
620 | // user input | |
621 | virtual void SetValidator( const wxValidator &validator ); | |
622 | virtual wxValidator *GetValidator() { return m_windowValidator; } | |
88ac883a | 623 | #endif // wxUSE_VALIDATORS |
f03fc89f | 624 | |
f03fc89f VZ |
625 | |
626 | // dialog oriented functions | |
627 | // ------------------------- | |
628 | ||
d4864e97 | 629 | // validate the correctness of input, return true if ok |
f03fc89f VZ |
630 | virtual bool Validate(); |
631 | ||
632 | // transfer data between internal and GUI representations | |
633 | virtual bool TransferDataToWindow(); | |
634 | virtual bool TransferDataFromWindow(); | |
635 | ||
636 | virtual void InitDialog(); | |
637 | ||
88ac883a | 638 | #if wxUSE_ACCEL |
f03fc89f VZ |
639 | // accelerators |
640 | // ------------ | |
641 | virtual void SetAcceleratorTable( const wxAcceleratorTable& accel ) | |
642 | { m_acceleratorTable = accel; } | |
643 | wxAcceleratorTable *GetAcceleratorTable() | |
644 | { return &m_acceleratorTable; } | |
5048c832 | 645 | |
540b6b09 VZ |
646 | #endif // wxUSE_ACCEL |
647 | ||
648 | #if wxUSE_HOTKEY | |
649 | // hot keys (system wide accelerators) | |
650 | // ----------------------------------- | |
651 | ||
652 | virtual bool RegisterHotKey(int hotkeyId, int modifiers, int keycode); | |
5048c832 | 653 | virtual bool UnregisterHotKey(int hotkeyId); |
540b6b09 | 654 | #endif // wxUSE_HOTKEY |
5048c832 | 655 | |
f03fc89f VZ |
656 | |
657 | // dialog units translations | |
658 | // ------------------------- | |
659 | ||
660 | wxPoint ConvertPixelsToDialog( const wxPoint& pt ); | |
661 | wxPoint ConvertDialogToPixels( const wxPoint& pt ); | |
662 | wxSize ConvertPixelsToDialog( const wxSize& sz ) | |
663 | { | |
664 | wxPoint pt(ConvertPixelsToDialog(wxPoint(sz.x, sz.y))); | |
665 | ||
666 | return wxSize(pt.x, pt.y); | |
667 | } | |
668 | ||
669 | wxSize ConvertDialogToPixels( const wxSize& sz ) | |
670 | { | |
671 | wxPoint pt(ConvertDialogToPixels(wxPoint(sz.x, sz.y))); | |
672 | ||
673 | return wxSize(pt.x, pt.y); | |
674 | } | |
675 | ||
676 | // mouse functions | |
677 | // --------------- | |
678 | ||
679 | // move the mouse to the specified position | |
680 | virtual void WarpPointer(int x, int y) = 0; | |
681 | ||
94633ad9 VZ |
682 | // start or end mouse capture, these functions maintain the stack of |
683 | // windows having captured the mouse and after calling ReleaseMouse() | |
684 | // the mouse is not released but returns to the window which had had | |
685 | // captured it previously (if any) | |
686 | void CaptureMouse(); | |
687 | void ReleaseMouse(); | |
f03fc89f | 688 | |
1e6feb95 VZ |
689 | // get the window which currently captures the mouse or NULL |
690 | static wxWindow *GetCapture(); | |
691 | ||
692 | // does this window have the capture? | |
693 | virtual bool HasCapture() const | |
694 | { return (wxWindow *)this == GetCapture(); } | |
695 | ||
f03fc89f VZ |
696 | // painting the window |
697 | // ------------------- | |
698 | ||
699 | // mark the specified rectangle (or the whole window) as "dirty" so it | |
700 | // will be repainted | |
d4864e97 | 701 | virtual void Refresh( bool eraseBackground = true, |
f03fc89f | 702 | const wxRect *rect = (const wxRect *) NULL ) = 0; |
1e6feb95 VZ |
703 | |
704 | // a less awkward wrapper for Refresh | |
8cfa09bd VZ |
705 | void RefreshRect(const wxRect& rect, bool eraseBackground = true) |
706 | { | |
707 | Refresh(eraseBackground, &rect); | |
708 | } | |
1e6feb95 VZ |
709 | |
710 | // repaint all invalid areas of the window immediately | |
711 | virtual void Update() { } | |
712 | ||
5da0803c VZ |
713 | // clear the window background |
714 | virtual void ClearBackground(); | |
f03fc89f | 715 | |
0cc7251e VZ |
716 | // freeze the window: don't redraw it until it is thawed |
717 | virtual void Freeze() { } | |
718 | ||
719 | // thaw the window: redraw it after it had been frozen | |
720 | virtual void Thaw() { } | |
721 | ||
d4a1433f VZ |
722 | // return true if window had been frozen and not unthawed yet |
723 | virtual bool IsFrozen() const { return false; } | |
724 | ||
f03fc89f | 725 | // adjust DC for drawing on this window |
f6147cfc | 726 | virtual void PrepareDC( wxDC & WXUNUSED(dc) ) { } |
f03fc89f VZ |
727 | |
728 | // the update region of the window contains the areas which must be | |
729 | // repainted by the program | |
730 | const wxRegion& GetUpdateRegion() const { return m_updateRegion; } | |
731 | wxRegion& GetUpdateRegion() { return m_updateRegion; } | |
732 | ||
1e6feb95 VZ |
733 | // get the update rectangleregion bounding box in client coords |
734 | wxRect GetUpdateClientRect() const; | |
735 | ||
f03fc89f VZ |
736 | // these functions verify whether the given point/rectangle belongs to |
737 | // (or at least intersects with) the update region | |
657b4fd4 RD |
738 | virtual bool DoIsExposed( int x, int y ) const; |
739 | virtual bool DoIsExposed( int x, int y, int w, int h ) const; | |
f03fc89f | 740 | |
657b4fd4 RD |
741 | bool IsExposed( int x, int y ) const |
742 | { return DoIsExposed(x, y); } | |
743 | bool IsExposed( int x, int y, int w, int h ) const | |
744 | { return DoIsExposed(x, y, w, h); } | |
f03fc89f | 745 | bool IsExposed( const wxPoint& pt ) const |
657b4fd4 | 746 | { return DoIsExposed(pt.x, pt.y); } |
f03fc89f | 747 | bool IsExposed( const wxRect& rect ) const |
657b4fd4 | 748 | { return DoIsExposed(rect.x, rect.y, rect.width, rect.height); } |
f03fc89f VZ |
749 | |
750 | // colours, fonts and cursors | |
751 | // -------------------------- | |
752 | ||
1b69c815 VZ |
753 | // get the default attributes for the controls of this class: we |
754 | // provide a virtual function which can be used to query the default | |
755 | // attributes of an existing control and a static function which can | |
756 | // be used even when no existing object of the given class is | |
757 | // available, but which won't return any styles specific to this | |
758 | // particular control, of course (e.g. "Ok" button might have | |
759 | // different -- bold for example -- font) | |
760 | virtual wxVisualAttributes GetDefaultAttributes() const | |
761 | { | |
762 | return GetClassDefaultAttributes(GetWindowVariant()); | |
763 | } | |
764 | ||
765 | static wxVisualAttributes | |
766 | GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL); | |
767 | ||
f03fc89f | 768 | // set/retrieve the window colours (system defaults are used by |
b8e7b673 | 769 | // default): SetXXX() functions return true if colour was changed, |
f8ff87ed VS |
770 | // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the |
771 | // value to prevent it from being inherited by our children | |
b8e7b673 | 772 | virtual bool SetBackgroundColour(const wxColour& colour); |
fa47d7a7 | 773 | void SetOwnBackgroundColour(const wxColour& colour) |
b8e7b673 VZ |
774 | { |
775 | if ( SetBackgroundColour(colour) ) | |
f8ff87ed | 776 | m_inheritBgCol = false; |
b8e7b673 | 777 | } |
1b69c815 | 778 | wxColour GetBackgroundColour() const; |
e5ecf1fc WS |
779 | bool InheritsBackgroundColour() const |
780 | { | |
781 | return m_inheritBgCol; | |
782 | } | |
783 | bool UseBgCol() const | |
784 | { | |
785 | return m_hasBgCol; | |
786 | } | |
b8e7b673 VZ |
787 | |
788 | virtual bool SetForegroundColour(const wxColour& colour); | |
fa47d7a7 | 789 | void SetOwnForegroundColour(const wxColour& colour) |
b8e7b673 VZ |
790 | { |
791 | if ( SetForegroundColour(colour) ) | |
f8ff87ed | 792 | m_inheritFgCol = false; |
b8e7b673 | 793 | } |
1b69c815 | 794 | wxColour GetForegroundColour() const; |
f03fc89f | 795 | |
50c53860 JS |
796 | // Set/get the background style. |
797 | // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM | |
798 | virtual bool SetBackgroundStyle(wxBackgroundStyle style) { m_backgroundStyle = style; return true; } | |
799 | virtual wxBackgroundStyle GetBackgroundStyle() const { return m_backgroundStyle; } | |
800 | ||
7c7a653b VZ |
801 | // returns true if the control has "transparent" areas such as a |
802 | // wxStaticText and wxCheckBox and the background should be adapted | |
803 | // from a parent window | |
804 | virtual bool HasTransparentBackground() { return false; } | |
805 | ||
b8e7b673 VZ |
806 | // set/retrieve the font for the window (SetFont() returns true if the |
807 | // font really changed) | |
808 | virtual bool SetFont(const wxFont& font) = 0; | |
fa47d7a7 | 809 | void SetOwnFont(const wxFont& font) |
b8e7b673 VZ |
810 | { |
811 | if ( SetFont(font) ) | |
f8ff87ed | 812 | m_inheritFont = false; |
b8e7b673 | 813 | } |
29094af0 | 814 | wxFont GetFont() const; |
b8e7b673 | 815 | |
d4864e97 | 816 | // set/retrieve the cursor for this window (SetCursor() returns true |
f03fc89f VZ |
817 | // if the cursor was really changed) |
818 | virtual bool SetCursor( const wxCursor &cursor ); | |
819 | const wxCursor& GetCursor() const { return m_cursor; } | |
f03fc89f | 820 | |
789295bf VZ |
821 | #if wxUSE_CARET |
822 | // associate a caret with the window | |
823 | void SetCaret(wxCaret *caret); | |
824 | // get the current caret (may be NULL) | |
825 | wxCaret *GetCaret() const { return m_caret; } | |
826 | #endif // wxUSE_CARET | |
827 | ||
f03fc89f VZ |
828 | // get the (average) character size for the current font |
829 | virtual int GetCharHeight() const = 0; | |
830 | virtual int GetCharWidth() const = 0; | |
831 | ||
832 | // get the width/height/... of the text using current or specified | |
833 | // font | |
834 | virtual void GetTextExtent(const wxString& string, | |
835 | int *x, int *y, | |
836 | int *descent = (int *) NULL, | |
837 | int *externalLeading = (int *) NULL, | |
838 | const wxFont *theFont = (const wxFont *) NULL) | |
839 | const = 0; | |
840 | ||
1e6feb95 VZ |
841 | // client <-> screen coords |
842 | // ------------------------ | |
843 | ||
f03fc89f | 844 | // translate to/from screen/client coordinates (pointers may be NULL) |
dabc0cd5 VZ |
845 | void ClientToScreen( int *x, int *y ) const |
846 | { DoClientToScreen(x, y); } | |
847 | void ScreenToClient( int *x, int *y ) const | |
848 | { DoScreenToClient(x, y); } | |
1e6feb95 VZ |
849 | |
850 | // wxPoint interface to do the same thing | |
dabc0cd5 VZ |
851 | wxPoint ClientToScreen(const wxPoint& pt) const |
852 | { | |
853 | int x = pt.x, y = pt.y; | |
854 | DoClientToScreen(&x, &y); | |
855 | ||
856 | return wxPoint(x, y); | |
857 | } | |
858 | ||
859 | wxPoint ScreenToClient(const wxPoint& pt) const | |
860 | { | |
861 | int x = pt.x, y = pt.y; | |
862 | DoScreenToClient(&x, &y); | |
863 | ||
864 | return wxPoint(x, y); | |
865 | } | |
f03fc89f | 866 | |
1e6feb95 VZ |
867 | // test where the given (in client coords) point lies |
868 | wxHitTest HitTest(wxCoord x, wxCoord y) const | |
869 | { return DoHitTest(x, y); } | |
870 | ||
871 | wxHitTest HitTest(const wxPoint& pt) const | |
872 | { return DoHitTest(pt.x, pt.y); } | |
873 | ||
f03fc89f VZ |
874 | // misc |
875 | // ---- | |
876 | ||
aede4ebb VZ |
877 | // get the window border style from the given flags: this is different from |
878 | // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to | |
879 | // translate wxBORDER_DEFAULT to something reasonable | |
880 | wxBorder GetBorder(long flags) const; | |
881 | ||
882 | // get border for the flags of this window | |
883 | wxBorder GetBorder() const { return GetBorder(GetWindowStyleFlag()); } | |
1e6feb95 | 884 | |
d4864e97 | 885 | // send wxUpdateUIEvents to this window, and children if recurse is true |
e39af974 JS |
886 | virtual void UpdateWindowUI(long flags = wxUPDATE_UI_NONE); |
887 | ||
888 | // do the window-specific processing after processing the update event | |
889 | virtual void DoUpdateWindowUI(wxUpdateUIEvent& event) ; | |
f03fc89f | 890 | |
1e6feb95 | 891 | #if wxUSE_MENUS |
45b8a256 | 892 | bool PopupMenu(wxMenu *menu, const wxPoint& pos = wxDefaultPosition) |
a1665b22 | 893 | { return DoPopupMenu(menu, pos.x, pos.y); } |
971562cb | 894 | bool PopupMenu(wxMenu *menu, int x, int y) |
a1665b22 | 895 | { return DoPopupMenu(menu, x, y); } |
1e6feb95 | 896 | #endif // wxUSE_MENUS |
f03fc89f | 897 | |
e71c530e VZ |
898 | // override this method to return true for controls having multiple pages |
899 | virtual bool HasMultiplePages() const { return false; } | |
900 | ||
901 | ||
f03fc89f VZ |
902 | // scrollbars |
903 | // ---------- | |
904 | ||
1e6feb95 VZ |
905 | // does the window have the scrollbar for this orientation? |
906 | bool HasScrollbar(int orient) const | |
907 | { | |
908 | return (m_windowStyle & | |
909 | (orient == wxHORIZONTAL ? wxHSCROLL : wxVSCROLL)) != 0; | |
910 | } | |
911 | ||
f03fc89f VZ |
912 | // configure the window scrollbars |
913 | virtual void SetScrollbar( int orient, | |
914 | int pos, | |
1e6feb95 | 915 | int thumbvisible, |
f03fc89f | 916 | int range, |
d4864e97 VZ |
917 | bool refresh = true ) = 0; |
918 | virtual void SetScrollPos( int orient, int pos, bool refresh = true ) = 0; | |
f03fc89f VZ |
919 | virtual int GetScrollPos( int orient ) const = 0; |
920 | virtual int GetScrollThumb( int orient ) const = 0; | |
921 | virtual int GetScrollRange( int orient ) const = 0; | |
922 | ||
923 | // scroll window to the specified position | |
924 | virtual void ScrollWindow( int dx, int dy, | |
925 | const wxRect* rect = (wxRect *) NULL ) = 0; | |
926 | ||
b9b3393e | 927 | // scrolls window by line/page: note that not all controls support this |
9cd6d737 | 928 | // |
d4864e97 VZ |
929 | // return true if the position changed, false otherwise |
930 | virtual bool ScrollLines(int WXUNUSED(lines)) { return false; } | |
931 | virtual bool ScrollPages(int WXUNUSED(pages)) { return false; } | |
9cd6d737 VZ |
932 | |
933 | // convenient wrappers for ScrollLines/Pages | |
934 | bool LineUp() { return ScrollLines(-1); } | |
935 | bool LineDown() { return ScrollLines(1); } | |
936 | bool PageUp() { return ScrollPages(-1); } | |
937 | bool PageDown() { return ScrollPages(1); } | |
b9b3393e | 938 | |
bd83cb56 VZ |
939 | // context-sensitive help |
940 | // ---------------------- | |
941 | ||
942 | // these are the convenience functions wrapping wxHelpProvider methods | |
943 | ||
944 | #if wxUSE_HELP | |
945 | // associate this help text with this window | |
946 | void SetHelpText(const wxString& text); | |
947 | // associate this help text with all windows with the same id as this | |
948 | // one | |
949 | void SetHelpTextForId(const wxString& text); | |
dc6588e7 VZ |
950 | // get the help string associated with the given position in this window |
951 | // | |
952 | // notice that pt may be invalid if event origin is keyboard or unknown | |
953 | // and this method should return the global window help text then | |
954 | virtual wxString GetHelpTextAtPoint(const wxPoint& pt, | |
955 | wxHelpEvent::Origin origin) const; | |
956 | // returns the position-independent help text | |
957 | wxString GetHelpText() const | |
958 | { | |
959 | return GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Unknown); | |
960 | } | |
961 | ||
962 | #else // !wxUSE_HELP | |
6c3c55cf VZ |
963 | // silently ignore SetHelpText() calls |
964 | void SetHelpText(const wxString& WXUNUSED(text)) { } | |
965 | void SetHelpTextForId(const wxString& WXUNUSED(text)) { } | |
bd83cb56 VZ |
966 | #endif // wxUSE_HELP |
967 | ||
f03fc89f VZ |
968 | // tooltips |
969 | // -------- | |
bd83cb56 | 970 | |
f03fc89f VZ |
971 | #if wxUSE_TOOLTIPS |
972 | // the easiest way to set a tooltip for a window is to use this method | |
973 | void SetToolTip( const wxString &tip ); | |
974 | // attach a tooltip to the window | |
975 | void SetToolTip( wxToolTip *tip ) { DoSetToolTip(tip); } | |
976 | // get the associated tooltip or NULL if none | |
977 | wxToolTip* GetToolTip() const { return m_tooltip; } | |
311a173b | 978 | wxString GetToolTipText() const ; |
7649d8fc JS |
979 | #else |
980 | // make it much easier to compile apps in an environment | |
981 | // that doesn't support tooltips, such as PocketPC | |
982 | inline void SetToolTip( const wxString & WXUNUSED(tip) ) {} | |
f03fc89f VZ |
983 | #endif // wxUSE_TOOLTIPS |
984 | ||
985 | // drag and drop | |
986 | // ------------- | |
987 | #if wxUSE_DRAG_AND_DROP | |
988 | // set/retrieve the drop target associated with this window (may be | |
989 | // NULL; it's owned by the window and will be deleted by it) | |
990 | virtual void SetDropTarget( wxDropTarget *dropTarget ) = 0; | |
991 | virtual wxDropTarget *GetDropTarget() const { return m_dropTarget; } | |
992 | #endif // wxUSE_DRAG_AND_DROP | |
993 | ||
994 | // constraints and sizers | |
995 | // ---------------------- | |
996 | #if wxUSE_CONSTRAINTS | |
997 | // set the constraints for this window or retrieve them (may be NULL) | |
998 | void SetConstraints( wxLayoutConstraints *constraints ); | |
999 | wxLayoutConstraints *GetConstraints() const { return m_constraints; } | |
1000 | ||
f03fc89f VZ |
1001 | // implementation only |
1002 | void UnsetConstraints(wxLayoutConstraints *c); | |
1003 | wxWindowList *GetConstraintsInvolvedIn() const | |
1004 | { return m_constraintsInvolvedIn; } | |
1005 | void AddConstraintReference(wxWindowBase *otherWin); | |
1006 | void RemoveConstraintReference(wxWindowBase *otherWin); | |
1007 | void DeleteRelatedConstraints(); | |
1008 | void ResetConstraints(); | |
1009 | ||
90e572f1 | 1010 | // these methods may be overridden for special layout algorithms |
d4864e97 | 1011 | virtual void SetConstraintSizes(bool recurse = true); |
f03fc89f VZ |
1012 | virtual bool LayoutPhase1(int *noChanges); |
1013 | virtual bool LayoutPhase2(int *noChanges); | |
4b7f2165 | 1014 | virtual bool DoPhase(int phase); |
f03fc89f VZ |
1015 | |
1016 | // these methods are virtual but normally won't be overridden | |
f03fc89f VZ |
1017 | virtual void SetSizeConstraint(int x, int y, int w, int h); |
1018 | virtual void MoveConstraint(int x, int y); | |
1019 | virtual void GetSizeConstraint(int *w, int *h) const ; | |
1020 | virtual void GetClientSizeConstraint(int *w, int *h) const ; | |
1021 | virtual void GetPositionConstraint(int *x, int *y) const ; | |
1022 | ||
461e93f9 JS |
1023 | #endif // wxUSE_CONSTRAINTS |
1024 | ||
1025 | // when using constraints or sizers, it makes sense to update | |
1026 | // children positions automatically whenever the window is resized | |
1027 | // - this is done if autoLayout is on | |
1028 | void SetAutoLayout( bool autoLayout ) { m_autoLayout = autoLayout; } | |
1029 | bool GetAutoLayout() const { return m_autoLayout; } | |
1030 | ||
1031 | // lay out the window and its children | |
1032 | virtual bool Layout(); | |
1033 | ||
f03fc89f | 1034 | // sizers |
d4864e97 VZ |
1035 | void SetSizer(wxSizer *sizer, bool deleteOld = true ); |
1036 | void SetSizerAndFit( wxSizer *sizer, bool deleteOld = true ); | |
566d84a7 | 1037 | |
f03fc89f | 1038 | wxSizer *GetSizer() const { return m_windowSizer; } |
be90c029 RD |
1039 | |
1040 | // Track if this window is a member of a sizer | |
1ebfafde | 1041 | void SetContainingSizer(wxSizer* sizer); |
be90c029 RD |
1042 | wxSizer *GetContainingSizer() const { return m_containingSizer; } |
1043 | ||
45a959a3 JS |
1044 | // accessibility |
1045 | // ---------------------- | |
1046 | #if wxUSE_ACCESSIBILITY | |
1047 | // Override to create a specific accessible object. | |
1048 | virtual wxAccessible* CreateAccessible(); | |
1049 | ||
1050 | // Sets the accessible object. | |
1051 | void SetAccessible(wxAccessible* accessible) ; | |
1052 | ||
1053 | // Returns the accessible object. | |
1054 | wxAccessible* GetAccessible() { return m_accessible; }; | |
1055 | ||
1056 | // Returns the accessible object, creating if necessary. | |
1057 | wxAccessible* GetOrCreateAccessible() ; | |
1058 | #endif | |
1059 | ||
b137e493 | 1060 | |
b58d5e2d RD |
1061 | // Set window transparency if the platform supports it |
1062 | virtual bool SetTransparent(wxByte WXUNUSED(alpha)) { return false; } | |
1063 | virtual bool CanSetTransparent() { return false; } | |
1064 | ||
1065 | ||
f03fc89f VZ |
1066 | // implementation |
1067 | // -------------- | |
1068 | ||
1069 | // event handlers | |
1070 | void OnSysColourChanged( wxSysColourChangedEvent& event ); | |
1071 | void OnInitDialog( wxInitDialogEvent &event ); | |
72fc5caf | 1072 | void OnMiddleClick( wxMouseEvent& event ); |
bd83cb56 VZ |
1073 | #if wxUSE_HELP |
1074 | void OnHelp(wxHelpEvent& event); | |
1075 | #endif // wxUSE_HELP | |
f03fc89f | 1076 | |
e39af974 JS |
1077 | // virtual function for implementing internal idle |
1078 | // behaviour | |
1079 | virtual void OnInternalIdle() {} | |
1080 | ||
1081 | // call internal idle recursively | |
5109ae5d | 1082 | // void ProcessInternalIdle() ; |
e39af974 JS |
1083 | |
1084 | // get the handle of the window for the underlying window system: this | |
d7c24517 VZ |
1085 | // is only used for wxWin itself or for user code which wants to call |
1086 | // platform-specific APIs | |
d22699b5 | 1087 | virtual WXWidget GetHandle() const = 0; |
ed4780ea VZ |
1088 | // associate the window with a new native handle |
1089 | virtual void AssociateHandle(WXWidget WXUNUSED(handle)) { } | |
1090 | // dissociate the current native handle from the window | |
1091 | virtual void DissociateHandle() { } | |
cc2b7472 | 1092 | |
574c939e KB |
1093 | #if wxUSE_PALETTE |
1094 | // Store the palette used by DCs in wxWindow so that the dcs can share | |
1095 | // a palette. And we can respond to palette messages. | |
1096 | wxPalette GetPalette() const { return m_palette; } | |
b95edd47 | 1097 | |
574c939e KB |
1098 | // When palette is changed tell the DC to set the system palette to the |
1099 | // new one. | |
b95edd47 VZ |
1100 | void SetPalette(const wxPalette& pal); |
1101 | ||
1102 | // return true if we have a specific palette | |
1103 | bool HasCustomPalette() const { return m_hasCustomPalette; } | |
1104 | ||
1105 | // return the first parent window with a custom palette or NULL | |
1106 | wxWindow *GetAncestorWithCustomPalette() const; | |
574c939e KB |
1107 | #endif // wxUSE_PALETTE |
1108 | ||
b8e7b673 VZ |
1109 | // inherit the parents visual attributes if they had been explicitly set |
1110 | // by the user (i.e. we don't inherit default attributes) and if we don't | |
1111 | // have our own explicitly set | |
1112 | virtual void InheritAttributes(); | |
1113 | ||
1114 | // returns false from here if this window doesn't want to inherit the | |
1115 | // parents colours even if InheritAttributes() would normally do it | |
1116 | // | |
1117 | // this just provides a simple way to customize InheritAttributes() | |
1118 | // behaviour in the most common case | |
1119 | virtual bool ShouldInheritColours() const { return false; } | |
1120 | ||
245c5d2e RD |
1121 | protected: |
1122 | // event handling specific to wxWindow | |
1123 | virtual bool TryValidator(wxEvent& event); | |
1124 | virtual bool TryParent(wxEvent& event); | |
1125 | ||
a24de76b VZ |
1126 | // common part of MoveBefore/AfterInTabOrder() |
1127 | enum MoveKind | |
1128 | { | |
1129 | MoveBefore, // insert before the given window | |
1130 | MoveAfter // insert after the given window | |
1131 | }; | |
1132 | virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move); | |
4caf847c | 1133 | |
ec5bb70d VZ |
1134 | #if wxUSE_CONSTRAINTS |
1135 | // satisfy the constraints for the windows but don't set the window sizes | |
1136 | void SatisfyConstraints(); | |
1137 | #endif // wxUSE_CONSTRAINTS | |
566d84a7 | 1138 | |
7de59551 RD |
1139 | // Send the wxWindowDestroyEvent |
1140 | void SendDestroyEvent(); | |
1141 | ||
0fe02759 VS |
1142 | // returns the main window of composite control; this is the window |
1143 | // that FindFocus returns if the focus is in one of composite control's | |
1144 | // windows | |
6fb99eb3 | 1145 | virtual wxWindow *GetMainWindowOfCompositeControl() |
0fe02759 VS |
1146 | { return (wxWindow*)this; } |
1147 | ||
7af6f327 | 1148 | // the window id - a number which uniquely identifies a window among |
a0d9c6cb | 1149 | // its siblings unless it is wxID_ANY |
f03fc89f | 1150 | wxWindowID m_windowId; |
456bc6d9 | 1151 | |
f03fc89f VZ |
1152 | // the parent window of this window (or NULL) and the list of the children |
1153 | // of this window | |
1154 | wxWindow *m_parent; | |
1155 | wxWindowList m_children; | |
1156 | ||
1157 | // the minimal allowed size for the window (no minimal size if variable(s) | |
a0d9c6cb | 1158 | // contain(s) wxDefaultCoord) |
ec5bb70d VZ |
1159 | int m_minWidth, |
1160 | m_minHeight, | |
1161 | m_maxWidth, | |
1162 | m_maxHeight; | |
f03fc89f VZ |
1163 | |
1164 | // event handler for this window: usually is just 'this' but may be | |
1165 | // changed with SetEventHandler() | |
1166 | wxEvtHandler *m_eventHandler; | |
1167 | ||
88ac883a | 1168 | #if wxUSE_VALIDATORS |
f03fc89f VZ |
1169 | // associated validator or NULL if none |
1170 | wxValidator *m_windowValidator; | |
88ac883a | 1171 | #endif // wxUSE_VALIDATORS |
f03fc89f VZ |
1172 | |
1173 | #if wxUSE_DRAG_AND_DROP | |
1174 | wxDropTarget *m_dropTarget; | |
1175 | #endif // wxUSE_DRAG_AND_DROP | |
1176 | ||
1177 | // visual window attributes | |
1178 | wxCursor m_cursor; | |
1b69c815 VZ |
1179 | wxFont m_font; // see m_hasFont |
1180 | wxColour m_backgroundColour, // m_hasBgCol | |
1181 | m_foregroundColour; // m_hasFgCol | |
f03fc89f | 1182 | |
789295bf VZ |
1183 | #if wxUSE_CARET |
1184 | wxCaret *m_caret; | |
1185 | #endif // wxUSE_CARET | |
1186 | ||
f03fc89f VZ |
1187 | // the region which should be repainted in response to paint event |
1188 | wxRegion m_updateRegion; | |
1189 | ||
88ac883a | 1190 | #if wxUSE_ACCEL |
f03fc89f VZ |
1191 | // the accelerator table for the window which translates key strokes into |
1192 | // command events | |
1193 | wxAcceleratorTable m_acceleratorTable; | |
88ac883a | 1194 | #endif // wxUSE_ACCEL |
f03fc89f | 1195 | |
f03fc89f VZ |
1196 | // the tooltip for this window (may be NULL) |
1197 | #if wxUSE_TOOLTIPS | |
1198 | wxToolTip *m_tooltip; | |
1199 | #endif // wxUSE_TOOLTIPS | |
1200 | ||
1201 | // constraints and sizers | |
1202 | #if wxUSE_CONSTRAINTS | |
1203 | // the constraints for this window or NULL | |
1204 | wxLayoutConstraints *m_constraints; | |
1205 | ||
1206 | // constraints this window is involved in | |
1207 | wxWindowList *m_constraintsInvolvedIn; | |
461e93f9 | 1208 | #endif // wxUSE_CONSTRAINTS |
f03fc89f | 1209 | |
be90c029 | 1210 | // this window's sizer |
f03fc89f | 1211 | wxSizer *m_windowSizer; |
be90c029 RD |
1212 | |
1213 | // The sizer this window is a member of, if any | |
1214 | wxSizer *m_containingSizer; | |
f03fc89f VZ |
1215 | |
1216 | // Layout() window automatically when its size changes? | |
1217 | bool m_autoLayout:1; | |
f03fc89f VZ |
1218 | |
1219 | // window state | |
1220 | bool m_isShown:1; | |
1221 | bool m_isEnabled:1; | |
1222 | bool m_isBeingDeleted:1; | |
1223 | ||
23895080 VZ |
1224 | // was the window colours/font explicitly changed by user? |
1225 | bool m_hasBgCol:1; | |
1226 | bool m_hasFgCol:1; | |
1227 | bool m_hasFont:1; | |
a0d9c6cb | 1228 | |
f8ff87ed VS |
1229 | // and should it be inherited by children? |
1230 | bool m_inheritBgCol:1; | |
1231 | bool m_inheritFgCol:1; | |
1232 | bool m_inheritFont:1; | |
23895080 | 1233 | |
f03fc89f | 1234 | // window attributes |
d80cd92a VZ |
1235 | long m_windowStyle, |
1236 | m_exStyle; | |
f03fc89f | 1237 | wxString m_windowName; |
a2d93e73 | 1238 | bool m_themeEnabled; |
50c53860 | 1239 | wxBackgroundStyle m_backgroundStyle; |
071e5fd9 | 1240 | #if wxUSE_PALETTE |
574c939e | 1241 | wxPalette m_palette; |
b95edd47 VZ |
1242 | bool m_hasCustomPalette; |
1243 | #endif // wxUSE_PALETTE | |
574c939e | 1244 | |
45a959a3 JS |
1245 | #if wxUSE_ACCESSIBILITY |
1246 | wxAccessible* m_accessible; | |
1247 | #endif | |
2654f7e4 | 1248 | |
566d84a7 RL |
1249 | // Virtual size (scrolling) |
1250 | wxSize m_virtualSize; | |
1251 | ||
f4fe2f20 RR |
1252 | wxScrollHelper *m_scrollHelper; |
1253 | ||
566d84a7 RL |
1254 | int m_minVirtualWidth; // VirtualSizeHints |
1255 | int m_minVirtualHeight; | |
1256 | int m_maxVirtualWidth; | |
1257 | int m_maxVirtualHeight; | |
400a9e41 | 1258 | |
69d90995 | 1259 | wxWindowVariant m_windowVariant ; |
45e0dc94 | 1260 | |
1e6feb95 VZ |
1261 | // override this to change the default (i.e. used when no style is |
1262 | // specified) border for the window class | |
1263 | virtual wxBorder GetDefaultBorder() const; | |
1264 | ||
5c2be659 RD |
1265 | // Get the default size for the new window if no explicit size given. TLWs |
1266 | // have their own default size so this is just for non top-level windows. | |
a0d9c6cb WS |
1267 | static int WidthDefault(int w) { return w == wxDefaultCoord ? 20 : w; } |
1268 | static int HeightDefault(int h) { return h == wxDefaultCoord ? 20 : h; } | |
f03fc89f | 1269 | |
9f884528 RD |
1270 | |
1271 | // Used to save the results of DoGetBestSize so it doesn't need to be | |
1272 | // recalculated each time the value is needed. | |
1273 | wxSize m_bestSizeCache; | |
1274 | ||
fe161a26 RD |
1275 | // keep the old name for compatibility, at least until all the internal |
1276 | // usages of it are changed to SetBestFittingSize | |
1277 | void SetBestSize(const wxSize& size) { SetBestFittingSize(size); } | |
a0d9c6cb | 1278 | |
d3b5db4b | 1279 | // set the initial window size if none is given (i.e. at least one of the |
cab1a605 | 1280 | // components of the size passed to ctor/Create() is wxDefaultCoord) |
d3b5db4b RD |
1281 | // |
1282 | // normally just calls SetBestSize() for controls, but can be overridden | |
1283 | // not to do it for the controls which have to do some additional | |
1284 | // initialization (e.g. add strings to list box) before their best size | |
1285 | // can be accurately calculated | |
1286 | virtual void SetInitialBestSize(const wxSize& WXUNUSED(size)) {} | |
1287 | ||
a0d9c6cb | 1288 | |
d3b5db4b | 1289 | |
f03fc89f VZ |
1290 | // more pure virtual functions |
1291 | // --------------------------- | |
1292 | ||
1293 | // NB: we must have DoSomething() function when Something() is an overloaded | |
1294 | // method: indeed, we can't just have "virtual Something()" in case when | |
1295 | // the function is overloaded because then we'd have to make virtual all | |
1296 | // the variants (otherwise only the virtual function may be called on a | |
1297 | // pointer to derived class according to C++ rules) which is, in | |
1298 | // general, absolutely not needed. So instead we implement all | |
1299 | // overloaded Something()s in terms of DoSomething() which will be the | |
1300 | // only one to be virtual. | |
1301 | ||
dabc0cd5 VZ |
1302 | // coordinates translation |
1303 | virtual void DoClientToScreen( int *x, int *y ) const = 0; | |
1304 | virtual void DoScreenToClient( int *x, int *y ) const = 0; | |
1305 | ||
1e6feb95 VZ |
1306 | virtual wxHitTest DoHitTest(wxCoord x, wxCoord y) const; |
1307 | ||
94633ad9 | 1308 | // capture/release the mouse, used by Capture/ReleaseMouse() |
a83e1475 VZ |
1309 | virtual void DoCaptureMouse() = 0; |
1310 | virtual void DoReleaseMouse() = 0; | |
be90c029 | 1311 | |
f03fc89f | 1312 | // retrieve the position/size of the window |
3c81c9aa VZ |
1313 | virtual void DoGetPosition(int *x, int *y) const = 0; |
1314 | virtual void DoGetScreenPosition(int *x, int *y) const; | |
1315 | virtual void DoGetSize(int *width, int *height) const = 0; | |
1316 | virtual void DoGetClientSize(int *width, int *height) const = 0; | |
f03fc89f | 1317 | |
f68586e5 VZ |
1318 | // get the size which best suits the window: for a control, it would be |
1319 | // the minimal size which doesn't truncate the control, for a panel - the | |
1320 | // same size as it would have after a call to Fit() | |
1321 | virtual wxSize DoGetBestSize() const; | |
1322 | ||
ee146bca VZ |
1323 | // called from DoGetBestSize() to convert best virtual size (returned by |
1324 | // the window sizer) to the best size for the window itself; this is | |
1325 | // overridden at wxScrolledWindow level to clump down virtual size to real | |
1326 | virtual wxSize GetWindowSizeForVirtualSize(const wxSize& size) const | |
1327 | { | |
1328 | return size; | |
1329 | } | |
1330 | ||
f03fc89f VZ |
1331 | // this is the virtual function to be overriden in any derived class which |
1332 | // wants to change how SetSize() or Move() works - it is called by all | |
1333 | // versions of these functions in the base class | |
1334 | virtual void DoSetSize(int x, int y, | |
1335 | int width, int height, | |
1336 | int sizeFlags = wxSIZE_AUTO) = 0; | |
1337 | ||
1338 | // same as DoSetSize() for the client size | |
1339 | virtual void DoSetClientSize(int width, int height) = 0; | |
1340 | ||
9d9b7755 VZ |
1341 | // move the window to the specified location and resize it: this is called |
1342 | // from both DoSetSize() and DoSetClientSize() and would usually just | |
1343 | // reposition this window except for composite controls which will want to | |
1344 | // arrange themselves inside the given rectangle | |
1345 | virtual void DoMoveWindow(int x, int y, int width, int height) = 0; | |
1346 | ||
1f464296 VZ |
1347 | // centre the window in the specified direction on parent, note that |
1348 | // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for | |
1349 | // TLWs | |
1350 | virtual void DoCentre(int dir); | |
1351 | ||
f03fc89f VZ |
1352 | #if wxUSE_TOOLTIPS |
1353 | virtual void DoSetToolTip( wxToolTip *tip ); | |
1354 | #endif // wxUSE_TOOLTIPS | |
1355 | ||
1e6feb95 | 1356 | #if wxUSE_MENUS |
971562cb | 1357 | virtual bool DoPopupMenu(wxMenu *menu, int x, int y) = 0; |
1e6feb95 | 1358 | #endif // wxUSE_MENUS |
a1665b22 | 1359 | |
716e96df VZ |
1360 | // Makes an adjustment to the window position to make it relative to the |
1361 | // parents client area, e.g. if the parent is a frame with a toolbar, its | |
1362 | // (0, 0) is just below the toolbar | |
1363 | virtual void AdjustForParentClientOrigin(int& x, int& y, | |
1364 | int sizeFlags = 0) const; | |
8d99be5f | 1365 | |
69d90995 SC |
1366 | // implements the window variants |
1367 | virtual void DoSetWindowVariant( wxWindowVariant variant ) ; | |
45e0dc94 | 1368 | |
63e819f2 | 1369 | // Must be called when mouse capture is lost to send |
72f8c792 VS |
1370 | // wxMouseCaptureLostEvent to windows on capture stack. |
1371 | static void NotifyCaptureLost(); | |
63e819f2 | 1372 | |
f03fc89f VZ |
1373 | private: |
1374 | // contains the last id generated by NewControlId | |
1375 | static int ms_lastControlId; | |
1376 | ||
a83e1475 VZ |
1377 | // the stack of windows which have captured the mouse |
1378 | static struct WXDLLEXPORT wxWindowNext *ms_winCaptureNext; | |
63e819f2 VS |
1379 | // the window that currently has mouse capture |
1380 | static wxWindow *ms_winCaptureCurrent; | |
1381 | // indicates if execution is inside CaptureMouse/ReleaseMouse | |
1382 | static bool ms_winCaptureChanging; | |
a83e1475 | 1383 | |
1e6feb95 VZ |
1384 | DECLARE_ABSTRACT_CLASS(wxWindowBase) |
1385 | DECLARE_NO_COPY_CLASS(wxWindowBase) | |
f03fc89f VZ |
1386 | DECLARE_EVENT_TABLE() |
1387 | }; | |
1388 | ||
1389 | // ---------------------------------------------------------------------------- | |
1390 | // now include the declaration of wxWindow class | |
1391 | // ---------------------------------------------------------------------------- | |
1392 | ||
1e6feb95 | 1393 | // include the declaration of the platform-specific class |
4055ed82 | 1394 | #if defined(__WXPALMOS__) |
ffecfa5a JS |
1395 | #ifdef __WXUNIVERSAL__ |
1396 | #define wxWindowNative wxWindowPalm | |
1397 | #else // !wxUniv | |
1398 | #define wxWindowPalm wxWindow | |
1399 | #endif // wxUniv/!wxUniv | |
1400 | #include "wx/palmos/window.h" | |
1401 | #elif defined(__WXMSW__) | |
a5b3669d VZ |
1402 | #ifdef __WXUNIVERSAL__ |
1403 | #define wxWindowNative wxWindowMSW | |
1404 | #else // !wxUniv | |
1e6feb95 | 1405 | #define wxWindowMSW wxWindow |
a5b3669d | 1406 | #endif // wxUniv/!wxUniv |
f03fc89f | 1407 | #include "wx/msw/window.h" |
2049ba38 | 1408 | #elif defined(__WXMOTIF__) |
f03fc89f | 1409 | #include "wx/motif/window.h" |
1be7a35c | 1410 | #elif defined(__WXGTK20__) |
a5b3669d VZ |
1411 | #ifdef __WXUNIVERSAL__ |
1412 | #define wxWindowNative wxWindowGTK | |
1413 | #else // !wxUniv | |
1e6feb95 | 1414 | #define wxWindowGTK wxWindow |
1e6feb95 | 1415 | #endif // wxUniv |
f03fc89f | 1416 | #include "wx/gtk/window.h" |
1be7a35c MR |
1417 | #elif defined(__WXGTK__) |
1418 | #ifdef __WXUNIVERSAL__ | |
1419 | #define wxWindowNative wxWindowGTK | |
1420 | #else // !wxUniv | |
1421 | #define wxWindowGTK wxWindow | |
1422 | #endif // wxUniv | |
1423 | #include "wx/gtk1/window.h" | |
83df96d6 JS |
1424 | #elif defined(__WXX11__) |
1425 | #ifdef __WXUNIVERSAL__ | |
1426 | #define wxWindowNative wxWindowX11 | |
1427 | #else // !wxUniv | |
1428 | #define wxWindowX11 wxWindow | |
83df96d6 JS |
1429 | #endif // wxUniv |
1430 | #include "wx/x11/window.h" | |
711c76db | 1431 | #elif defined(__WXMGL__) |
b3c86150 | 1432 | #define wxWindowNative wxWindowMGL |
386c7058 | 1433 | #include "wx/mgl/window.h" |
b3c86150 VS |
1434 | #elif defined(__WXDFB__) |
1435 | #define wxWindowNative wxWindowDFB | |
1436 | #include "wx/dfb/window.h" | |
34138703 | 1437 | #elif defined(__WXMAC__) |
e766c8a9 SC |
1438 | #ifdef __WXUNIVERSAL__ |
1439 | #define wxWindowNative wxWindowMac | |
1440 | #else // !wxUniv | |
1441 | #define wxWindowMac wxWindow | |
e766c8a9 | 1442 | #endif // wxUniv |
f03fc89f | 1443 | #include "wx/mac/window.h" |
e64df9bc DE |
1444 | #elif defined(__WXCOCOA__) |
1445 | #ifdef __WXUNIVERSAL__ | |
1446 | #define wxWindowNative wxWindowCocoa | |
1447 | #else // !wxUniv | |
1448 | #define wxWindowCocoa wxWindow | |
e64df9bc DE |
1449 | #endif // wxUniv |
1450 | #include "wx/cocoa/window.h" | |
1777b9bb | 1451 | #elif defined(__WXPM__) |
210a651b DW |
1452 | #ifdef __WXUNIVERSAL__ |
1453 | #define wxWindowNative wxWindowOS2 | |
1454 | #else // !wxUniv | |
1455 | #define wxWindowOS2 wxWindow | |
210a651b | 1456 | #endif // wxUniv/!wxUniv |
1777b9bb | 1457 | #include "wx/os2/window.h" |
c801d85f KB |
1458 | #endif |
1459 | ||
1e6feb95 VZ |
1460 | // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>, |
1461 | // for the native ports we already have defined it above | |
1462 | #if defined(__WXUNIVERSAL__) | |
a5b3669d VZ |
1463 | #ifndef wxWindowNative |
1464 | #error "wxWindowNative must be defined above!" | |
1465 | #endif | |
1466 | ||
1e6feb95 VZ |
1467 | #include "wx/univ/window.h" |
1468 | #endif // wxUniv | |
1469 | ||
f03fc89f VZ |
1470 | // ---------------------------------------------------------------------------- |
1471 | // inline functions which couldn't be declared in the class body because of | |
1472 | // forward dependencies | |
1473 | // ---------------------------------------------------------------------------- | |
1474 | ||
bacd69f9 | 1475 | inline wxWindow *wxWindowBase::GetGrandParent() const |
f03fc89f VZ |
1476 | { |
1477 | return m_parent ? m_parent->GetParent() : (wxWindow *)NULL; | |
1478 | } | |
1479 | ||
1480 | // ---------------------------------------------------------------------------- | |
3723b7b1 | 1481 | // global functions |
f03fc89f VZ |
1482 | // ---------------------------------------------------------------------------- |
1483 | ||
3723b7b1 JS |
1484 | // Find the wxWindow at the current mouse position, also returning the mouse |
1485 | // position. | |
16cba29d | 1486 | extern WXDLLEXPORT wxWindow* wxFindWindowAtPointer(wxPoint& pt); |
3723b7b1 JS |
1487 | |
1488 | // Get the current mouse position. | |
16cba29d | 1489 | extern WXDLLEXPORT wxPoint wxGetMousePosition(); |
3723b7b1 | 1490 | |
1e6feb95 | 1491 | // get the currently active window of this application or NULL |
16cba29d | 1492 | extern WXDLLEXPORT wxWindow *wxGetActiveWindow(); |
1e6feb95 | 1493 | |
33b494d6 VZ |
1494 | // get the (first) top level parent window |
1495 | WXDLLEXPORT wxWindow* wxGetTopLevelParent(wxWindow *win); | |
1496 | ||
40ff126a WS |
1497 | #if WXWIN_COMPATIBILITY_2_6 |
1498 | // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId() | |
1499 | wxDEPRECATED( int NewControlId() ); | |
1500 | inline int NewControlId() { return wxWindowBase::NewControlId(); } | |
1501 | #endif // WXWIN_COMPATIBILITY_2_6 | |
f03fc89f | 1502 | |
45a959a3 JS |
1503 | #if wxUSE_ACCESSIBILITY |
1504 | // ---------------------------------------------------------------------------- | |
1505 | // accessible object for windows | |
1506 | // ---------------------------------------------------------------------------- | |
1507 | ||
1508 | class WXDLLEXPORT wxWindowAccessible: public wxAccessible | |
1509 | { | |
1510 | public: | |
f81387bd | 1511 | wxWindowAccessible(wxWindow* win): wxAccessible(win) { if (win) win->SetAccessible(this); } |
6fb99eb3 | 1512 | virtual ~wxWindowAccessible() {} |
45a959a3 JS |
1513 | |
1514 | // Overridables | |
1515 | ||
1516 | // Can return either a child object, or an integer | |
1517 | // representing the child element, starting from 1. | |
1518 | virtual wxAccStatus HitTest(const wxPoint& pt, int* childId, wxAccessible** childObject); | |
1519 | ||
1520 | // Returns the rectangle for this object (id = 0) or a child element (id > 0). | |
1521 | virtual wxAccStatus GetLocation(wxRect& rect, int elementId); | |
1522 | ||
1523 | // Navigates from fromId to toId/toObject. | |
1524 | virtual wxAccStatus Navigate(wxNavDir navDir, int fromId, | |
1525 | int* toId, wxAccessible** toObject); | |
1526 | ||
1527 | // Gets the name of the specified object. | |
1528 | virtual wxAccStatus GetName(int childId, wxString* name); | |
1529 | ||
1530 | // Gets the number of children. | |
a37e4a07 | 1531 | virtual wxAccStatus GetChildCount(int* childCount); |
45a959a3 JS |
1532 | |
1533 | // Gets the specified child (starting from 1). | |
1534 | // If *child is NULL and return value is wxACC_OK, | |
1535 | // this means that the child is a simple element and | |
1536 | // not an accessible object. | |
1537 | virtual wxAccStatus GetChild(int childId, wxAccessible** child); | |
1538 | ||
1539 | // Gets the parent, or NULL. | |
1540 | virtual wxAccStatus GetParent(wxAccessible** parent); | |
1541 | ||
1542 | // Performs the default action. childId is 0 (the action for this object) | |
1543 | // or > 0 (the action for a child). | |
1544 | // Return wxACC_NOT_SUPPORTED if there is no default action for this | |
1545 | // window (e.g. an edit control). | |
1546 | virtual wxAccStatus DoDefaultAction(int childId); | |
1547 | ||
1548 | // Gets the default action for this object (0) or > 0 (the action for a child). | |
1549 | // Return wxACC_OK even if there is no action. actionName is the action, or the empty | |
1550 | // string if there is no action. | |
1551 | // The retrieved string describes the action that is performed on an object, | |
1552 | // not what the object does as a result. For example, a toolbar button that prints | |
1553 | // a document has a default action of "Press" rather than "Prints the current document." | |
1554 | virtual wxAccStatus GetDefaultAction(int childId, wxString* actionName); | |
1555 | ||
1556 | // Returns the description for this object or a child. | |
1557 | virtual wxAccStatus GetDescription(int childId, wxString* description); | |
1558 | ||
1559 | // Returns help text for this object or a child, similar to tooltip text. | |
1560 | virtual wxAccStatus GetHelpText(int childId, wxString* helpText); | |
1561 | ||
1562 | // Returns the keyboard shortcut for this object or child. | |
1563 | // Return e.g. ALT+K | |
1564 | virtual wxAccStatus GetKeyboardShortcut(int childId, wxString* shortcut); | |
1565 | ||
1566 | // Returns a role constant. | |
1567 | virtual wxAccStatus GetRole(int childId, wxAccRole* role); | |
1568 | ||
1569 | // Returns a state constant. | |
1570 | virtual wxAccStatus GetState(int childId, long* state); | |
1571 | ||
1572 | // Returns a localized string representing the value for the object | |
1573 | // or child. | |
1574 | virtual wxAccStatus GetValue(int childId, wxString* strValue); | |
1575 | ||
1576 | // Selects the object or child. | |
1577 | virtual wxAccStatus Select(int childId, wxAccSelectionFlags selectFlags); | |
1578 | ||
1579 | // Gets the window with the keyboard focus. | |
1580 | // If childId is 0 and child is NULL, no object in | |
1581 | // this subhierarchy has the focus. | |
1582 | // If this object has the focus, child should be 'this'. | |
1583 | virtual wxAccStatus GetFocus(int* childId, wxAccessible** child); | |
1584 | ||
1585 | // Gets a variant representing the selected children | |
1586 | // of this object. | |
1587 | // Acceptable values: | |
d4864e97 | 1588 | // - a null variant (IsNull() returns true) |
45a959a3 JS |
1589 | // - a list variant (GetType() == wxT("list") |
1590 | // - an integer representing the selected child element, | |
1591 | // or 0 if this object is selected (GetType() == wxT("long") | |
1592 | // - a "void*" pointer to a wxAccessible child object | |
1593 | virtual wxAccStatus GetSelections(wxVariant* selections); | |
1594 | }; | |
1595 | ||
1596 | #endif // wxUSE_ACCESSIBILITY | |
1597 | ||
1598 | ||
faa49bfd | 1599 | #endif // _WX_WINDOW_H_BASE_ |