1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/window.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
28 #include "wx/string.h"
32 #include "wx/window.h"
33 #include "wx/control.h"
34 #include "wx/checkbox.h"
35 #include "wx/radiobut.h"
36 #include "wx/statbox.h"
37 #include "wx/textctrl.h"
38 #include "wx/settings.h"
39 #include "wx/dialog.h"
40 #include "wx/msgdlg.h"
41 #include "wx/msgout.h"
42 #include "wx/statusbr.h"
43 #include "wx/toolbar.h"
44 #include "wx/dcclient.h"
45 #include "wx/scrolbar.h"
46 #include "wx/layout.h"
51 #if wxUSE_DRAG_AND_DROP
53 #endif // wxUSE_DRAG_AND_DROP
55 #if wxUSE_ACCESSIBILITY
56 #include "wx/access.h"
60 #include "wx/cshelp.h"
64 #include "wx/tooltip.h"
65 #endif // wxUSE_TOOLTIPS
71 #if wxUSE_SYSTEM_OPTIONS
72 #include "wx/sysopt.h"
75 #include "wx/platinfo.h"
76 #include "wx/private/window.h"
79 #include "wx/msw/wrapwin.h"
83 WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
87 wxMenu
*wxCurrentPopupMenu
= NULL
;
90 // ----------------------------------------------------------------------------
92 // ----------------------------------------------------------------------------
95 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
97 // ----------------------------------------------------------------------------
99 // ----------------------------------------------------------------------------
101 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
102 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
103 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
104 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
107 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
110 EVT_SIZE(wxWindowBase::InternalOnSize
)
113 // ============================================================================
114 // implementation of the common functionality of the wxWindow class
115 // ============================================================================
117 // ----------------------------------------------------------------------------
119 // ----------------------------------------------------------------------------
121 // the default initialization
122 wxWindowBase::wxWindowBase()
124 // no window yet, no parent nor children
126 m_windowId
= wxID_ANY
;
128 // no constraints on the minimal window size
130 m_maxWidth
= wxDefaultCoord
;
132 m_maxHeight
= wxDefaultCoord
;
134 // invalidiated cache value
135 m_bestSizeCache
= wxDefaultSize
;
137 // window are created enabled and visible by default
141 // the default event handler is just this window
142 m_eventHandler
= this;
146 m_windowValidator
= NULL
;
147 #endif // wxUSE_VALIDATORS
149 // the colours/fonts are default for now, so leave m_font,
150 // m_backgroundColour and m_foregroundColour uninitialized and set those
156 m_inheritFont
= false;
162 m_backgroundStyle
= wxBG_STYLE_ERASE
;
164 #if wxUSE_CONSTRAINTS
165 // no constraints whatsoever
166 m_constraints
= NULL
;
167 m_constraintsInvolvedIn
= NULL
;
168 #endif // wxUSE_CONSTRAINTS
170 m_windowSizer
= NULL
;
171 m_containingSizer
= NULL
;
172 m_autoLayout
= false;
174 #if wxUSE_DRAG_AND_DROP
176 #endif // wxUSE_DRAG_AND_DROP
180 #endif // wxUSE_TOOLTIPS
184 #endif // wxUSE_CARET
187 m_hasCustomPalette
= false;
188 #endif // wxUSE_PALETTE
190 #if wxUSE_ACCESSIBILITY
194 m_virtualSize
= wxDefaultSize
;
196 m_scrollHelper
= NULL
;
198 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
199 #if wxUSE_SYSTEM_OPTIONS
200 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
202 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
206 // Whether we're using the current theme for this window (wxGTK only for now)
207 m_themeEnabled
= false;
209 // This is set to true by SendDestroyEvent() which should be called by the
210 // most derived class to ensure that the destruction event is sent as soon
211 // as possible to allow its handlers to still see the undestroyed window
212 m_isBeingDeleted
= false;
217 // common part of window creation process
218 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
220 const wxPoint
& WXUNUSED(pos
),
223 const wxString
& name
)
225 // ids are limited to 16 bits under MSW so if you care about portability,
226 // it's not a good idea to use ids out of this range (and negative ids are
227 // reserved for wxWidgets own usage)
228 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767) ||
229 (id
>= wxID_AUTO_LOWEST
&& id
<= wxID_AUTO_HIGHEST
),
230 wxT("invalid id value") );
232 // generate a new id if the user doesn't care about it
233 if ( id
== wxID_ANY
)
235 m_windowId
= NewControlId();
237 else // valid id specified
242 // don't use SetWindowStyleFlag() here, this function should only be called
243 // to change the flag after creation as it tries to reflect the changes in
244 // flags by updating the window dynamically and we don't need this here
245 m_windowStyle
= style
;
247 // assume the user doesn't want this window to shrink beneath its initial
248 // size, this worked like this in wxWidgets 2.8 and before and generally
249 // often makes sense for child windows (for top level ones it definitely
250 // does not as the user should be able to resize the window)
252 // note that we can't use IsTopLevel() from ctor
253 if ( size
!= wxDefaultSize
&& !wxTopLevelWindows
.Find((wxWindow
*)this) )
262 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
267 const wxValidator
& wxVALIDATOR_PARAM(validator
),
268 const wxString
& name
)
270 if ( !CreateBase(parent
, id
, pos
, size
, style
, name
) )
274 SetValidator(validator
);
275 #endif // wxUSE_VALIDATORS
277 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
278 // have it too - like this it's possible to set it only in the top level
279 // dialog/frame and all children will inherit it by defult
280 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
282 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
288 bool wxWindowBase::ToggleWindowStyle(int flag
)
290 wxASSERT_MSG( flag
, wxT("flags with 0 value can't be toggled") );
293 long style
= GetWindowStyleFlag();
299 else // currently off
305 SetWindowStyleFlag(style
);
310 // ----------------------------------------------------------------------------
312 // ----------------------------------------------------------------------------
315 wxWindowBase::~wxWindowBase()
317 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
319 // FIXME if these 2 cases result from programming errors in the user code
320 // we should probably assert here instead of silently fixing them
322 // Just in case the window has been Closed, but we're then deleting
323 // immediately: don't leave dangling pointers.
324 wxPendingDelete
.DeleteObject(this);
326 // Just in case we've loaded a top-level window via LoadNativeDialog but
327 // we weren't a dialog class
328 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
330 // Any additional event handlers should be popped before the window is
331 // deleted as otherwise the last handler will be left with a dangling
332 // pointer to this window result in a difficult to diagnose crash later on.
333 wxASSERT_MSG( GetEventHandler() == this,
334 wxT("any pushed event handlers must have been removed") );
337 // The associated popup menu can still be alive, disassociate from it in
339 if ( wxCurrentPopupMenu
&& wxCurrentPopupMenu
->GetInvokingWindow() == this )
340 wxCurrentPopupMenu
->SetInvokingWindow(NULL
);
341 #endif // wxUSE_MENUS
343 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
345 // notify the parent about this window destruction
347 m_parent
->RemoveChild(this);
351 #endif // wxUSE_CARET
354 delete m_windowValidator
;
355 #endif // wxUSE_VALIDATORS
357 #if wxUSE_CONSTRAINTS
358 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
359 // at deleted windows as they delete themselves.
360 DeleteRelatedConstraints();
364 // This removes any dangling pointers to this window in other windows'
365 // constraintsInvolvedIn lists.
366 UnsetConstraints(m_constraints
);
367 wxDELETE(m_constraints
);
369 #endif // wxUSE_CONSTRAINTS
371 if ( m_containingSizer
)
372 m_containingSizer
->Detach( (wxWindow
*)this );
374 delete m_windowSizer
;
376 #if wxUSE_DRAG_AND_DROP
378 #endif // wxUSE_DRAG_AND_DROP
382 #endif // wxUSE_TOOLTIPS
384 #if wxUSE_ACCESSIBILITY
389 // NB: this has to be called unconditionally, because we don't know
390 // whether this window has associated help text or not
391 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
393 helpProvider
->RemoveHelp(this);
397 bool wxWindowBase::IsBeingDeleted() const
399 return m_isBeingDeleted
||
400 (!IsTopLevel() && m_parent
&& m_parent
->IsBeingDeleted());
403 void wxWindowBase::SendDestroyEvent()
405 if ( m_isBeingDeleted
)
407 // we could have been already called from a more derived class dtor,
408 // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call
409 // should be simply ignored
413 m_isBeingDeleted
= true;
415 wxWindowDestroyEvent event
;
416 event
.SetEventObject(this);
417 event
.SetId(GetId());
418 GetEventHandler()->ProcessEvent(event
);
421 bool wxWindowBase::Destroy()
430 bool wxWindowBase::Close(bool force
)
432 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
433 event
.SetEventObject(this);
434 event
.SetCanVeto(!force
);
436 // return false if window wasn't closed because the application vetoed the
438 return HandleWindowEvent(event
) && !event
.GetVeto();
441 bool wxWindowBase::DestroyChildren()
443 wxWindowList::compatibility_iterator node
;
446 // we iterate until the list becomes empty
447 node
= GetChildren().GetFirst();
451 wxWindow
*child
= node
->GetData();
453 // note that we really want to delete it immediately so don't call the
454 // possible overridden Destroy() version which might not delete the
455 // child immediately resulting in problems with our (top level) child
456 // outliving its parent
457 child
->wxWindowBase::Destroy();
459 wxASSERT_MSG( !GetChildren().Find(child
),
460 wxT("child didn't remove itself using RemoveChild()") );
466 // ----------------------------------------------------------------------------
467 // size/position related methods
468 // ----------------------------------------------------------------------------
470 // centre the window with respect to its parent in either (or both) directions
471 void wxWindowBase::DoCentre(int dir
)
473 wxCHECK_RET( !(dir
& wxCENTRE_ON_SCREEN
) && GetParent(),
474 wxT("this method only implements centering child windows") );
476 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir
));
479 // fits the window around the children
480 void wxWindowBase::Fit()
482 if ( !GetChildren().empty() )
484 SetSize(GetBestSize());
486 //else: do nothing if we have no children
489 // fits virtual size (ie. scrolled area etc.) around children
490 void wxWindowBase::FitInside()
492 if ( GetChildren().GetCount() > 0 )
494 SetVirtualSize( GetBestVirtualSize() );
498 // On Mac, scrollbars are explicitly children.
499 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
500 static bool wxHasRealChildren(const wxWindowBase
* win
)
502 int realChildCount
= 0;
504 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
506 node
= node
->GetNext() )
508 wxWindow
*win
= node
->GetData();
509 if ( !win
->IsTopLevel() && win
->IsShown()
511 && !win
->IsKindOf(CLASSINFO(wxScrollBar
))
516 return (realChildCount
> 0);
520 void wxWindowBase::InvalidateBestSize()
522 m_bestSizeCache
= wxDefaultSize
;
524 // parent's best size calculation may depend on its children's
525 // as long as child window we are in is not top level window itself
526 // (because the TLW size is never resized automatically)
527 // so let's invalidate it as well to be safe:
528 if (m_parent
&& !IsTopLevel())
529 m_parent
->InvalidateBestSize();
532 // return the size best suited for the current window
533 wxSize
wxWindowBase::DoGetBestSize() const
539 best
= m_windowSizer
->GetMinSize();
541 #if wxUSE_CONSTRAINTS
542 else if ( m_constraints
)
544 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
546 // our minimal acceptable size is such that all our windows fit inside
550 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
552 node
= node
->GetNext() )
554 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
557 // it's not normal that we have an unconstrained child, but
558 // what can we do about it?
562 int x
= c
->right
.GetValue(),
563 y
= c
->bottom
.GetValue();
571 // TODO: we must calculate the overlaps somehow, otherwise we
572 // will never return a size bigger than the current one :-(
575 best
= wxSize(maxX
, maxY
);
577 #endif // wxUSE_CONSTRAINTS
578 else if ( !GetChildren().empty()
579 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
580 && wxHasRealChildren(this)
584 // our minimal acceptable size is such that all our visible child
585 // windows fit inside
589 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
591 node
= node
->GetNext() )
593 wxWindow
*win
= node
->GetData();
594 if ( win
->IsTopLevel()
597 || wxDynamicCast(win
, wxStatusBar
)
598 #endif // wxUSE_STATUSBAR
601 // dialogs and frames lie in different top level windows -
602 // don't deal with them here; as for the status bars, they
603 // don't lie in the client area at all
608 win
->GetPosition(&wx
, &wy
);
610 // if the window hadn't been positioned yet, assume that it is in
612 if ( wx
== wxDefaultCoord
)
614 if ( wy
== wxDefaultCoord
)
617 win
->GetSize(&ww
, &wh
);
618 if ( wx
+ ww
> maxX
)
620 if ( wy
+ wh
> maxY
)
624 best
= wxSize(maxX
, maxY
);
626 else // ! has children
628 wxSize size
= GetMinSize();
629 if ( !size
.IsFullySpecified() )
631 // if the window doesn't define its best size we assume that it can
632 // be arbitrarily small -- usually this is not the case, of course,
633 // but we have no way to know what the limit is, it should really
634 // override DoGetBestClientSize() itself to tell us
635 size
.SetDefaults(wxSize(1, 1));
638 // return as-is, unadjusted by the client size difference.
642 // Add any difference between size and client size
643 wxSize diff
= GetSize() - GetClientSize();
644 best
.x
+= wxMax(0, diff
.x
);
645 best
.y
+= wxMax(0, diff
.y
);
650 // helper of GetWindowBorderSize(): as many ports don't implement support for
651 // wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
652 // fallbacks in this case
653 static int wxGetMetricOrDefault(wxSystemMetric what
, const wxWindowBase
* win
)
655 int rc
= wxSystemSettings::GetMetric(
656 what
, static_cast<wxWindow
*>(const_cast<wxWindowBase
*>(win
)));
663 // 2D border is by default 1 pixel wide
669 // 3D borders are by default 2 pixels
674 wxFAIL_MSG( wxT("unexpected wxGetMetricOrDefault() argument") );
682 wxSize
wxWindowBase::GetWindowBorderSize() const
686 switch ( GetBorder() )
689 // nothing to do, size is already (0, 0)
692 case wxBORDER_SIMPLE
:
693 case wxBORDER_STATIC
:
694 size
.x
= wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
695 size
.y
= wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
698 case wxBORDER_SUNKEN
:
699 case wxBORDER_RAISED
:
700 size
.x
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X
, this),
701 wxGetMetricOrDefault(wxSYS_BORDER_X
, this));
702 size
.y
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y
, this),
703 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this));
706 case wxBORDER_DOUBLE
:
707 size
.x
= wxGetMetricOrDefault(wxSYS_EDGE_X
, this) +
708 wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
709 size
.y
= wxGetMetricOrDefault(wxSYS_EDGE_Y
, this) +
710 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
714 wxFAIL_MSG(wxT("Unknown border style."));
718 // we have borders on both sides
722 wxSize
wxWindowBase::GetEffectiveMinSize() const
724 // merge the best size with the min size, giving priority to the min size
725 wxSize min
= GetMinSize();
727 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
729 wxSize best
= GetBestSize();
730 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
731 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
737 wxSize
wxWindowBase::DoGetBorderSize() const
739 // there is one case in which we can implement it for all ports easily:
740 // do it as some classes used by both wxUniv and native ports (e.g.
741 // wxGenericStaticText) do override DoGetBestClientSize() and so this
742 // method must work for them and that ensures that it does, at least in
744 if ( GetBorder() == wxBORDER_NONE
)
747 wxFAIL_MSG( "must be overridden if called" );
749 return wxDefaultSize
;
752 wxSize
wxWindowBase::GetBestSize() const
754 if ( !m_windowSizer
&& m_bestSizeCache
.IsFullySpecified() )
755 return m_bestSizeCache
;
757 // call DoGetBestClientSize() first, if a derived class overrides it wants
759 wxSize size
= DoGetBestClientSize();
760 if ( size
!= wxDefaultSize
)
762 size
+= DoGetBorderSize();
768 return DoGetBestSize();
771 void wxWindowBase::SetMinSize(const wxSize
& minSize
)
773 m_minWidth
= minSize
.x
;
774 m_minHeight
= minSize
.y
;
777 void wxWindowBase::SetMaxSize(const wxSize
& maxSize
)
779 m_maxWidth
= maxSize
.x
;
780 m_maxHeight
= maxSize
.y
;
783 void wxWindowBase::SetInitialSize(const wxSize
& size
)
785 // Set the min size to the size passed in. This will usually either be
786 // wxDefaultSize or the size passed to this window's ctor/Create function.
789 // Merge the size with the best size if needed
790 wxSize best
= GetEffectiveMinSize();
792 // If the current size doesn't match then change it
793 if (GetSize() != best
)
798 // by default the origin is not shifted
799 wxPoint
wxWindowBase::GetClientAreaOrigin() const
804 wxSize
wxWindowBase::ClientToWindowSize(const wxSize
& size
) const
806 const wxSize
diff(GetSize() - GetClientSize());
808 return wxSize(size
.x
== -1 ? -1 : size
.x
+ diff
.x
,
809 size
.y
== -1 ? -1 : size
.y
+ diff
.y
);
812 wxSize
wxWindowBase::WindowToClientSize(const wxSize
& size
) const
814 const wxSize
diff(GetSize() - GetClientSize());
816 return wxSize(size
.x
== -1 ? -1 : size
.x
- diff
.x
,
817 size
.y
== -1 ? -1 : size
.y
- diff
.y
);
820 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
822 if ( m_windowVariant
!= variant
)
824 m_windowVariant
= variant
;
826 DoSetWindowVariant(variant
);
830 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
832 // adjust the font height to correspond to our new variant (notice that
833 // we're only called if something really changed)
834 wxFont font
= GetFont();
835 int size
= font
.GetPointSize();
838 case wxWINDOW_VARIANT_NORMAL
:
841 case wxWINDOW_VARIANT_SMALL
:
846 case wxWINDOW_VARIANT_MINI
:
851 case wxWINDOW_VARIANT_LARGE
:
857 wxFAIL_MSG(wxT("unexpected window variant"));
861 font
.SetPointSize(size
);
865 void wxWindowBase::DoSetSizeHints( int minW
, int minH
,
867 int WXUNUSED(incW
), int WXUNUSED(incH
) )
869 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
870 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
871 wxT("min width/height must be less than max width/height!") );
880 #if WXWIN_COMPATIBILITY_2_8
881 void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW
), int WXUNUSED(minH
),
882 int WXUNUSED(maxW
), int WXUNUSED(maxH
))
886 void wxWindowBase::SetVirtualSizeHints(const wxSize
& WXUNUSED(minsize
),
887 const wxSize
& WXUNUSED(maxsize
))
890 #endif // WXWIN_COMPATIBILITY_2_8
892 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
894 m_virtualSize
= wxSize(x
, y
);
897 wxSize
wxWindowBase::DoGetVirtualSize() const
899 // we should use the entire client area so if it is greater than our
900 // virtual size, expand it to fit (otherwise if the window is big enough we
901 // wouldn't be using parts of it)
902 wxSize size
= GetClientSize();
903 if ( m_virtualSize
.x
> size
.x
)
904 size
.x
= m_virtualSize
.x
;
906 if ( m_virtualSize
.y
>= size
.y
)
907 size
.y
= m_virtualSize
.y
;
912 void wxWindowBase::DoGetScreenPosition(int *x
, int *y
) const
914 // screen position is the same as (0, 0) in client coords for non TLWs (and
915 // TLWs override this method)
921 ClientToScreen(x
, y
);
924 void wxWindowBase::SendSizeEvent(int flags
)
926 wxSizeEvent
event(GetSize(), GetId());
927 event
.SetEventObject(this);
928 if ( flags
& wxSEND_EVENT_POST
)
929 wxPostEvent(this, event
);
931 HandleWindowEvent(event
);
934 void wxWindowBase::SendSizeEventToParent(int flags
)
936 wxWindow
* const parent
= GetParent();
937 if ( parent
&& !parent
->IsBeingDeleted() )
938 parent
->SendSizeEvent(flags
);
941 bool wxWindowBase::HasScrollbar(int orient
) const
943 // if scrolling in the given direction is disabled, we can't have the
944 // corresponding scrollbar no matter what
945 if ( !CanScroll(orient
) )
948 const wxSize sizeVirt
= GetVirtualSize();
949 const wxSize sizeClient
= GetClientSize();
951 return orient
== wxHORIZONTAL
? sizeVirt
.x
> sizeClient
.x
952 : sizeVirt
.y
> sizeClient
.y
;
955 // ----------------------------------------------------------------------------
956 // show/hide/enable/disable the window
957 // ----------------------------------------------------------------------------
959 bool wxWindowBase::Show(bool show
)
961 if ( show
!= m_isShown
)
973 bool wxWindowBase::IsEnabled() const
975 return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
978 void wxWindowBase::NotifyWindowOnEnableChange(bool enabled
)
980 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
982 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
986 // If we are top-level then the logic doesn't apply - otherwise
987 // showing a modal dialog would result in total greying out (and ungreying
988 // out later) of everything which would be really ugly
992 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
994 node
= node
->GetNext() )
996 wxWindowBase
* const child
= node
->GetData();
997 if ( !child
->IsTopLevel() && child
->IsThisEnabled() )
998 child
->NotifyWindowOnEnableChange(enabled
);
1002 bool wxWindowBase::Enable(bool enable
)
1004 if ( enable
== IsThisEnabled() )
1007 m_isEnabled
= enable
;
1009 #ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
1011 #else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1012 wxWindowBase
* const parent
= GetParent();
1013 if( !IsTopLevel() && parent
&& !parent
->IsEnabled() )
1017 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1019 NotifyWindowOnEnableChange(enable
);
1024 bool wxWindowBase::IsShownOnScreen() const
1026 // A window is shown on screen if it itself is shown and so are all its
1027 // parents. But if a window is toplevel one, then its always visible on
1028 // screen if IsShown() returns true, even if it has a hidden parent.
1030 (IsTopLevel() || GetParent() == NULL
|| GetParent()->IsShownOnScreen());
1033 // ----------------------------------------------------------------------------
1035 // ----------------------------------------------------------------------------
1037 bool wxWindowBase::IsTopLevel() const
1042 // ----------------------------------------------------------------------------
1044 // ----------------------------------------------------------------------------
1046 void wxWindowBase::Freeze()
1048 if ( !m_freezeCount
++ )
1050 // physically freeze this window:
1053 // and recursively freeze all children:
1054 for ( wxWindowList::iterator i
= GetChildren().begin();
1055 i
!= GetChildren().end(); ++i
)
1057 wxWindow
*child
= *i
;
1058 if ( child
->IsTopLevel() )
1066 void wxWindowBase::Thaw()
1068 wxASSERT_MSG( m_freezeCount
, "Thaw() without matching Freeze()" );
1070 if ( !--m_freezeCount
)
1072 // recursively thaw all children:
1073 for ( wxWindowList::iterator i
= GetChildren().begin();
1074 i
!= GetChildren().end(); ++i
)
1076 wxWindow
*child
= *i
;
1077 if ( child
->IsTopLevel() )
1083 // physically thaw this window:
1088 // ----------------------------------------------------------------------------
1089 // reparenting the window
1090 // ----------------------------------------------------------------------------
1092 void wxWindowBase::AddChild(wxWindowBase
*child
)
1094 wxCHECK_RET( child
, wxT("can't add a NULL child") );
1096 // this should never happen and it will lead to a crash later if it does
1097 // because RemoveChild() will remove only one node from the children list
1098 // and the other(s) one(s) will be left with dangling pointers in them
1099 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), wxT("AddChild() called twice") );
1101 GetChildren().Append((wxWindow
*)child
);
1102 child
->SetParent(this);
1104 // adding a child while frozen will assert when thawed, so freeze it as if
1105 // it had been already present when we were frozen
1106 if ( IsFrozen() && !child
->IsTopLevel() )
1110 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
1112 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
1114 // removing a child while frozen may result in permanently frozen window
1115 // if used e.g. from Reparent(), so thaw it
1117 // NB: IsTopLevel() doesn't return true any more when a TLW child is being
1118 // removed from its ~wxWindowBase, so check for IsBeingDeleted() too
1119 if ( IsFrozen() && !child
->IsBeingDeleted() && !child
->IsTopLevel() )
1122 GetChildren().DeleteObject((wxWindow
*)child
);
1123 child
->SetParent(NULL
);
1126 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
1128 wxWindow
*oldParent
= GetParent();
1129 if ( newParent
== oldParent
)
1135 const bool oldEnabledState
= IsEnabled();
1137 // unlink this window from the existing parent.
1140 oldParent
->RemoveChild(this);
1144 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
1147 // add it to the new one
1150 newParent
->AddChild(this);
1154 wxTopLevelWindows
.Append((wxWindow
*)this);
1157 // We need to notify window (and its subwindows) if by changing the parent
1158 // we also change our enabled/disabled status.
1159 const bool newEnabledState
= IsEnabled();
1160 if ( newEnabledState
!= oldEnabledState
)
1162 NotifyWindowOnEnableChange(newEnabledState
);
1168 // ----------------------------------------------------------------------------
1169 // event handler stuff
1170 // ----------------------------------------------------------------------------
1172 void wxWindowBase::SetEventHandler(wxEvtHandler
*handler
)
1174 wxCHECK_RET(handler
!= NULL
, "SetEventHandler(NULL) called");
1176 m_eventHandler
= handler
;
1179 void wxWindowBase::SetNextHandler(wxEvtHandler
*WXUNUSED(handler
))
1181 // disable wxEvtHandler chain mechanism for wxWindows:
1182 // wxWindow uses its own stack mechanism which doesn't mix well with wxEvtHandler's one
1184 wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1186 void wxWindowBase::SetPreviousHandler(wxEvtHandler
*WXUNUSED(handler
))
1188 // we can't simply wxFAIL here as in SetNextHandler: in fact the last
1189 // handler of our stack when is destroyed will be Unlink()ed and thus
1190 // will call this function to update the pointer of this window...
1192 //wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1195 void wxWindowBase::PushEventHandler(wxEvtHandler
*handlerToPush
)
1197 wxCHECK_RET( handlerToPush
!= NULL
, "PushEventHandler(NULL) called" );
1199 // the new handler is going to be part of the wxWindow stack of event handlers:
1200 // it can't be part also of an event handler double-linked chain:
1201 wxASSERT_MSG(handlerToPush
->IsUnlinked(),
1202 "The handler being pushed in the wxWindow stack shouldn't be part of "
1203 "a wxEvtHandler chain; call Unlink() on it first");
1205 wxEvtHandler
*handlerOld
= GetEventHandler();
1206 wxCHECK_RET( handlerOld
, "an old event handler is NULL?" );
1208 // now use wxEvtHandler double-linked list to implement a stack:
1209 handlerToPush
->SetNextHandler(handlerOld
);
1211 if (handlerOld
!= this)
1212 handlerOld
->SetPreviousHandler(handlerToPush
);
1214 SetEventHandler(handlerToPush
);
1217 // final checks of the operations done above:
1218 wxASSERT_MSG( handlerToPush
->GetPreviousHandler() == NULL
,
1219 "the first handler of the wxWindow stack should "
1220 "have no previous handlers set" );
1221 wxASSERT_MSG( handlerToPush
->GetNextHandler() != NULL
,
1222 "the first handler of the wxWindow stack should "
1223 "have non-NULL next handler" );
1225 wxEvtHandler
* pLast
= handlerToPush
;
1226 while ( pLast
&& pLast
!= this )
1227 pLast
= pLast
->GetNextHandler();
1228 wxASSERT_MSG( pLast
->GetNextHandler() == NULL
,
1229 "the last handler of the wxWindow stack should "
1230 "have this window as next handler" );
1231 #endif // wxDEBUG_LEVEL
1234 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
1236 // we need to pop the wxWindow stack, i.e. we need to remove the first handler
1238 wxEvtHandler
*firstHandler
= GetEventHandler();
1239 wxCHECK_MSG( firstHandler
!= NULL
, NULL
, "wxWindow cannot have a NULL event handler" );
1240 wxCHECK_MSG( firstHandler
!= this, NULL
, "cannot pop the wxWindow itself" );
1241 wxCHECK_MSG( firstHandler
->GetPreviousHandler() == NULL
, NULL
,
1242 "the first handler of the wxWindow stack should have no previous handlers set" );
1244 wxEvtHandler
*secondHandler
= firstHandler
->GetNextHandler();
1245 wxCHECK_MSG( secondHandler
!= NULL
, NULL
,
1246 "the first handler of the wxWindow stack should have non-NULL next handler" );
1248 firstHandler
->SetNextHandler(NULL
);
1249 secondHandler
->SetPreviousHandler(NULL
);
1251 // now firstHandler is completely unlinked; set secondHandler as the new window event handler
1252 SetEventHandler(secondHandler
);
1254 if ( deleteHandler
)
1256 wxDELETE(firstHandler
);
1259 return firstHandler
;
1262 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handlerToRemove
)
1264 wxCHECK_MSG( handlerToRemove
!= NULL
, false, "RemoveEventHandler(NULL) called" );
1265 wxCHECK_MSG( handlerToRemove
!= this, false, "Cannot remove the window itself" );
1267 if (handlerToRemove
== GetEventHandler())
1269 // removing the first event handler is equivalent to "popping" the stack
1270 PopEventHandler(false);
1274 // NOTE: the wxWindow event handler list is always terminated with "this" handler
1275 wxEvtHandler
*handlerCur
= GetEventHandler()->GetNextHandler();
1276 while ( handlerCur
!= this && handlerCur
)
1278 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
1280 if ( handlerCur
== handlerToRemove
)
1282 handlerCur
->Unlink();
1284 wxASSERT_MSG( handlerCur
!= GetEventHandler(),
1285 "the case Remove == Pop should was already handled" );
1289 handlerCur
= handlerNext
;
1292 wxFAIL_MSG( wxT("where has the event handler gone?") );
1297 bool wxWindowBase::HandleWindowEvent(wxEvent
& event
) const
1299 // SafelyProcessEvent() will handle exceptions nicely
1300 return GetEventHandler()->SafelyProcessEvent(event
);
1303 // ----------------------------------------------------------------------------
1304 // colours, fonts &c
1305 // ----------------------------------------------------------------------------
1307 void wxWindowBase::InheritAttributes()
1309 const wxWindowBase
* const parent
= GetParent();
1313 // we only inherit attributes which had been explicitly set for the parent
1314 // which ensures that this only happens if the user really wants it and
1315 // not by default which wouldn't make any sense in modern GUIs where the
1316 // controls don't all use the same fonts (nor colours)
1317 if ( parent
->m_inheritFont
&& !m_hasFont
)
1318 SetFont(parent
->GetFont());
1320 // in addition, there is a possibility to explicitly forbid inheriting
1321 // colours at each class level by overriding ShouldInheritColours()
1322 if ( ShouldInheritColours() )
1324 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
1325 SetForegroundColour(parent
->GetForegroundColour());
1327 // inheriting (solid) background colour is wrong as it totally breaks
1328 // any kind of themed backgrounds
1330 // instead, the controls should use the same background as their parent
1331 // (ideally by not drawing it at all)
1333 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
1334 SetBackgroundColour(parent
->GetBackgroundColour());
1339 /* static */ wxVisualAttributes
1340 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1342 // it is important to return valid values for all attributes from here,
1343 // GetXXX() below rely on this
1344 wxVisualAttributes attrs
;
1345 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
1346 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1348 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1349 // the usual background colour than wxSYS_COLOUR_BTNFACE.
1350 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1351 // colour on other platforms.
1353 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1354 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1356 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
1361 wxColour
wxWindowBase::GetBackgroundColour() const
1363 if ( !m_backgroundColour
.IsOk() )
1365 wxASSERT_MSG( !m_hasBgCol
, wxT("we have invalid explicit bg colour?") );
1367 // get our default background colour
1368 wxColour colBg
= GetDefaultAttributes().colBg
;
1370 // we must return some valid colour to avoid redoing this every time
1371 // and also to avoid surprising the applications written for older
1372 // wxWidgets versions where GetBackgroundColour() always returned
1373 // something -- so give them something even if it doesn't make sense
1374 // for this window (e.g. it has a themed background)
1376 colBg
= GetClassDefaultAttributes().colBg
;
1381 return m_backgroundColour
;
1384 wxColour
wxWindowBase::GetForegroundColour() const
1386 // logic is the same as above
1387 if ( !m_hasFgCol
&& !m_foregroundColour
.Ok() )
1389 wxColour colFg
= GetDefaultAttributes().colFg
;
1391 if ( !colFg
.IsOk() )
1392 colFg
= GetClassDefaultAttributes().colFg
;
1397 return m_foregroundColour
;
1400 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1402 if ( colour
== m_backgroundColour
)
1405 m_hasBgCol
= colour
.IsOk();
1407 m_inheritBgCol
= m_hasBgCol
;
1408 m_backgroundColour
= colour
;
1409 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.Ok() );
1413 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1415 if (colour
== m_foregroundColour
)
1418 m_hasFgCol
= colour
.IsOk();
1419 m_inheritFgCol
= m_hasFgCol
;
1420 m_foregroundColour
= colour
;
1421 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.Ok() );
1425 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1427 // setting an invalid cursor is ok, it means that we don't have any special
1429 if ( m_cursor
.IsSameAs(cursor
) )
1440 wxFont
wxWindowBase::GetFont() const
1442 // logic is the same as in GetBackgroundColour()
1443 if ( !m_font
.IsOk() )
1445 wxASSERT_MSG( !m_hasFont
, wxT("we have invalid explicit font?") );
1447 wxFont font
= GetDefaultAttributes().font
;
1449 font
= GetClassDefaultAttributes().font
;
1457 bool wxWindowBase::SetFont(const wxFont
& font
)
1459 if ( font
== m_font
)
1466 m_hasFont
= font
.IsOk();
1467 m_inheritFont
= m_hasFont
;
1469 InvalidateBestSize();
1476 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1478 m_hasCustomPalette
= true;
1481 // VZ: can anyone explain me what do we do here?
1482 wxWindowDC
d((wxWindow
*) this);
1486 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1488 wxWindow
*win
= (wxWindow
*)this;
1489 while ( win
&& !win
->HasCustomPalette() )
1491 win
= win
->GetParent();
1497 #endif // wxUSE_PALETTE
1500 void wxWindowBase::SetCaret(wxCaret
*caret
)
1511 wxASSERT_MSG( m_caret
->GetWindow() == this,
1512 wxT("caret should be created associated to this window") );
1515 #endif // wxUSE_CARET
1517 #if wxUSE_VALIDATORS
1518 // ----------------------------------------------------------------------------
1520 // ----------------------------------------------------------------------------
1522 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1524 if ( m_windowValidator
)
1525 delete m_windowValidator
;
1527 m_windowValidator
= (wxValidator
*)validator
.Clone();
1529 if ( m_windowValidator
)
1530 m_windowValidator
->SetWindow(this);
1532 #endif // wxUSE_VALIDATORS
1534 // ----------------------------------------------------------------------------
1535 // update region stuff
1536 // ----------------------------------------------------------------------------
1538 wxRect
wxWindowBase::GetUpdateClientRect() const
1540 wxRegion rgnUpdate
= GetUpdateRegion();
1541 rgnUpdate
.Intersect(GetClientRect());
1542 wxRect rectUpdate
= rgnUpdate
.GetBox();
1543 wxPoint ptOrigin
= GetClientAreaOrigin();
1544 rectUpdate
.x
-= ptOrigin
.x
;
1545 rectUpdate
.y
-= ptOrigin
.y
;
1550 bool wxWindowBase::DoIsExposed(int x
, int y
) const
1552 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1555 bool wxWindowBase::DoIsExposed(int x
, int y
, int w
, int h
) const
1557 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1560 void wxWindowBase::ClearBackground()
1562 // wxGTK uses its own version, no need to add never used code
1564 wxClientDC
dc((wxWindow
*)this);
1565 wxBrush
brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
);
1566 dc
.SetBackground(brush
);
1571 // ----------------------------------------------------------------------------
1572 // find child window by id or name
1573 // ----------------------------------------------------------------------------
1575 wxWindow
*wxWindowBase::FindWindow(long id
) const
1577 if ( id
== m_windowId
)
1578 return (wxWindow
*)this;
1580 wxWindowBase
*res
= NULL
;
1581 wxWindowList::compatibility_iterator node
;
1582 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1584 wxWindowBase
*child
= node
->GetData();
1585 res
= child
->FindWindow( id
);
1588 return (wxWindow
*)res
;
1591 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1593 if ( name
== m_windowName
)
1594 return (wxWindow
*)this;
1596 wxWindowBase
*res
= NULL
;
1597 wxWindowList::compatibility_iterator node
;
1598 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1600 wxWindow
*child
= node
->GetData();
1601 res
= child
->FindWindow(name
);
1604 return (wxWindow
*)res
;
1608 // find any window by id or name or label: If parent is non-NULL, look through
1609 // children for a label or title matching the specified string. If NULL, look
1610 // through all top-level windows.
1612 // to avoid duplicating code we reuse the same helper function but with
1613 // different comparators
1615 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1616 const wxString
& label
, long id
);
1619 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1622 return win
->GetLabel() == label
;
1626 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1629 return win
->GetName() == label
;
1633 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1636 return win
->GetId() == id
;
1639 // recursive helper for the FindWindowByXXX() functions
1641 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1642 const wxString
& label
,
1644 wxFindWindowCmp cmp
)
1648 // see if this is the one we're looking for
1649 if ( (*cmp
)(parent
, label
, id
) )
1650 return (wxWindow
*)parent
;
1652 // It wasn't, so check all its children
1653 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1655 node
= node
->GetNext() )
1657 // recursively check each child
1658 wxWindow
*win
= (wxWindow
*)node
->GetData();
1659 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1669 // helper for FindWindowByXXX()
1671 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1672 const wxString
& label
,
1674 wxFindWindowCmp cmp
)
1678 // just check parent and all its children
1679 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1682 // start at very top of wx's windows
1683 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1685 node
= node
->GetNext() )
1687 // recursively check each window & its children
1688 wxWindow
*win
= node
->GetData();
1689 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1699 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1701 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1706 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1708 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1712 // fall back to the label
1713 win
= FindWindowByLabel(title
, parent
);
1721 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1723 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1726 // ----------------------------------------------------------------------------
1727 // dialog oriented functions
1728 // ----------------------------------------------------------------------------
1730 void wxWindowBase::MakeModal(bool modal
)
1732 // Disable all other windows
1735 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1738 wxWindow
*win
= node
->GetData();
1740 win
->Enable(!modal
);
1742 node
= node
->GetNext();
1747 bool wxWindowBase::Validate()
1749 #if wxUSE_VALIDATORS
1750 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1752 wxWindowList::compatibility_iterator node
;
1753 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1755 wxWindowBase
*child
= node
->GetData();
1756 wxValidator
*validator
= child
->GetValidator();
1757 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1762 if ( recurse
&& !child
->Validate() )
1767 #endif // wxUSE_VALIDATORS
1772 bool wxWindowBase::TransferDataToWindow()
1774 #if wxUSE_VALIDATORS
1775 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1777 wxWindowList::compatibility_iterator node
;
1778 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1780 wxWindowBase
*child
= node
->GetData();
1781 wxValidator
*validator
= child
->GetValidator();
1782 if ( validator
&& !validator
->TransferToWindow() )
1784 wxLogWarning(_("Could not transfer data to window"));
1786 wxLog::FlushActive();
1794 if ( !child
->TransferDataToWindow() )
1796 // warning already given
1801 #endif // wxUSE_VALIDATORS
1806 bool wxWindowBase::TransferDataFromWindow()
1808 #if wxUSE_VALIDATORS
1809 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1811 wxWindowList::compatibility_iterator node
;
1812 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1814 wxWindow
*child
= node
->GetData();
1815 wxValidator
*validator
= child
->GetValidator();
1816 if ( validator
&& !validator
->TransferFromWindow() )
1818 // nop warning here because the application is supposed to give
1819 // one itself - we don't know here what might have gone wrongly
1826 if ( !child
->TransferDataFromWindow() )
1828 // warning already given
1833 #endif // wxUSE_VALIDATORS
1838 void wxWindowBase::InitDialog()
1840 wxInitDialogEvent
event(GetId());
1841 event
.SetEventObject( this );
1842 GetEventHandler()->ProcessEvent(event
);
1845 // ----------------------------------------------------------------------------
1846 // context-sensitive help support
1847 // ----------------------------------------------------------------------------
1851 // associate this help text with this window
1852 void wxWindowBase::SetHelpText(const wxString
& text
)
1854 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1857 helpProvider
->AddHelp(this, text
);
1861 #if WXWIN_COMPATIBILITY_2_8
1862 // associate this help text with all windows with the same id as this
1864 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
1866 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1869 helpProvider
->AddHelp(GetId(), text
);
1872 #endif // WXWIN_COMPATIBILITY_2_8
1874 // get the help string associated with this window (may be empty)
1875 // default implementation forwards calls to the help provider
1877 wxWindowBase::GetHelpTextAtPoint(const wxPoint
& WXUNUSED(pt
),
1878 wxHelpEvent::Origin
WXUNUSED(origin
)) const
1881 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1884 text
= helpProvider
->GetHelp(this);
1890 // show help for this window
1891 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
1893 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1896 wxPoint pos
= event
.GetPosition();
1897 const wxHelpEvent::Origin origin
= event
.GetOrigin();
1898 if ( origin
== wxHelpEvent::Origin_Keyboard
)
1900 // if the help event was generated from keyboard it shouldn't
1901 // appear at the mouse position (which is still the only position
1902 // associated with help event) if the mouse is far away, although
1903 // we still do use the mouse position if it's over the window
1904 // because we suppose the user looks approximately at the mouse
1905 // already and so it would be more convenient than showing tooltip
1906 // at some arbitrary position which can be quite far from it
1907 const wxRect rectClient
= GetClientRect();
1908 if ( !rectClient
.Contains(ScreenToClient(pos
)) )
1910 // position help slightly under and to the right of this window
1911 pos
= ClientToScreen(wxPoint(
1913 rectClient
.height
+ GetCharHeight()
1918 if ( helpProvider
->ShowHelpAtPoint(this, pos
, origin
) )
1920 // skip the event.Skip() below
1928 #endif // wxUSE_HELP
1930 // ----------------------------------------------------------------------------
1932 // ----------------------------------------------------------------------------
1936 wxString
wxWindowBase::GetToolTipText() const
1938 return m_tooltip
? m_tooltip
->GetTip() : wxString();
1941 void wxWindowBase::SetToolTip( const wxString
&tip
)
1943 // don't create the new tooltip if we already have one
1946 m_tooltip
->SetTip( tip
);
1950 SetToolTip( new wxToolTip( tip
) );
1953 // setting empty tooltip text does not remove the tooltip any more - use
1954 // SetToolTip(NULL) for this
1957 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
1959 if ( m_tooltip
!= tooltip
)
1964 m_tooltip
= tooltip
;
1968 #endif // wxUSE_TOOLTIPS
1970 // ----------------------------------------------------------------------------
1971 // constraints and sizers
1972 // ----------------------------------------------------------------------------
1974 #if wxUSE_CONSTRAINTS
1976 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
1978 if ( m_constraints
)
1980 UnsetConstraints(m_constraints
);
1981 delete m_constraints
;
1983 m_constraints
= constraints
;
1984 if ( m_constraints
)
1986 // Make sure other windows know they're part of a 'meaningful relationship'
1987 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
1988 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
1989 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
1990 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
1991 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
1992 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
1993 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
1994 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
1995 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
1996 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
1997 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
1998 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
1999 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
2000 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
2001 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
2002 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
2006 // This removes any dangling pointers to this window in other windows'
2007 // constraintsInvolvedIn lists.
2008 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
2012 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
2013 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
2014 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
2015 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
2016 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
2017 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
2018 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
2019 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
2020 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
2021 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
2022 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
2023 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
2024 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
2025 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
2026 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
2027 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
2031 // Back-pointer to other windows we're involved with, so if we delete this
2032 // window, we must delete any constraints we're involved with.
2033 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
2035 if ( !m_constraintsInvolvedIn
)
2036 m_constraintsInvolvedIn
= new wxWindowList
;
2037 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
2038 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
2041 // REMOVE back-pointer to other windows we're involved with.
2042 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
2044 if ( m_constraintsInvolvedIn
)
2045 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
2048 // Reset any constraints that mention this window
2049 void wxWindowBase::DeleteRelatedConstraints()
2051 if ( m_constraintsInvolvedIn
)
2053 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
2056 wxWindow
*win
= node
->GetData();
2057 wxLayoutConstraints
*constr
= win
->GetConstraints();
2059 // Reset any constraints involving this window
2062 constr
->left
.ResetIfWin(this);
2063 constr
->top
.ResetIfWin(this);
2064 constr
->right
.ResetIfWin(this);
2065 constr
->bottom
.ResetIfWin(this);
2066 constr
->width
.ResetIfWin(this);
2067 constr
->height
.ResetIfWin(this);
2068 constr
->centreX
.ResetIfWin(this);
2069 constr
->centreY
.ResetIfWin(this);
2072 wxWindowList::compatibility_iterator next
= node
->GetNext();
2073 m_constraintsInvolvedIn
->Erase(node
);
2077 wxDELETE(m_constraintsInvolvedIn
);
2081 #endif // wxUSE_CONSTRAINTS
2083 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
2085 if ( sizer
== m_windowSizer
)
2088 if ( m_windowSizer
)
2090 m_windowSizer
->SetContainingWindow(NULL
);
2093 delete m_windowSizer
;
2096 m_windowSizer
= sizer
;
2097 if ( m_windowSizer
)
2099 m_windowSizer
->SetContainingWindow((wxWindow
*)this);
2102 SetAutoLayout(m_windowSizer
!= NULL
);
2105 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
2107 SetSizer( sizer
, deleteOld
);
2108 sizer
->SetSizeHints( (wxWindow
*) this );
2112 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
2114 // adding a window to a sizer twice is going to result in fatal and
2115 // hard to debug problems later because when deleting the second
2116 // associated wxSizerItem we're going to dereference a dangling
2117 // pointer; so try to detect this as early as possible
2118 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
2119 wxT("Adding a window to the same sizer twice?") );
2121 m_containingSizer
= sizer
;
2124 #if wxUSE_CONSTRAINTS
2126 void wxWindowBase::SatisfyConstraints()
2128 wxLayoutConstraints
*constr
= GetConstraints();
2129 bool wasOk
= constr
&& constr
->AreSatisfied();
2131 ResetConstraints(); // Mark all constraints as unevaluated
2135 // if we're a top level panel (i.e. our parent is frame/dialog), our
2136 // own constraints will never be satisfied any more unless we do it
2140 while ( noChanges
> 0 )
2142 LayoutPhase1(&noChanges
);
2146 LayoutPhase2(&noChanges
);
2149 #endif // wxUSE_CONSTRAINTS
2151 bool wxWindowBase::Layout()
2153 // If there is a sizer, use it instead of the constraints
2157 GetVirtualSize(&w
, &h
);
2158 GetSizer()->SetDimension( 0, 0, w
, h
);
2160 #if wxUSE_CONSTRAINTS
2163 SatisfyConstraints(); // Find the right constraints values
2164 SetConstraintSizes(); // Recursively set the real window sizes
2171 void wxWindowBase::InternalOnSize(wxSizeEvent
& event
)
2173 if ( GetAutoLayout() )
2179 #if wxUSE_CONSTRAINTS
2181 // first phase of the constraints evaluation: set our own constraints
2182 bool wxWindowBase::LayoutPhase1(int *noChanges
)
2184 wxLayoutConstraints
*constr
= GetConstraints();
2186 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
2189 // second phase: set the constraints for our children
2190 bool wxWindowBase::LayoutPhase2(int *noChanges
)
2197 // Layout grand children
2203 // Do a phase of evaluating child constraints
2204 bool wxWindowBase::DoPhase(int phase
)
2206 // the list containing the children for which the constraints are already
2208 wxWindowList succeeded
;
2210 // the max number of iterations we loop before concluding that we can't set
2212 static const int maxIterations
= 500;
2214 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
2218 // loop over all children setting their constraints
2219 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2221 node
= node
->GetNext() )
2223 wxWindow
*child
= node
->GetData();
2224 if ( child
->IsTopLevel() )
2226 // top level children are not inside our client area
2230 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
2232 // this one is either already ok or nothing we can do about it
2236 int tempNoChanges
= 0;
2237 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
2238 : child
->LayoutPhase2(&tempNoChanges
);
2239 noChanges
+= tempNoChanges
;
2243 succeeded
.Append(child
);
2249 // constraints are set
2257 void wxWindowBase::ResetConstraints()
2259 wxLayoutConstraints
*constr
= GetConstraints();
2262 constr
->left
.SetDone(false);
2263 constr
->top
.SetDone(false);
2264 constr
->right
.SetDone(false);
2265 constr
->bottom
.SetDone(false);
2266 constr
->width
.SetDone(false);
2267 constr
->height
.SetDone(false);
2268 constr
->centreX
.SetDone(false);
2269 constr
->centreY
.SetDone(false);
2272 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2275 wxWindow
*win
= node
->GetData();
2276 if ( !win
->IsTopLevel() )
2277 win
->ResetConstraints();
2278 node
= node
->GetNext();
2282 // Need to distinguish between setting the 'fake' size for windows and sizers,
2283 // and setting the real values.
2284 void wxWindowBase::SetConstraintSizes(bool recurse
)
2286 wxLayoutConstraints
*constr
= GetConstraints();
2287 if ( constr
&& constr
->AreSatisfied() )
2289 int x
= constr
->left
.GetValue();
2290 int y
= constr
->top
.GetValue();
2291 int w
= constr
->width
.GetValue();
2292 int h
= constr
->height
.GetValue();
2294 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
2295 (constr
->height
.GetRelationship() != wxAsIs
) )
2297 SetSize(x
, y
, w
, h
);
2301 // If we don't want to resize this window, just move it...
2307 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
2308 GetClassInfo()->GetClassName(),
2314 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2317 wxWindow
*win
= node
->GetData();
2318 if ( !win
->IsTopLevel() && win
->GetConstraints() )
2319 win
->SetConstraintSizes();
2320 node
= node
->GetNext();
2325 // Only set the size/position of the constraint (if any)
2326 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
2328 wxLayoutConstraints
*constr
= GetConstraints();
2331 if ( x
!= wxDefaultCoord
)
2333 constr
->left
.SetValue(x
);
2334 constr
->left
.SetDone(true);
2336 if ( y
!= wxDefaultCoord
)
2338 constr
->top
.SetValue(y
);
2339 constr
->top
.SetDone(true);
2341 if ( w
!= wxDefaultCoord
)
2343 constr
->width
.SetValue(w
);
2344 constr
->width
.SetDone(true);
2346 if ( h
!= wxDefaultCoord
)
2348 constr
->height
.SetValue(h
);
2349 constr
->height
.SetDone(true);
2354 void wxWindowBase::MoveConstraint(int x
, int y
)
2356 wxLayoutConstraints
*constr
= GetConstraints();
2359 if ( x
!= wxDefaultCoord
)
2361 constr
->left
.SetValue(x
);
2362 constr
->left
.SetDone(true);
2364 if ( y
!= wxDefaultCoord
)
2366 constr
->top
.SetValue(y
);
2367 constr
->top
.SetDone(true);
2372 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
2374 wxLayoutConstraints
*constr
= GetConstraints();
2377 *w
= constr
->width
.GetValue();
2378 *h
= constr
->height
.GetValue();
2384 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
2386 wxLayoutConstraints
*constr
= GetConstraints();
2389 *w
= constr
->width
.GetValue();
2390 *h
= constr
->height
.GetValue();
2393 GetClientSize(w
, h
);
2396 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
2398 wxLayoutConstraints
*constr
= GetConstraints();
2401 *x
= constr
->left
.GetValue();
2402 *y
= constr
->top
.GetValue();
2408 #endif // wxUSE_CONSTRAINTS
2410 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
2412 // don't do it for the dialogs/frames - they float independently of their
2414 if ( !IsTopLevel() )
2416 wxWindow
*parent
= GetParent();
2417 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
2419 wxPoint
pt(parent
->GetClientAreaOrigin());
2426 // ----------------------------------------------------------------------------
2427 // Update UI processing
2428 // ----------------------------------------------------------------------------
2430 void wxWindowBase::UpdateWindowUI(long flags
)
2432 wxUpdateUIEvent
event(GetId());
2433 event
.SetEventObject(this);
2435 if ( GetEventHandler()->ProcessEvent(event
) )
2437 DoUpdateWindowUI(event
);
2440 if (flags
& wxUPDATE_UI_RECURSE
)
2442 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2445 wxWindow
* child
= (wxWindow
*) node
->GetData();
2446 child
->UpdateWindowUI(flags
);
2447 node
= node
->GetNext();
2452 // do the window-specific processing after processing the update event
2453 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2455 if ( event
.GetSetEnabled() )
2456 Enable(event
.GetEnabled());
2458 if ( event
.GetSetShown() )
2459 Show(event
.GetShown());
2462 // ----------------------------------------------------------------------------
2463 // dialog units translations
2464 // ----------------------------------------------------------------------------
2466 // Windows' computes dialog units using average character width over upper-
2467 // and lower-case ASCII alphabet and not using the average character width
2468 // metadata stored in the font; see
2469 // http://support.microsoft.com/default.aspx/kb/145994 for detailed discussion.
2470 // It's important that we perform the conversion in identical way, because
2471 // dialog units natively exist only on Windows and Windows HIG is expressed
2473 wxSize
wxWindowBase::GetDlgUnitBase() const
2475 const wxWindow
*parent
= wxGetTopLevelParent((wxWindow
*)this);
2477 if ( !parent
->m_font
.IsOk() )
2479 // Default GUI font is used. This is the most common case, so
2480 // cache the results.
2481 static wxSize s_defFontSize
;
2482 if ( s_defFontSize
.x
== 0 )
2483 s_defFontSize
= wxPrivate::GetAverageASCIILetterSize(*parent
);
2484 return s_defFontSize
;
2488 // Custom font, we always need to compute the result
2489 return wxPrivate::GetAverageASCIILetterSize(*parent
);
2493 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
) const
2495 const wxSize base
= GetDlgUnitBase();
2497 // NB: wxMulDivInt32() is used, because it correctly rounds the result
2499 wxPoint pt2
= wxDefaultPosition
;
2500 if (pt
.x
!= wxDefaultCoord
)
2501 pt2
.x
= wxMulDivInt32(pt
.x
, 4, base
.x
);
2502 if (pt
.y
!= wxDefaultCoord
)
2503 pt2
.y
= wxMulDivInt32(pt
.y
, 8, base
.y
);
2508 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
) const
2510 const wxSize base
= GetDlgUnitBase();
2512 wxPoint pt2
= wxDefaultPosition
;
2513 if (pt
.x
!= wxDefaultCoord
)
2514 pt2
.x
= wxMulDivInt32(pt
.x
, base
.x
, 4);
2515 if (pt
.y
!= wxDefaultCoord
)
2516 pt2
.y
= wxMulDivInt32(pt
.y
, base
.y
, 8);
2521 // ----------------------------------------------------------------------------
2523 // ----------------------------------------------------------------------------
2525 // propagate the colour change event to the subwindows
2526 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
2528 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2531 // Only propagate to non-top-level windows
2532 wxWindow
*win
= node
->GetData();
2533 if ( !win
->IsTopLevel() )
2535 wxSysColourChangedEvent event2
;
2536 event2
.SetEventObject(win
);
2537 win
->GetEventHandler()->ProcessEvent(event2
);
2540 node
= node
->GetNext();
2546 // the default action is to populate dialog with data when it's created,
2547 // and nudge the UI into displaying itself correctly in case
2548 // we've turned the wxUpdateUIEvents frequency down low.
2549 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2551 TransferDataToWindow();
2553 // Update the UI at this point
2554 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2557 // ----------------------------------------------------------------------------
2558 // menu-related functions
2559 // ----------------------------------------------------------------------------
2563 bool wxWindowBase::PopupMenu(wxMenu
*menu
, int x
, int y
)
2565 wxCHECK_MSG( menu
, false, "can't popup NULL menu" );
2567 wxMenuInvokingWindowSetter
2568 setInvokingWin(*menu
, static_cast<wxWindow
*>(this));
2570 wxCurrentPopupMenu
= menu
;
2571 const bool rc
= DoPopupMenu(menu
, x
, y
);
2572 wxCurrentPopupMenu
= NULL
;
2577 // this is used to pass the id of the selected item from the menu event handler
2578 // to the main function itself
2580 // it's ok to use a global here as there can be at most one popup menu shown at
2582 static int gs_popupMenuSelection
= wxID_NONE
;
2584 void wxWindowBase::InternalOnPopupMenu(wxCommandEvent
& event
)
2586 // store the id in a global variable where we'll retrieve it from later
2587 gs_popupMenuSelection
= event
.GetId();
2590 void wxWindowBase::InternalOnPopupMenuUpdate(wxUpdateUIEvent
& WXUNUSED(event
))
2592 // nothing to do but do not skip it
2596 wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
2598 gs_popupMenuSelection
= wxID_NONE
;
2600 Connect(wxEVT_COMMAND_MENU_SELECTED
,
2601 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2605 // it is common to construct the menu passed to this function dynamically
2606 // using some fixed range of ids which could clash with the ids used
2607 // elsewhere in the program, which could result in some menu items being
2608 // unintentionally disabled or otherwise modified by update UI handlers
2609 // elsewhere in the program code and this is difficult to avoid in the
2610 // program itself, so instead we just temporarily suspend UI updating while
2611 // this menu is shown
2612 Connect(wxEVT_UPDATE_UI
,
2613 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2617 PopupMenu(&menu
, x
, y
);
2619 Disconnect(wxEVT_UPDATE_UI
,
2620 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2623 Disconnect(wxEVT_COMMAND_MENU_SELECTED
,
2624 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2628 return gs_popupMenuSelection
;
2631 #endif // wxUSE_MENUS
2633 // methods for drawing the sizers in a visible way: this is currently only
2634 // enabled for "full debug" builds with wxDEBUG_LEVEL==2 as it doesn't work
2635 // that well and also because we don't want to leave it enabled in default
2636 // builds used for production
2637 #if wxDEBUG_LEVEL > 1
2639 static void DrawSizers(wxWindowBase
*win
);
2641 static void DrawBorder(wxWindowBase
*win
, const wxRect
& rect
, bool fill
, const wxPen
* pen
)
2643 wxClientDC
dc((wxWindow
*)win
);
2645 dc
.SetBrush(fill
? wxBrush(pen
->GetColour(), wxBRUSHSTYLE_CROSSDIAG_HATCH
) :
2646 *wxTRANSPARENT_BRUSH
);
2647 dc
.DrawRectangle(rect
.Deflate(1, 1));
2650 static void DrawSizer(wxWindowBase
*win
, wxSizer
*sizer
)
2652 const wxSizerItemList
& items
= sizer
->GetChildren();
2653 for ( wxSizerItemList::const_iterator i
= items
.begin(),
2658 wxSizerItem
*item
= *i
;
2659 if ( item
->IsSizer() )
2661 DrawBorder(win
, item
->GetRect().Deflate(2), false, wxRED_PEN
);
2662 DrawSizer(win
, item
->GetSizer());
2664 else if ( item
->IsSpacer() )
2666 DrawBorder(win
, item
->GetRect().Deflate(2), true, wxBLUE_PEN
);
2668 else if ( item
->IsWindow() )
2670 DrawSizers(item
->GetWindow());
2673 wxFAIL_MSG("inconsistent wxSizerItem status!");
2677 static void DrawSizers(wxWindowBase
*win
)
2679 DrawBorder(win
, win
->GetClientSize(), false, wxGREEN_PEN
);
2681 wxSizer
*sizer
= win
->GetSizer();
2684 DrawSizer(win
, sizer
);
2686 else // no sizer, still recurse into the children
2688 const wxWindowList
& children
= win
->GetChildren();
2689 for ( wxWindowList::const_iterator i
= children
.begin(),
2690 end
= children
.end();
2697 // show all kind of sizes of this window; see the "window sizing" topic
2698 // overview for more info about the various differences:
2699 wxSize fullSz
= win
->GetSize();
2700 wxSize clientSz
= win
->GetClientSize();
2701 wxSize bestSz
= win
->GetBestSize();
2702 wxSize minSz
= win
->GetMinSize();
2703 wxSize maxSz
= win
->GetMaxSize();
2704 wxSize virtualSz
= win
->GetVirtualSize();
2706 wxMessageOutputDebug dbgout
;
2708 "%-10s => fullsz=%4d;%-4d clientsz=%4d;%-4d bestsz=%4d;%-4d minsz=%4d;%-4d maxsz=%4d;%-4d virtualsz=%4d;%-4d\n",
2711 clientSz
.x
, clientSz
.y
,
2715 virtualSz
.x
, virtualSz
.y
);
2719 #endif // wxDEBUG_LEVEL
2721 // process special middle clicks
2722 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2724 if ( event
.ControlDown() && event
.AltDown() )
2726 #if wxDEBUG_LEVEL > 1
2727 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2728 if ( event
.ShiftDown() )
2733 #endif // __WXDEBUG__
2735 // just Ctrl-Alt-middle click shows information about wx version
2736 ::wxInfoMessageBox((wxWindow
*)this);
2745 // ----------------------------------------------------------------------------
2747 // ----------------------------------------------------------------------------
2749 #if wxUSE_ACCESSIBILITY
2750 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2752 if (m_accessible
&& (accessible
!= m_accessible
))
2753 delete m_accessible
;
2754 m_accessible
= accessible
;
2756 m_accessible
->SetWindow((wxWindow
*) this);
2759 // Returns the accessible object, creating if necessary.
2760 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2763 m_accessible
= CreateAccessible();
2764 return m_accessible
;
2767 // Override to create a specific accessible object.
2768 wxAccessible
* wxWindowBase::CreateAccessible()
2770 return new wxWindowAccessible((wxWindow
*) this);
2775 // ----------------------------------------------------------------------------
2776 // list classes implementation
2777 // ----------------------------------------------------------------------------
2781 #include "wx/listimpl.cpp"
2782 WX_DEFINE_LIST(wxWindowList
)
2786 void wxWindowListNode::DeleteData()
2788 delete (wxWindow
*)GetData();
2791 #endif // wxUSE_STL/!wxUSE_STL
2793 // ----------------------------------------------------------------------------
2795 // ----------------------------------------------------------------------------
2797 wxBorder
wxWindowBase::GetBorder(long flags
) const
2799 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
2800 if ( border
== wxBORDER_DEFAULT
)
2802 border
= GetDefaultBorder();
2804 else if ( border
== wxBORDER_THEME
)
2806 border
= GetDefaultBorderForControl();
2812 wxBorder
wxWindowBase::GetDefaultBorder() const
2814 return wxBORDER_NONE
;
2817 // ----------------------------------------------------------------------------
2819 // ----------------------------------------------------------------------------
2821 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
2823 // here we just check if the point is inside the window or not
2825 // check the top and left border first
2826 bool outside
= x
< 0 || y
< 0;
2829 // check the right and bottom borders too
2830 wxSize size
= GetSize();
2831 outside
= x
>= size
.x
|| y
>= size
.y
;
2834 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
2837 // ----------------------------------------------------------------------------
2839 // ----------------------------------------------------------------------------
2841 struct WXDLLEXPORT wxWindowNext
2845 } *wxWindowBase::ms_winCaptureNext
= NULL
;
2846 wxWindow
*wxWindowBase::ms_winCaptureCurrent
= NULL
;
2847 bool wxWindowBase::ms_winCaptureChanging
= false;
2849 void wxWindowBase::CaptureMouse()
2851 wxLogTrace(wxT("mousecapture"), wxT("CaptureMouse(%p)"), static_cast<void*>(this));
2853 wxASSERT_MSG( !ms_winCaptureChanging
, wxT("recursive CaptureMouse call?") );
2855 ms_winCaptureChanging
= true;
2857 wxWindow
*winOld
= GetCapture();
2860 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
2863 wxWindowNext
*item
= new wxWindowNext
;
2865 item
->next
= ms_winCaptureNext
;
2866 ms_winCaptureNext
= item
;
2868 //else: no mouse capture to save
2871 ms_winCaptureCurrent
= (wxWindow
*)this;
2873 ms_winCaptureChanging
= false;
2876 void wxWindowBase::ReleaseMouse()
2878 wxLogTrace(wxT("mousecapture"), wxT("ReleaseMouse(%p)"), static_cast<void*>(this));
2880 wxASSERT_MSG( !ms_winCaptureChanging
, wxT("recursive ReleaseMouse call?") );
2882 wxASSERT_MSG( GetCapture() == this,
2883 "attempt to release mouse, but this window hasn't captured it" );
2884 wxASSERT_MSG( ms_winCaptureCurrent
== this,
2885 "attempt to release mouse, but this window hasn't captured it" );
2887 ms_winCaptureChanging
= true;
2890 ms_winCaptureCurrent
= NULL
;
2892 if ( ms_winCaptureNext
)
2894 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
2895 ms_winCaptureCurrent
= ms_winCaptureNext
->win
;
2897 wxWindowNext
*item
= ms_winCaptureNext
;
2898 ms_winCaptureNext
= item
->next
;
2901 //else: stack is empty, no previous capture
2903 ms_winCaptureChanging
= false;
2905 wxLogTrace(wxT("mousecapture"),
2906 (const wxChar
*) wxT("After ReleaseMouse() mouse is captured by %p"),
2907 static_cast<void*>(GetCapture()));
2910 static void DoNotifyWindowAboutCaptureLost(wxWindow
*win
)
2912 wxMouseCaptureLostEvent
event(win
->GetId());
2913 event
.SetEventObject(win
);
2914 if ( !win
->GetEventHandler()->ProcessEvent(event
) )
2916 // windows must handle this event, otherwise the app wouldn't behave
2917 // correctly if it loses capture unexpectedly; see the discussion here:
2918 // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
2919 // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
2920 wxFAIL_MSG( wxT("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
2925 void wxWindowBase::NotifyCaptureLost()
2927 // don't do anything if capture lost was expected, i.e. resulted from
2928 // a wx call to ReleaseMouse or CaptureMouse:
2929 if ( ms_winCaptureChanging
)
2932 // if the capture was lost unexpectedly, notify every window that has
2933 // capture (on stack or current) about it and clear the stack:
2935 if ( ms_winCaptureCurrent
)
2937 DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent
);
2938 ms_winCaptureCurrent
= NULL
;
2941 while ( ms_winCaptureNext
)
2943 wxWindowNext
*item
= ms_winCaptureNext
;
2944 ms_winCaptureNext
= item
->next
;
2946 DoNotifyWindowAboutCaptureLost(item
->win
);
2955 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
2956 int WXUNUSED(modifiers
),
2957 int WXUNUSED(keycode
))
2963 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
2969 #endif // wxUSE_HOTKEY
2971 // ----------------------------------------------------------------------------
2973 // ----------------------------------------------------------------------------
2975 bool wxWindowBase::TryBefore(wxEvent
& event
)
2977 #if wxUSE_VALIDATORS
2978 // Can only use the validator of the window which
2979 // is receiving the event
2980 if ( event
.GetEventObject() == this )
2982 wxValidator
* const validator
= GetValidator();
2983 if ( validator
&& validator
->ProcessEventLocally(event
) )
2988 #endif // wxUSE_VALIDATORS
2990 return wxEvtHandler::TryBefore(event
);
2993 bool wxWindowBase::TryAfter(wxEvent
& event
)
2995 // carry on up the parent-child hierarchy if the propagation count hasn't
2997 if ( event
.ShouldPropagate() )
2999 // honour the requests to stop propagation at this window: this is
3000 // used by the dialogs, for example, to prevent processing the events
3001 // from the dialog controls in the parent frame which rarely, if ever,
3003 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
3005 wxWindow
*parent
= GetParent();
3006 if ( parent
&& !parent
->IsBeingDeleted() )
3008 wxPropagateOnce
propagateOnce(event
);
3010 return parent
->GetEventHandler()->ProcessEvent(event
);
3015 return wxEvtHandler::TryAfter(event
);
3018 // ----------------------------------------------------------------------------
3019 // window relationships
3020 // ----------------------------------------------------------------------------
3022 wxWindow
*wxWindowBase::DoGetSibling(WindowOrder order
) const
3024 wxCHECK_MSG( GetParent(), NULL
,
3025 wxT("GetPrev/NextSibling() don't work for TLWs!") );
3027 wxWindowList
& siblings
= GetParent()->GetChildren();
3028 wxWindowList::compatibility_iterator i
= siblings
.Find((wxWindow
*)this);
3029 wxCHECK_MSG( i
, NULL
, wxT("window not a child of its parent?") );
3031 if ( order
== OrderBefore
)
3032 i
= i
->GetPrevious();
3036 return i
? i
->GetData() : NULL
;
3039 // ----------------------------------------------------------------------------
3040 // keyboard navigation
3041 // ----------------------------------------------------------------------------
3043 // Navigates in the specified direction inside this window
3044 bool wxWindowBase::DoNavigateIn(int flags
)
3046 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
3047 // native code doesn't process our wxNavigationKeyEvents anyhow
3050 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
3051 wxNavigationKeyEvent eventNav
;
3052 wxWindow
*focused
= FindFocus();
3053 eventNav
.SetCurrentFocus(focused
);
3054 eventNav
.SetEventObject(focused
);
3055 eventNav
.SetFlags(flags
);
3056 return GetEventHandler()->ProcessEvent(eventNav
);
3057 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
3060 bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent
& event
)
3062 if ( event
.GetKeyCode() != WXK_TAB
)
3065 int flags
= wxNavigationKeyEvent::FromTab
;
3067 if ( event
.ShiftDown() )
3068 flags
|= wxNavigationKeyEvent::IsBackward
;
3070 flags
|= wxNavigationKeyEvent::IsForward
;
3072 if ( event
.ControlDown() )
3073 flags
|= wxNavigationKeyEvent::WinChange
;
3079 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3081 // check that we're not a top level window
3082 wxCHECK_RET( GetParent(),
3083 wxT("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
3085 // detect the special case when we have nothing to do anyhow and when the
3086 // code below wouldn't work
3090 // find the target window in the siblings list
3091 wxWindowList
& siblings
= GetParent()->GetChildren();
3092 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
3093 wxCHECK_RET( i
, wxT("MoveBefore/AfterInTabOrder(): win is not a sibling") );
3095 // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
3096 // can't just move the node around
3097 wxWindow
*self
= (wxWindow
*)this;
3098 siblings
.DeleteObject(self
);
3099 if ( move
== OrderAfter
)
3106 siblings
.Insert(i
, self
);
3108 else // OrderAfter and win was the last sibling
3110 siblings
.Append(self
);
3114 // ----------------------------------------------------------------------------
3116 // ----------------------------------------------------------------------------
3118 /*static*/ wxWindow
* wxWindowBase::FindFocus()
3120 wxWindowBase
*win
= DoFindFocus();
3121 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
3124 bool wxWindowBase::HasFocus() const
3126 wxWindowBase
*win
= DoFindFocus();
3127 return win
== this ||
3128 win
== wxConstCast(this, wxWindowBase
)->GetMainWindowOfCompositeControl();
3131 // ----------------------------------------------------------------------------
3133 // ----------------------------------------------------------------------------
3135 #if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3140 class DragAcceptFilesTarget
: public wxFileDropTarget
3143 DragAcceptFilesTarget(wxWindowBase
*win
) : m_win(win
) {}
3145 virtual bool OnDropFiles(wxCoord x
, wxCoord y
,
3146 const wxArrayString
& filenames
)
3148 wxDropFilesEvent
event(wxEVT_DROP_FILES
,
3150 wxCArrayString(filenames
).Release());
3151 event
.SetEventObject(m_win
);
3155 return m_win
->HandleWindowEvent(event
);
3159 wxWindowBase
* const m_win
;
3161 wxDECLARE_NO_COPY_CLASS(DragAcceptFilesTarget
);
3165 } // anonymous namespace
3167 // Generic version of DragAcceptFiles(). It works by installing a simple
3168 // wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used
3169 // together with explicit SetDropTarget() calls.
3170 void wxWindowBase::DragAcceptFiles(bool accept
)
3174 wxASSERT_MSG( !GetDropTarget(),
3175 "cannot use DragAcceptFiles() and SetDropTarget() together" );
3176 SetDropTarget(new DragAcceptFilesTarget(this));
3180 SetDropTarget(NULL
);
3184 #endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3186 // ----------------------------------------------------------------------------
3188 // ----------------------------------------------------------------------------
3190 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
3192 while ( win
&& !win
->IsTopLevel() )
3193 win
= win
->GetParent();
3198 #if wxUSE_ACCESSIBILITY
3199 // ----------------------------------------------------------------------------
3200 // accessible object for windows
3201 // ----------------------------------------------------------------------------
3203 // Can return either a child object, or an integer
3204 // representing the child element, starting from 1.
3205 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
3207 wxASSERT( GetWindow() != NULL
);
3211 return wxACC_NOT_IMPLEMENTED
;
3214 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
3215 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
3217 wxASSERT( GetWindow() != NULL
);
3221 wxWindow
* win
= NULL
;
3228 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
3230 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
3237 rect
= win
->GetRect();
3238 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
3239 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
3243 return wxACC_NOT_IMPLEMENTED
;
3246 // Navigates from fromId to toId/toObject.
3247 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
3248 int* WXUNUSED(toId
), wxAccessible
** toObject
)
3250 wxASSERT( GetWindow() != NULL
);
3256 case wxNAVDIR_FIRSTCHILD
:
3258 if (GetWindow()->GetChildren().GetCount() == 0)
3260 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
3261 *toObject
= childWindow
->GetOrCreateAccessible();
3265 case wxNAVDIR_LASTCHILD
:
3267 if (GetWindow()->GetChildren().GetCount() == 0)
3269 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
3270 *toObject
= childWindow
->GetOrCreateAccessible();
3274 case wxNAVDIR_RIGHT
:
3278 wxWindowList::compatibility_iterator node
=
3279 wxWindowList::compatibility_iterator();
3282 // Can't navigate to sibling of this window
3283 // if we're a top-level window.
3284 if (!GetWindow()->GetParent())
3285 return wxACC_NOT_IMPLEMENTED
;
3287 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3291 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3292 node
= GetWindow()->GetChildren().Item(fromId
-1);
3295 if (node
&& node
->GetNext())
3297 wxWindow
* nextWindow
= node
->GetNext()->GetData();
3298 *toObject
= nextWindow
->GetOrCreateAccessible();
3306 case wxNAVDIR_PREVIOUS
:
3308 wxWindowList::compatibility_iterator node
=
3309 wxWindowList::compatibility_iterator();
3312 // Can't navigate to sibling of this window
3313 // if we're a top-level window.
3314 if (!GetWindow()->GetParent())
3315 return wxACC_NOT_IMPLEMENTED
;
3317 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3321 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3322 node
= GetWindow()->GetChildren().Item(fromId
-1);
3325 if (node
&& node
->GetPrevious())
3327 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
3328 *toObject
= previousWindow
->GetOrCreateAccessible();
3336 return wxACC_NOT_IMPLEMENTED
;
3339 // Gets the name of the specified object.
3340 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
3342 wxASSERT( GetWindow() != NULL
);
3348 // If a child, leave wxWidgets to call the function on the actual
3351 return wxACC_NOT_IMPLEMENTED
;
3353 // This will eventually be replaced by specialised
3354 // accessible classes, one for each kind of wxWidgets
3355 // control or window.
3357 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
3358 title
= ((wxButton
*) GetWindow())->GetLabel();
3361 title
= GetWindow()->GetName();
3369 return wxACC_NOT_IMPLEMENTED
;
3372 // Gets the number of children.
3373 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
3375 wxASSERT( GetWindow() != NULL
);
3379 *childId
= (int) GetWindow()->GetChildren().GetCount();
3383 // Gets the specified child (starting from 1).
3384 // If *child is NULL and return value is wxACC_OK,
3385 // this means that the child is a simple element and
3386 // not an accessible object.
3387 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
3389 wxASSERT( GetWindow() != NULL
);
3399 if (childId
> (int) GetWindow()->GetChildren().GetCount())
3402 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
3403 *child
= childWindow
->GetOrCreateAccessible();
3410 // Gets the parent, or NULL.
3411 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
3413 wxASSERT( GetWindow() != NULL
);
3417 wxWindow
* parentWindow
= GetWindow()->GetParent();
3425 *parent
= parentWindow
->GetOrCreateAccessible();
3433 // Performs the default action. childId is 0 (the action for this object)
3434 // or > 0 (the action for a child).
3435 // Return wxACC_NOT_SUPPORTED if there is no default action for this
3436 // window (e.g. an edit control).
3437 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
3439 wxASSERT( GetWindow() != NULL
);
3443 return wxACC_NOT_IMPLEMENTED
;
3446 // Gets the default action for this object (0) or > 0 (the action for a child).
3447 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
3448 // string if there is no action.
3449 // The retrieved string describes the action that is performed on an object,
3450 // not what the object does as a result. For example, a toolbar button that prints
3451 // a document has a default action of "Press" rather than "Prints the current document."
3452 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
3454 wxASSERT( GetWindow() != NULL
);
3458 return wxACC_NOT_IMPLEMENTED
;
3461 // Returns the description for this object or a child.
3462 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
3464 wxASSERT( GetWindow() != NULL
);
3468 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3474 return wxACC_NOT_IMPLEMENTED
;
3477 // Returns help text for this object or a child, similar to tooltip text.
3478 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
3480 wxASSERT( GetWindow() != NULL
);
3484 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3490 return wxACC_NOT_IMPLEMENTED
;
3493 // Returns the keyboard shortcut for this object or child.
3494 // Return e.g. ALT+K
3495 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
3497 wxASSERT( GetWindow() != NULL
);
3501 return wxACC_NOT_IMPLEMENTED
;
3504 // Returns a role constant.
3505 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
3507 wxASSERT( GetWindow() != NULL
);
3511 // If a child, leave wxWidgets to call the function on the actual
3514 return wxACC_NOT_IMPLEMENTED
;
3516 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3517 return wxACC_NOT_IMPLEMENTED
;
3519 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3520 return wxACC_NOT_IMPLEMENTED
;
3523 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3524 return wxACC_NOT_IMPLEMENTED
;
3527 //*role = wxROLE_SYSTEM_CLIENT;
3528 *role
= wxROLE_SYSTEM_CLIENT
;
3532 return wxACC_NOT_IMPLEMENTED
;
3536 // Returns a state constant.
3537 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
3539 wxASSERT( GetWindow() != NULL
);
3543 // If a child, leave wxWidgets to call the function on the actual
3546 return wxACC_NOT_IMPLEMENTED
;
3548 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3549 return wxACC_NOT_IMPLEMENTED
;
3552 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3553 return wxACC_NOT_IMPLEMENTED
;
3556 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3557 return wxACC_NOT_IMPLEMENTED
;
3564 return wxACC_NOT_IMPLEMENTED
;
3568 // Returns a localized string representing the value for the object
3570 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
3572 wxASSERT( GetWindow() != NULL
);
3576 return wxACC_NOT_IMPLEMENTED
;
3579 // Selects the object or child.
3580 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
3582 wxASSERT( GetWindow() != NULL
);
3586 return wxACC_NOT_IMPLEMENTED
;
3589 // Gets the window with the keyboard focus.
3590 // If childId is 0 and child is NULL, no object in
3591 // this subhierarchy has the focus.
3592 // If this object has the focus, child should be 'this'.
3593 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
3595 wxASSERT( GetWindow() != NULL
);
3599 return wxACC_NOT_IMPLEMENTED
;
3603 // Gets a variant representing the selected children
3605 // Acceptable values:
3606 // - a null variant (IsNull() returns true)
3607 // - a list variant (GetType() == wxT("list")
3608 // - an integer representing the selected child element,
3609 // or 0 if this object is selected (GetType() == wxT("long")
3610 // - a "void*" pointer to a wxAccessible child object
3611 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
3613 wxASSERT( GetWindow() != NULL
);
3617 return wxACC_NOT_IMPLEMENTED
;
3619 #endif // wxUSE_VARIANT
3621 #endif // wxUSE_ACCESSIBILITY
3623 // ----------------------------------------------------------------------------
3625 // ----------------------------------------------------------------------------
3628 wxWindowBase::AdjustForLayoutDirection(wxCoord x
,
3630 wxCoord widthTotal
) const
3632 if ( GetLayoutDirection() == wxLayout_RightToLeft
)
3634 x
= widthTotal
- x
- width
;