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