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 wxItemResource
;
75 class WXDLLIMPEXP_FWD_CORE wxLayoutConstraints
;
76 class WXDLLIMPEXP_FWD_CORE wxResourceTable
;
77 class WXDLLIMPEXP_FWD_CORE wxSizer
;
78 class WXDLLIMPEXP_FWD_CORE wxToolTip
;
79 class WXDLLIMPEXP_FWD_CORE wxWindowBase
;
80 class WXDLLIMPEXP_FWD_CORE wxWindow
;
81 class WXDLLIMPEXP_FWD_CORE wxScrollHelper
;
83 #if wxUSE_ACCESSIBILITY
84 class WXDLLIMPEXP_FWD_CORE wxAccessible
;
87 // ----------------------------------------------------------------------------
88 // helper stuff used by wxWindow
89 // ----------------------------------------------------------------------------
91 // struct containing all the visual attributes of a control
92 struct WXDLLEXPORT wxVisualAttributes
94 // the font used for control label/text inside it
97 // the foreground colour
100 // the background colour, may be wxNullColour if the controls background
101 // colour is not solid
105 // different window variants, on platforms like eg mac uses different
109 wxWINDOW_VARIANT_NORMAL
, // Normal size
110 wxWINDOW_VARIANT_SMALL
, // Smaller size (about 25 % smaller than normal)
111 wxWINDOW_VARIANT_MINI
, // Mini size (about 33 % smaller than normal)
112 wxWINDOW_VARIANT_LARGE
, // Large size (about 25 % larger than normal)
116 #if wxUSE_SYSTEM_OPTIONS
117 #define wxWINDOW_DEFAULT_VARIANT wxT("window-default-variant")
120 // ----------------------------------------------------------------------------
121 // (pseudo)template list classes
122 // ----------------------------------------------------------------------------
124 WX_DECLARE_LIST_3(wxWindow
, wxWindowBase
, wxWindowList
, wxWindowListNode
, class WXDLLEXPORT
);
126 // ----------------------------------------------------------------------------
128 // ----------------------------------------------------------------------------
130 extern WXDLLEXPORT_DATA(wxWindowList
) wxTopLevelWindows
;
131 extern WXDLLIMPEXP_DATA_CORE(wxList
) wxPendingDelete
;
133 // ----------------------------------------------------------------------------
134 // wxWindowBase is the base class for all GUI controls/widgets, this is the public
135 // interface of this class.
137 // Event handler: windows have themselves as their event handlers by default,
138 // but their event handlers could be set to another object entirely. This
139 // separation can reduce the amount of derivation required, and allow
140 // alteration of a window's functionality (e.g. by a resource editor that
141 // temporarily switches event handlers).
142 // ----------------------------------------------------------------------------
144 class WXDLLEXPORT wxWindowBase
: public wxEvtHandler
147 // creating the window
148 // -------------------
150 // default ctor, initializes everything which can be initialized before
154 // pseudo ctor (can't be virtual, called from ctor)
155 bool CreateBase(wxWindowBase
*parent
,
157 const wxPoint
& pos
= wxDefaultPosition
,
158 const wxSize
& size
= wxDefaultSize
,
160 const wxValidator
& validator
= wxDefaultValidator
,
161 const wxString
& name
= wxPanelNameStr
);
163 virtual ~wxWindowBase();
165 // deleting the window
166 // -------------------
168 // ask the window to close itself, return true if the event handler
169 // honoured our request
170 bool Close( bool force
= false );
172 // the following functions delete the C++ objects (the window itself
173 // or its children) as well as the GUI windows and normally should
174 // never be used directly
176 // delete window unconditionally (dangerous!), returns true if ok
177 virtual bool Destroy();
178 // delete all children of this window, returns true if ok
179 bool DestroyChildren();
181 // is the window being deleted?
182 bool IsBeingDeleted() const { return m_isBeingDeleted
; }
187 // label is just the same as the title (but for, e.g., buttons it
188 // makes more sense to speak about labels), title access
189 // is available from wxTLW classes only (frames, dialogs)
190 virtual void SetLabel(const wxString
& label
) = 0;
191 virtual wxString
GetLabel() const = 0;
193 // the window name is used for ressource setting in X, it is not the
194 // same as the window title/label
195 virtual void SetName( const wxString
&name
) { m_windowName
= name
; }
196 virtual wxString
GetName() const { return m_windowName
; }
198 // sets the window variant, calls internally DoSetVariant if variant
200 void SetWindowVariant(wxWindowVariant variant
);
201 wxWindowVariant
GetWindowVariant() const { return m_windowVariant
; }
204 // get or change the layout direction (LTR or RTL) for this window,
205 // wxLayout_Default is returned if layout direction is not supported
206 virtual wxLayoutDirection
GetLayoutDirection() const
207 { return wxLayout_Default
; }
208 virtual void SetLayoutDirection(wxLayoutDirection
WXUNUSED(dir
))
211 // mirror coordinates for RTL layout if this window uses it and if the
212 // mirroring is not done automatically like Win32
213 virtual wxCoord
AdjustForLayoutDirection(wxCoord x
,
215 wxCoord widthTotal
) const;
218 // window id uniquely identifies the window among its siblings unless
219 // it is wxID_ANY which means "don't care"
220 void SetId( wxWindowID winid
) { m_windowId
= winid
; }
221 wxWindowID
GetId() const { return m_windowId
; }
223 // returns true if this id value belong to the range reserved for the
224 // auto-generated (by NewControlId()) ids (they're always negative)
225 static bool IsAutoGeneratedId(wxWindowID id
);
227 // generate a unique id (or count of them consecutively), returns a
228 // valid id in IsAutoGeneratedId() range or wxID_NONE if failed
229 static wxWindowID
NewControlId(int count
= 1);
231 // mark an id previously returned by NewControlId() as being unused any
232 // more so that it can be reused again for another control later
233 static void ReleaseControlId(wxWindowID id
);
239 // set the window size and/or position
240 void SetSize( int x
, int y
, int width
, int height
,
241 int sizeFlags
= wxSIZE_AUTO
)
242 { DoSetSize(x
, y
, width
, height
, sizeFlags
); }
244 void SetSize( int width
, int height
)
245 { DoSetSize( wxDefaultCoord
, wxDefaultCoord
, width
, height
, wxSIZE_USE_EXISTING
); }
247 void SetSize( const wxSize
& size
)
248 { SetSize( size
.x
, size
.y
); }
250 void SetSize(const wxRect
& rect
, int sizeFlags
= wxSIZE_AUTO
)
251 { DoSetSize(rect
.x
, rect
.y
, rect
.width
, rect
.height
, sizeFlags
); }
253 void Move(int x
, int y
, int flags
= wxSIZE_USE_EXISTING
)
254 { DoSetSize(x
, y
, wxDefaultCoord
, wxDefaultCoord
, flags
); }
256 void Move(const wxPoint
& pt
, int flags
= wxSIZE_USE_EXISTING
)
257 { Move(pt
.x
, pt
.y
, flags
); }
259 void SetPosition(const wxPoint
& pt
) { Move(pt
); }
262 virtual void Raise() = 0;
263 virtual void Lower() = 0;
265 // client size is the size of area available for subwindows
266 void SetClientSize( int width
, int height
)
267 { DoSetClientSize(width
, height
); }
269 void SetClientSize( const wxSize
& size
)
270 { DoSetClientSize(size
.x
, size
.y
); }
272 void SetClientSize(const wxRect
& rect
)
273 { SetClientSize( rect
.width
, rect
.height
); }
275 // get the window position (pointers may be NULL): notice that it is in
276 // client coordinates for child windows and screen coordinates for the
277 // top level ones, use GetScreenPosition() if you need screen
278 // coordinates for all kinds of windows
279 void GetPosition( int *x
, int *y
) const { DoGetPosition(x
, y
); }
280 wxPoint
GetPosition() const
283 DoGetPosition(&x
, &y
);
285 return wxPoint(x
, y
);
288 // get the window position in screen coordinates
289 void GetScreenPosition(int *x
, int *y
) const { DoGetScreenPosition(x
, y
); }
290 wxPoint
GetScreenPosition() const
293 DoGetScreenPosition(&x
, &y
);
295 return wxPoint(x
, y
);
298 // get the window size (pointers may be NULL)
299 void GetSize( int *w
, int *h
) const { DoGetSize(w
, h
); }
300 wxSize
GetSize() const
307 void GetClientSize( int *w
, int *h
) const { DoGetClientSize(w
, h
); }
308 wxSize
GetClientSize() const
311 DoGetClientSize(&w
, &h
);
316 // get the position and size at once
317 wxRect
GetRect() const
323 return wxRect(x
, y
, w
, h
);
326 wxRect
GetScreenRect() const
329 GetScreenPosition(&x
, &y
);
332 return wxRect(x
, y
, w
, h
);
335 // get the origin of the client area of the window relative to the
336 // window top left corner (the client area may be shifted because of
337 // the borders, scrollbars, other decorations...)
338 virtual wxPoint
GetClientAreaOrigin() const;
340 // get the client rectangle in window (i.e. client) coordinates
341 wxRect
GetClientRect() const
343 return wxRect(GetClientAreaOrigin(), GetClientSize());
346 // get the size best suited for the window (in fact, minimal
347 // acceptable size using which it will still look "nice" in
349 wxSize
GetBestSize() const
351 if (m_bestSizeCache
.IsFullySpecified())
352 return m_bestSizeCache
;
353 return DoGetBestSize();
355 void GetBestSize(int *w
, int *h
) const
357 wxSize s
= GetBestSize();
364 void SetScrollHelper( wxScrollHelper
*sh
) { m_scrollHelper
= sh
; }
365 wxScrollHelper
*GetScrollHelper() { return m_scrollHelper
; }
367 // reset the cached best size value so it will be recalculated the
368 // next time it is needed.
369 void InvalidateBestSize();
370 void CacheBestSize(const wxSize
& size
) const
371 { wxConstCast(this, wxWindowBase
)->m_bestSizeCache
= size
; }
374 // This function will merge the window's best size into the window's
375 // minimum size, giving priority to the min size components, and
376 // returns the results.
377 wxSize
GetEffectiveMinSize() const;
378 wxDEPRECATED( wxSize
GetBestFittingSize() const ); // replaced by GetEffectiveMinSize
379 wxDEPRECATED( wxSize
GetAdjustedMinSize() const ); // replaced by GetEffectiveMinSize
381 // A 'Smart' SetSize that will fill in default size values with 'best'
382 // size. Sets the minsize to what was passed in.
383 void SetInitialSize(const wxSize
& size
=wxDefaultSize
);
384 wxDEPRECATED( void SetBestFittingSize(const wxSize
& size
=wxDefaultSize
) ); // replaced by SetInitialSize
387 // the generic centre function - centers the window on parent by`
388 // default or on screen if it doesn't have parent or
389 // wxCENTER_ON_SCREEN flag is given
390 void Centre(int dir
= wxBOTH
) { DoCentre(dir
); }
391 void Center(int dir
= wxBOTH
) { DoCentre(dir
); }
393 // centre with respect to the the parent window
394 void CentreOnParent(int dir
= wxBOTH
) { DoCentre(dir
); }
395 void CenterOnParent(int dir
= wxBOTH
) { CentreOnParent(dir
); }
397 // set window size to wrap around its children
400 // set virtual size to satisfy children
401 virtual void FitInside();
404 // SetSizeHints is actually for setting the size hints
405 // for the wxTLW for a Window Manager - hence the name -
406 // and it is therefore overridden in wxTLW to do that.
407 // In wxWindow(Base), it has (unfortunately) been abused
408 // to mean the same as SetMinSize() and SetMaxSize().
410 virtual void SetSizeHints( int minW
, int minH
,
411 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
,
412 int incW
= wxDefaultCoord
, int incH
= wxDefaultCoord
)
413 { DoSetSizeHints(minW
, minH
, maxW
, maxH
, incW
, incH
); }
415 void SetSizeHints( const wxSize
& minSize
,
416 const wxSize
& maxSize
=wxDefaultSize
,
417 const wxSize
& incSize
=wxDefaultSize
)
418 { DoSetSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
, incSize
.x
, incSize
.y
); }
420 virtual void DoSetSizeHints( int minW
, int minH
,
422 int incW
, int incH
);
424 // Methods for setting virtual size hints
425 // FIXME: What are virtual size hints?
427 virtual void SetVirtualSizeHints( int minW
, int minH
,
428 int maxW
= wxDefaultCoord
, int maxH
= wxDefaultCoord
);
429 void SetVirtualSizeHints( const wxSize
& minSize
,
430 const wxSize
& maxSize
=wxDefaultSize
)
432 SetVirtualSizeHints(minSize
.x
, minSize
.y
, maxSize
.x
, maxSize
.y
);
436 // Call these to override what GetBestSize() returns. This
437 // method is only virtual because it is overriden in wxTLW
438 // as a different API for SetSizeHints().
439 virtual void SetMinSize(const wxSize
& minSize
) { m_minWidth
= minSize
.x
; m_minHeight
= minSize
.y
; }
440 virtual void SetMaxSize(const wxSize
& maxSize
) { m_maxWidth
= maxSize
.x
; m_maxHeight
= maxSize
.y
; }
442 // Override these methods to impose restrictions on min/max size.
443 // The easier way is to call SetMinSize() and SetMaxSize() which
444 // will have the same effect. Doing both is non-sense.
445 virtual wxSize
GetMinSize() const { return wxSize(m_minWidth
, m_minHeight
); }
446 virtual wxSize
GetMaxSize() const { return wxSize(m_maxWidth
, m_maxHeight
); }
448 // Get the min and max values one by one
449 int GetMinWidth() const { return GetMinSize().x
; }
450 int GetMinHeight() const { return GetMinSize().y
; }
451 int GetMaxWidth() const { return GetMaxSize().x
; }
452 int GetMaxHeight() const { return GetMaxSize().y
; }
455 // Methods for accessing the virtual size of a window. For most
456 // windows this is just the client area of the window, but for
457 // some like scrolled windows it is more or less independent of
458 // the screen window size. You may override the DoXXXVirtual
459 // methods below for classes where that is is the case.
461 void SetVirtualSize( const wxSize
&size
) { DoSetVirtualSize( size
.x
, size
.y
); }
462 void SetVirtualSize( int x
, int y
) { DoSetVirtualSize( x
, y
); }
464 wxSize
GetVirtualSize() const { return DoGetVirtualSize(); }
465 void GetVirtualSize( int *x
, int *y
) const
467 wxSize
s( DoGetVirtualSize() );
475 // Override these methods for windows that have a virtual size
476 // independent of their client size. eg. the virtual area of a
479 virtual void DoSetVirtualSize( int x
, int y
);
480 virtual wxSize
DoGetVirtualSize() const;
482 // Return the largest of ClientSize and BestSize (as determined
483 // by a sizer, interior children, or other means)
485 virtual wxSize
GetBestVirtualSize() const
487 wxSize
client( GetClientSize() );
488 wxSize
best( GetBestSize() );
490 return wxSize( wxMax( client
.x
, best
.x
), wxMax( client
.y
, best
.y
) );
493 // return the size of the left/right and top/bottom borders in x and y
494 // components of the result respectively
495 virtual wxSize
GetWindowBorderSize() const;
501 // returns true if window was shown/hidden, false if the nothing was
502 // done (window was already shown/hidden)
503 virtual bool Show( bool show
= true );
504 bool Hide() { return Show(false); }
506 // returns true if window was enabled/disabled, false if nothing done
507 virtual bool Enable( bool enable
= true );
508 bool Disable() { return Enable(false); }
510 virtual bool IsShown() const { return m_isShown
; }
511 // returns true if the window is really enabled and false otherwise,
512 // whether because it had been explicitly disabled itself or because
513 // its parent is currently disabled -- then this method returns false
514 // whatever is the intrinsic state of this window, use IsThisEnabled(0
515 // to retrieve it. In other words, this relation always holds:
517 // IsEnabled() == IsThisEnabled() && parent.IsEnabled()
519 bool IsEnabled() const;
521 // returns the internal window state independently of the parent(s)
522 // state, i.e. the state in which the window would be if all its
523 // parents were enabled (use IsEnabled() above to get the effective
525 bool IsThisEnabled() const { return m_isEnabled
; }
527 // returns true if the window is visible, i.e. IsShown() returns true
528 // if called on it and all its parents up to the first TLW
529 virtual bool IsShownOnScreen() const;
531 // get/set window style (setting style won't update the window and so
532 // is only useful for internal usage)
533 virtual void SetWindowStyleFlag( long style
) { m_windowStyle
= style
; }
534 virtual long GetWindowStyleFlag() const { return m_windowStyle
; }
536 // just some (somewhat shorter) synonims
537 void SetWindowStyle( long style
) { SetWindowStyleFlag(style
); }
538 long GetWindowStyle() const { return GetWindowStyleFlag(); }
540 // check if the flag is set
541 bool HasFlag(int flag
) const { return (m_windowStyle
& flag
) != 0; }
542 virtual bool IsRetained() const { return HasFlag(wxRETAINED
); }
544 // turn the flag on if it had been turned off before and vice versa,
545 // return true if the flag is currently turned on
546 bool ToggleWindowStyle(int flag
);
548 // extra style: the less often used style bits which can't be set with
549 // SetWindowStyleFlag()
550 virtual void SetExtraStyle(long exStyle
) { m_exStyle
= exStyle
; }
551 long GetExtraStyle() const { return m_exStyle
; }
553 bool HasExtraStyle(int exFlag
) const { return (m_exStyle
& exFlag
) != 0; }
555 // make the window modal (all other windows unresponsive)
556 virtual void MakeModal(bool modal
= true);
559 // (primitive) theming support
560 // ---------------------------
562 virtual void SetThemeEnabled(bool enableTheme
) { m_themeEnabled
= enableTheme
; }
563 virtual bool GetThemeEnabled() const { return m_themeEnabled
; }
566 // focus and keyboard handling
567 // ---------------------------
569 // set focus to this window
570 virtual void SetFocus() = 0;
572 // set focus to this window as the result of a keyboard action
573 virtual void SetFocusFromKbd() { SetFocus(); }
575 // return the window which currently has the focus or NULL
576 static wxWindow
*FindFocus();
578 static wxWindow
*DoFindFocus() /* = 0: implement in derived classes */;
580 // can this window have focus in principle?
582 // the difference between AcceptsFocus[FromKeyboard]() and CanAcceptFocus
583 // [FromKeyboard]() is that the former functions are meant to be
584 // overridden in the derived classes to simply return false if the
585 // control can't have focus, while the latter are meant to be used by
586 // this class clients and take into account the current window state
587 virtual bool AcceptsFocus() const { return true; }
589 // can this window or one of its children accept focus?
591 // usually it's the same as AcceptsFocus() but is overridden for
593 virtual bool AcceptsFocusRecursively() const { return AcceptsFocus(); }
595 // can this window be given focus by keyboard navigation? if not, the
596 // only way to give it focus (provided it accepts it at all) is to
598 virtual bool AcceptsFocusFromKeyboard() const { return AcceptsFocus(); }
601 // this is mostly a helper for the various functions using it below
602 bool CanBeFocused() const { return IsShown() && IsEnabled(); }
604 // can this window itself have focus?
605 bool IsFocusable() const { return AcceptsFocus() && CanBeFocused(); }
607 // can this window have focus right now?
609 // if this method returns true, it means that calling SetFocus() will
610 // put focus either to this window or one of its children, if you need
611 // to know whether this window accepts focus itself, use IsFocusable()
612 bool CanAcceptFocus() const
613 { return AcceptsFocusRecursively() && CanBeFocused(); }
615 // can this window be assigned focus from keyboard right now?
616 bool CanAcceptFocusFromKeyboard() const
617 { return AcceptsFocusFromKeyboard() && CanBeFocused(); }
619 // call this when the return value of AcceptsFocus() changes
620 virtual void SetCanFocus(bool WXUNUSED(canFocus
)) { }
622 // navigates inside this window
623 bool NavigateIn(int flags
= wxNavigationKeyEvent::IsForward
)
624 { return DoNavigateIn(flags
); }
626 // navigates in the specified direction from this window, this is
627 // equivalent to GetParent()->NavigateIn()
628 bool Navigate(int flags
= wxNavigationKeyEvent::IsForward
)
629 { return m_parent
&& ((wxWindowBase
*)m_parent
)->DoNavigateIn(flags
); }
631 // move this window just before/after the specified one in tab order
632 // (the other window must be our sibling!)
633 void MoveBeforeInTabOrder(wxWindow
*win
)
634 { DoMoveInTabOrder(win
, OrderBefore
); }
635 void MoveAfterInTabOrder(wxWindow
*win
)
636 { DoMoveInTabOrder(win
, OrderAfter
); }
639 // parent/children relations
640 // -------------------------
642 // get the list of children
643 const wxWindowList
& GetChildren() const { return m_children
; }
644 wxWindowList
& GetChildren() { return m_children
; }
646 // needed just for extended runtime
647 const wxWindowList
& GetWindowChildren() const { return GetChildren() ; }
649 // get the window before/after this one in the parents children list,
650 // returns NULL if this is the first/last window
651 wxWindow
*GetPrevSibling() const { return DoGetSibling(OrderBefore
); }
652 wxWindow
*GetNextSibling() const { return DoGetSibling(OrderAfter
); }
654 // get the parent or the parent of the parent
655 wxWindow
*GetParent() const { return m_parent
; }
656 inline wxWindow
*GetGrandParent() const;
658 // is this window a top level one?
659 virtual bool IsTopLevel() const;
661 // it doesn't really change parent, use Reparent() instead
662 void SetParent( wxWindowBase
*parent
) { m_parent
= (wxWindow
*)parent
; }
663 // change the real parent of this window, return true if the parent
664 // was changed, false otherwise (error or newParent == oldParent)
665 virtual bool Reparent( wxWindowBase
*newParent
);
667 // implementation mostly
668 virtual void AddChild( wxWindowBase
*child
);
669 virtual void RemoveChild( wxWindowBase
*child
);
671 // returns true if the child is in the client area of the window, i.e. is
672 // not scrollbar, toolbar etc.
673 virtual bool IsClientAreaChild(const wxWindow
*WXUNUSED(child
)) const
676 // looking for windows
677 // -------------------
679 // find window among the descendants of this one either by id or by
680 // name (return NULL if not found)
681 wxWindow
*FindWindow(long winid
) const;
682 wxWindow
*FindWindow(const wxString
& name
) const;
684 // Find a window among any window (all return NULL if not found)
685 static wxWindow
*FindWindowById( long winid
, const wxWindow
*parent
= NULL
);
686 static wxWindow
*FindWindowByName( const wxString
& name
,
687 const wxWindow
*parent
= NULL
);
688 static wxWindow
*FindWindowByLabel( const wxString
& label
,
689 const wxWindow
*parent
= NULL
);
691 // event handler stuff
692 // -------------------
694 // get the current event handler
695 wxEvtHandler
*GetEventHandler() const { return m_eventHandler
; }
697 // replace the event handler (allows to completely subclass the
699 void SetEventHandler( wxEvtHandler
*handler
) { m_eventHandler
= handler
; }
701 // push/pop event handler: allows to chain a custom event handler to
702 // alreasy existing ones
703 void PushEventHandler( wxEvtHandler
*handler
);
704 wxEvtHandler
*PopEventHandler( bool deleteHandler
= false );
706 // find the given handler in the event handler chain and remove (but
707 // not delete) it from the event handler chain, return true if it was
708 // found and false otherwise (this also results in an assert failure so
709 // this function should only be called when the handler is supposed to
711 bool RemoveEventHandler(wxEvtHandler
*handler
);
717 // a window may have an associated validator which is used to control
719 virtual void SetValidator( const wxValidator
&validator
);
720 virtual wxValidator
*GetValidator() { return m_windowValidator
; }
721 #endif // wxUSE_VALIDATORS
724 // dialog oriented functions
725 // -------------------------
727 // validate the correctness of input, return true if ok
728 virtual bool Validate();
730 // transfer data between internal and GUI representations
731 virtual bool TransferDataToWindow();
732 virtual bool TransferDataFromWindow();
734 virtual void InitDialog();
739 virtual void SetAcceleratorTable( const wxAcceleratorTable
& accel
)
740 { m_acceleratorTable
= accel
; }
741 wxAcceleratorTable
*GetAcceleratorTable()
742 { return &m_acceleratorTable
; }
744 #endif // wxUSE_ACCEL
747 // hot keys (system wide accelerators)
748 // -----------------------------------
750 virtual bool RegisterHotKey(int hotkeyId
, int modifiers
, int keycode
);
751 virtual bool UnregisterHotKey(int hotkeyId
);
752 #endif // wxUSE_HOTKEY
755 // dialog units translations
756 // -------------------------
758 wxPoint
ConvertPixelsToDialog( const wxPoint
& pt
);
759 wxPoint
ConvertDialogToPixels( const wxPoint
& pt
);
760 wxSize
ConvertPixelsToDialog( const wxSize
& sz
)
762 wxPoint
pt(ConvertPixelsToDialog(wxPoint(sz
.x
, sz
.y
)));
764 return wxSize(pt
.x
, pt
.y
);
767 wxSize
ConvertDialogToPixels( const wxSize
& sz
)
769 wxPoint
pt(ConvertDialogToPixels(wxPoint(sz
.x
, sz
.y
)));
771 return wxSize(pt
.x
, pt
.y
);
777 // move the mouse to the specified position
778 virtual void WarpPointer(int x
, int y
) = 0;
780 // start or end mouse capture, these functions maintain the stack of
781 // windows having captured the mouse and after calling ReleaseMouse()
782 // the mouse is not released but returns to the window which had had
783 // captured it previously (if any)
787 // get the window which currently captures the mouse or NULL
788 static wxWindow
*GetCapture();
790 // does this window have the capture?
791 virtual bool HasCapture() const
792 { return (wxWindow
*)this == GetCapture(); }
794 // painting the window
795 // -------------------
797 // mark the specified rectangle (or the whole window) as "dirty" so it
799 virtual void Refresh( bool eraseBackground
= true,
800 const wxRect
*rect
= (const wxRect
*) NULL
) = 0;
802 // a less awkward wrapper for Refresh
803 void RefreshRect(const wxRect
& rect
, bool eraseBackground
= true)
805 Refresh(eraseBackground
, &rect
);
808 // repaint all invalid areas of the window immediately
809 virtual void Update() { }
811 // clear the window background
812 virtual void ClearBackground();
814 // freeze the window: don't redraw it until it is thawed
815 virtual void Freeze() { }
817 // thaw the window: redraw it after it had been frozen
818 virtual void Thaw() { }
820 // return true if window had been frozen and not unthawed yet
821 virtual bool IsFrozen() const { return false; }
823 // adjust DC for drawing on this window
824 virtual void PrepareDC( wxDC
& WXUNUSED(dc
) ) { }
826 // return true if the window contents is double buffered by the system
827 virtual bool IsDoubleBuffered() const { return false; }
829 // the update region of the window contains the areas which must be
830 // repainted by the program
831 const wxRegion
& GetUpdateRegion() const { return m_updateRegion
; }
832 wxRegion
& GetUpdateRegion() { return m_updateRegion
; }
834 // get the update rectangleregion bounding box in client coords
835 wxRect
GetUpdateClientRect() const;
837 // these functions verify whether the given point/rectangle belongs to
838 // (or at least intersects with) the update region
839 virtual bool DoIsExposed( int x
, int y
) const;
840 virtual bool DoIsExposed( int x
, int y
, int w
, int h
) const;
842 bool IsExposed( int x
, int y
) const
843 { return DoIsExposed(x
, y
); }
844 bool IsExposed( int x
, int y
, int w
, int h
) const
845 { return DoIsExposed(x
, y
, w
, h
); }
846 bool IsExposed( const wxPoint
& pt
) const
847 { return DoIsExposed(pt
.x
, pt
.y
); }
848 bool IsExposed( const wxRect
& rect
) const
849 { return DoIsExposed(rect
.x
, rect
.y
, rect
.width
, rect
.height
); }
851 // colours, fonts and cursors
852 // --------------------------
854 // get the default attributes for the controls of this class: we
855 // provide a virtual function which can be used to query the default
856 // attributes of an existing control and a static function which can
857 // be used even when no existing object of the given class is
858 // available, but which won't return any styles specific to this
859 // particular control, of course (e.g. "Ok" button might have
860 // different -- bold for example -- font)
861 virtual wxVisualAttributes
GetDefaultAttributes() const
863 return GetClassDefaultAttributes(GetWindowVariant());
866 static wxVisualAttributes
867 GetClassDefaultAttributes(wxWindowVariant variant
= wxWINDOW_VARIANT_NORMAL
);
869 // set/retrieve the window colours (system defaults are used by
870 // default): SetXXX() functions return true if colour was changed,
871 // SetDefaultXXX() reset the "m_inheritXXX" flag after setting the
872 // value to prevent it from being inherited by our children
873 virtual bool SetBackgroundColour(const wxColour
& colour
);
874 void SetOwnBackgroundColour(const wxColour
& colour
)
876 if ( SetBackgroundColour(colour
) )
877 m_inheritBgCol
= false;
879 wxColour
GetBackgroundColour() const;
880 bool InheritsBackgroundColour() const
882 return m_inheritBgCol
;
884 bool UseBgCol() const
889 virtual bool SetForegroundColour(const wxColour
& colour
);
890 void SetOwnForegroundColour(const wxColour
& colour
)
892 if ( SetForegroundColour(colour
) )
893 m_inheritFgCol
= false;
895 wxColour
GetForegroundColour() const;
897 // Set/get the background style.
898 // Pass one of wxBG_STYLE_SYSTEM, wxBG_STYLE_COLOUR, wxBG_STYLE_CUSTOM
899 virtual bool SetBackgroundStyle(wxBackgroundStyle style
) { m_backgroundStyle
= style
; return true; }
900 virtual wxBackgroundStyle
GetBackgroundStyle() const { return m_backgroundStyle
; }
902 // returns true if the control has "transparent" areas such as a
903 // wxStaticText and wxCheckBox and the background should be adapted
904 // from a parent window
905 virtual bool HasTransparentBackground() { return false; }
907 // set/retrieve the font for the window (SetFont() returns true if the
908 // font really changed)
909 virtual bool SetFont(const wxFont
& font
) = 0;
910 void SetOwnFont(const wxFont
& font
)
913 m_inheritFont
= false;
915 wxFont
GetFont() const;
917 // set/retrieve the cursor for this window (SetCursor() returns true
918 // if the cursor was really changed)
919 virtual bool SetCursor( const wxCursor
&cursor
);
920 const wxCursor
& GetCursor() const { return m_cursor
; }
923 // associate a caret with the window
924 void SetCaret(wxCaret
*caret
);
925 // get the current caret (may be NULL)
926 wxCaret
*GetCaret() const { return m_caret
; }
927 #endif // wxUSE_CARET
929 // get the (average) character size for the current font
930 virtual int GetCharHeight() const = 0;
931 virtual int GetCharWidth() const = 0;
933 // get the width/height/... of the text using current or specified
935 virtual void GetTextExtent(const wxString
& string
,
937 int *descent
= (int *) NULL
,
938 int *externalLeading
= (int *) NULL
,
939 const wxFont
*theFont
= (const wxFont
*) NULL
)
942 wxSize
GetTextExtent(const wxString
& string
) const
945 GetTextExtent(string
, &w
, &h
);
949 // client <-> screen coords
950 // ------------------------
952 // translate to/from screen/client coordinates (pointers may be NULL)
953 void ClientToScreen( int *x
, int *y
) const
954 { DoClientToScreen(x
, y
); }
955 void ScreenToClient( int *x
, int *y
) const
956 { DoScreenToClient(x
, y
); }
958 // wxPoint interface to do the same thing
959 wxPoint
ClientToScreen(const wxPoint
& pt
) const
961 int x
= pt
.x
, y
= pt
.y
;
962 DoClientToScreen(&x
, &y
);
964 return wxPoint(x
, y
);
967 wxPoint
ScreenToClient(const wxPoint
& pt
) const
969 int x
= pt
.x
, y
= pt
.y
;
970 DoScreenToClient(&x
, &y
);
972 return wxPoint(x
, y
);
975 // test where the given (in client coords) point lies
976 wxHitTest
HitTest(wxCoord x
, wxCoord y
) const
977 { return DoHitTest(x
, y
); }
979 wxHitTest
HitTest(const wxPoint
& pt
) const
980 { return DoHitTest(pt
.x
, pt
.y
); }
985 // get the window border style from the given flags: this is different from
986 // simply doing flags & wxBORDER_MASK because it uses GetDefaultBorder() to
987 // translate wxBORDER_DEFAULT to something reasonable
988 wxBorder
GetBorder(long flags
) const;
990 // get border for the flags of this window
991 wxBorder
GetBorder() const { return GetBorder(GetWindowStyleFlag()); }
993 // send wxUpdateUIEvents to this window, and children if recurse is true
994 virtual void UpdateWindowUI(long flags
= wxUPDATE_UI_NONE
);
996 // do the window-specific processing after processing the update event
997 virtual void DoUpdateWindowUI(wxUpdateUIEvent
& event
) ;
1000 // show popup menu at the given position, generate events for the items
1002 bool PopupMenu(wxMenu
*menu
, const wxPoint
& pos
= wxDefaultPosition
)
1003 { return DoPopupMenu(menu
, pos
.x
, pos
.y
); }
1004 bool PopupMenu(wxMenu
*menu
, int x
, int y
)
1005 { return DoPopupMenu(menu
, x
, y
); }
1007 // simply return the id of the selected item or wxID_NONE without
1008 // generating any events
1009 int GetPopupMenuSelectionFromUser(wxMenu
& menu
, const wxPoint
& pos
)
1010 { return DoGetPopupMenuSelectionFromUser(menu
, pos
.x
, pos
.y
); }
1011 int GetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
1012 { return DoGetPopupMenuSelectionFromUser(menu
, x
, y
); }
1013 #endif // wxUSE_MENUS
1015 // override this method to return true for controls having multiple pages
1016 virtual bool HasMultiplePages() const { return false; }
1022 // does the window have the scrollbar for this orientation?
1023 bool HasScrollbar(int orient
) const
1025 return (m_windowStyle
&
1026 (orient
== wxHORIZONTAL
? wxHSCROLL
: wxVSCROLL
)) != 0;
1029 // configure the window scrollbars
1030 virtual void SetScrollbar( int orient
,
1034 bool refresh
= true ) = 0;
1035 virtual void SetScrollPos( int orient
, int pos
, bool refresh
= true ) = 0;
1036 virtual int GetScrollPos( int orient
) const = 0;
1037 virtual int GetScrollThumb( int orient
) const = 0;
1038 virtual int GetScrollRange( int orient
) const = 0;
1040 // scroll window to the specified position
1041 virtual void ScrollWindow( int dx
, int dy
,
1042 const wxRect
* rect
= (wxRect
*) NULL
) = 0;
1044 // scrolls window by line/page: note that not all controls support this
1046 // return true if the position changed, false otherwise
1047 virtual bool ScrollLines(int WXUNUSED(lines
)) { return false; }
1048 virtual bool ScrollPages(int WXUNUSED(pages
)) { return false; }
1050 // convenient wrappers for ScrollLines/Pages
1051 bool LineUp() { return ScrollLines(-1); }
1052 bool LineDown() { return ScrollLines(1); }
1053 bool PageUp() { return ScrollPages(-1); }
1054 bool PageDown() { return ScrollPages(1); }
1056 // call this to always show one or both scrollbars, even if the window
1057 // is big enough to not require them
1058 virtual void AlwaysShowScrollbars(bool WXUNUSED(horz
) = true,
1059 bool WXUNUSED(vert
) = true)
1063 // return true if AlwaysShowScrollbars() had been called before for the
1064 // corresponding orientation
1065 virtual bool IsScrollbarAlwaysShown(int WXUNUSED(orient
)) const
1070 // context-sensitive help
1071 // ----------------------
1073 // these are the convenience functions wrapping wxHelpProvider methods
1076 // associate this help text with this window
1077 void SetHelpText(const wxString
& text
);
1078 // associate this help text with all windows with the same id as this
1080 void SetHelpTextForId(const wxString
& text
);
1081 // get the help string associated with the given position in this window
1083 // notice that pt may be invalid if event origin is keyboard or unknown
1084 // and this method should return the global window help text then
1085 virtual wxString
GetHelpTextAtPoint(const wxPoint
& pt
,
1086 wxHelpEvent::Origin origin
) const;
1087 // returns the position-independent help text
1088 wxString
GetHelpText() const
1090 return GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Unknown
);
1093 #else // !wxUSE_HELP
1094 // silently ignore SetHelpText() calls
1095 void SetHelpText(const wxString
& WXUNUSED(text
)) { }
1096 void SetHelpTextForId(const wxString
& WXUNUSED(text
)) { }
1097 #endif // wxUSE_HELP
1103 // the easiest way to set a tooltip for a window is to use this method
1104 void SetToolTip( const wxString
&tip
);
1105 // attach a tooltip to the window
1106 void SetToolTip( wxToolTip
*tip
) { DoSetToolTip(tip
); }
1107 // get the associated tooltip or NULL if none
1108 wxToolTip
* GetToolTip() const { return m_tooltip
; }
1109 wxString
GetToolTipText() const ;
1111 // make it much easier to compile apps in an environment
1112 // that doesn't support tooltips, such as PocketPC
1113 inline void SetToolTip( const wxString
& WXUNUSED(tip
) ) {}
1114 #endif // wxUSE_TOOLTIPS
1118 #if wxUSE_DRAG_AND_DROP
1119 // set/retrieve the drop target associated with this window (may be
1120 // NULL; it's owned by the window and will be deleted by it)
1121 virtual void SetDropTarget( wxDropTarget
*dropTarget
) = 0;
1122 virtual wxDropTarget
*GetDropTarget() const { return m_dropTarget
; }
1123 #endif // wxUSE_DRAG_AND_DROP
1125 // constraints and sizers
1126 // ----------------------
1127 #if wxUSE_CONSTRAINTS
1128 // set the constraints for this window or retrieve them (may be NULL)
1129 void SetConstraints( wxLayoutConstraints
*constraints
);
1130 wxLayoutConstraints
*GetConstraints() const { return m_constraints
; }
1132 // implementation only
1133 void UnsetConstraints(wxLayoutConstraints
*c
);
1134 wxWindowList
*GetConstraintsInvolvedIn() const
1135 { return m_constraintsInvolvedIn
; }
1136 void AddConstraintReference(wxWindowBase
*otherWin
);
1137 void RemoveConstraintReference(wxWindowBase
*otherWin
);
1138 void DeleteRelatedConstraints();
1139 void ResetConstraints();
1141 // these methods may be overridden for special layout algorithms
1142 virtual void SetConstraintSizes(bool recurse
= true);
1143 virtual bool LayoutPhase1(int *noChanges
);
1144 virtual bool LayoutPhase2(int *noChanges
);
1145 virtual bool DoPhase(int phase
);
1147 // these methods are virtual but normally won't be overridden
1148 virtual void SetSizeConstraint(int x
, int y
, int w
, int h
);
1149 virtual void MoveConstraint(int x
, int y
);
1150 virtual void GetSizeConstraint(int *w
, int *h
) const ;
1151 virtual void GetClientSizeConstraint(int *w
, int *h
) const ;
1152 virtual void GetPositionConstraint(int *x
, int *y
) const ;
1154 #endif // wxUSE_CONSTRAINTS
1156 // when using constraints or sizers, it makes sense to update
1157 // children positions automatically whenever the window is resized
1158 // - this is done if autoLayout is on
1159 void SetAutoLayout( bool autoLayout
) { m_autoLayout
= autoLayout
; }
1160 bool GetAutoLayout() const { return m_autoLayout
; }
1162 // lay out the window and its children
1163 virtual bool Layout();
1166 void SetSizer(wxSizer
*sizer
, bool deleteOld
= true );
1167 void SetSizerAndFit( wxSizer
*sizer
, bool deleteOld
= true );
1169 wxSizer
*GetSizer() const { return m_windowSizer
; }
1171 // Track if this window is a member of a sizer
1172 void SetContainingSizer(wxSizer
* sizer
);
1173 wxSizer
*GetContainingSizer() const { return m_containingSizer
; }
1176 // ----------------------
1177 #if wxUSE_ACCESSIBILITY
1178 // Override to create a specific accessible object.
1179 virtual wxAccessible
* CreateAccessible();
1181 // Sets the accessible object.
1182 void SetAccessible(wxAccessible
* accessible
) ;
1184 // Returns the accessible object.
1185 wxAccessible
* GetAccessible() { return m_accessible
; }
1187 // Returns the accessible object, creating if necessary.
1188 wxAccessible
* GetOrCreateAccessible() ;
1192 // Set window transparency if the platform supports it
1193 virtual bool SetTransparent(wxByte
WXUNUSED(alpha
)) { return false; }
1194 virtual bool CanSetTransparent() { return false; }
1201 void OnSysColourChanged( wxSysColourChangedEvent
& event
);
1202 void OnInitDialog( wxInitDialogEvent
&event
);
1203 void OnMiddleClick( wxMouseEvent
& event
);
1205 void OnHelp(wxHelpEvent
& event
);
1206 #endif // wxUSE_HELP
1208 // virtual function for implementing internal idle
1210 virtual void OnInternalIdle() {}
1212 // call internal idle recursively
1213 // void ProcessInternalIdle() ;
1215 // get the handle of the window for the underlying window system: this
1216 // is only used for wxWin itself or for user code which wants to call
1217 // platform-specific APIs
1218 virtual WXWidget
GetHandle() const = 0;
1219 // associate the window with a new native handle
1220 virtual void AssociateHandle(WXWidget
WXUNUSED(handle
)) { }
1221 // dissociate the current native handle from the window
1222 virtual void DissociateHandle() { }
1225 // Store the palette used by DCs in wxWindow so that the dcs can share
1226 // a palette. And we can respond to palette messages.
1227 wxPalette
GetPalette() const { return m_palette
; }
1229 // When palette is changed tell the DC to set the system palette to the
1231 void SetPalette(const wxPalette
& pal
);
1233 // return true if we have a specific palette
1234 bool HasCustomPalette() const { return m_hasCustomPalette
; }
1236 // return the first parent window with a custom palette or NULL
1237 wxWindow
*GetAncestorWithCustomPalette() const;
1238 #endif // wxUSE_PALETTE
1240 // inherit the parents visual attributes if they had been explicitly set
1241 // by the user (i.e. we don't inherit default attributes) and if we don't
1242 // have our own explicitly set
1243 virtual void InheritAttributes();
1245 // returns false from here if this window doesn't want to inherit the
1246 // parents colours even if InheritAttributes() would normally do it
1248 // this just provides a simple way to customize InheritAttributes()
1249 // behaviour in the most common case
1250 virtual bool ShouldInheritColours() const { return false; }
1252 // returns true if the window can be positioned outside of parent's client
1253 // area (normal windows can't, but e.g. menubar or statusbar can):
1254 virtual bool CanBeOutsideClientArea() const { return false; }
1256 // returns true if the platform should explicitly apply a theme border. Currently
1257 // used only by Windows
1258 virtual bool CanApplyThemeBorder() const { return true; }
1261 // event handling specific to wxWindow
1262 virtual bool TryValidator(wxEvent
& event
);
1263 virtual bool TryParent(wxEvent
& event
);
1267 OrderBefore
, // insert before the given window
1268 OrderAfter
// insert after the given window
1271 // common part of GetPrev/NextSibling()
1272 wxWindow
*DoGetSibling(WindowOrder order
) const;
1274 // common part of MoveBefore/AfterInTabOrder()
1275 virtual void DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
);
1277 // implementation of Navigate() and NavigateIn()
1278 virtual bool DoNavigateIn(int flags
);
1280 #if wxUSE_CONSTRAINTS
1281 // satisfy the constraints for the windows but don't set the window sizes
1282 void SatisfyConstraints();
1283 #endif // wxUSE_CONSTRAINTS
1285 // Send the wxWindowDestroyEvent
1286 void SendDestroyEvent();
1288 // returns the main window of composite control; this is the window
1289 // that FindFocus returns if the focus is in one of composite control's
1291 virtual wxWindow
*GetMainWindowOfCompositeControl()
1292 { return (wxWindow
*)this; }
1294 // this method should be implemented to use operating system specific code
1295 // to really enable/disable the widget, it will only be called when we
1296 // really need to enable/disable window and so no additional checks on the
1297 // widgets state are necessary
1298 virtual void DoEnable(bool WXUNUSED(enable
)) { }
1300 // called when the on-screen widget state changes and provides an
1301 // an opportunity for the widget to update its visual state (colours,
1302 // fonts, anything else) as necessary
1303 virtual void OnEnabled(bool WXUNUSED(enabled
)) { }
1306 // the window id - a number which uniquely identifies a window among
1307 // its siblings unless it is wxID_ANY
1308 wxWindowID m_windowId
;
1310 // the parent window of this window (or NULL) and the list of the children
1313 wxWindowList m_children
;
1315 // the minimal allowed size for the window (no minimal size if variable(s)
1316 // contain(s) wxDefaultCoord)
1322 // event handler for this window: usually is just 'this' but may be
1323 // changed with SetEventHandler()
1324 wxEvtHandler
*m_eventHandler
;
1326 #if wxUSE_VALIDATORS
1327 // associated validator or NULL if none
1328 wxValidator
*m_windowValidator
;
1329 #endif // wxUSE_VALIDATORS
1331 #if wxUSE_DRAG_AND_DROP
1332 wxDropTarget
*m_dropTarget
;
1333 #endif // wxUSE_DRAG_AND_DROP
1335 // visual window attributes
1337 wxFont m_font
; // see m_hasFont
1338 wxColour m_backgroundColour
, // m_hasBgCol
1339 m_foregroundColour
; // m_hasFgCol
1343 #endif // wxUSE_CARET
1345 // the region which should be repainted in response to paint event
1346 wxRegion m_updateRegion
;
1349 // the accelerator table for the window which translates key strokes into
1351 wxAcceleratorTable m_acceleratorTable
;
1352 #endif // wxUSE_ACCEL
1354 // the tooltip for this window (may be NULL)
1356 wxToolTip
*m_tooltip
;
1357 #endif // wxUSE_TOOLTIPS
1359 // constraints and sizers
1360 #if wxUSE_CONSTRAINTS
1361 // the constraints for this window or NULL
1362 wxLayoutConstraints
*m_constraints
;
1364 // constraints this window is involved in
1365 wxWindowList
*m_constraintsInvolvedIn
;
1366 #endif // wxUSE_CONSTRAINTS
1368 // this window's sizer
1369 wxSizer
*m_windowSizer
;
1371 // The sizer this window is a member of, if any
1372 wxSizer
*m_containingSizer
;
1374 // Layout() window automatically when its size changes?
1375 bool m_autoLayout
:1;
1377 // true if we had automatically allocated the id value for this window
1378 // (i.e. wxID_ANY had been passed to the ctor)
1384 bool m_isBeingDeleted
:1;
1386 // was the window colours/font explicitly changed by user?
1391 // and should it be inherited by children?
1392 bool m_inheritBgCol
:1;
1393 bool m_inheritFgCol
:1;
1394 bool m_inheritFont
:1;
1396 // window attributes
1399 wxString m_windowName
;
1400 bool m_themeEnabled
;
1401 wxBackgroundStyle m_backgroundStyle
;
1403 wxPalette m_palette
;
1404 bool m_hasCustomPalette
;
1405 #endif // wxUSE_PALETTE
1407 #if wxUSE_ACCESSIBILITY
1408 wxAccessible
* m_accessible
;
1411 // Virtual size (scrolling)
1412 wxSize m_virtualSize
;
1414 wxScrollHelper
*m_scrollHelper
;
1416 int m_minVirtualWidth
; // VirtualSizeHints
1417 int m_minVirtualHeight
;
1418 int m_maxVirtualWidth
;
1419 int m_maxVirtualHeight
;
1421 wxWindowVariant m_windowVariant
;
1423 // override this to change the default (i.e. used when no style is
1424 // specified) border for the window class
1425 virtual wxBorder
GetDefaultBorder() const;
1427 // this allows you to implement standard control borders without
1428 // repeating the code in different classes that are not derived from
1430 virtual wxBorder
GetDefaultBorderForControl() const { return wxBORDER_THEME
; }
1432 // Get the default size for the new window if no explicit size given. TLWs
1433 // have their own default size so this is just for non top-level windows.
1434 static int WidthDefault(int w
) { return w
== wxDefaultCoord
? 20 : w
; }
1435 static int HeightDefault(int h
) { return h
== wxDefaultCoord
? 20 : h
; }
1438 // Used to save the results of DoGetBestSize so it doesn't need to be
1439 // recalculated each time the value is needed.
1440 wxSize m_bestSizeCache
;
1442 wxDEPRECATED( void SetBestSize(const wxSize
& size
) ); // use SetInitialSize
1443 wxDEPRECATED( virtual void SetInitialBestSize(const wxSize
& size
) ); // use SetInitialSize
1447 // more pure virtual functions
1448 // ---------------------------
1450 // NB: we must have DoSomething() function when Something() is an overloaded
1451 // method: indeed, we can't just have "virtual Something()" in case when
1452 // the function is overloaded because then we'd have to make virtual all
1453 // the variants (otherwise only the virtual function may be called on a
1454 // pointer to derived class according to C++ rules) which is, in
1455 // general, absolutely not needed. So instead we implement all
1456 // overloaded Something()s in terms of DoSomething() which will be the
1457 // only one to be virtual.
1459 // coordinates translation
1460 virtual void DoClientToScreen( int *x
, int *y
) const = 0;
1461 virtual void DoScreenToClient( int *x
, int *y
) const = 0;
1463 virtual wxHitTest
DoHitTest(wxCoord x
, wxCoord y
) const;
1465 // capture/release the mouse, used by Capture/ReleaseMouse()
1466 virtual void DoCaptureMouse() = 0;
1467 virtual void DoReleaseMouse() = 0;
1469 // retrieve the position/size of the window
1470 virtual void DoGetPosition(int *x
, int *y
) const = 0;
1471 virtual void DoGetScreenPosition(int *x
, int *y
) const;
1472 virtual void DoGetSize(int *width
, int *height
) const = 0;
1473 virtual void DoGetClientSize(int *width
, int *height
) const = 0;
1475 // get the size which best suits the window: for a control, it would be
1476 // the minimal size which doesn't truncate the control, for a panel - the
1477 // same size as it would have after a call to Fit()
1478 virtual wxSize
DoGetBestSize() const;
1480 // called from DoGetBestSize() to convert best virtual size (returned by
1481 // the window sizer) to the best size for the window itself; this is
1482 // overridden at wxScrolledWindow level to clump down virtual size to real
1483 virtual wxSize
GetWindowSizeForVirtualSize(const wxSize
& size
) const
1488 // this is the virtual function to be overriden in any derived class which
1489 // wants to change how SetSize() or Move() works - it is called by all
1490 // versions of these functions in the base class
1491 virtual void DoSetSize(int x
, int y
,
1492 int width
, int height
,
1493 int sizeFlags
= wxSIZE_AUTO
) = 0;
1495 // same as DoSetSize() for the client size
1496 virtual void DoSetClientSize(int width
, int height
) = 0;
1498 // move the window to the specified location and resize it: this is called
1499 // from both DoSetSize() and DoSetClientSize() and would usually just
1500 // reposition this window except for composite controls which will want to
1501 // arrange themselves inside the given rectangle
1503 // Important note: the coordinates passed to this method are in parent's
1504 // *window* coordinates and not parent's client coordinates (as the values
1505 // passed to DoSetSize and returned by DoGetPosition are)!
1506 virtual void DoMoveWindow(int x
, int y
, int width
, int height
) = 0;
1508 // centre the window in the specified direction on parent, note that
1509 // wxCENTRE_ON_SCREEN shouldn't be specified here, it only makes sense for
1511 virtual void DoCentre(int dir
);
1514 virtual void DoSetToolTip( wxToolTip
*tip
);
1515 #endif // wxUSE_TOOLTIPS
1518 virtual bool DoPopupMenu(wxMenu
*menu
, int x
, int y
) = 0;
1519 #endif // wxUSE_MENUS
1521 // Makes an adjustment to the window position to make it relative to the
1522 // parents client area, e.g. if the parent is a frame with a toolbar, its
1523 // (0, 0) is just below the toolbar
1524 virtual void AdjustForParentClientOrigin(int& x
, int& y
,
1525 int sizeFlags
= 0) const;
1527 // implements the window variants
1528 virtual void DoSetWindowVariant( wxWindowVariant variant
) ;
1530 // Must be called when mouse capture is lost to send
1531 // wxMouseCaptureLostEvent to windows on capture stack.
1532 static void NotifyCaptureLost();
1535 // recursively call our own and our children OnEnabled() when the
1536 // enabled/disabled status changed because a parent window had been
1538 void NotifyWindowOnEnableChange(bool enabled
);
1541 // temporary event handler used by GetPopupMenuSelectionFromUser()
1542 void InternalOnPopupMenu(wxCommandEvent
& event
);
1544 // implementation of the public GetPopupMenuSelectionFromUser() method
1545 int DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
);
1546 #endif // wxUSE_MENUS
1548 // the stack of windows which have captured the mouse
1549 static struct WXDLLIMPEXP_FWD_CORE wxWindowNext
*ms_winCaptureNext
;
1550 // the window that currently has mouse capture
1551 static wxWindow
*ms_winCaptureCurrent
;
1552 // indicates if execution is inside CaptureMouse/ReleaseMouse
1553 static bool ms_winCaptureChanging
;
1555 DECLARE_ABSTRACT_CLASS(wxWindowBase
)
1556 DECLARE_NO_COPY_CLASS(wxWindowBase
)
1557 DECLARE_EVENT_TABLE()
1562 // Inlines for some deprecated methods
1563 inline wxSize
wxWindowBase::GetBestFittingSize() const
1565 return GetEffectiveMinSize();
1568 inline void wxWindowBase::SetBestFittingSize(const wxSize
& size
)
1570 SetInitialSize(size
);
1573 inline void wxWindowBase::SetBestSize(const wxSize
& size
)
1575 SetInitialSize(size
);
1578 inline void wxWindowBase::SetInitialBestSize(const wxSize
& size
)
1580 SetInitialSize(size
);
1584 // ----------------------------------------------------------------------------
1585 // now include the declaration of wxWindow class
1586 // ----------------------------------------------------------------------------
1588 // include the declaration of the platform-specific class
1589 #if defined(__WXPALMOS__)
1590 #ifdef __WXUNIVERSAL__
1591 #define wxWindowNative wxWindowPalm
1593 #define wxWindowPalm wxWindow
1594 #endif // wxUniv/!wxUniv
1595 #include "wx/palmos/window.h"
1596 #elif defined(__WXMSW__)
1597 #ifdef __WXUNIVERSAL__
1598 #define wxWindowNative wxWindowMSW
1600 #define wxWindowMSW wxWindow
1601 #endif // wxUniv/!wxUniv
1602 #include "wx/msw/window.h"
1603 #elif defined(__WXMOTIF__)
1604 #include "wx/motif/window.h"
1605 #elif defined(__WXGTK20__)
1606 #ifdef __WXUNIVERSAL__
1607 #define wxWindowNative wxWindowGTK
1609 #define wxWindowGTK wxWindow
1611 #include "wx/gtk/window.h"
1612 #elif defined(__WXGTK__)
1613 #ifdef __WXUNIVERSAL__
1614 #define wxWindowNative wxWindowGTK
1616 #define wxWindowGTK wxWindow
1618 #include "wx/gtk1/window.h"
1619 #elif defined(__WXX11__)
1620 #ifdef __WXUNIVERSAL__
1621 #define wxWindowNative wxWindowX11
1623 #define wxWindowX11 wxWindow
1625 #include "wx/x11/window.h"
1626 #elif defined(__WXMGL__)
1627 #define wxWindowNative wxWindowMGL
1628 #include "wx/mgl/window.h"
1629 #elif defined(__WXDFB__)
1630 #define wxWindowNative wxWindowDFB
1631 #include "wx/dfb/window.h"
1632 #elif defined(__WXMAC__)
1633 #ifdef __WXUNIVERSAL__
1634 #define wxWindowNative wxWindowMac
1636 #define wxWindowMac wxWindow
1638 #include "wx/mac/window.h"
1639 #elif defined(__WXCOCOA__)
1640 #ifdef __WXUNIVERSAL__
1641 #define wxWindowNative wxWindowCocoa
1643 #define wxWindowCocoa wxWindow
1645 #include "wx/cocoa/window.h"
1646 #elif defined(__WXPM__)
1647 #ifdef __WXUNIVERSAL__
1648 #define wxWindowNative wxWindowOS2
1650 #define wxWindowOS2 wxWindow
1651 #endif // wxUniv/!wxUniv
1652 #include "wx/os2/window.h"
1655 // for wxUniversal, we now derive the real wxWindow from wxWindow<platform>,
1656 // for the native ports we already have defined it above
1657 #if defined(__WXUNIVERSAL__)
1658 #ifndef wxWindowNative
1659 #error "wxWindowNative must be defined above!"
1662 #include "wx/univ/window.h"
1665 // ----------------------------------------------------------------------------
1666 // inline functions which couldn't be declared in the class body because of
1667 // forward dependencies
1668 // ----------------------------------------------------------------------------
1670 inline wxWindow
*wxWindowBase::GetGrandParent() const
1672 return m_parent
? m_parent
->GetParent() : (wxWindow
*)NULL
;
1675 // ----------------------------------------------------------------------------
1677 // ----------------------------------------------------------------------------
1679 // Find the wxWindow at the current mouse position, also returning the mouse
1681 extern WXDLLEXPORT wxWindow
* wxFindWindowAtPointer(wxPoint
& pt
);
1683 // Get the current mouse position.
1684 extern WXDLLEXPORT wxPoint
wxGetMousePosition();
1686 // get the currently active window of this application or NULL
1687 extern WXDLLEXPORT wxWindow
*wxGetActiveWindow();
1689 // get the (first) top level parent window
1690 WXDLLEXPORT wxWindow
* wxGetTopLevelParent(wxWindow
*win
);
1692 #if WXWIN_COMPATIBILITY_2_6
1693 // deprecated (doesn't start with 'wx' prefix), use wxWindow::NewControlId()
1694 wxDEPRECATED( int NewControlId() );
1695 inline int NewControlId() { return wxWindowBase::NewControlId(); }
1696 #endif // WXWIN_COMPATIBILITY_2_6
1698 #if wxUSE_ACCESSIBILITY
1699 // ----------------------------------------------------------------------------
1700 // accessible object for windows
1701 // ----------------------------------------------------------------------------
1703 class WXDLLEXPORT wxWindowAccessible
: public wxAccessible
1706 wxWindowAccessible(wxWindow
* win
): wxAccessible(win
) { if (win
) win
->SetAccessible(this); }
1707 virtual ~wxWindowAccessible() {}
1711 // Can return either a child object, or an integer
1712 // representing the child element, starting from 1.
1713 virtual wxAccStatus
HitTest(const wxPoint
& pt
, int* childId
, wxAccessible
** childObject
);
1715 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
1716 virtual wxAccStatus
GetLocation(wxRect
& rect
, int elementId
);
1718 // Navigates from fromId to toId/toObject.
1719 virtual wxAccStatus
Navigate(wxNavDir navDir
, int fromId
,
1720 int* toId
, wxAccessible
** toObject
);
1722 // Gets the name of the specified object.
1723 virtual wxAccStatus
GetName(int childId
, wxString
* name
);
1725 // Gets the number of children.
1726 virtual wxAccStatus
GetChildCount(int* childCount
);
1728 // Gets the specified child (starting from 1).
1729 // If *child is NULL and return value is wxACC_OK,
1730 // this means that the child is a simple element and
1731 // not an accessible object.
1732 virtual wxAccStatus
GetChild(int childId
, wxAccessible
** child
);
1734 // Gets the parent, or NULL.
1735 virtual wxAccStatus
GetParent(wxAccessible
** parent
);
1737 // Performs the default action. childId is 0 (the action for this object)
1738 // or > 0 (the action for a child).
1739 // Return wxACC_NOT_SUPPORTED if there is no default action for this
1740 // window (e.g. an edit control).
1741 virtual wxAccStatus
DoDefaultAction(int childId
);
1743 // Gets the default action for this object (0) or > 0 (the action for a child).
1744 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
1745 // string if there is no action.
1746 // The retrieved string describes the action that is performed on an object,
1747 // not what the object does as a result. For example, a toolbar button that prints
1748 // a document has a default action of "Press" rather than "Prints the current document."
1749 virtual wxAccStatus
GetDefaultAction(int childId
, wxString
* actionName
);
1751 // Returns the description for this object or a child.
1752 virtual wxAccStatus
GetDescription(int childId
, wxString
* description
);
1754 // Returns help text for this object or a child, similar to tooltip text.
1755 virtual wxAccStatus
GetHelpText(int childId
, wxString
* helpText
);
1757 // Returns the keyboard shortcut for this object or child.
1758 // Return e.g. ALT+K
1759 virtual wxAccStatus
GetKeyboardShortcut(int childId
, wxString
* shortcut
);
1761 // Returns a role constant.
1762 virtual wxAccStatus
GetRole(int childId
, wxAccRole
* role
);
1764 // Returns a state constant.
1765 virtual wxAccStatus
GetState(int childId
, long* state
);
1767 // Returns a localized string representing the value for the object
1769 virtual wxAccStatus
GetValue(int childId
, wxString
* strValue
);
1771 // Selects the object or child.
1772 virtual wxAccStatus
Select(int childId
, wxAccSelectionFlags selectFlags
);
1774 // Gets the window with the keyboard focus.
1775 // If childId is 0 and child is NULL, no object in
1776 // this subhierarchy has the focus.
1777 // If this object has the focus, child should be 'this'.
1778 virtual wxAccStatus
GetFocus(int* childId
, wxAccessible
** child
);
1781 // Gets a variant representing the selected children
1783 // Acceptable values:
1784 // - a null variant (IsNull() returns true)
1785 // - a list variant (GetType() == wxT("list")
1786 // - an integer representing the selected child element,
1787 // or 0 if this object is selected (GetType() == wxT("long")
1788 // - a "void*" pointer to a wxAccessible child object
1789 virtual wxAccStatus
GetSelections(wxVariant
* selections
);
1790 #endif // wxUSE_VARIANT
1793 #endif // wxUSE_ACCESSIBILITY
1796 #endif // _WX_WINDOW_H_BASE_