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