1 ///////////////////////////////////////////////////////////////////////////////
3 // Purpose: wxWindowBase class - the interface of wxWindow
4 // Author: Vadim Zeitlin
5 // Modified by: Ron Lee
8 // Copyright: (c) Vadim Zeitlin
9 // Licence: wxWindows licence
10 ///////////////////////////////////////////////////////////////////////////////
12 #ifndef _WX_WINDOW_H_BASE_
13 #define _WX_WINDOW_H_BASE_
15 // ----------------------------------------------------------------------------
16 // headers which we must include here
17 // ----------------------------------------------------------------------------
19 #include "wx/event.h" // the base class
21 #include "wx/list.h" // defines wxWindowList
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"
30 #include "wx/validate.h" // for wxDefaultValidator (always include it)
33 #include "wx/palette.h"
34 #endif // wxUSE_PALETTE
40 #if wxUSE_ACCESSIBILITY
41 #include "wx/access.h"
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
48 #else // !__WXUNIVERSAL__
49 #define wxUSE_MENUS_NATIVE wxUSE_MENUS
50 #endif // __WXUNIVERSAL__/!__WXUNIVERSAL__
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
62 #define wxHAS_NATIVE_ENABLED_MANAGEMENT
65 // ----------------------------------------------------------------------------
66 // forward declarations
67 // ----------------------------------------------------------------------------
69 class WXDLLIMPEXP_FWD_CORE wxCaret
;
70 class WXDLLIMPEXP_FWD_CORE wxControl
;
71 class WXDLLIMPEXP_FWD_CORE wxCursor
;
72 class WXDLLIMPEXP_FWD_CORE wxDC
;
73 class WXDLLIMPEXP_FWD_CORE wxDropTarget
;
74 class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints
;
75 class WXDLLIMPEXP_FWD_CORE wxSizer
;
76 class WXDLLIMPEXP_FWD_CORE wxToolTip
;
77 class WXDLLIMPEXP_FWD_CORE wxWindowBase
;
78 class WXDLLIMPEXP_FWD_CORE wxWindow
;
79 class WXDLLIMPEXP_FWD_CORE wxScrollHelper
;
81 #if wxUSE_ACCESSIBILITY
82 class WXDLLIMPEXP_FWD_CORE wxAccessible
;
85 // ----------------------------------------------------------------------------
86 // helper stuff used by wxWindow
87 // ----------------------------------------------------------------------------
89 // struct containing all the visual attributes of a control
90 struct WXDLLIMPEXP_CORE wxVisualAttributes
92 // the font used for control label/text inside it
95 // the foreground colour
98 // the background colour, may be wxNullColour if the controls background
99 // colour is not solid
103 // different window variants, on platforms like eg mac uses different
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)
114 #if wxUSE_SYSTEM_OPTIONS
115 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
118 // valid values for Show/HideWithEffect()
121 wxSHOW_EFFECT_ROLL_TO_LEFT
,
122 wxSHOW_EFFECT_ROLL_TO_RIGHT
,
123 wxSHOW_EFFECT_ROLL_TO_TOP
,
124 wxSHOW_EFFECT_ROLL_TO_BOTTOM
,
125 wxSHOW_EFFECT_SLIDE_TO_LEFT
,
126 wxSHOW_EFFECT_SLIDE_TO_RIGHT
,
127 wxSHOW_EFFECT_SLIDE_TO_TOP
,
128 wxSHOW_EFFECT_SLIDE_TO_BOTTOM
,
130 wxSHOW_EFFECT_EXPAND
,
134 // flags for SendSizeEvent()
137 wxSEND_EVENT_POST
= 1
140 // ----------------------------------------------------------------------------
141 // (pseudo)template list classes
142 // ----------------------------------------------------------------------------
144 WX_DECLARE_LIST_3(wxWindow
, wxWindowBase
, wxWindowList
, wxWindowListNode
, class WXDLLIMPEXP_CORE
);
146 // ----------------------------------------------------------------------------
148 // ----------------------------------------------------------------------------
150 extern WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
152 // declared here for compatibility only, main declaration is in wx/app.h
153 extern WXDLLIMPEXP_DATA_BASE(wxList
) wxPendingDelete
;
155 // ----------------------------------------------------------------------------
156 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
157 // interface of this class.
159 // Event handler: windows have themselves as their event handlers by default,
160 // but their event handlers could be set to another object entirely. This
161 // separation can reduce the amount of derivation required, and allow
162 // alteration of a window's functionality (e.g. by a resource editor that
163 // temporarily switches event handlers).
164 // ----------------------------------------------------------------------------
166 class WXDLLIMPEXP_CORE wxWindowBase
: public wxEvtHandler
169 // creating the window
170 // -------------------
172 // default ctor, initializes everything which can be initialized before
176 // pseudo ctor (can't be virtual, called from ctor)
177 bool CreateBase(wxWindowBase
*parent
,
179 const wxPoint
& pos
= wxDefaultPosition
,
180 const wxSize
& size
= wxDefaultSize
,
182 const wxValidator
& validator
= wxDefaultValidator
,
183 const wxString
& name
= wxPanelNameStr
);
185 virtual ~wxWindowBase();
187 // deleting the window
188 // -------------------
190 // ask the window to close itself, return true if the event handler
191 // honoured our request
192 bool Close( bool force
= false );
194 // the following functions delete the C++ objects (the window itself
195 // or its children) as well as the GUI windows and normally should
196 // never be used directly
198 // delete window unconditionally (dangerous!), returns true if ok
199 virtual bool Destroy();
200 // delete all children of this window, returns true if ok
201 bool DestroyChildren();
203 // is the window being deleted?
204 bool IsBeingDeleted() const;
209 // label is just the same as the title (but for, e.g., buttons it
210 // makes more sense to speak about labels), title access
211 // is available from wxTLW classes only (frames, dialogs)
212 virtual void SetLabel(const wxString
& label
) = 0;
213 virtual wxString
GetLabel() const = 0;
215 // the window name is used for ressource setting in X, it is not the
216 // same as the window title/label
217 virtual void SetName( const wxString
&name
) { m_windowName
= name
; }
218 virtual wxString
GetName() const { return m_windowName
; }
220 // sets the window variant, calls internally DoSetVariant if variant
222 void SetWindowVariant(wxWindowVariant variant
);
223 wxWindowVariant
GetWindowVariant() const { return m_windowVariant
; }
226 // get or change the layout direction (LTR or RTL) for this window,
227 // wxLayout_Default is returned if layout direction is not supported
228 virtual wxLayoutDirection
GetLayoutDirection() const
229 { return wxLayout_Default
; }
230 virtual void SetLayoutDirection(wxLayoutDirection
WXUNUSED(dir
))
233 // mirror coordinates for RTL layout if this window uses it and if the
234 // mirroring is not done automatically like Win32
235 virtual wxCoord
AdjustForLayoutDirection(wxCoord x
,
237 wxCoord widthTotal
) const;
240 // window id uniquely identifies the window among its siblings unless
241 // it is wxID_ANY which means "don't care"
242 void SetId( wxWindowID winid
) { m_windowId
= winid
; }
243 wxWindowID
GetId() const { return m_windowId
; }
245 // generate a unique id (or count of them consecutively), returns a
246 // valid id in the auto-id range or wxID_NONE if failed. If using
247 // autoid management, it will mark the id as reserved until it is
248 // used (by assigning it to a wxWindowIDRef) or unreserved.
249 static wxWindowID
NewControlId(int count
= 1)
251 return wxIdManager::ReserveId(count
);
254 // If an ID generated from NewControlId is not assigned to a wxWindowIDRef,
255 // it must be unreserved
256 static void UnreserveControlId(wxWindowID id
, int count
= 1)
258 wxIdManager::UnreserveId(id
, count
);
265 // set the window size and/or position
266 void SetSize( int x
, int y
, int width
, int height
,
267 int sizeFlags
= wxSIZE_AUTO
)
268 { DoSetSize(x
, y
, width
, height
, sizeFlags
); }
270 void SetSize( int width
, int height
)
271 { DoSetSize( wxDefaultCoord
, wxDefaultCoord
, width
, height
, wxSIZE_USE_EXISTING
); }
273 void SetSize( const wxSize
& size
)
274 { SetSize( size
.x
, size
.y
); }
276 void SetSize(const wxRect
& rect
, int sizeFlags
= wxSIZE_AUTO
)
277 { DoSetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
, sizeFlags
); }
279 void Move(int x
, int y
, int flags
= wxSIZE_USE_EXISTING
)
280 { DoSetSize(x
, y
, wxDefaultCoord
, wxDefaultCoord
, flags
); }
282 void Move(const wxPoint
& pt
, int flags
= wxSIZE_USE_EXISTING
)
283 { Move(pt
.x
, pt
.y
, flags
); }
285 void SetPosition(const wxPoint
& pt
) { Move(pt
); }
288 virtual void Raise() = 0;
289 virtual void Lower() = 0;
291 // client size is the size of area available for subwindows
292 void SetClientSize( int width
, int height
)
293 { DoSetClientSize(width
, height
); }
295 void SetClientSize( const wxSize
& size
)
296 { DoSetClientSize(size
.x
, size
.y
); }
298 void SetClientSize(const wxRect
& rect
)
299 { SetClientSize( rect
.width
, rect
.height
); }
301 // get the window position (pointers may be NULL): notice that it is in
302 // client coordinates for child windows and screen coordinates for the
303 // top level ones, use GetScreenPosition() if you need screen
304 // coordinates for all kinds of windows
305 void GetPosition( int *x
, int *y
) const { DoGetPosition(x
, y
); }
306 wxPoint
GetPosition() const
309 DoGetPosition(&x
, &y
);
311 return wxPoint(x
, y
);
314 // get the window position in screen coordinates
315 void GetScreenPosition(int *x
, int *y
) const { DoGetScreenPosition(x
, y
); }
316 wxPoint
GetScreenPosition() const
319 DoGetScreenPosition(&x
, &y
);
321 return wxPoint(x
, y
);
324 // get the window size (pointers may be NULL)
325 void GetSize( int *w
, int *h
) const { DoGetSize(w
, h
); }
326 wxSize
GetSize() const
333 void GetClientSize( int *w
, int *h
) const { DoGetClientSize(w
, h
); }
334 wxSize
GetClientSize() const
337 DoGetClientSize(&w
, &h
);
342 // get the position and size at once
343 wxRect
GetRect() const
349 return wxRect(x
, y
, w
, h
);
352 wxRect
GetScreenRect() const
355 GetScreenPosition(&x
, &y
);
358 return wxRect(x
, y
, w
, h
);
361 // get the origin of the client area of the window relative to the
362 // window top left corner (the client area may be shifted because of
363 // the borders, scrollbars, other decorations...)
364 virtual wxPoint
GetClientAreaOrigin() const;
366 // get the client rectangle in window (i.e. client) coordinates
367 wxRect
GetClientRect() const
369 return wxRect(GetClientAreaOrigin(), GetClientSize());
372 // client<->window size conversion
373 virtual wxSize
ClientToWindowSize(const wxSize
& size
) const;
374 virtual wxSize
WindowToClientSize(const wxSize
& size
) const;
376 // get the size best suited for the window (in fact, minimal
377 // acceptable size using which it will still look "nice" in
379 wxSize
GetBestSize() const;
381 void GetBestSize(int *w
, int *h
) const
383 wxSize s
= GetBestSize();
390 void SetScrollHelper( wxScrollHelper
*sh
) { m_scrollHelper
= sh
; }
391 wxScrollHelper
*GetScrollHelper() { return m_scrollHelper
; }
393 // reset the cached best size value so it will be recalculated the
394 // next time it is needed.
395 void InvalidateBestSize();
396 void CacheBestSize(const wxSize
& size
) const
397 { wxConstCast(this, wxWindowBase
)->m_bestSizeCache
= size
; }
400 // This function will merge the window's best size into the window's
401 // minimum size, giving priority to the min size components, and
402 // returns the results.
403 virtual wxSize
GetEffectiveMinSize() const;
404 wxDEPRECATED( wxSize
GetBestFittingSize() const ); // replaced by GetEffectiveMinSize
405 wxDEPRECATED( wxSize
GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize
407 // A 'Smart' SetSize that will fill in default size values with 'best'
408 // size. Sets the minsize to what was passed in.
409 void SetInitialSize(const wxSize
& size
=wxDefaultSize
);
410 wxDEPRECATED( void SetBestFittingSize(const wxSize
& size
=wxDefaultSize
) ); // replaced by SetInitialSize
413 // the generic centre function - centers the window on parent by`
414 // default or on screen if it doesn't have parent or
415 // wxCENTER_ON_SCREEN flag is given
416 void Centre(int dir
= wxBOTH
) { DoCentre(dir
); }
417 void Center(int dir
= wxBOTH
) { DoCentre(dir
); }
419 // centre with respect to the the parent window
420 void CentreOnParent(int dir
= wxBOTH
) { DoCentre(dir
); }
421 void CenterOnParent(int dir
= wxBOTH
) { CentreOnParent(dir
); }
423 // set window size to wrap around its children
426 // set virtual size to satisfy children
427 virtual void FitInside();
430 // SetSizeHints is actually for setting the size hints
431 // for the wxTLW for a Window Manager - hence the name -
432 // and it is therefore overridden in wxTLW to do that.
433 // In wxWindow(Base), it has (unfortunately) been abused
434 // to mean the same as SetMinSize() and SetMaxSize().
436 virtual void SetSizeHints( int minW
, int minH
,
437 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
,
438 int incW
= wxDefaultCoord
, int incH
= wxDefaultCoord
)
439 { DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
); }
441 void SetSizeHints( const wxSize
& minSize
,
442 const wxSize
& maxSize
=wxDefaultSize
,
443 const wxSize
& incSize
=wxDefaultSize
)
444 { DoSetSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
, incSize
.x
, incSize
.y
); }
447 #if WXWIN_COMPATIBILITY_2_8
448 // these are useless and do nothing since wxWidgets 2.9
449 wxDEPRECATED( virtual void SetVirtualSizeHints( int minW
, int minH
,
450 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
) );
451 wxDEPRECATED( void SetVirtualSizeHints( const wxSize
& minSize
,
452 const wxSize
& maxSize
=wxDefaultSize
) );
453 #endif // WXWIN_COMPATIBILITY_2_8
456 // Call these to override what GetBestSize() returns. This
457 // method is only virtual because it is overriden in wxTLW
458 // as a different API for SetSizeHints().
459 virtual void SetMinSize(const wxSize
& minSize
);
460 virtual void SetMaxSize(const wxSize
& maxSize
);
462 // Like Set*Size, but for client, not window, size
463 virtual void SetMinClientSize(const wxSize
& size
)
464 { SetMinSize(ClientToWindowSize(size
)); }
465 virtual void SetMaxClientSize(const wxSize
& size
)
466 { SetMaxSize(ClientToWindowSize(size
)); }
468 // Override these methods to impose restrictions on min/max size.
469 // The easier way is to call SetMinSize() and SetMaxSize() which
470 // will have the same effect. Doing both is non-sense.
471 virtual wxSize
GetMinSize() const { return wxSize(m_minWidth
, m_minHeight
); }
472 virtual wxSize
GetMaxSize() const { return wxSize(m_maxWidth
, m_maxHeight
); }
474 // Like Get*Size, but for client, not window, size
475 virtual wxSize
GetMinClientSize() const
476 { return WindowToClientSize(GetMinSize()); }
477 virtual wxSize
GetMaxClientSize() const
478 { return WindowToClientSize(GetMaxSize()); }
480 // Get the min and max values one by one
481 int GetMinWidth() const { return GetMinSize().x
; }
482 int GetMinHeight() const { return GetMinSize().y
; }
483 int GetMaxWidth() const { return GetMaxSize().x
; }
484 int GetMaxHeight() const { return GetMaxSize().y
; }
487 // Methods for accessing the virtual size of a window. For most
488 // windows this is just the client area of the window, but for
489 // some like scrolled windows it is more or less independent of
490 // the screen window size. You may override the DoXXXVirtual
491 // methods below for classes where that is is the case.
493 void SetVirtualSize( const wxSize
&size
) { DoSetVirtualSize( size
.x
, size
.y
); }
494 void SetVirtualSize( int x
, int y
) { DoSetVirtualSize( x
, y
); }
496 wxSize
GetVirtualSize() const { return DoGetVirtualSize(); }
497 void GetVirtualSize( int *x
, int *y
) const
499 wxSize
s( DoGetVirtualSize() );
507 // Override these methods for windows that have a virtual size
508 // independent of their client size. eg. the virtual area of a
511 virtual void DoSetVirtualSize( int x
, int y
);
512 virtual wxSize
DoGetVirtualSize() const;
514 // Return the largest of ClientSize and BestSize (as determined
515 // by a sizer, interior children, or other means)
517 virtual wxSize
GetBestVirtualSize() const
519 wxSize
client( GetClientSize() );
520 wxSize
best( GetBestSize() );
522 return wxSize( wxMax( client
.x
, best
.x
), wxMax( client
.y
, best
.y
) );
525 // return the size of the left/right and top/bottom borders in x and y
526 // components of the result respectively
527 virtual wxSize
GetWindowBorderSize() const;
529 // wxSizer and friends use this to give a chance to a component to recalc
530 // its min size once one of the final size components is known. Override
531 // this function when that is useful (such as for wxStaticText which can
532 // stretch over several lines). Parameter availableOtherDir
533 // tells the item how much more space there is available in the opposite
534 // direction (-1 if unknown).
536 InformFirstDirection(int WXUNUSED(direction
),
538 int WXUNUSED(availableOtherDir
))
543 // sends a size event to the window using its current size -- this has an
544 // effect of refreshing the window layout
546 // by default the event is sent, i.e. processed immediately, but if flags
547 // value includes wxSEND_EVENT_POST then it's posted, i.e. only schedule
548 // for later processing
549 virtual void SendSizeEvent(int flags
= 0);
551 // this is a safe wrapper for GetParent()->SendSizeEvent(): it checks that
552 // we have a parent window and it's not in process of being deleted
554 // this is used by controls such as tool/status bars changes to which must
555 // also result in parent re-layout
556 void SendSizeEventToParent(int flags
= 0);
558 // this is a more readable synonym for SendSizeEvent(wxSEND_EVENT_POST)
559 void PostSizeEvent() { SendSizeEvent(wxSEND_EVENT_POST
); }
561 // this is the same as SendSizeEventToParent() but using PostSizeEvent()
562 void PostSizeEventToParent() { SendSizeEventToParent(wxSEND_EVENT_POST
); }
568 // returns true if window was shown/hidden, false if the nothing was
569 // done (window was already shown/hidden)
570 virtual bool Show( bool show
= true );
571 bool Hide() { return Show(false); }
573 // show or hide the window with a special effect, not implemented on
574 // most platforms (where it is the same as Show()/Hide() respectively)
576 // timeout specifies how long the animation should take, in ms, the
577 // default value of 0 means to use the default (system-dependent) value
578 virtual bool ShowWithEffect(wxShowEffect
WXUNUSED(effect
),
579 unsigned WXUNUSED(timeout
) = 0)
584 virtual bool HideWithEffect(wxShowEffect
WXUNUSED(effect
),
585 unsigned WXUNUSED(timeout
) = 0)
590 // returns true if window was enabled/disabled, false if nothing done
591 virtual bool Enable( bool enable
= true );
592 bool Disable() { return Enable(false); }
594 virtual bool IsShown() const { return m_isShown
; }
595 // returns true if the window is really enabled and false otherwise,
596 // whether because it had been explicitly disabled itself or because
597 // its parent is currently disabled -- then this method returns false
598 // whatever is the intrinsic state of this window, use IsThisEnabled(0
599 // to retrieve it. In other words, this relation always holds:
601 // IsEnabled() == IsThisEnabled() && parent.IsEnabled()
603 bool IsEnabled() const;
605 // returns the internal window state independently of the parent(s)
606 // state, i.e. the state in which the window would be if all its
607 // parents were enabled (use IsEnabled() above to get the effective
609 bool IsThisEnabled() const { return m_isEnabled
; }
611 // returns true if the window is visible, i.e. IsShown() returns true
612 // if called on it and all its parents up to the first TLW
613 virtual bool IsShownOnScreen() const;
615 // get/set window style (setting style won't update the window and so
616 // is only useful for internal usage)
617 virtual void SetWindowStyleFlag( long style
) { m_windowStyle
= style
; }
618 virtual long GetWindowStyleFlag() const { return m_windowStyle
; }
620 // just some (somewhat shorter) synonims
621 void SetWindowStyle( long style
) { SetWindowStyleFlag(style
); }
622 long GetWindowStyle() const { return GetWindowStyleFlag(); }
624 // check if the flag is set
625 bool HasFlag(int flag
) const { return (m_windowStyle
& flag
) != 0; }
626 virtual bool IsRetained() const { return HasFlag(wxRETAINED
); }
628 // turn the flag on if it had been turned off before and vice versa,
629 // return true if the flag is currently turned on
630 bool ToggleWindowStyle(int flag
);
632 // extra style: the less often used style bits which can't be set with
633 // SetWindowStyleFlag()
634 virtual void SetExtraStyle(long exStyle
) { m_exStyle
= exStyle
; }
635 long GetExtraStyle() const { return m_exStyle
; }
637 bool HasExtraStyle(int exFlag
) const { return (m_exStyle
& exFlag
) != 0; }
639 // make the window modal (all other windows unresponsive)
640 virtual void MakeModal(bool modal
= true);
643 // (primitive) theming support
644 // ---------------------------
646 virtual void SetThemeEnabled(bool enableTheme
) { m_themeEnabled
= enableTheme
; }
647 virtual bool GetThemeEnabled() const { return m_themeEnabled
; }
650 // focus and keyboard handling
651 // ---------------------------
653 // set focus to this window
654 virtual void SetFocus() = 0;
656 // set focus to this window as the result of a keyboard action
657 virtual void SetFocusFromKbd() { SetFocus(); }
659 // return the window which currently has the focus or NULL
660 static wxWindow
*FindFocus();
662 static wxWindow
*DoFindFocus() /* = 0: implement in derived classes */;
664 // return true if the window has focus (handles composite windows
665 // correctly - returns true if GetMainWindowOfCompositeControl()
667 virtual bool HasFocus() const;
669 // can this window have focus in principle?
671 // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus
672 // [FromKeyboard]() is that the former functions are meant to be
673 // overridden in the derived classes to simply return false if the
674 // control can't have focus, while the latter are meant to be used by
675 // this class clients and take into account the current window state
676 virtual bool AcceptsFocus() const { return true; }
678 // can this window or one of its children accept focus?
680 // usually it's the same as AcceptsFocus() but is overridden for
682 virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); }
684 // can this window be given focus by keyboard navigation? if not, the
685 // only way to give it focus (provided it accepts it at all) is to
687 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
690 // this is mostly a helper for the various functions using it below
691 bool CanBeFocused() const { return IsShown() && IsEnabled(); }
693 // can this window itself have focus?
694 bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); }
696 // can this window have focus right now?
698 // if this method returns true, it means that calling SetFocus() will
699 // put focus either to this window or one of its children, if you need
700 // to know whether this window accepts focus itself, use IsFocusable()
701 bool CanAcceptFocus() const
702 { return AcceptsFocusRecursively() && CanBeFocused(); }
704 // can this window be assigned focus from keyboard right now?
705 bool CanAcceptFocusFromKeyboard() const
706 { return AcceptsFocusFromKeyboard() && CanBeFocused(); }
708 // call this when the return value of AcceptsFocus() changes
709 virtual void SetCanFocus(bool WXUNUSED(canFocus
)) { }
711 // navigates inside this window
712 bool NavigateIn(int flags
= wxNavigationKeyEvent::IsForward
)
713 { return DoNavigateIn(flags
); }
715 // navigates in the specified direction from this window, this is
716 // equivalent to GetParent()->NavigateIn()
717 bool Navigate(int flags
= wxNavigationKeyEvent::IsForward
)
718 { return m_parent
&& ((wxWindowBase
*)m_parent
)->DoNavigateIn(flags
); }
720 // this function will generate the appropriate call to Navigate() if the
721 // key event is one normally used for keyboard navigation and return true
723 bool HandleAsNavigationKey(const wxKeyEvent
& event
);
725 // move this window just before/after the specified one in tab order
726 // (the other window must be our sibling!)
727 void MoveBeforeInTabOrder(wxWindow
*win
)
728 { DoMoveInTabOrder(win
, OrderBefore
); }
729 void MoveAfterInTabOrder(wxWindow
*win
)
730 { DoMoveInTabOrder(win
, OrderAfter
); }
733 // parent/children relations
734 // -------------------------
736 // get the list of children
737 const wxWindowList
& GetChildren() const { return m_children
; }
738 wxWindowList
& GetChildren() { return m_children
; }
740 // needed just for extended runtime
741 const wxWindowList
& GetWindowChildren() const { return GetChildren() ; }
743 // get the window before/after this one in the parents children list,
744 // returns NULL if this is the first/last window
745 wxWindow
*GetPrevSibling() const { return DoGetSibling(OrderBefore
); }
746 wxWindow
*GetNextSibling() const { return DoGetSibling(OrderAfter
); }
748 // get the parent or the parent of the parent
749 wxWindow
*GetParent() const { return m_parent
; }
750 inline wxWindow
*GetGrandParent() const;
752 // is this window a top level one?
753 virtual bool IsTopLevel() const;
755 // it doesn't really change parent, use Reparent() instead
756 void SetParent( wxWindowBase
*parent
) { m_parent
= (wxWindow
*)parent
; }
757 // change the real parent of this window, return true if the parent
758 // was changed, false otherwise (error or newParent == oldParent)
759 virtual bool Reparent( wxWindowBase
*newParent
);
761 // implementation mostly
762 virtual void AddChild( wxWindowBase
*child
);
763 virtual void RemoveChild( wxWindowBase
*child
);
765 // returns true if the child is in the client area of the window, i.e. is
766 // not scrollbar, toolbar etc.
767 virtual bool IsClientAreaChild(const wxWindow
*WXUNUSED(child
)) const
770 // looking for windows
771 // -------------------
773 // find window among the descendants of this one either by id or by
774 // name (return NULL if not found)
775 wxWindow
*FindWindow(long winid
) const;
776 wxWindow
*FindWindow(const wxString
& name
) const;
778 // Find a window among any window (all return NULL if not found)
779 static wxWindow
*FindWindowById( long winid
, const wxWindow
*parent
= NULL
);
780 static wxWindow
*FindWindowByName( const wxString
& name
,
781 const wxWindow
*parent
= NULL
);
782 static wxWindow
*FindWindowByLabel( const wxString
& label
,
783 const wxWindow
*parent
= NULL
);
785 // event handler stuff
786 // -------------------
788 // get the current event handler
789 wxEvtHandler
*GetEventHandler() const { return m_eventHandler
; }
791 // replace the event handler (allows to completely subclass the
793 void SetEventHandler( wxEvtHandler
*handler
);
795 // push/pop event handler: allows to chain a custom event handler to
796 // alreasy existing ones
797 void PushEventHandler( wxEvtHandler
*handler
);
798 wxEvtHandler
*PopEventHandler( bool deleteHandler
= false );
800 // find the given handler in the event handler chain and remove (but
801 // not delete) it from the event handler chain, return true if it was
802 // found and false otherwise (this also results in an assert failure so
803 // this function should only be called when the handler is supposed to
805 bool RemoveEventHandler(wxEvtHandler
*handler
);
807 // Process an event by calling GetEventHandler()->ProcessEvent(): this
808 // is a straightforward replacement for ProcessEvent() itself which
809 // shouldn't be used directly with windows as it doesn't take into
810 // account any event handlers associated with the window
811 bool ProcessWindowEvent(wxEvent
& event
)
812 { return GetEventHandler()->ProcessEvent(event
); }
814 // Process an event by calling GetEventHandler()->ProcessEvent() and
815 // handling any exceptions thrown by event handlers. It's mostly useful
816 // when processing wx events when called from C code (e.g. in GTK+
817 // callback) when the exception wouldn't correctly propagate to
819 bool HandleWindowEvent(wxEvent
& event
) const;
821 // disable wxEvtHandler double-linked list mechanism:
822 virtual void SetNextHandler(wxEvtHandler
*handler
);
823 virtual void SetPreviousHandler(wxEvtHandler
*handler
);
826 // Watcom doesn't allow reducing access with using access declaration, see
831 // NOTE: we change the access specifier of the following wxEvtHandler functions
832 // so that the user won't be able to call them directly.
833 // Calling wxWindow::ProcessEvent in fact only works when there are NO
834 // event handlers pushed on the window.
835 // To ensure correct operation, instead of wxWindow::ProcessEvent
836 // you must always call wxWindow::GetEventHandler()->ProcessEvent()
837 // or HandleWindowEvent().
838 // The same holds for all other wxEvtHandler functions.
840 using wxEvtHandler::ProcessEvent
;
842 using wxEvtHandler::ProcessThreadEvent
;
844 using wxEvtHandler::SafelyProcessEvent
;
845 using wxEvtHandler::ProcessPendingEvents
;
846 using wxEvtHandler::AddPendingEvent
;
847 using wxEvtHandler::QueueEvent
;
848 #endif // __WATCOMC__
856 // a window may have an associated validator which is used to control
858 virtual void SetValidator( const wxValidator
&validator
);
859 virtual wxValidator
*GetValidator() { return m_windowValidator
; }
860 #endif // wxUSE_VALIDATORS
863 // dialog oriented functions
864 // -------------------------
866 // validate the correctness of input, return true if ok
867 virtual bool Validate();
869 // transfer data between internal and GUI representations
870 virtual bool TransferDataToWindow();
871 virtual bool TransferDataFromWindow();
873 virtual void InitDialog();
878 virtual void SetAcceleratorTable( const wxAcceleratorTable
& accel
)
879 { m_acceleratorTable
= accel
; }
880 wxAcceleratorTable
*GetAcceleratorTable()
881 { return &m_acceleratorTable
; }
883 #endif // wxUSE_ACCEL
886 // hot keys (system wide accelerators)
887 // -----------------------------------
889 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
);
890 virtual bool UnregisterHotKey(int hotkeyId
);
891 #endif // wxUSE_HOTKEY
894 // dialog units translations
895 // -------------------------
897 wxPoint
ConvertPixelsToDialog( const wxPoint
& pt
);
898 wxPoint
ConvertDialogToPixels( const wxPoint
& pt
);
899 wxSize
ConvertPixelsToDialog( const wxSize
& sz
)
901 wxPoint
pt(ConvertPixelsToDialog(wxPoint(sz
.x
, sz
.y
)));
903 return wxSize(pt
.x
, pt
.y
);
906 wxSize
ConvertDialogToPixels( const wxSize
& sz
)
908 wxPoint
pt(ConvertDialogToPixels(wxPoint(sz
.x
, sz
.y
)));
910 return wxSize(pt
.x
, pt
.y
);
916 // move the mouse to the specified position
917 virtual void WarpPointer(int x
, int y
) = 0;
919 // start or end mouse capture, these functions maintain the stack of
920 // windows having captured the mouse and after calling ReleaseMouse()
921 // the mouse is not released but returns to the window which had had
922 // captured it previously (if any)
926 // get the window which currently captures the mouse or NULL
927 static wxWindow
*GetCapture();
929 // does this window have the capture?
930 virtual bool HasCapture() const
931 { return (wxWindow
*)this == GetCapture(); }
933 // painting the window
934 // -------------------
936 // mark the specified rectangle (or the whole window) as "dirty" so it
938 virtual void Refresh( bool eraseBackground
= true,
939 const wxRect
*rect
= (const wxRect
*) NULL
) = 0;
941 // a less awkward wrapper for Refresh
942 void RefreshRect(const wxRect
& rect
, bool eraseBackground
= true)
944 Refresh(eraseBackground
, &rect
);
947 // repaint all invalid areas of the window immediately
948 virtual void Update() { }
950 // clear the window background
951 virtual void ClearBackground();
953 // freeze the window: don't redraw it until it is thawed
956 // thaw the window: redraw it after it had been frozen
959 // return true if window had been frozen and not unthawed yet
960 bool IsFrozen() const { return m_freezeCount
!= 0; }
962 // adjust DC for drawing on this window
963 virtual void PrepareDC( wxDC
& WXUNUSED(dc
) ) { }
965 // return true if the window contents is double buffered by the system
966 virtual bool IsDoubleBuffered() const { return false; }
968 // the update region of the window contains the areas which must be
969 // repainted by the program
970 const wxRegion
& GetUpdateRegion() const { return m_updateRegion
; }
971 wxRegion
& GetUpdateRegion() { return m_updateRegion
; }
973 // get the update rectangleregion bounding box in client coords
974 wxRect
GetUpdateClientRect() const;
976 // these functions verify whether the given point/rectangle belongs to
977 // (or at least intersects with) the update region
978 virtual bool DoIsExposed( int x
, int y
) const;
979 virtual bool DoIsExposed( int x
, int y
, int w
, int h
) const;
981 bool IsExposed( int x
, int y
) const
982 { return DoIsExposed(x
, y
); }
983 bool IsExposed( int x
, int y
, int w
, int h
) const
984 { return DoIsExposed(x
, y
, w
, h
); }
985 bool IsExposed( const wxPoint
& pt
) const
986 { return DoIsExposed(pt
.x
, pt
.y
); }
987 bool IsExposed( const wxRect
& rect
) const
988 { return DoIsExposed(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
990 // colours, fonts and cursors
991 // --------------------------
993 // get the default attributes for the controls of this class: we
994 // provide a virtual function which can be used to query the default
995 // attributes of an existing control and a static function which can
996 // be used even when no existing object of the given class is
997 // available, but which won't return any styles specific to this
998 // particular control, of course (e.g. "Ok" button might have
999 // different -- bold for example -- font)
1000 virtual wxVisualAttributes
GetDefaultAttributes() const
1002 return GetClassDefaultAttributes(GetWindowVariant());
1005 static wxVisualAttributes
1006 GetClassDefaultAttributes(wxWindowVariant variant
= wxWINDOW_VARIANT_NORMAL
);
1008 // set/retrieve the window colours (system defaults are used by
1009 // default): SetXXX() functions return true if colour was changed,
1010 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
1011 // value to prevent it from being inherited by our children
1012 virtual bool SetBackgroundColour(const wxColour
& colour
);
1013 void SetOwnBackgroundColour(const wxColour
& colour
)
1015 if ( SetBackgroundColour(colour
) )
1016 m_inheritBgCol
= false;
1018 wxColour
GetBackgroundColour() const;
1019 bool InheritsBackgroundColour() const
1021 return m_inheritBgCol
;
1023 bool UseBgCol() const
1028 virtual bool SetForegroundColour(const wxColour
& colour
);
1029 void SetOwnForegroundColour(const wxColour
& colour
)
1031 if ( SetForegroundColour(colour
) )
1032 m_inheritFgCol
= false;
1034 wxColour
GetForegroundColour() const;
1036 // Set/get the background style.
1037 virtual bool SetBackgroundStyle(wxBackgroundStyle style
)
1038 { m_backgroundStyle
= style
; return true; }
1039 wxBackgroundStyle
GetBackgroundStyle() const
1040 { return m_backgroundStyle
; }
1042 // returns true if the control has "transparent" areas such as a
1043 // wxStaticText and wxCheckBox and the background should be adapted
1044 // from a parent window
1045 virtual bool HasTransparentBackground() { return false; }
1047 // set/retrieve the font for the window (SetFont() returns true if the
1048 // font really changed)
1049 virtual bool SetFont(const wxFont
& font
) = 0;
1050 void SetOwnFont(const wxFont
& font
)
1052 if ( SetFont(font
) )
1053 m_inheritFont
= false;
1055 wxFont
GetFont() const;
1057 // set/retrieve the cursor for this window (SetCursor() returns true
1058 // if the cursor was really changed)
1059 virtual bool SetCursor( const wxCursor
&cursor
);
1060 const wxCursor
& GetCursor() const { return m_cursor
; }
1063 // associate a caret with the window
1064 void SetCaret(wxCaret
*caret
);
1065 // get the current caret (may be NULL)
1066 wxCaret
*GetCaret() const { return m_caret
; }
1067 #endif // wxUSE_CARET
1069 // get the (average) character size for the current font
1070 virtual int GetCharHeight() const = 0;
1071 virtual int GetCharWidth() const = 0;
1073 // get the width/height/... of the text using current or specified
1075 void GetTextExtent(const wxString
& string
,
1077 int *descent
= NULL
,
1078 int *externalLeading
= NULL
,
1079 const wxFont
*font
= NULL
) const
1081 DoGetTextExtent(string
, x
, y
, descent
, externalLeading
, font
);
1084 wxSize
GetTextExtent(const wxString
& string
) const
1087 GetTextExtent(string
, &w
, &h
);
1088 return wxSize(w
, h
);
1091 // client <-> screen coords
1092 // ------------------------
1094 // translate to/from screen/client coordinates (pointers may be NULL)
1095 void ClientToScreen( int *x
, int *y
) const
1096 { DoClientToScreen(x
, y
); }
1097 void ScreenToClient( int *x
, int *y
) const
1098 { DoScreenToClient(x
, y
); }
1100 // wxPoint interface to do the same thing
1101 wxPoint
ClientToScreen(const wxPoint
& pt
) const
1103 int x
= pt
.x
, y
= pt
.y
;
1104 DoClientToScreen(&x
, &y
);
1106 return wxPoint(x
, y
);
1109 wxPoint
ScreenToClient(const wxPoint
& pt
) const
1111 int x
= pt
.x
, y
= pt
.y
;
1112 DoScreenToClient(&x
, &y
);
1114 return wxPoint(x
, y
);
1117 // test where the given (in client coords) point lies
1118 wxHitTest
HitTest(wxCoord x
, wxCoord y
) const
1119 { return DoHitTest(x
, y
); }
1121 wxHitTest
HitTest(const wxPoint
& pt
) const
1122 { return DoHitTest(pt
.x
, pt
.y
); }
1127 // get the window border style from the given flags: this is different from
1128 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
1129 // translate wxBORDER_DEFAULT to something reasonable
1130 wxBorder
GetBorder(long flags
) const;
1132 // get border for the flags of this window
1133 wxBorder
GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
1135 // send wxUpdateUIEvents to this window, and children if recurse is true
1136 virtual void UpdateWindowUI(long flags
= wxUPDATE_UI_NONE
);
1138 // do the window-specific processing after processing the update event
1139 virtual void DoUpdateWindowUI(wxUpdateUIEvent
& event
) ;
1142 // show popup menu at the given position, generate events for the items
1144 bool PopupMenu(wxMenu
*menu
, const wxPoint
& pos
= wxDefaultPosition
)
1145 { return PopupMenu(menu
, pos
.x
, pos
.y
); }
1146 bool PopupMenu(wxMenu
*menu
, int x
, int y
);
1148 // simply return the id of the selected item or wxID_NONE without
1149 // generating any events
1150 int GetPopupMenuSelectionFromUser(wxMenu
& menu
, const wxPoint
& pos
)
1151 { return DoGetPopupMenuSelectionFromUser(menu
, pos
.x
, pos
.y
); }
1152 int GetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
1153 { return DoGetPopupMenuSelectionFromUser(menu
, x
, y
); }
1154 #endif // wxUSE_MENUS
1156 // override this method to return true for controls having multiple pages
1157 virtual bool HasMultiplePages() const { return false; }
1163 // does the window have the scrollbar for this orientation?
1164 bool HasScrollbar(int orient
) const
1166 return (m_windowStyle
&
1167 (orient
== wxHORIZONTAL
? wxHSCROLL
: wxVSCROLL
)) != 0;
1170 // configure the window scrollbars
1171 virtual void SetScrollbar( int orient
,
1175 bool refresh
= true ) = 0;
1176 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= true ) = 0;
1177 virtual int GetScrollPos( int orient
) const = 0;
1178 virtual int GetScrollThumb( int orient
) const = 0;
1179 virtual int GetScrollRange( int orient
) const = 0;
1181 // scroll window to the specified position
1182 virtual void ScrollWindow( int dx
, int dy
,
1183 const wxRect
* rect
= NULL
) = 0;
1185 // scrolls window by line/page: note that not all controls support this
1187 // return true if the position changed, false otherwise
1188 virtual bool ScrollLines(int WXUNUSED(lines
)) { return false; }
1189 virtual bool ScrollPages(int WXUNUSED(pages
)) { return false; }
1191 // convenient wrappers for ScrollLines/Pages
1192 bool LineUp() { return ScrollLines(-1); }
1193 bool LineDown() { return ScrollLines(1); }
1194 bool PageUp() { return ScrollPages(-1); }
1195 bool PageDown() { return ScrollPages(1); }
1197 // call this to always show one or both scrollbars, even if the window
1198 // is big enough to not require them
1199 virtual void AlwaysShowScrollbars(bool WXUNUSED(horz
) = true,
1200 bool WXUNUSED(vert
) = true)
1204 // return true if AlwaysShowScrollbars() had been called before for the
1205 // corresponding orientation
1206 virtual bool IsScrollbarAlwaysShown(int WXUNUSED(orient
)) const
1211 // context-sensitive help
1212 // ----------------------
1214 // these are the convenience functions wrapping wxHelpProvider methods
1217 // associate this help text with this window
1218 void SetHelpText(const wxString
& text
);
1220 #if WXWIN_COMPATIBILITY_2_8
1221 // Associate this help text with all windows with the same id as this one.
1222 // Don't use this, do wxHelpProvider::Get()->AddHelp(id, text);
1223 wxDEPRECATED( void SetHelpTextForId(const wxString
& text
) );
1224 #endif // WXWIN_COMPATIBILITY_2_8
1226 // get the help string associated with the given position in this window
1228 // notice that pt may be invalid if event origin is keyboard or unknown
1229 // and this method should return the global window help text then
1230 virtual wxString
GetHelpTextAtPoint(const wxPoint
& pt
,
1231 wxHelpEvent::Origin origin
) const;
1232 // returns the position-independent help text
1233 wxString
GetHelpText() const
1235 return GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Unknown
);
1238 #else // !wxUSE_HELP
1239 // silently ignore SetHelpText() calls
1240 void SetHelpText(const wxString
& WXUNUSED(text
)) { }
1241 void SetHelpTextForId(const wxString
& WXUNUSED(text
)) { }
1242 #endif // wxUSE_HELP
1248 // the easiest way to set a tooltip for a window is to use this method
1249 void SetToolTip( const wxString
&tip
);
1250 // attach a tooltip to the window, pointer can be NULL to remove
1252 void SetToolTip( wxToolTip
*tip
) { DoSetToolTip(tip
); }
1253 // more readable synonym for SetToolTip(NULL)
1254 void UnsetToolTip() { SetToolTip(NULL
); }
1255 // get the associated tooltip or NULL if none
1256 wxToolTip
* GetToolTip() const { return m_tooltip
; }
1257 wxString
GetToolTipText() const;
1258 #else // !wxUSE_TOOLTIPS
1259 // make it much easier to compile apps in an environment
1260 // that doesn't support tooltips, such as PocketPC
1261 void SetToolTip(const wxString
& WXUNUSED(tip
)) { }
1262 void UnsetToolTip() { }
1263 #endif // wxUSE_TOOLTIPS/!wxUSE_TOOLTIPS
1267 #if wxUSE_DRAG_AND_DROP
1268 // set/retrieve the drop target associated with this window (may be
1269 // NULL; it's owned by the window and will be deleted by it)
1270 virtual void SetDropTarget( wxDropTarget
*dropTarget
) = 0;
1271 virtual wxDropTarget
*GetDropTarget() const { return m_dropTarget
; }
1273 // Accept files for dragging
1274 virtual void DragAcceptFiles(bool accept
)
1276 // it does have common implementation but not for MSW which has its own
1277 // native version of it
1282 #endif // wxUSE_DRAG_AND_DROP
1284 // constraints and sizers
1285 // ----------------------
1286 #if wxUSE_CONSTRAINTS
1287 // set the constraints for this window or retrieve them (may be NULL)
1288 void SetConstraints( wxLayoutConstraints
*constraints
);
1289 wxLayoutConstraints
*GetConstraints() const { return m_constraints
; }
1291 // implementation only
1292 void UnsetConstraints(wxLayoutConstraints
*c
);
1293 wxWindowList
*GetConstraintsInvolvedIn() const
1294 { return m_constraintsInvolvedIn
; }
1295 void AddConstraintReference(wxWindowBase
*otherWin
);
1296 void RemoveConstraintReference(wxWindowBase
*otherWin
);
1297 void DeleteRelatedConstraints();
1298 void ResetConstraints();
1300 // these methods may be overridden for special layout algorithms
1301 virtual void SetConstraintSizes(bool recurse
= true);
1302 virtual bool LayoutPhase1(int *noChanges
);
1303 virtual bool LayoutPhase2(int *noChanges
);
1304 virtual bool DoPhase(int phase
);
1306 // these methods are virtual but normally won't be overridden
1307 virtual void SetSizeConstraint(int x
, int y
, int w
, int h
);
1308 virtual void MoveConstraint(int x
, int y
);
1309 virtual void GetSizeConstraint(int *w
, int *h
) const ;
1310 virtual void GetClientSizeConstraint(int *w
, int *h
) const ;
1311 virtual void GetPositionConstraint(int *x
, int *y
) const ;
1313 #endif // wxUSE_CONSTRAINTS
1315 // when using constraints or sizers, it makes sense to update
1316 // children positions automatically whenever the window is resized
1317 // - this is done if autoLayout is on
1318 void SetAutoLayout( bool autoLayout
) { m_autoLayout
= autoLayout
; }
1319 bool GetAutoLayout() const { return m_autoLayout
; }
1321 // lay out the window and its children
1322 virtual bool Layout();
1325 void SetSizer(wxSizer
*sizer
, bool deleteOld
= true );
1326 void SetSizerAndFit( wxSizer
*sizer
, bool deleteOld
= true );
1328 wxSizer
*GetSizer() const { return m_windowSizer
; }
1330 // Track if this window is a member of a sizer
1331 void SetContainingSizer(wxSizer
* sizer
);
1332 wxSizer
*GetContainingSizer() const { return m_containingSizer
; }
1335 // ----------------------
1336 #if wxUSE_ACCESSIBILITY
1337 // Override to create a specific accessible object.
1338 virtual wxAccessible
* CreateAccessible();
1340 // Sets the accessible object.
1341 void SetAccessible(wxAccessible
* accessible
) ;
1343 // Returns the accessible object.
1344 wxAccessible
* GetAccessible() { return m_accessible
; }
1346 // Returns the accessible object, creating if necessary.
1347 wxAccessible
* GetOrCreateAccessible() ;
1351 // Set window transparency if the platform supports it
1352 virtual bool SetTransparent(wxByte
WXUNUSED(alpha
)) { return false; }
1353 virtual bool CanSetTransparent() { return false; }
1360 void OnSysColourChanged( wxSysColourChangedEvent
& event
);
1361 void OnInitDialog( wxInitDialogEvent
&event
);
1362 void OnMiddleClick( wxMouseEvent
& event
);
1364 void OnHelp(wxHelpEvent
& event
);
1365 #endif // wxUSE_HELP
1367 // virtual function for implementing internal idle
1369 virtual void OnInternalIdle() {}
1371 // call internal idle recursively
1372 // void ProcessInternalIdle() ;
1374 // get the handle of the window for the underlying window system: this
1375 // is only used for wxWin itself or for user code which wants to call
1376 // platform-specific APIs
1377 virtual WXWidget
GetHandle() const = 0;
1378 // associate the window with a new native handle
1379 virtual void AssociateHandle(WXWidget
WXUNUSED(handle
)) { }
1380 // dissociate the current native handle from the window
1381 virtual void DissociateHandle() { }
1384 // Store the palette used by DCs in wxWindow so that the dcs can share
1385 // a palette. And we can respond to palette messages.
1386 wxPalette
GetPalette() const { return m_palette
; }
1388 // When palette is changed tell the DC to set the system palette to the
1390 void SetPalette(const wxPalette
& pal
);
1392 // return true if we have a specific palette
1393 bool HasCustomPalette() const { return m_hasCustomPalette
; }
1395 // return the first parent window with a custom palette or NULL
1396 wxWindow
*GetAncestorWithCustomPalette() const;
1397 #endif // wxUSE_PALETTE
1399 // inherit the parents visual attributes if they had been explicitly set
1400 // by the user (i.e. we don't inherit default attributes) and if we don't
1401 // have our own explicitly set
1402 virtual void InheritAttributes();
1404 // returns false from here if this window doesn't want to inherit the
1405 // parents colours even if InheritAttributes() would normally do it
1407 // this just provides a simple way to customize InheritAttributes()
1408 // behaviour in the most common case
1409 virtual bool ShouldInheritColours() const { return false; }
1411 // returns true if the window can be positioned outside of parent's client
1412 // area (normal windows can't, but e.g. menubar or statusbar can):
1413 virtual bool CanBeOutsideClientArea() const { return false; }
1415 // returns true if the platform should explicitly apply a theme border. Currently
1416 // used only by Windows
1417 virtual bool CanApplyThemeBorder() const { return true; }
1420 // event handling specific to wxWindow
1421 virtual bool TryBefore(wxEvent
& event
);
1422 virtual bool TryAfter(wxEvent
& event
);
1426 OrderBefore
, // insert before the given window
1427 OrderAfter
// insert after the given window
1430 // common part of GetPrev/NextSibling()
1431 wxWindow
*DoGetSibling(WindowOrder order
) const;
1433 // common part of MoveBefore/AfterInTabOrder()
1434 virtual void DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
);
1436 // implementation of Navigate() and NavigateIn()
1437 virtual bool DoNavigateIn(int flags
);
1439 #if wxUSE_CONSTRAINTS
1440 // satisfy the constraints for the windows but don't set the window sizes
1441 void SatisfyConstraints();
1442 #endif // wxUSE_CONSTRAINTS
1444 // Send the wxWindowDestroyEvent if not done yet and sets m_isBeingDeleted
1446 void SendDestroyEvent();
1448 // returns the main window of composite control; this is the window
1449 // that FindFocus returns if the focus is in one of composite control's
1451 virtual wxWindow
*GetMainWindowOfCompositeControl()
1452 { return (wxWindow
*)this; }
1454 // this method should be implemented to use operating system specific code
1455 // to really enable/disable the widget, it will only be called when we
1456 // really need to enable/disable window and so no additional checks on the
1457 // widgets state are necessary
1458 virtual void DoEnable(bool WXUNUSED(enable
)) { }
1460 // called when the on-screen widget state changes and provides an
1461 // an opportunity for the widget to update its visual state (colours,
1462 // fonts, anything else) as necessary
1463 virtual void OnEnabled(bool WXUNUSED(enabled
)) { }
1466 // the window id - a number which uniquely identifies a window among
1467 // its siblings unless it is wxID_ANY
1468 wxWindowIDRef m_windowId
;
1470 // the parent window of this window (or NULL) and the list of the children
1473 wxWindowList m_children
;
1475 // the minimal allowed size for the window (no minimal size if variable(s)
1476 // contain(s) wxDefaultCoord)
1482 // event handler for this window: usually is just 'this' but may be
1483 // changed with SetEventHandler()
1484 wxEvtHandler
*m_eventHandler
;
1486 #if wxUSE_VALIDATORS
1487 // associated validator or NULL if none
1488 wxValidator
*m_windowValidator
;
1489 #endif // wxUSE_VALIDATORS
1491 #if wxUSE_DRAG_AND_DROP
1492 wxDropTarget
*m_dropTarget
;
1493 #endif // wxUSE_DRAG_AND_DROP
1495 // visual window attributes
1497 wxFont m_font
; // see m_hasFont
1498 wxColour m_backgroundColour
, // m_hasBgCol
1499 m_foregroundColour
; // m_hasFgCol
1503 #endif // wxUSE_CARET
1505 // the region which should be repainted in response to paint event
1506 wxRegion m_updateRegion
;
1509 // the accelerator table for the window which translates key strokes into
1511 wxAcceleratorTable m_acceleratorTable
;
1512 #endif // wxUSE_ACCEL
1514 // the tooltip for this window (may be NULL)
1516 wxToolTip
*m_tooltip
;
1517 #endif // wxUSE_TOOLTIPS
1519 // constraints and sizers
1520 #if wxUSE_CONSTRAINTS
1521 // the constraints for this window or NULL
1522 wxLayoutConstraints
*m_constraints
;
1524 // constraints this window is involved in
1525 wxWindowList
*m_constraintsInvolvedIn
;
1526 #endif // wxUSE_CONSTRAINTS
1528 // this window's sizer
1529 wxSizer
*m_windowSizer
;
1531 // The sizer this window is a member of, if any
1532 wxSizer
*m_containingSizer
;
1534 // Layout() window automatically when its size changes?
1535 bool m_autoLayout
:1;
1540 bool m_isBeingDeleted
:1;
1542 // was the window colours/font explicitly changed by user?
1547 // and should it be inherited by children?
1548 bool m_inheritBgCol
:1;
1549 bool m_inheritFgCol
:1;
1550 bool m_inheritFont
:1;
1552 // window attributes
1555 wxString m_windowName
;
1556 bool m_themeEnabled
;
1557 wxBackgroundStyle m_backgroundStyle
;
1559 wxPalette m_palette
;
1560 bool m_hasCustomPalette
;
1561 #endif // wxUSE_PALETTE
1563 #if wxUSE_ACCESSIBILITY
1564 wxAccessible
* m_accessible
;
1567 // Virtual size (scrolling)
1568 wxSize m_virtualSize
;
1570 wxScrollHelper
*m_scrollHelper
;
1572 wxWindowVariant m_windowVariant
;
1574 // override this to change the default (i.e. used when no style is
1575 // specified) border for the window class
1576 virtual wxBorder
GetDefaultBorder() const;
1578 // this allows you to implement standard control borders without
1579 // repeating the code in different classes that are not derived from
1581 virtual wxBorder
GetDefaultBorderForControl() const { return wxBORDER_THEME
; }
1583 // Get the default size for the new window if no explicit size given. TLWs
1584 // have their own default size so this is just for non top-level windows.
1585 static int WidthDefault(int w
) { return w
== wxDefaultCoord
? 20 : w
; }
1586 static int HeightDefault(int h
) { return h
== wxDefaultCoord
? 20 : h
; }
1589 // Used to save the results of DoGetBestSize so it doesn't need to be
1590 // recalculated each time the value is needed.
1591 wxSize m_bestSizeCache
;
1593 wxDEPRECATED( void SetBestSize(const wxSize
& size
) ); // use SetInitialSize
1594 wxDEPRECATED( virtual void SetInitialBestSize(const wxSize
& size
) ); // use SetInitialSize
1598 // more pure virtual functions
1599 // ---------------------------
1601 // NB: we must have DoSomething() function when Something() is an overloaded
1602 // method: indeed, we can't just have "virtual Something()" in case when
1603 // the function is overloaded because then we'd have to make virtual all
1604 // the variants (otherwise only the virtual function may be called on a
1605 // pointer to derived class according to C++ rules) which is, in
1606 // general, absolutely not needed. So instead we implement all
1607 // overloaded Something()s in terms of DoSomething() which will be the
1608 // only one to be virtual.
1611 virtual void DoGetTextExtent(const wxString
& string
,
1613 int *descent
= NULL
,
1614 int *externalLeading
= NULL
,
1615 const wxFont
*font
= NULL
) const = 0;
1617 // coordinates translation
1618 virtual void DoClientToScreen( int *x
, int *y
) const = 0;
1619 virtual void DoScreenToClient( int *x
, int *y
) const = 0;
1621 virtual wxHitTest
DoHitTest(wxCoord x
, wxCoord y
) const;
1623 // capture/release the mouse, used by Capture/ReleaseMouse()
1624 virtual void DoCaptureMouse() = 0;
1625 virtual void DoReleaseMouse() = 0;
1627 // retrieve the position/size of the window
1628 virtual void DoGetPosition(int *x
, int *y
) const = 0;
1629 virtual void DoGetScreenPosition(int *x
, int *y
) const;
1630 virtual void DoGetSize(int *width
, int *height
) const = 0;
1631 virtual void DoGetClientSize(int *width
, int *height
) const = 0;
1633 // get the size which best suits the window: for a control, it would be
1634 // the minimal size which doesn't truncate the control, for a panel - the
1635 // same size as it would have after a call to Fit()
1636 virtual wxSize
DoGetBestSize() const;
1638 // this method can be overridden instead of DoGetBestSize() if it computes
1639 // the best size of the client area of the window only, excluding borders
1640 // (GetBorderSize() will be used to add them)
1641 virtual wxSize
DoGetBestClientSize() const { return wxDefaultSize
; }
1643 // this is the virtual function to be overriden in any derived class which
1644 // wants to change how SetSize() or Move() works - it is called by all
1645 // versions of these functions in the base class
1646 virtual void DoSetSize(int x
, int y
,
1647 int width
, int height
,
1648 int sizeFlags
= wxSIZE_AUTO
) = 0;
1650 // same as DoSetSize() for the client size
1651 virtual void DoSetClientSize(int width
, int height
) = 0;
1653 virtual void DoSetSizeHints( int minW
, int minH
,
1655 int incW
, int incH
);
1657 // return the total size of the window borders, i.e. the sum of the widths
1658 // of the left and the right border in the x component of the returned size
1659 // and the sum of the heights of the top and bottom borders in the y one
1661 // NB: this is new/temporary API only implemented by wxMSW so far and
1662 // subject to change, don't use
1663 virtual wxSize
DoGetBorderSize() const
1665 wxFAIL_MSG( "must be overridden if called" );
1667 return wxDefaultSize
;
1670 // move the window to the specified location and resize it: this is called
1671 // from both DoSetSize() and DoSetClientSize() and would usually just
1672 // reposition this window except for composite controls which will want to
1673 // arrange themselves inside the given rectangle
1675 // Important note: the coordinates passed to this method are in parent's
1676 // *window* coordinates and not parent's client coordinates (as the values
1677 // passed to DoSetSize and returned by DoGetPosition are)!
1678 virtual void DoMoveWindow(int x
, int y
, int width
, int height
) = 0;
1680 // centre the window in the specified direction on parent, note that
1681 // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for
1683 virtual void DoCentre(int dir
);
1686 virtual void DoSetToolTip( wxToolTip
*tip
);
1687 #endif // wxUSE_TOOLTIPS
1690 virtual bool DoPopupMenu(wxMenu
*menu
, int x
, int y
) = 0;
1691 #endif // wxUSE_MENUS
1693 // Makes an adjustment to the window position to make it relative to the
1694 // parents client area, e.g. if the parent is a frame with a toolbar, its
1695 // (0, 0) is just below the toolbar
1696 virtual void AdjustForParentClientOrigin(int& x
, int& y
,
1697 int sizeFlags
= 0) const;
1699 // implements the window variants
1700 virtual void DoSetWindowVariant( wxWindowVariant variant
) ;
1703 // really freeze/thaw the window (should have port-specific implementation)
1704 virtual void DoFreeze() { }
1705 virtual void DoThaw() { }
1708 // Must be called when mouse capture is lost to send
1709 // wxMouseCaptureLostEvent to windows on capture stack.
1710 static void NotifyCaptureLost();
1713 // recursively call our own and our children OnEnabled() when the
1714 // enabled/disabled status changed because a parent window had been
1716 void NotifyWindowOnEnableChange(bool enabled
);
1719 // temporary event handlers used by GetPopupMenuSelectionFromUser()
1720 void InternalOnPopupMenu(wxCommandEvent
& event
);
1721 void InternalOnPopupMenuUpdate(wxUpdateUIEvent
& event
);
1723 // implementation of the public GetPopupMenuSelectionFromUser() method
1724 int DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
);
1725 #endif // wxUSE_MENUS
1727 // layout the window children when its size changes unless this was
1728 // explicitly disabled with SetAutoLayout(false)
1729 void InternalOnSize(wxSizeEvent
& event
);
1732 // the stack of windows which have captured the mouse
1733 static struct WXDLLIMPEXP_FWD_CORE wxWindowNext
*ms_winCaptureNext
;
1735 // the window that currently has mouse capture
1736 static wxWindow
*ms_winCaptureCurrent
;
1738 // indicates if execution is inside CaptureMouse/ReleaseMouse
1739 static bool ms_winCaptureChanging
;
1742 // number of Freeze() calls minus the number of Thaw() calls: we're frozen
1743 // (i.e. not being updated) if it is positive
1744 unsigned int m_freezeCount
;
1747 DECLARE_ABSTRACT_CLASS(wxWindowBase
)
1748 wxDECLARE_NO_COPY_CLASS(wxWindowBase
);
1749 DECLARE_EVENT_TABLE()
1754 // Inlines for some deprecated methods
1755 inline wxSize
wxWindowBase::GetBestFittingSize() const
1757 return GetEffectiveMinSize();
1760 inline void wxWindowBase::SetBestFittingSize(const wxSize
& size
)
1762 SetInitialSize(size
);
1765 inline void wxWindowBase::SetBestSize(const wxSize
& size
)
1767 SetInitialSize(size
);
1770 inline void wxWindowBase::SetInitialBestSize(const wxSize
& size
)
1772 SetInitialSize(size
);
1776 // ----------------------------------------------------------------------------
1777 // now include the declaration of wxWindow class
1778 // ----------------------------------------------------------------------------
1780 // include the declaration of the platform-specific class
1781 #if defined(__WXPALMOS__)
1782 #ifdef __WXUNIVERSAL__
1783 #define wxWindowNative wxWindowPalm
1785 #define wxWindowPalm wxWindow
1786 #endif // wxUniv/!wxUniv
1787 #include "wx/palmos/window.h"
1788 #elif defined(__WXMSW__)
1789 #ifdef __WXUNIVERSAL__
1790 #define wxWindowNative wxWindowMSW
1792 #define wxWindowMSW wxWindow
1793 #endif // wxUniv/!wxUniv
1794 #include "wx/msw/window.h"
1795 #elif defined(__WXMOTIF__)
1796 #include "wx/motif/window.h"
1797 #elif defined(__WXGTK20__)
1798 #ifdef __WXUNIVERSAL__
1799 #define wxWindowNative wxWindowGTK
1801 #define wxWindowGTK wxWindow
1803 #include "wx/gtk/window.h"
1804 #elif defined(__WXGTK__)
1805 #ifdef __WXUNIVERSAL__
1806 #define wxWindowNative wxWindowGTK
1808 #define wxWindowGTK wxWindow
1810 #include "wx/gtk1/window.h"
1811 #elif defined(__WXX11__)
1812 #ifdef __WXUNIVERSAL__
1813 #define wxWindowNative wxWindowX11
1815 #define wxWindowX11 wxWindow
1817 #include "wx/x11/window.h"
1818 #elif defined(__WXMGL__)
1819 #define wxWindowNative wxWindowMGL
1820 #include "wx/mgl/window.h"
1821 #elif defined(__WXDFB__)
1822 #define wxWindowNative wxWindowDFB
1823 #include "wx/dfb/window.h"
1824 #elif defined(__WXMAC__)
1825 #ifdef __WXUNIVERSAL__
1826 #define wxWindowNative wxWindowMac
1828 #define wxWindowMac wxWindow
1830 #include "wx/osx/window.h"
1831 #elif defined(__WXCOCOA__)
1832 #ifdef __WXUNIVERSAL__
1833 #define wxWindowNative wxWindowCocoa
1835 #define wxWindowCocoa wxWindow
1837 #include "wx/cocoa/window.h"
1838 #elif defined(__WXPM__)
1839 #ifdef __WXUNIVERSAL__
1840 #define wxWindowNative wxWindowOS2
1842 #define wxWindowOS2 wxWindow
1843 #endif // wxUniv/!wxUniv
1844 #include "wx/os2/window.h"
1847 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1848 // for the native ports we already have defined it above
1849 #if defined(__WXUNIVERSAL__)
1850 #ifndef wxWindowNative
1851 #error "wxWindowNative must be defined above!"
1854 #include "wx/univ/window.h"
1857 // ----------------------------------------------------------------------------
1858 // inline functions which couldn't be declared in the class body because of
1859 // forward dependencies
1860 // ----------------------------------------------------------------------------
1862 inline wxWindow
*wxWindowBase::GetGrandParent() const
1864 return m_parent
? m_parent
->GetParent() : NULL
;
1867 // ----------------------------------------------------------------------------
1869 // ----------------------------------------------------------------------------
1871 // Find the wxWindow at the current mouse position, also returning the mouse
1873 extern WXDLLIMPEXP_CORE wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
);
1875 // Get the current mouse position.
1876 extern WXDLLIMPEXP_CORE wxPoint
wxGetMousePosition();
1878 // get the currently active window of this application or NULL
1879 extern WXDLLIMPEXP_CORE wxWindow
*wxGetActiveWindow();
1881 // get the (first) top level parent window
1882 WXDLLIMPEXP_CORE wxWindow
* wxGetTopLevelParent(wxWindow
*win
);
1884 #if WXWIN_COMPATIBILITY_2_6
1885 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1886 wxDEPRECATED( wxWindowID
NewControlId() );
1887 inline wxWindowID
NewControlId() { return wxWindowBase::NewControlId(); }
1888 #endif // WXWIN_COMPATIBILITY_2_6
1890 #if wxUSE_ACCESSIBILITY
1891 // ----------------------------------------------------------------------------
1892 // accessible object for windows
1893 // ----------------------------------------------------------------------------
1895 class WXDLLIMPEXP_CORE wxWindowAccessible
: public wxAccessible
1898 wxWindowAccessible(wxWindow
* win
): wxAccessible(win
) { if (win
) win
->SetAccessible(this); }
1899 virtual ~wxWindowAccessible() {}
1903 // Can return either a child object, or an integer
1904 // representing the child element, starting from 1.
1905 virtual wxAccStatus
HitTest(const wxPoint
& pt
, int* childId
, wxAccessible
** childObject
);
1907 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1908 virtual wxAccStatus
GetLocation(wxRect
& rect
, int elementId
);
1910 // Navigates from fromId to toId/toObject.
1911 virtual wxAccStatus
Navigate(wxNavDir navDir
, int fromId
,
1912 int* toId
, wxAccessible
** toObject
);
1914 // Gets the name of the specified object.
1915 virtual wxAccStatus
GetName(int childId
, wxString
* name
);
1917 // Gets the number of children.
1918 virtual wxAccStatus
GetChildCount(int* childCount
);
1920 // Gets the specified child (starting from 1).
1921 // If *child is NULL and return value is wxACC_OK,
1922 // this means that the child is a simple element and
1923 // not an accessible object.
1924 virtual wxAccStatus
GetChild(int childId
, wxAccessible
** child
);
1926 // Gets the parent, or NULL.
1927 virtual wxAccStatus
GetParent(wxAccessible
** parent
);
1929 // Performs the default action. childId is 0 (the action for this object)
1930 // or > 0 (the action for a child).
1931 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1932 // window (e.g. an edit control).
1933 virtual wxAccStatus
DoDefaultAction(int childId
);
1935 // Gets the default action for this object (0) or > 0 (the action for a child).
1936 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1937 // string if there is no action.
1938 // The retrieved string describes the action that is performed on an object,
1939 // not what the object does as a result. For example, a toolbar button that prints
1940 // a document has a default action of "Press" rather than "Prints the current document."
1941 virtual wxAccStatus
GetDefaultAction(int childId
, wxString
* actionName
);
1943 // Returns the description for this object or a child.
1944 virtual wxAccStatus
GetDescription(int childId
, wxString
* description
);
1946 // Returns help text for this object or a child, similar to tooltip text.
1947 virtual wxAccStatus
GetHelpText(int childId
, wxString
* helpText
);
1949 // Returns the keyboard shortcut for this object or child.
1950 // Return e.g. ALT+K
1951 virtual wxAccStatus
GetKeyboardShortcut(int childId
, wxString
* shortcut
);
1953 // Returns a role constant.
1954 virtual wxAccStatus
GetRole(int childId
, wxAccRole
* role
);
1956 // Returns a state constant.
1957 virtual wxAccStatus
GetState(int childId
, long* state
);
1959 // Returns a localized string representing the value for the object
1961 virtual wxAccStatus
GetValue(int childId
, wxString
* strValue
);
1963 // Selects the object or child.
1964 virtual wxAccStatus
Select(int childId
, wxAccSelectionFlags selectFlags
);
1966 // Gets the window with the keyboard focus.
1967 // If childId is 0 and child is NULL, no object in
1968 // this subhierarchy has the focus.
1969 // If this object has the focus, child should be 'this'.
1970 virtual wxAccStatus
GetFocus(int* childId
, wxAccessible
** child
);
1973 // Gets a variant representing the selected children
1975 // Acceptable values:
1976 // - a null variant (IsNull() returns true)
1977 // - a list variant (GetType() == wxT("list")
1978 // - an integer representing the selected child element,
1979 // or 0 if this object is selected (GetType() == wxT("long")
1980 // - a "void*" pointer to a wxAccessible child object
1981 virtual wxAccStatus
GetSelections(wxVariant
* selections
);
1982 #endif // wxUSE_VARIANT
1985 #endif // wxUSE_ACCESSIBILITY
1988 #endif // _WX_WINDOW_H_BASE_