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