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/statusbr.h"
42 #include "wx/toolbar.h"
43 #include "wx/dcclient.h"
44 #include "wx/scrolbar.h"
45 #include "wx/layout.h"
50 #if wxUSE_DRAG_AND_DROP
52 #endif // wxUSE_DRAG_AND_DROP
54 #if wxUSE_ACCESSIBILITY
55 #include "wx/access.h"
59 #include "wx/cshelp.h"
63 #include "wx/tooltip.h"
64 #endif // wxUSE_TOOLTIPS
70 #if wxUSE_SYSTEM_OPTIONS
71 #include "wx/sysopt.h"
74 // For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
75 // The gtk includes don't pull any other headers in, at least not on my system - MR
78 #include <gtk/gtkversion.h>
80 #include <gtk/gtkfeatures.h>
84 #include "wx/platinfo.h"
87 WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
91 wxMenu
*wxCurrentPopupMenu
= NULL
;
94 // ----------------------------------------------------------------------------
96 // ----------------------------------------------------------------------------
99 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
101 // ----------------------------------------------------------------------------
103 // ----------------------------------------------------------------------------
105 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
106 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
107 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
108 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
111 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
116 // ============================================================================
117 // implementation of the common functionality of the wxWindow class
118 // ============================================================================
120 // ----------------------------------------------------------------------------
122 // ----------------------------------------------------------------------------
124 // the default initialization
125 wxWindowBase::wxWindowBase()
127 // no window yet, no parent nor children
129 m_windowId
= wxID_ANY
;
131 // no constraints on the minimal window size
133 m_maxWidth
= wxDefaultCoord
;
135 m_maxHeight
= wxDefaultCoord
;
137 // invalidiated cache value
138 m_bestSizeCache
= wxDefaultSize
;
140 // window are created enabled and visible by default
144 // the default event handler is just this window
145 m_eventHandler
= this;
149 m_windowValidator
= NULL
;
150 #endif // wxUSE_VALIDATORS
152 // the colours/fonts are default for now, so leave m_font,
153 // m_backgroundColour and m_foregroundColour uninitialized and set those
159 m_inheritFont
= false;
165 m_backgroundStyle
= wxBG_STYLE_SYSTEM
;
167 #if wxUSE_CONSTRAINTS
168 // no constraints whatsoever
169 m_constraints
= NULL
;
170 m_constraintsInvolvedIn
= NULL
;
171 #endif // wxUSE_CONSTRAINTS
173 m_windowSizer
= NULL
;
174 m_containingSizer
= NULL
;
175 m_autoLayout
= false;
177 #if wxUSE_DRAG_AND_DROP
179 #endif // wxUSE_DRAG_AND_DROP
183 #endif // wxUSE_TOOLTIPS
187 #endif // wxUSE_CARET
190 m_hasCustomPalette
= false;
191 #endif // wxUSE_PALETTE
193 #if wxUSE_ACCESSIBILITY
197 m_virtualSize
= wxDefaultSize
;
199 m_scrollHelper
= NULL
;
201 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
202 #if wxUSE_SYSTEM_OPTIONS
203 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
205 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
209 // Whether we're using the current theme for this window (wxGTK only for now)
210 m_themeEnabled
= false;
212 // This is set to true by SendDestroyEvent() which should be called by the
213 // most derived class to ensure that the destruction event is sent as soon
214 // as possible to allow its handlers to still see the undestroyed window
215 m_isBeingDeleted
= false;
220 // common part of window creation process
221 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
223 const wxPoint
& WXUNUSED(pos
),
224 const wxSize
& WXUNUSED(size
),
226 const wxValidator
& wxVALIDATOR_PARAM(validator
),
227 const wxString
& name
)
230 // wxGTK doesn't allow to create controls with static box as the parent so
231 // this will result in a crash when the program is ported to wxGTK so warn
234 // if you get this assert, the correct solution is to create the controls
235 // as siblings of the static box
236 wxASSERT_MSG( !parent
|| !wxDynamicCast(parent
, wxStaticBox
),
237 _T("wxStaticBox can't be used as a window parent!") );
238 #endif // wxUSE_STATBOX
240 // ids are limited to 16 bits under MSW so if you care about portability,
241 // it's not a good idea to use ids out of this range (and negative ids are
242 // reserved for wxWidgets own usage)
243 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767) ||
244 (id
>= wxID_AUTO_LOWEST
&& id
<= wxID_AUTO_HIGHEST
),
245 _T("invalid id value") );
247 // generate a new id if the user doesn't care about it
248 if ( id
== wxID_ANY
)
250 m_windowId
= NewControlId();
252 else // valid id specified
257 // don't use SetWindowStyleFlag() here, this function should only be called
258 // to change the flag after creation as it tries to reflect the changes in
259 // flags by updating the window dynamically and we don't need this here
260 m_windowStyle
= style
;
266 SetValidator(validator
);
267 #endif // wxUSE_VALIDATORS
269 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
270 // have it too - like this it's possible to set it only in the top level
271 // dialog/frame and all children will inherit it by defult
272 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
274 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
280 bool wxWindowBase::ToggleWindowStyle(int flag
)
282 wxASSERT_MSG( flag
, _T("flags with 0 value can't be toggled") );
285 long style
= GetWindowStyleFlag();
291 else // currently off
297 SetWindowStyleFlag(style
);
302 // ----------------------------------------------------------------------------
304 // ----------------------------------------------------------------------------
307 wxWindowBase::~wxWindowBase()
309 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
311 // FIXME if these 2 cases result from programming errors in the user code
312 // we should probably assert here instead of silently fixing them
314 // Just in case the window has been Closed, but we're then deleting
315 // immediately: don't leave dangling pointers.
316 wxPendingDelete
.DeleteObject(this);
318 // Just in case we've loaded a top-level window via LoadNativeDialog but
319 // we weren't a dialog class
320 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
323 // The associated popup menu can still be alive, disassociate from it in
325 if ( wxCurrentPopupMenu
&& wxCurrentPopupMenu
->GetInvokingWindow() == this )
326 wxCurrentPopupMenu
->SetInvokingWindow(NULL
);
327 #endif // wxUSE_MENUS
329 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
331 // notify the parent about this window destruction
333 m_parent
->RemoveChild(this);
337 #endif // wxUSE_CARET
340 delete m_windowValidator
;
341 #endif // wxUSE_VALIDATORS
343 #if wxUSE_CONSTRAINTS
344 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
345 // at deleted windows as they delete themselves.
346 DeleteRelatedConstraints();
350 // This removes any dangling pointers to this window in other windows'
351 // constraintsInvolvedIn lists.
352 UnsetConstraints(m_constraints
);
353 delete m_constraints
;
354 m_constraints
= NULL
;
356 #endif // wxUSE_CONSTRAINTS
358 if ( m_containingSizer
)
359 m_containingSizer
->Detach( (wxWindow
*)this );
361 delete m_windowSizer
;
363 #if wxUSE_DRAG_AND_DROP
365 #endif // wxUSE_DRAG_AND_DROP
369 #endif // wxUSE_TOOLTIPS
371 #if wxUSE_ACCESSIBILITY
376 // NB: this has to be called unconditionally, because we don't know
377 // whether this window has associated help text or not
378 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
380 helpProvider
->RemoveHelp(this);
384 bool wxWindowBase::IsBeingDeleted() const
386 return m_isBeingDeleted
||
387 (!IsTopLevel() && m_parent
&& m_parent
->IsBeingDeleted());
390 void wxWindowBase::SendDestroyEvent()
392 if ( m_isBeingDeleted
)
394 // we could have been already called from a more derived class dtor,
395 // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call
396 // should be simply ignored
400 m_isBeingDeleted
= true;
402 wxWindowDestroyEvent event
;
403 event
.SetEventObject(this);
404 event
.SetId(GetId());
405 GetEventHandler()->ProcessEvent(event
);
408 bool wxWindowBase::Destroy()
417 bool wxWindowBase::Close(bool force
)
419 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
420 event
.SetEventObject(this);
421 event
.SetCanVeto(!force
);
423 // return false if window wasn't closed because the application vetoed the
425 return HandleWindowEvent(event
) && !event
.GetVeto();
428 bool wxWindowBase::DestroyChildren()
430 wxWindowList::compatibility_iterator node
;
433 // we iterate until the list becomes empty
434 node
= GetChildren().GetFirst();
438 wxWindow
*child
= node
->GetData();
440 // note that we really want to delete it immediately so don't call the
441 // possible overridden Destroy() version which might not delete the
442 // child immediately resulting in problems with our (top level) child
443 // outliving its parent
444 child
->wxWindowBase::Destroy();
446 wxASSERT_MSG( !GetChildren().Find(child
),
447 wxT("child didn't remove itself using RemoveChild()") );
453 // ----------------------------------------------------------------------------
454 // size/position related methods
455 // ----------------------------------------------------------------------------
457 // centre the window with respect to its parent in either (or both) directions
458 void wxWindowBase::DoCentre(int dir
)
460 wxCHECK_RET( !(dir
& wxCENTRE_ON_SCREEN
) && GetParent(),
461 _T("this method only implements centering child windows") );
463 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir
));
466 // fits the window around the children
467 void wxWindowBase::Fit()
469 if ( !GetChildren().empty() )
471 SetSize(GetBestSize());
473 //else: do nothing if we have no children
476 // fits virtual size (ie. scrolled area etc.) around children
477 void wxWindowBase::FitInside()
479 if ( GetChildren().GetCount() > 0 )
481 SetVirtualSize( GetBestVirtualSize() );
485 // On Mac, scrollbars are explicitly children.
487 static bool wxHasRealChildren(const wxWindowBase
* win
)
489 int realChildCount
= 0;
491 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
493 node
= node
->GetNext() )
495 wxWindow
*win
= node
->GetData();
496 if ( !win
->IsTopLevel() && win
->IsShown() && !win
->IsKindOf(CLASSINFO(wxScrollBar
)))
499 return (realChildCount
> 0);
503 void wxWindowBase::InvalidateBestSize()
505 m_bestSizeCache
= wxDefaultSize
;
507 // parent's best size calculation may depend on its children's
508 // as long as child window we are in is not top level window itself
509 // (because the TLW size is never resized automatically)
510 // so let's invalidate it as well to be safe:
511 if (m_parent
&& !IsTopLevel())
512 m_parent
->InvalidateBestSize();
515 // return the size best suited for the current window
516 wxSize
wxWindowBase::DoGetBestSize() const
522 best
= m_windowSizer
->GetMinSize();
524 #if wxUSE_CONSTRAINTS
525 else if ( m_constraints
)
527 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
529 // our minimal acceptable size is such that all our windows fit inside
533 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
535 node
= node
->GetNext() )
537 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
540 // it's not normal that we have an unconstrained child, but
541 // what can we do about it?
545 int x
= c
->right
.GetValue(),
546 y
= c
->bottom
.GetValue();
554 // TODO: we must calculate the overlaps somehow, otherwise we
555 // will never return a size bigger than the current one :-(
558 best
= wxSize(maxX
, maxY
);
560 #endif // wxUSE_CONSTRAINTS
561 else if ( !GetChildren().empty()
563 && wxHasRealChildren(this)
567 // our minimal acceptable size is such that all our visible child
568 // windows fit inside
572 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
574 node
= node
->GetNext() )
576 wxWindow
*win
= node
->GetData();
577 if ( win
->IsTopLevel()
580 || wxDynamicCast(win
, wxStatusBar
)
581 #endif // wxUSE_STATUSBAR
584 // dialogs and frames lie in different top level windows -
585 // don't deal with them here; as for the status bars, they
586 // don't lie in the client area at all
591 win
->GetPosition(&wx
, &wy
);
593 // if the window hadn't been positioned yet, assume that it is in
595 if ( wx
== wxDefaultCoord
)
597 if ( wy
== wxDefaultCoord
)
600 win
->GetSize(&ww
, &wh
);
601 if ( wx
+ ww
> maxX
)
603 if ( wy
+ wh
> maxY
)
607 best
= wxSize(maxX
, maxY
);
609 else // ! has children
611 // for a generic window there is no natural best size so, if the
612 // minimal size is not set, use the current size but take care to
613 // remember it as minimal size for the next time because our best size
614 // should be constant: otherwise we could get into a situation when the
615 // window is initially at some size, then expanded to a larger size and
616 // then, when the containing window is shrunk back (because our initial
617 // best size had been used for computing the parent min size), we can't
618 // be shrunk back any more because our best size is now bigger
619 wxSize size
= GetMinSize();
620 if ( !size
.IsFullySpecified() )
622 size
.SetDefaults(GetSize());
623 wxConstCast(this, wxWindowBase
)->SetMinSize(size
);
626 // return as-is, unadjusted by the client size difference.
630 // Add any difference between size and client size
631 wxSize diff
= GetSize() - GetClientSize();
632 best
.x
+= wxMax(0, diff
.x
);
633 best
.y
+= wxMax(0, diff
.y
);
638 // helper of GetWindowBorderSize(): as many ports don't implement support for
639 // wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
640 // fallbacks in this case
641 static int wxGetMetricOrDefault(wxSystemMetric what
, const wxWindowBase
* win
)
643 int rc
= wxSystemSettings::GetMetric(
644 what
, static_cast<wxWindow
*>(const_cast<wxWindowBase
*>(win
)));
651 // 2D border is by default 1 pixel wide
657 // 3D borders are by default 2 pixels
662 wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
670 wxSize
wxWindowBase::GetWindowBorderSize() const
674 switch ( GetBorder() )
677 // nothing to do, size is already (0, 0)
680 case wxBORDER_SIMPLE
:
681 case wxBORDER_STATIC
:
682 size
.x
= wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
683 size
.y
= wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
686 case wxBORDER_SUNKEN
:
687 case wxBORDER_RAISED
:
688 size
.x
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X
, this),
689 wxGetMetricOrDefault(wxSYS_BORDER_X
, this));
690 size
.y
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y
, this),
691 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this));
694 case wxBORDER_DOUBLE
:
695 size
.x
= wxGetMetricOrDefault(wxSYS_EDGE_X
, this) +
696 wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
697 size
.y
= wxGetMetricOrDefault(wxSYS_EDGE_Y
, this) +
698 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
702 wxFAIL_MSG(_T("Unknown border style."));
706 // we have borders on both sides
710 wxSize
wxWindowBase::GetEffectiveMinSize() const
712 // merge the best size with the min size, giving priority to the min size
713 wxSize min
= GetMinSize();
714 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
716 wxSize best
= GetBestSize();
717 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
718 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
724 void wxWindowBase::SetInitialSize(const wxSize
& size
)
726 // Set the min size to the size passed in. This will usually either be
727 // wxDefaultSize or the size passed to this window's ctor/Create function.
730 // Merge the size with the best size if needed
731 wxSize best
= GetEffectiveMinSize();
733 // If the current size doesn't match then change it
734 if (GetSize() != best
)
739 // by default the origin is not shifted
740 wxPoint
wxWindowBase::GetClientAreaOrigin() const
745 wxSize
wxWindowBase::ClientToWindowSize(const wxSize
& size
) const
747 const wxSize
diff(GetSize() - GetClientSize());
749 return wxSize(size
.x
== -1 ? -1 : size
.x
+ diff
.x
,
750 size
.y
== -1 ? -1 : size
.y
+ diff
.y
);
753 wxSize
wxWindowBase::WindowToClientSize(const wxSize
& size
) const
755 const wxSize
diff(GetSize() - GetClientSize());
757 return wxSize(size
.x
== -1 ? -1 : size
.x
- diff
.x
,
758 size
.y
== -1 ? -1 : size
.y
- diff
.y
);
761 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
763 if ( m_windowVariant
!= variant
)
765 m_windowVariant
= variant
;
767 DoSetWindowVariant(variant
);
771 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
773 // adjust the font height to correspond to our new variant (notice that
774 // we're only called if something really changed)
775 wxFont font
= GetFont();
776 int size
= font
.GetPointSize();
779 case wxWINDOW_VARIANT_NORMAL
:
782 case wxWINDOW_VARIANT_SMALL
:
787 case wxWINDOW_VARIANT_MINI
:
792 case wxWINDOW_VARIANT_LARGE
:
798 wxFAIL_MSG(_T("unexpected window variant"));
802 font
.SetPointSize(size
);
806 void wxWindowBase::DoSetSizeHints( int minW
, int minH
,
808 int WXUNUSED(incW
), int WXUNUSED(incH
) )
810 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
811 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
812 _T("min width/height must be less than max width/height!") );
821 #if WXWIN_COMPATIBILITY_2_8
822 void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW
), int WXUNUSED(minH
),
823 int WXUNUSED(maxW
), int WXUNUSED(maxH
))
827 void wxWindowBase::SetVirtualSizeHints(const wxSize
& WXUNUSED(minsize
),
828 const wxSize
& WXUNUSED(maxsize
))
831 #endif // WXWIN_COMPATIBILITY_2_8
833 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
835 m_virtualSize
= wxSize(x
, y
);
838 wxSize
wxWindowBase::DoGetVirtualSize() const
840 // we should use the entire client area so if it is greater than our
841 // virtual size, expand it to fit (otherwise if the window is big enough we
842 // wouldn't be using parts of it)
843 wxSize size
= GetClientSize();
844 if ( m_virtualSize
.x
> size
.x
)
845 size
.x
= m_virtualSize
.x
;
847 if ( m_virtualSize
.y
>= size
.y
)
848 size
.y
= m_virtualSize
.y
;
853 void wxWindowBase::DoGetScreenPosition(int *x
, int *y
) const
855 // screen position is the same as (0, 0) in client coords for non TLWs (and
856 // TLWs override this method)
862 ClientToScreen(x
, y
);
865 void wxWindowBase::SendSizeEvent(int flags
)
867 wxSizeEvent
event(GetSize(), GetId());
868 event
.SetEventObject(this);
869 if ( flags
& wxSEND_EVENT_POST
)
870 wxPostEvent(this, event
);
872 HandleWindowEvent(event
);
875 void wxWindowBase::SendSizeEventToParent(int flags
)
877 wxWindow
* const parent
= GetParent();
878 if ( parent
&& !parent
->IsBeingDeleted() )
879 parent
->SendSizeEvent(flags
);
882 // ----------------------------------------------------------------------------
883 // show/hide/enable/disable the window
884 // ----------------------------------------------------------------------------
886 bool wxWindowBase::Show(bool show
)
888 if ( show
!= m_isShown
)
900 bool wxWindowBase::IsEnabled() const
902 return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
905 void wxWindowBase::NotifyWindowOnEnableChange(bool enabled
)
907 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
909 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
913 // If we are top-level then the logic doesn't apply - otherwise
914 // showing a modal dialog would result in total greying out (and ungreying
915 // out later) of everything which would be really ugly
919 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
921 node
= node
->GetNext() )
923 wxWindowBase
* const child
= node
->GetData();
924 if ( !child
->IsTopLevel() && child
->IsThisEnabled() )
925 child
->NotifyWindowOnEnableChange(enabled
);
929 bool wxWindowBase::Enable(bool enable
)
931 if ( enable
== IsThisEnabled() )
934 m_isEnabled
= enable
;
936 #ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
938 #else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
939 wxWindowBase
* const parent
= GetParent();
940 if( !IsTopLevel() && parent
&& !parent
->IsEnabled() )
944 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
946 NotifyWindowOnEnableChange(enable
);
951 bool wxWindowBase::IsShownOnScreen() const
953 // A window is shown on screen if it itself is shown and so are all its
954 // parents. But if a window is toplevel one, then its always visible on
955 // screen if IsShown() returns true, even if it has a hidden parent.
957 (IsTopLevel() || GetParent() == NULL
|| GetParent()->IsShownOnScreen());
960 // ----------------------------------------------------------------------------
962 // ----------------------------------------------------------------------------
964 bool wxWindowBase::IsTopLevel() const
969 // ----------------------------------------------------------------------------
971 // ----------------------------------------------------------------------------
973 void wxWindowBase::Freeze()
975 if ( !m_freezeCount
++ )
977 // physically freeze this window:
980 // and recursively freeze all children:
981 for ( wxWindowList::iterator i
= GetChildren().begin();
982 i
!= GetChildren().end(); ++i
)
984 wxWindow
*child
= *i
;
985 if ( child
->IsTopLevel() )
993 void wxWindowBase::Thaw()
995 wxASSERT_MSG( m_freezeCount
, "Thaw() without matching Freeze()" );
997 if ( !--m_freezeCount
)
999 // recursively thaw all children:
1000 for ( wxWindowList::iterator i
= GetChildren().begin();
1001 i
!= GetChildren().end(); ++i
)
1003 wxWindow
*child
= *i
;
1004 if ( child
->IsTopLevel() )
1010 // physically thaw this window:
1015 // ----------------------------------------------------------------------------
1016 // reparenting the window
1017 // ----------------------------------------------------------------------------
1019 void wxWindowBase::AddChild(wxWindowBase
*child
)
1021 wxCHECK_RET( child
, wxT("can't add a NULL child") );
1023 // this should never happen and it will lead to a crash later if it does
1024 // because RemoveChild() will remove only one node from the children list
1025 // and the other(s) one(s) will be left with dangling pointers in them
1026 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), _T("AddChild() called twice") );
1028 GetChildren().Append((wxWindow
*)child
);
1029 child
->SetParent(this);
1031 // adding a child while frozen will assert when thawed, so freeze it as if
1032 // it had been already present when we were frozen
1033 if ( IsFrozen() && !child
->IsTopLevel() )
1037 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
1039 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
1041 // removing a child while frozen may result in permanently frozen window
1042 // if used e.g. from Reparent(), so thaw it
1044 // NB: IsTopLevel() doesn't return true any more when a TLW child is being
1045 // removed from its ~wxWindowBase, so check for IsBeingDeleted() too
1046 if ( IsFrozen() && !child
->IsBeingDeleted() && !child
->IsTopLevel() )
1049 GetChildren().DeleteObject((wxWindow
*)child
);
1050 child
->SetParent(NULL
);
1053 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
1055 wxWindow
*oldParent
= GetParent();
1056 if ( newParent
== oldParent
)
1062 const bool oldEnabledState
= IsEnabled();
1064 // unlink this window from the existing parent.
1067 oldParent
->RemoveChild(this);
1071 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
1074 // add it to the new one
1077 newParent
->AddChild(this);
1081 wxTopLevelWindows
.Append((wxWindow
*)this);
1084 // We need to notify window (and its subwindows) if by changing the parent
1085 // we also change our enabled/disabled status.
1086 const bool newEnabledState
= IsEnabled();
1087 if ( newEnabledState
!= oldEnabledState
)
1089 NotifyWindowOnEnableChange(newEnabledState
);
1095 // ----------------------------------------------------------------------------
1096 // event handler stuff
1097 // ----------------------------------------------------------------------------
1099 void wxWindowBase::PushEventHandler(wxEvtHandler
*handler
)
1101 wxEvtHandler
*handlerOld
= GetEventHandler();
1103 handler
->SetNextHandler(handlerOld
);
1106 GetEventHandler()->SetPreviousHandler(handler
);
1108 SetEventHandler(handler
);
1111 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
1113 wxEvtHandler
*handlerA
= GetEventHandler();
1116 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
1117 handlerA
->SetNextHandler(NULL
);
1120 handlerB
->SetPreviousHandler(NULL
);
1121 SetEventHandler(handlerB
);
1123 if ( deleteHandler
)
1133 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handler
)
1135 wxCHECK_MSG( handler
, false, _T("RemoveEventHandler(NULL) called") );
1137 wxEvtHandler
*handlerPrev
= NULL
,
1138 *handlerCur
= GetEventHandler();
1139 while ( handlerCur
)
1141 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
1143 if ( handlerCur
== handler
)
1147 handlerPrev
->SetNextHandler(handlerNext
);
1151 SetEventHandler(handlerNext
);
1156 handlerNext
->SetPreviousHandler ( handlerPrev
);
1159 handler
->SetNextHandler(NULL
);
1160 handler
->SetPreviousHandler(NULL
);
1165 handlerPrev
= handlerCur
;
1166 handlerCur
= handlerNext
;
1169 wxFAIL_MSG( _T("where has the event handler gone?") );
1174 bool wxWindowBase::HandleWindowEvent(wxEvent
& event
) const
1176 return GetEventHandler()->SafelyProcessEvent(event
);
1179 // ----------------------------------------------------------------------------
1180 // colours, fonts &c
1181 // ----------------------------------------------------------------------------
1183 void wxWindowBase::InheritAttributes()
1185 const wxWindowBase
* const parent
= GetParent();
1189 // we only inherit attributes which had been explicitly set for the parent
1190 // which ensures that this only happens if the user really wants it and
1191 // not by default which wouldn't make any sense in modern GUIs where the
1192 // controls don't all use the same fonts (nor colours)
1193 if ( parent
->m_inheritFont
&& !m_hasFont
)
1194 SetFont(parent
->GetFont());
1196 // in addition, there is a possibility to explicitly forbid inheriting
1197 // colours at each class level by overriding ShouldInheritColours()
1198 if ( ShouldInheritColours() )
1200 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
1201 SetForegroundColour(parent
->GetForegroundColour());
1203 // inheriting (solid) background colour is wrong as it totally breaks
1204 // any kind of themed backgrounds
1206 // instead, the controls should use the same background as their parent
1207 // (ideally by not drawing it at all)
1209 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
1210 SetBackgroundColour(parent
->GetBackgroundColour());
1215 /* static */ wxVisualAttributes
1216 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1218 // it is important to return valid values for all attributes from here,
1219 // GetXXX() below rely on this
1220 wxVisualAttributes attrs
;
1221 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
1222 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1224 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1225 // the usual background colour than wxSYS_COLOUR_BTNFACE.
1226 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1227 // colour on other platforms.
1229 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1230 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1232 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
1237 wxColour
wxWindowBase::GetBackgroundColour() const
1239 if ( !m_backgroundColour
.IsOk() )
1241 wxASSERT_MSG( !m_hasBgCol
, _T("we have invalid explicit bg colour?") );
1243 // get our default background colour
1244 wxColour colBg
= GetDefaultAttributes().colBg
;
1246 // we must return some valid colour to avoid redoing this every time
1247 // and also to avoid surprizing the applications written for older
1248 // wxWidgets versions where GetBackgroundColour() always returned
1249 // something -- so give them something even if it doesn't make sense
1250 // for this window (e.g. it has a themed background)
1252 colBg
= GetClassDefaultAttributes().colBg
;
1257 return m_backgroundColour
;
1260 wxColour
wxWindowBase::GetForegroundColour() const
1262 // logic is the same as above
1263 if ( !m_hasFgCol
&& !m_foregroundColour
.Ok() )
1265 wxColour colFg
= GetDefaultAttributes().colFg
;
1267 if ( !colFg
.IsOk() )
1268 colFg
= GetClassDefaultAttributes().colFg
;
1273 return m_foregroundColour
;
1276 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1278 if ( colour
== m_backgroundColour
)
1281 m_hasBgCol
= colour
.IsOk();
1282 if ( m_backgroundStyle
!= wxBG_STYLE_CUSTOM
)
1283 m_backgroundStyle
= m_hasBgCol
? wxBG_STYLE_COLOUR
: wxBG_STYLE_SYSTEM
;
1285 m_inheritBgCol
= m_hasBgCol
;
1286 m_backgroundColour
= colour
;
1287 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.Ok() );
1291 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1293 if (colour
== m_foregroundColour
)
1296 m_hasFgCol
= colour
.IsOk();
1297 m_inheritFgCol
= m_hasFgCol
;
1298 m_foregroundColour
= colour
;
1299 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.Ok() );
1303 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1305 // setting an invalid cursor is ok, it means that we don't have any special
1307 if ( m_cursor
.IsSameAs(cursor
) )
1318 wxFont
wxWindowBase::GetFont() const
1320 // logic is the same as in GetBackgroundColour()
1321 if ( !m_font
.IsOk() )
1323 wxASSERT_MSG( !m_hasFont
, _T("we have invalid explicit font?") );
1325 wxFont font
= GetDefaultAttributes().font
;
1327 font
= GetClassDefaultAttributes().font
;
1335 bool wxWindowBase::SetFont(const wxFont
& font
)
1337 if ( font
== m_font
)
1344 m_hasFont
= font
.IsOk();
1345 m_inheritFont
= m_hasFont
;
1347 InvalidateBestSize();
1354 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1356 m_hasCustomPalette
= true;
1359 // VZ: can anyone explain me what do we do here?
1360 wxWindowDC
d((wxWindow
*) this);
1364 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1366 wxWindow
*win
= (wxWindow
*)this;
1367 while ( win
&& !win
->HasCustomPalette() )
1369 win
= win
->GetParent();
1375 #endif // wxUSE_PALETTE
1378 void wxWindowBase::SetCaret(wxCaret
*caret
)
1389 wxASSERT_MSG( m_caret
->GetWindow() == this,
1390 wxT("caret should be created associated to this window") );
1393 #endif // wxUSE_CARET
1395 #if wxUSE_VALIDATORS
1396 // ----------------------------------------------------------------------------
1398 // ----------------------------------------------------------------------------
1400 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1402 if ( m_windowValidator
)
1403 delete m_windowValidator
;
1405 m_windowValidator
= (wxValidator
*)validator
.Clone();
1407 if ( m_windowValidator
)
1408 m_windowValidator
->SetWindow(this);
1410 #endif // wxUSE_VALIDATORS
1412 // ----------------------------------------------------------------------------
1413 // update region stuff
1414 // ----------------------------------------------------------------------------
1416 wxRect
wxWindowBase::GetUpdateClientRect() const
1418 wxRegion rgnUpdate
= GetUpdateRegion();
1419 rgnUpdate
.Intersect(GetClientRect());
1420 wxRect rectUpdate
= rgnUpdate
.GetBox();
1421 wxPoint ptOrigin
= GetClientAreaOrigin();
1422 rectUpdate
.x
-= ptOrigin
.x
;
1423 rectUpdate
.y
-= ptOrigin
.y
;
1428 bool wxWindowBase::DoIsExposed(int x
, int y
) const
1430 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1433 bool wxWindowBase::DoIsExposed(int x
, int y
, int w
, int h
) const
1435 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1438 void wxWindowBase::ClearBackground()
1440 // wxGTK uses its own version, no need to add never used code
1442 wxClientDC
dc((wxWindow
*)this);
1443 wxBrush
brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
);
1444 dc
.SetBackground(brush
);
1449 // ----------------------------------------------------------------------------
1450 // find child window by id or name
1451 // ----------------------------------------------------------------------------
1453 wxWindow
*wxWindowBase::FindWindow(long id
) const
1455 if ( id
== m_windowId
)
1456 return (wxWindow
*)this;
1458 wxWindowBase
*res
= NULL
;
1459 wxWindowList::compatibility_iterator node
;
1460 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1462 wxWindowBase
*child
= node
->GetData();
1463 res
= child
->FindWindow( id
);
1466 return (wxWindow
*)res
;
1469 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1471 if ( name
== m_windowName
)
1472 return (wxWindow
*)this;
1474 wxWindowBase
*res
= NULL
;
1475 wxWindowList::compatibility_iterator node
;
1476 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1478 wxWindow
*child
= node
->GetData();
1479 res
= child
->FindWindow(name
);
1482 return (wxWindow
*)res
;
1486 // find any window by id or name or label: If parent is non-NULL, look through
1487 // children for a label or title matching the specified string. If NULL, look
1488 // through all top-level windows.
1490 // to avoid duplicating code we reuse the same helper function but with
1491 // different comparators
1493 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1494 const wxString
& label
, long id
);
1497 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1500 return win
->GetLabel() == label
;
1504 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1507 return win
->GetName() == label
;
1511 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1514 return win
->GetId() == id
;
1517 // recursive helper for the FindWindowByXXX() functions
1519 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1520 const wxString
& label
,
1522 wxFindWindowCmp cmp
)
1526 // see if this is the one we're looking for
1527 if ( (*cmp
)(parent
, label
, id
) )
1528 return (wxWindow
*)parent
;
1530 // It wasn't, so check all its children
1531 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1533 node
= node
->GetNext() )
1535 // recursively check each child
1536 wxWindow
*win
= (wxWindow
*)node
->GetData();
1537 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1547 // helper for FindWindowByXXX()
1549 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1550 const wxString
& label
,
1552 wxFindWindowCmp cmp
)
1556 // just check parent and all its children
1557 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1560 // start at very top of wx's windows
1561 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1563 node
= node
->GetNext() )
1565 // recursively check each window & its children
1566 wxWindow
*win
= node
->GetData();
1567 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1577 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1579 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1584 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1586 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1590 // fall back to the label
1591 win
= FindWindowByLabel(title
, parent
);
1599 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1601 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1604 // ----------------------------------------------------------------------------
1605 // dialog oriented functions
1606 // ----------------------------------------------------------------------------
1608 void wxWindowBase::MakeModal(bool modal
)
1610 // Disable all other windows
1613 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1616 wxWindow
*win
= node
->GetData();
1618 win
->Enable(!modal
);
1620 node
= node
->GetNext();
1625 bool wxWindowBase::Validate()
1627 #if wxUSE_VALIDATORS
1628 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1630 wxWindowList::compatibility_iterator node
;
1631 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1633 wxWindowBase
*child
= node
->GetData();
1634 wxValidator
*validator
= child
->GetValidator();
1635 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1640 if ( recurse
&& !child
->Validate() )
1645 #endif // wxUSE_VALIDATORS
1650 bool wxWindowBase::TransferDataToWindow()
1652 #if wxUSE_VALIDATORS
1653 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1655 wxWindowList::compatibility_iterator node
;
1656 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1658 wxWindowBase
*child
= node
->GetData();
1659 wxValidator
*validator
= child
->GetValidator();
1660 if ( validator
&& !validator
->TransferToWindow() )
1662 wxLogWarning(_("Could not transfer data to window"));
1664 wxLog::FlushActive();
1672 if ( !child
->TransferDataToWindow() )
1674 // warning already given
1679 #endif // wxUSE_VALIDATORS
1684 bool wxWindowBase::TransferDataFromWindow()
1686 #if wxUSE_VALIDATORS
1687 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1689 wxWindowList::compatibility_iterator node
;
1690 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1692 wxWindow
*child
= node
->GetData();
1693 wxValidator
*validator
= child
->GetValidator();
1694 if ( validator
&& !validator
->TransferFromWindow() )
1696 // nop warning here because the application is supposed to give
1697 // one itself - we don't know here what might have gone wrongly
1704 if ( !child
->TransferDataFromWindow() )
1706 // warning already given
1711 #endif // wxUSE_VALIDATORS
1716 void wxWindowBase::InitDialog()
1718 wxInitDialogEvent
event(GetId());
1719 event
.SetEventObject( this );
1720 GetEventHandler()->ProcessEvent(event
);
1723 // ----------------------------------------------------------------------------
1724 // context-sensitive help support
1725 // ----------------------------------------------------------------------------
1729 // associate this help text with this window
1730 void wxWindowBase::SetHelpText(const wxString
& text
)
1732 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1735 helpProvider
->AddHelp(this, text
);
1739 #if WXWIN_COMPATIBILITY_2_8
1740 // associate this help text with all windows with the same id as this
1742 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
1744 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1747 helpProvider
->AddHelp(GetId(), text
);
1750 #endif // WXWIN_COMPATIBILITY_2_8
1752 // get the help string associated with this window (may be empty)
1753 // default implementation forwards calls to the help provider
1755 wxWindowBase::GetHelpTextAtPoint(const wxPoint
& WXUNUSED(pt
),
1756 wxHelpEvent::Origin
WXUNUSED(origin
)) const
1759 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1762 text
= helpProvider
->GetHelp(this);
1768 // show help for this window
1769 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
1771 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1774 wxPoint pos
= event
.GetPosition();
1775 const wxHelpEvent::Origin origin
= event
.GetOrigin();
1776 if ( origin
== wxHelpEvent::Origin_Keyboard
)
1778 // if the help event was generated from keyboard it shouldn't
1779 // appear at the mouse position (which is still the only position
1780 // associated with help event) if the mouse is far away, although
1781 // we still do use the mouse position if it's over the window
1782 // because we suppose the user looks approximately at the mouse
1783 // already and so it would be more convenient than showing tooltip
1784 // at some arbitrary position which can be quite far from it
1785 const wxRect rectClient
= GetClientRect();
1786 if ( !rectClient
.Contains(ScreenToClient(pos
)) )
1788 // position help slightly under and to the right of this window
1789 pos
= ClientToScreen(wxPoint(
1791 rectClient
.height
+ GetCharHeight()
1796 if ( helpProvider
->ShowHelpAtPoint(this, pos
, origin
) )
1798 // skip the event.Skip() below
1806 #endif // wxUSE_HELP
1808 // ----------------------------------------------------------------------------
1810 // ----------------------------------------------------------------------------
1814 void wxWindowBase::SetToolTip( const wxString
&tip
)
1816 // don't create the new tooltip if we already have one
1819 m_tooltip
->SetTip( tip
);
1823 SetToolTip( new wxToolTip( tip
) );
1826 // setting empty tooltip text does not remove the tooltip any more - use
1827 // SetToolTip(NULL) for this
1830 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
1832 if ( m_tooltip
!= tooltip
)
1837 m_tooltip
= tooltip
;
1841 #endif // wxUSE_TOOLTIPS
1843 // ----------------------------------------------------------------------------
1844 // constraints and sizers
1845 // ----------------------------------------------------------------------------
1847 #if wxUSE_CONSTRAINTS
1849 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
1851 if ( m_constraints
)
1853 UnsetConstraints(m_constraints
);
1854 delete m_constraints
;
1856 m_constraints
= constraints
;
1857 if ( m_constraints
)
1859 // Make sure other windows know they're part of a 'meaningful relationship'
1860 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
1861 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
1862 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
1863 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
1864 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
1865 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
1866 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
1867 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
1868 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
1869 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
1870 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
1871 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
1872 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
1873 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
1874 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
1875 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
1879 // This removes any dangling pointers to this window in other windows'
1880 // constraintsInvolvedIn lists.
1881 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
1885 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1886 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
1887 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1888 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
1889 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
1890 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
1891 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
1892 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
1893 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
1894 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
1895 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
1896 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
1897 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
1898 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
1899 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
1900 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
1904 // Back-pointer to other windows we're involved with, so if we delete this
1905 // window, we must delete any constraints we're involved with.
1906 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
1908 if ( !m_constraintsInvolvedIn
)
1909 m_constraintsInvolvedIn
= new wxWindowList
;
1910 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
1911 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
1914 // REMOVE back-pointer to other windows we're involved with.
1915 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
1917 if ( m_constraintsInvolvedIn
)
1918 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
1921 // Reset any constraints that mention this window
1922 void wxWindowBase::DeleteRelatedConstraints()
1924 if ( m_constraintsInvolvedIn
)
1926 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
1929 wxWindow
*win
= node
->GetData();
1930 wxLayoutConstraints
*constr
= win
->GetConstraints();
1932 // Reset any constraints involving this window
1935 constr
->left
.ResetIfWin(this);
1936 constr
->top
.ResetIfWin(this);
1937 constr
->right
.ResetIfWin(this);
1938 constr
->bottom
.ResetIfWin(this);
1939 constr
->width
.ResetIfWin(this);
1940 constr
->height
.ResetIfWin(this);
1941 constr
->centreX
.ResetIfWin(this);
1942 constr
->centreY
.ResetIfWin(this);
1945 wxWindowList::compatibility_iterator next
= node
->GetNext();
1946 m_constraintsInvolvedIn
->Erase(node
);
1950 delete m_constraintsInvolvedIn
;
1951 m_constraintsInvolvedIn
= NULL
;
1955 #endif // wxUSE_CONSTRAINTS
1957 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
1959 if ( sizer
== m_windowSizer
)
1962 if ( m_windowSizer
)
1964 m_windowSizer
->SetContainingWindow(NULL
);
1967 delete m_windowSizer
;
1970 m_windowSizer
= sizer
;
1971 if ( m_windowSizer
)
1973 m_windowSizer
->SetContainingWindow((wxWindow
*)this);
1976 SetAutoLayout(m_windowSizer
!= NULL
);
1979 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
1981 SetSizer( sizer
, deleteOld
);
1982 sizer
->SetSizeHints( (wxWindow
*) this );
1986 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
1988 // adding a window to a sizer twice is going to result in fatal and
1989 // hard to debug problems later because when deleting the second
1990 // associated wxSizerItem we're going to dereference a dangling
1991 // pointer; so try to detect this as early as possible
1992 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
1993 _T("Adding a window to the same sizer twice?") );
1995 m_containingSizer
= sizer
;
1998 #if wxUSE_CONSTRAINTS
2000 void wxWindowBase::SatisfyConstraints()
2002 wxLayoutConstraints
*constr
= GetConstraints();
2003 bool wasOk
= constr
&& constr
->AreSatisfied();
2005 ResetConstraints(); // Mark all constraints as unevaluated
2009 // if we're a top level panel (i.e. our parent is frame/dialog), our
2010 // own constraints will never be satisfied any more unless we do it
2014 while ( noChanges
> 0 )
2016 LayoutPhase1(&noChanges
);
2020 LayoutPhase2(&noChanges
);
2023 #endif // wxUSE_CONSTRAINTS
2025 bool wxWindowBase::Layout()
2027 // If there is a sizer, use it instead of the constraints
2031 GetVirtualSize(&w
, &h
);
2032 GetSizer()->SetDimension( 0, 0, w
, h
);
2034 #if wxUSE_CONSTRAINTS
2037 SatisfyConstraints(); // Find the right constraints values
2038 SetConstraintSizes(); // Recursively set the real window sizes
2045 #if wxUSE_CONSTRAINTS
2047 // first phase of the constraints evaluation: set our own constraints
2048 bool wxWindowBase::LayoutPhase1(int *noChanges
)
2050 wxLayoutConstraints
*constr
= GetConstraints();
2052 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
2055 // second phase: set the constraints for our children
2056 bool wxWindowBase::LayoutPhase2(int *noChanges
)
2063 // Layout grand children
2069 // Do a phase of evaluating child constraints
2070 bool wxWindowBase::DoPhase(int phase
)
2072 // the list containing the children for which the constraints are already
2074 wxWindowList succeeded
;
2076 // the max number of iterations we loop before concluding that we can't set
2078 static const int maxIterations
= 500;
2080 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
2084 // loop over all children setting their constraints
2085 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2087 node
= node
->GetNext() )
2089 wxWindow
*child
= node
->GetData();
2090 if ( child
->IsTopLevel() )
2092 // top level children are not inside our client area
2096 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
2098 // this one is either already ok or nothing we can do about it
2102 int tempNoChanges
= 0;
2103 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
2104 : child
->LayoutPhase2(&tempNoChanges
);
2105 noChanges
+= tempNoChanges
;
2109 succeeded
.Append(child
);
2115 // constraints are set
2123 void wxWindowBase::ResetConstraints()
2125 wxLayoutConstraints
*constr
= GetConstraints();
2128 constr
->left
.SetDone(false);
2129 constr
->top
.SetDone(false);
2130 constr
->right
.SetDone(false);
2131 constr
->bottom
.SetDone(false);
2132 constr
->width
.SetDone(false);
2133 constr
->height
.SetDone(false);
2134 constr
->centreX
.SetDone(false);
2135 constr
->centreY
.SetDone(false);
2138 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2141 wxWindow
*win
= node
->GetData();
2142 if ( !win
->IsTopLevel() )
2143 win
->ResetConstraints();
2144 node
= node
->GetNext();
2148 // Need to distinguish between setting the 'fake' size for windows and sizers,
2149 // and setting the real values.
2150 void wxWindowBase::SetConstraintSizes(bool recurse
)
2152 wxLayoutConstraints
*constr
= GetConstraints();
2153 if ( constr
&& constr
->AreSatisfied() )
2155 int x
= constr
->left
.GetValue();
2156 int y
= constr
->top
.GetValue();
2157 int w
= constr
->width
.GetValue();
2158 int h
= constr
->height
.GetValue();
2160 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
2161 (constr
->height
.GetRelationship() != wxAsIs
) )
2163 SetSize(x
, y
, w
, h
);
2167 // If we don't want to resize this window, just move it...
2173 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
2174 GetClassInfo()->GetClassName(),
2180 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2183 wxWindow
*win
= node
->GetData();
2184 if ( !win
->IsTopLevel() && win
->GetConstraints() )
2185 win
->SetConstraintSizes();
2186 node
= node
->GetNext();
2191 // Only set the size/position of the constraint (if any)
2192 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
2194 wxLayoutConstraints
*constr
= GetConstraints();
2197 if ( x
!= wxDefaultCoord
)
2199 constr
->left
.SetValue(x
);
2200 constr
->left
.SetDone(true);
2202 if ( y
!= wxDefaultCoord
)
2204 constr
->top
.SetValue(y
);
2205 constr
->top
.SetDone(true);
2207 if ( w
!= wxDefaultCoord
)
2209 constr
->width
.SetValue(w
);
2210 constr
->width
.SetDone(true);
2212 if ( h
!= wxDefaultCoord
)
2214 constr
->height
.SetValue(h
);
2215 constr
->height
.SetDone(true);
2220 void wxWindowBase::MoveConstraint(int x
, int y
)
2222 wxLayoutConstraints
*constr
= GetConstraints();
2225 if ( x
!= wxDefaultCoord
)
2227 constr
->left
.SetValue(x
);
2228 constr
->left
.SetDone(true);
2230 if ( y
!= wxDefaultCoord
)
2232 constr
->top
.SetValue(y
);
2233 constr
->top
.SetDone(true);
2238 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
2240 wxLayoutConstraints
*constr
= GetConstraints();
2243 *w
= constr
->width
.GetValue();
2244 *h
= constr
->height
.GetValue();
2250 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
2252 wxLayoutConstraints
*constr
= GetConstraints();
2255 *w
= constr
->width
.GetValue();
2256 *h
= constr
->height
.GetValue();
2259 GetClientSize(w
, h
);
2262 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
2264 wxLayoutConstraints
*constr
= GetConstraints();
2267 *x
= constr
->left
.GetValue();
2268 *y
= constr
->top
.GetValue();
2274 #endif // wxUSE_CONSTRAINTS
2276 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
2278 // don't do it for the dialogs/frames - they float independently of their
2280 if ( !IsTopLevel() )
2282 wxWindow
*parent
= GetParent();
2283 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
2285 wxPoint
pt(parent
->GetClientAreaOrigin());
2292 // ----------------------------------------------------------------------------
2293 // Update UI processing
2294 // ----------------------------------------------------------------------------
2296 void wxWindowBase::UpdateWindowUI(long flags
)
2298 wxUpdateUIEvent
event(GetId());
2299 event
.SetEventObject(this);
2301 if ( GetEventHandler()->ProcessEvent(event
) )
2303 DoUpdateWindowUI(event
);
2306 if (flags
& wxUPDATE_UI_RECURSE
)
2308 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2311 wxWindow
* child
= (wxWindow
*) node
->GetData();
2312 child
->UpdateWindowUI(flags
);
2313 node
= node
->GetNext();
2318 // do the window-specific processing after processing the update event
2319 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2321 if ( event
.GetSetEnabled() )
2322 Enable(event
.GetEnabled());
2324 if ( event
.GetSetShown() )
2325 Show(event
.GetShown());
2328 // ----------------------------------------------------------------------------
2329 // dialog units translations
2330 // ----------------------------------------------------------------------------
2332 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
)
2334 int charWidth
= GetCharWidth();
2335 int charHeight
= GetCharHeight();
2336 wxPoint pt2
= wxDefaultPosition
;
2337 if (pt
.x
!= wxDefaultCoord
)
2338 pt2
.x
= (int) ((pt
.x
* 4) / charWidth
);
2339 if (pt
.y
!= wxDefaultCoord
)
2340 pt2
.y
= (int) ((pt
.y
* 8) / charHeight
);
2345 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
)
2347 int charWidth
= GetCharWidth();
2348 int charHeight
= GetCharHeight();
2349 wxPoint pt2
= wxDefaultPosition
;
2350 if (pt
.x
!= wxDefaultCoord
)
2351 pt2
.x
= (int) ((pt
.x
* charWidth
) / 4);
2352 if (pt
.y
!= wxDefaultCoord
)
2353 pt2
.y
= (int) ((pt
.y
* charHeight
) / 8);
2358 // ----------------------------------------------------------------------------
2360 // ----------------------------------------------------------------------------
2362 // propagate the colour change event to the subwindows
2363 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& event
)
2365 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2368 // Only propagate to non-top-level windows
2369 wxWindow
*win
= node
->GetData();
2370 if ( !win
->IsTopLevel() )
2372 wxSysColourChangedEvent event2
;
2373 event
.SetEventObject(win
);
2374 win
->GetEventHandler()->ProcessEvent(event2
);
2377 node
= node
->GetNext();
2383 // the default action is to populate dialog with data when it's created,
2384 // and nudge the UI into displaying itself correctly in case
2385 // we've turned the wxUpdateUIEvents frequency down low.
2386 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2388 TransferDataToWindow();
2390 // Update the UI at this point
2391 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2394 // ----------------------------------------------------------------------------
2395 // menu-related functions
2396 // ----------------------------------------------------------------------------
2400 bool wxWindowBase::PopupMenu(wxMenu
*menu
, int x
, int y
)
2402 wxCHECK_MSG( menu
, false, "can't popup NULL menu" );
2404 wxCurrentPopupMenu
= menu
;
2405 const bool rc
= DoPopupMenu(menu
, x
, y
);
2406 wxCurrentPopupMenu
= NULL
;
2411 // this is used to pass the id of the selected item from the menu event handler
2412 // to the main function itself
2414 // it's ok to use a global here as there can be at most one popup menu shown at
2416 static int gs_popupMenuSelection
= wxID_NONE
;
2418 void wxWindowBase::InternalOnPopupMenu(wxCommandEvent
& event
)
2420 // store the id in a global variable where we'll retrieve it from later
2421 gs_popupMenuSelection
= event
.GetId();
2424 void wxWindowBase::InternalOnPopupMenuUpdate(wxUpdateUIEvent
& WXUNUSED(event
))
2426 // nothing to do but do not skip it
2430 wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
2432 gs_popupMenuSelection
= wxID_NONE
;
2434 Connect(wxEVT_COMMAND_MENU_SELECTED
,
2435 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2439 // it is common to construct the menu passed to this function dynamically
2440 // using some fixed range of ids which could clash with the ids used
2441 // elsewhere in the program, which could result in some menu items being
2442 // unintentionally disabled or otherwise modified by update UI handlers
2443 // elsewhere in the program code and this is difficult to avoid in the
2444 // program itself, so instead we just temporarily suspend UI updating while
2445 // this menu is shown
2446 Connect(wxEVT_UPDATE_UI
,
2447 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2451 PopupMenu(&menu
, x
, y
);
2453 Disconnect(wxEVT_UPDATE_UI
,
2454 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2457 Disconnect(wxEVT_COMMAND_MENU_SELECTED
,
2458 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2462 return gs_popupMenuSelection
;
2465 #endif // wxUSE_MENUS
2467 // methods for drawing the sizers in a visible way
2470 static void DrawSizers(wxWindowBase
*win
);
2472 static void DrawBorder(wxWindowBase
*win
, const wxRect
& rect
, bool fill
= false)
2474 wxClientDC
dc((wxWindow
*)win
);
2475 dc
.SetPen(*wxRED_PEN
);
2476 dc
.SetBrush(fill
? wxBrush(*wxRED
, wxBRUSHSTYLE_CROSSDIAG_HATCH
) : *wxTRANSPARENT_BRUSH
);
2477 dc
.DrawRectangle(rect
.Deflate(1, 1));
2480 static void DrawSizer(wxWindowBase
*win
, wxSizer
*sizer
)
2482 const wxSizerItemList
& items
= sizer
->GetChildren();
2483 for ( wxSizerItemList::const_iterator i
= items
.begin(),
2488 wxSizerItem
*item
= *i
;
2489 if ( item
->IsSizer() )
2491 DrawBorder(win
, item
->GetRect().Deflate(2));
2492 DrawSizer(win
, item
->GetSizer());
2494 else if ( item
->IsSpacer() )
2496 DrawBorder(win
, item
->GetRect().Deflate(2), true);
2498 else if ( item
->IsWindow() )
2500 DrawSizers(item
->GetWindow());
2505 static void DrawSizers(wxWindowBase
*win
)
2507 wxSizer
*sizer
= win
->GetSizer();
2510 DrawBorder(win
, win
->GetClientSize());
2511 DrawSizer(win
, sizer
);
2513 else // no sizer, still recurse into the children
2515 const wxWindowList
& children
= win
->GetChildren();
2516 for ( wxWindowList::const_iterator i
= children
.begin(),
2517 end
= children
.end();
2526 #endif // __WXDEBUG__
2528 // process special middle clicks
2529 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2531 if ( event
.ControlDown() && event
.AltDown() )
2534 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2535 if ( event
.ShiftDown() )
2540 #endif // __WXDEBUG__
2541 ::wxInfoMessageBox((wxWindow
*)this);
2549 // ----------------------------------------------------------------------------
2551 // ----------------------------------------------------------------------------
2553 #if wxUSE_ACCESSIBILITY
2554 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2556 if (m_accessible
&& (accessible
!= m_accessible
))
2557 delete m_accessible
;
2558 m_accessible
= accessible
;
2560 m_accessible
->SetWindow((wxWindow
*) this);
2563 // Returns the accessible object, creating if necessary.
2564 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2567 m_accessible
= CreateAccessible();
2568 return m_accessible
;
2571 // Override to create a specific accessible object.
2572 wxAccessible
* wxWindowBase::CreateAccessible()
2574 return new wxWindowAccessible((wxWindow
*) this);
2579 // ----------------------------------------------------------------------------
2580 // list classes implementation
2581 // ----------------------------------------------------------------------------
2585 #include "wx/listimpl.cpp"
2586 WX_DEFINE_LIST(wxWindowList
)
2590 void wxWindowListNode::DeleteData()
2592 delete (wxWindow
*)GetData();
2595 #endif // wxUSE_STL/!wxUSE_STL
2597 // ----------------------------------------------------------------------------
2599 // ----------------------------------------------------------------------------
2601 wxBorder
wxWindowBase::GetBorder(long flags
) const
2603 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
2604 if ( border
== wxBORDER_DEFAULT
)
2606 border
= GetDefaultBorder();
2608 else if ( border
== wxBORDER_THEME
)
2610 border
= GetDefaultBorderForControl();
2616 wxBorder
wxWindowBase::GetDefaultBorder() const
2618 return wxBORDER_NONE
;
2621 // ----------------------------------------------------------------------------
2623 // ----------------------------------------------------------------------------
2625 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
2627 // here we just check if the point is inside the window or not
2629 // check the top and left border first
2630 bool outside
= x
< 0 || y
< 0;
2633 // check the right and bottom borders too
2634 wxSize size
= GetSize();
2635 outside
= x
>= size
.x
|| y
>= size
.y
;
2638 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
2641 // ----------------------------------------------------------------------------
2643 // ----------------------------------------------------------------------------
2645 struct WXDLLEXPORT wxWindowNext
2649 } *wxWindowBase::ms_winCaptureNext
= NULL
;
2650 wxWindow
*wxWindowBase::ms_winCaptureCurrent
= NULL
;
2651 bool wxWindowBase::ms_winCaptureChanging
= false;
2653 void wxWindowBase::CaptureMouse()
2655 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), static_cast<void*>(this));
2657 wxASSERT_MSG( !ms_winCaptureChanging
, _T("recursive CaptureMouse call?") );
2659 ms_winCaptureChanging
= true;
2661 wxWindow
*winOld
= GetCapture();
2664 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
2667 wxWindowNext
*item
= new wxWindowNext
;
2669 item
->next
= ms_winCaptureNext
;
2670 ms_winCaptureNext
= item
;
2672 //else: no mouse capture to save
2675 ms_winCaptureCurrent
= (wxWindow
*)this;
2677 ms_winCaptureChanging
= false;
2680 void wxWindowBase::ReleaseMouse()
2682 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), static_cast<void*>(this));
2684 wxASSERT_MSG( !ms_winCaptureChanging
, _T("recursive ReleaseMouse call?") );
2686 wxASSERT_MSG( GetCapture() == this,
2687 "attempt to release mouse, but this window hasn't captured it" );
2688 wxASSERT_MSG( ms_winCaptureCurrent
== this,
2689 "attempt to release mouse, but this window hasn't captured it" );
2691 ms_winCaptureChanging
= true;
2694 ms_winCaptureCurrent
= NULL
;
2696 if ( ms_winCaptureNext
)
2698 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
2699 ms_winCaptureCurrent
= ms_winCaptureNext
->win
;
2701 wxWindowNext
*item
= ms_winCaptureNext
;
2702 ms_winCaptureNext
= item
->next
;
2705 //else: stack is empty, no previous capture
2707 ms_winCaptureChanging
= false;
2709 wxLogTrace(_T("mousecapture"),
2710 (const wxChar
*) _T("After ReleaseMouse() mouse is captured by %p"),
2711 static_cast<void*>(GetCapture()));
2714 static void DoNotifyWindowAboutCaptureLost(wxWindow
*win
)
2716 wxMouseCaptureLostEvent
event(win
->GetId());
2717 event
.SetEventObject(win
);
2718 if ( !win
->GetEventHandler()->ProcessEvent(event
) )
2720 // windows must handle this event, otherwise the app wouldn't behave
2721 // correctly if it loses capture unexpectedly; see the discussion here:
2722 // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
2723 // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
2724 wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
2729 void wxWindowBase::NotifyCaptureLost()
2731 // don't do anything if capture lost was expected, i.e. resulted from
2732 // a wx call to ReleaseMouse or CaptureMouse:
2733 if ( ms_winCaptureChanging
)
2736 // if the capture was lost unexpectedly, notify every window that has
2737 // capture (on stack or current) about it and clear the stack:
2739 if ( ms_winCaptureCurrent
)
2741 DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent
);
2742 ms_winCaptureCurrent
= NULL
;
2745 while ( ms_winCaptureNext
)
2747 wxWindowNext
*item
= ms_winCaptureNext
;
2748 ms_winCaptureNext
= item
->next
;
2750 DoNotifyWindowAboutCaptureLost(item
->win
);
2759 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
2760 int WXUNUSED(modifiers
),
2761 int WXUNUSED(keycode
))
2767 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
2773 #endif // wxUSE_HOTKEY
2775 // ----------------------------------------------------------------------------
2777 // ----------------------------------------------------------------------------
2779 bool wxWindowBase::TryValidator(wxEvent
& wxVALIDATOR_PARAM(event
))
2781 #if wxUSE_VALIDATORS
2782 // Can only use the validator of the window which
2783 // is receiving the event
2784 if ( event
.GetEventObject() == this )
2786 wxValidator
* const validator
= GetValidator();
2787 if ( validator
&& validator
->ProcessEventHere(event
) )
2792 #endif // wxUSE_VALIDATORS
2797 bool wxWindowBase::TryParent(wxEvent
& event
)
2799 // carry on up the parent-child hierarchy if the propagation count hasn't
2801 if ( event
.ShouldPropagate() )
2803 // honour the requests to stop propagation at this window: this is
2804 // used by the dialogs, for example, to prevent processing the events
2805 // from the dialog controls in the parent frame which rarely, if ever,
2807 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
2809 wxWindow
*parent
= GetParent();
2810 if ( parent
&& !parent
->IsBeingDeleted() )
2812 wxPropagateOnce
propagateOnce(event
);
2814 return parent
->GetEventHandler()->ProcessEvent(event
);
2819 return wxEvtHandler::TryParent(event
);
2822 // ----------------------------------------------------------------------------
2823 // window relationships
2824 // ----------------------------------------------------------------------------
2826 wxWindow
*wxWindowBase::DoGetSibling(WindowOrder order
) const
2828 wxCHECK_MSG( GetParent(), NULL
,
2829 _T("GetPrev/NextSibling() don't work for TLWs!") );
2831 wxWindowList
& siblings
= GetParent()->GetChildren();
2832 wxWindowList::compatibility_iterator i
= siblings
.Find((wxWindow
*)this);
2833 wxCHECK_MSG( i
, NULL
, _T("window not a child of its parent?") );
2835 if ( order
== OrderBefore
)
2836 i
= i
->GetPrevious();
2840 return i
? i
->GetData() : NULL
;
2843 // ----------------------------------------------------------------------------
2844 // keyboard navigation
2845 // ----------------------------------------------------------------------------
2847 // Navigates in the specified direction inside this window
2848 bool wxWindowBase::DoNavigateIn(int flags
)
2850 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
2851 // native code doesn't process our wxNavigationKeyEvents anyhow
2854 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
2855 wxNavigationKeyEvent eventNav
;
2856 wxWindow
*focused
= FindFocus();
2857 eventNav
.SetCurrentFocus(focused
);
2858 eventNav
.SetEventObject(focused
);
2859 eventNav
.SetFlags(flags
);
2860 return GetEventHandler()->ProcessEvent(eventNav
);
2861 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
2864 bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent
& event
)
2866 if ( event
.GetKeyCode() != WXK_TAB
)
2869 int flags
= wxNavigationKeyEvent::FromTab
;
2871 if ( event
.ShiftDown() )
2872 flags
|= wxNavigationKeyEvent::IsBackward
;
2874 flags
|= wxNavigationKeyEvent::IsForward
;
2876 if ( event
.ControlDown() )
2877 flags
|= wxNavigationKeyEvent::WinChange
;
2883 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
2885 // check that we're not a top level window
2886 wxCHECK_RET( GetParent(),
2887 _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
2889 // detect the special case when we have nothing to do anyhow and when the
2890 // code below wouldn't work
2894 // find the target window in the siblings list
2895 wxWindowList
& siblings
= GetParent()->GetChildren();
2896 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
2897 wxCHECK_RET( i
, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
2899 // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
2900 // can't just move the node around
2901 wxWindow
*self
= (wxWindow
*)this;
2902 siblings
.DeleteObject(self
);
2903 if ( move
== OrderAfter
)
2910 siblings
.Insert(i
, self
);
2912 else // OrderAfter and win was the last sibling
2914 siblings
.Append(self
);
2918 // ----------------------------------------------------------------------------
2920 // ----------------------------------------------------------------------------
2922 /*static*/ wxWindow
* wxWindowBase::FindFocus()
2924 wxWindowBase
*win
= DoFindFocus();
2925 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
2928 bool wxWindowBase::HasFocus() const
2930 wxWindowBase
*win
= DoFindFocus();
2931 return win
== this ||
2932 win
== wxConstCast(this, wxWindowBase
)->GetMainWindowOfCompositeControl();
2935 // ----------------------------------------------------------------------------
2937 // ----------------------------------------------------------------------------
2939 #if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
2944 class DragAcceptFilesTarget
: public wxFileDropTarget
2947 DragAcceptFilesTarget(wxWindowBase
*win
) : m_win(win
) {}
2949 virtual bool OnDropFiles(wxCoord x
, wxCoord y
,
2950 const wxArrayString
& filenames
)
2952 wxDropFilesEvent
event(wxEVT_DROP_FILES
,
2954 wxCArrayString(filenames
).Release());
2955 event
.SetEventObject(m_win
);
2959 return m_win
->HandleWindowEvent(event
);
2963 wxWindowBase
* const m_win
;
2965 DECLARE_NO_COPY_CLASS(DragAcceptFilesTarget
)
2969 } // anonymous namespace
2971 // Generic version of DragAcceptFiles(). It works by installing a simple
2972 // wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used
2973 // together with explicit SetDropTarget() calls.
2974 void wxWindowBase::DragAcceptFiles(bool accept
)
2978 wxASSERT_MSG( !GetDropTarget(),
2979 "cannot use DragAcceptFiles() and SetDropTarget() together" );
2980 SetDropTarget(new DragAcceptFilesTarget(this));
2984 SetDropTarget(NULL
);
2988 #endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
2990 // ----------------------------------------------------------------------------
2992 // ----------------------------------------------------------------------------
2994 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
2996 while ( win
&& !win
->IsTopLevel() )
2997 win
= win
->GetParent();
3002 #if wxUSE_ACCESSIBILITY
3003 // ----------------------------------------------------------------------------
3004 // accessible object for windows
3005 // ----------------------------------------------------------------------------
3007 // Can return either a child object, or an integer
3008 // representing the child element, starting from 1.
3009 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
3011 wxASSERT( GetWindow() != NULL
);
3015 return wxACC_NOT_IMPLEMENTED
;
3018 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
3019 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
3021 wxASSERT( GetWindow() != NULL
);
3025 wxWindow
* win
= NULL
;
3032 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
3034 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
3041 rect
= win
->GetRect();
3042 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
3043 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
3047 return wxACC_NOT_IMPLEMENTED
;
3050 // Navigates from fromId to toId/toObject.
3051 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
3052 int* WXUNUSED(toId
), wxAccessible
** toObject
)
3054 wxASSERT( GetWindow() != NULL
);
3060 case wxNAVDIR_FIRSTCHILD
:
3062 if (GetWindow()->GetChildren().GetCount() == 0)
3064 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
3065 *toObject
= childWindow
->GetOrCreateAccessible();
3069 case wxNAVDIR_LASTCHILD
:
3071 if (GetWindow()->GetChildren().GetCount() == 0)
3073 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
3074 *toObject
= childWindow
->GetOrCreateAccessible();
3078 case wxNAVDIR_RIGHT
:
3082 wxWindowList::compatibility_iterator node
=
3083 wxWindowList::compatibility_iterator();
3086 // Can't navigate to sibling of this window
3087 // if we're a top-level window.
3088 if (!GetWindow()->GetParent())
3089 return wxACC_NOT_IMPLEMENTED
;
3091 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3095 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3096 node
= GetWindow()->GetChildren().Item(fromId
-1);
3099 if (node
&& node
->GetNext())
3101 wxWindow
* nextWindow
= node
->GetNext()->GetData();
3102 *toObject
= nextWindow
->GetOrCreateAccessible();
3110 case wxNAVDIR_PREVIOUS
:
3112 wxWindowList::compatibility_iterator node
=
3113 wxWindowList::compatibility_iterator();
3116 // Can't navigate to sibling of this window
3117 // if we're a top-level window.
3118 if (!GetWindow()->GetParent())
3119 return wxACC_NOT_IMPLEMENTED
;
3121 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3125 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3126 node
= GetWindow()->GetChildren().Item(fromId
-1);
3129 if (node
&& node
->GetPrevious())
3131 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
3132 *toObject
= previousWindow
->GetOrCreateAccessible();
3140 return wxACC_NOT_IMPLEMENTED
;
3143 // Gets the name of the specified object.
3144 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
3146 wxASSERT( GetWindow() != NULL
);
3152 // If a child, leave wxWidgets to call the function on the actual
3155 return wxACC_NOT_IMPLEMENTED
;
3157 // This will eventually be replaced by specialised
3158 // accessible classes, one for each kind of wxWidgets
3159 // control or window.
3161 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
3162 title
= ((wxButton
*) GetWindow())->GetLabel();
3165 title
= GetWindow()->GetName();
3173 return wxACC_NOT_IMPLEMENTED
;
3176 // Gets the number of children.
3177 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
3179 wxASSERT( GetWindow() != NULL
);
3183 *childId
= (int) GetWindow()->GetChildren().GetCount();
3187 // Gets the specified child (starting from 1).
3188 // If *child is NULL and return value is wxACC_OK,
3189 // this means that the child is a simple element and
3190 // not an accessible object.
3191 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
3193 wxASSERT( GetWindow() != NULL
);
3203 if (childId
> (int) GetWindow()->GetChildren().GetCount())
3206 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
3207 *child
= childWindow
->GetOrCreateAccessible();
3214 // Gets the parent, or NULL.
3215 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
3217 wxASSERT( GetWindow() != NULL
);
3221 wxWindow
* parentWindow
= GetWindow()->GetParent();
3229 *parent
= parentWindow
->GetOrCreateAccessible();
3237 // Performs the default action. childId is 0 (the action for this object)
3238 // or > 0 (the action for a child).
3239 // Return wxACC_NOT_SUPPORTED if there is no default action for this
3240 // window (e.g. an edit control).
3241 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
3243 wxASSERT( GetWindow() != NULL
);
3247 return wxACC_NOT_IMPLEMENTED
;
3250 // Gets the default action for this object (0) or > 0 (the action for a child).
3251 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
3252 // string if there is no action.
3253 // The retrieved string describes the action that is performed on an object,
3254 // not what the object does as a result. For example, a toolbar button that prints
3255 // a document has a default action of "Press" rather than "Prints the current document."
3256 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
3258 wxASSERT( GetWindow() != NULL
);
3262 return wxACC_NOT_IMPLEMENTED
;
3265 // Returns the description for this object or a child.
3266 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
3268 wxASSERT( GetWindow() != NULL
);
3272 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3278 return wxACC_NOT_IMPLEMENTED
;
3281 // Returns help text for this object or a child, similar to tooltip text.
3282 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
3284 wxASSERT( GetWindow() != NULL
);
3288 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3294 return wxACC_NOT_IMPLEMENTED
;
3297 // Returns the keyboard shortcut for this object or child.
3298 // Return e.g. ALT+K
3299 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
3301 wxASSERT( GetWindow() != NULL
);
3305 return wxACC_NOT_IMPLEMENTED
;
3308 // Returns a role constant.
3309 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
3311 wxASSERT( GetWindow() != NULL
);
3315 // If a child, leave wxWidgets to call the function on the actual
3318 return wxACC_NOT_IMPLEMENTED
;
3320 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3321 return wxACC_NOT_IMPLEMENTED
;
3323 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3324 return wxACC_NOT_IMPLEMENTED
;
3327 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3328 return wxACC_NOT_IMPLEMENTED
;
3331 //*role = wxROLE_SYSTEM_CLIENT;
3332 *role
= wxROLE_SYSTEM_CLIENT
;
3336 return wxACC_NOT_IMPLEMENTED
;
3340 // Returns a state constant.
3341 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
3343 wxASSERT( GetWindow() != NULL
);
3347 // If a child, leave wxWidgets to call the function on the actual
3350 return wxACC_NOT_IMPLEMENTED
;
3352 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3353 return wxACC_NOT_IMPLEMENTED
;
3356 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3357 return wxACC_NOT_IMPLEMENTED
;
3360 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3361 return wxACC_NOT_IMPLEMENTED
;
3368 return wxACC_NOT_IMPLEMENTED
;
3372 // Returns a localized string representing the value for the object
3374 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
3376 wxASSERT( GetWindow() != NULL
);
3380 return wxACC_NOT_IMPLEMENTED
;
3383 // Selects the object or child.
3384 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
3386 wxASSERT( GetWindow() != NULL
);
3390 return wxACC_NOT_IMPLEMENTED
;
3393 // Gets the window with the keyboard focus.
3394 // If childId is 0 and child is NULL, no object in
3395 // this subhierarchy has the focus.
3396 // If this object has the focus, child should be 'this'.
3397 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
3399 wxASSERT( GetWindow() != NULL
);
3403 return wxACC_NOT_IMPLEMENTED
;
3407 // Gets a variant representing the selected children
3409 // Acceptable values:
3410 // - a null variant (IsNull() returns true)
3411 // - a list variant (GetType() == wxT("list")
3412 // - an integer representing the selected child element,
3413 // or 0 if this object is selected (GetType() == wxT("long")
3414 // - a "void*" pointer to a wxAccessible child object
3415 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
3417 wxASSERT( GetWindow() != NULL
);
3421 return wxACC_NOT_IMPLEMENTED
;
3423 #endif // wxUSE_VARIANT
3425 #endif // wxUSE_ACCESSIBILITY
3427 // ----------------------------------------------------------------------------
3429 // ----------------------------------------------------------------------------
3432 wxWindowBase::AdjustForLayoutDirection(wxCoord x
,
3434 wxCoord widthTotal
) const
3436 if ( GetLayoutDirection() == wxLayout_RightToLeft
)
3438 x
= widthTotal
- x
- width
;