1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/wincmn.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
7 // Copyright: (c) wxWidgets team
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
11 // ============================================================================
13 // ============================================================================
15 // ----------------------------------------------------------------------------
17 // ----------------------------------------------------------------------------
19 // For compilers that support precompilation, includes "wx.h".
20 #include "wx/wxprec.h"
27 #include "wx/string.h"
31 #include "wx/window.h"
32 #include "wx/control.h"
33 #include "wx/checkbox.h"
34 #include "wx/radiobut.h"
35 #include "wx/statbox.h"
36 #include "wx/textctrl.h"
37 #include "wx/settings.h"
38 #include "wx/dialog.h"
39 #include "wx/msgdlg.h"
40 #include "wx/msgout.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 #include "wx/platinfo.h"
75 #include "wx/recguard.h"
76 #include "wx/private/window.h"
79 #include "wx/msw/wrapwin.h"
83 WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
87 wxMenu
*wxCurrentPopupMenu
= NULL
;
90 extern WXDLLEXPORT_DATA(const char) wxPanelNameStr
[] = "panel";
92 namespace wxMouseCapture
95 // Check if the given window is in the capture stack.
96 bool IsInCaptureStack(wxWindowBase
* win
);
100 // ----------------------------------------------------------------------------
102 // ----------------------------------------------------------------------------
105 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
107 // ----------------------------------------------------------------------------
109 // ----------------------------------------------------------------------------
111 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
112 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
113 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
114 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
117 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
120 EVT_SIZE(wxWindowBase::InternalOnSize
)
123 // ============================================================================
124 // implementation of the common functionality of the wxWindow class
125 // ============================================================================
127 // ----------------------------------------------------------------------------
129 // ----------------------------------------------------------------------------
131 #if wxUSE_EXTENDED_RTTI
133 // windows that are created from a parent window during its Create method,
134 // eg. spin controls in a calendar controls must never been streamed out
135 // separately otherwise chaos occurs. Right now easiest is to test for negative ids,
136 // as windows with negative ids never can be recreated anyway
139 bool wxWindowStreamingCallback( const wxObject
*object
, wxObjectWriter
*,
140 wxObjectWriterCallback
*, const wxStringToAnyHashMap
& )
142 const wxWindow
* win
= wx_dynamic_cast(const wxWindow
*, object
);
143 if ( win
&& win
->GetId() < 0 )
148 wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
, "wx/window.h", \
149 wxWindowStreamingCallback
)
151 // make wxWindowList known before the property is used
153 wxCOLLECTION_TYPE_INFO( wxWindow
*, wxWindowList
);
155 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
,
158 wxListCollectionToAnyList
<wxWindowList::compatibility_iterator
>( theList
, value
);
161 wxDEFINE_FLAGS( wxWindowStyle
)
163 wxBEGIN_FLAGS( wxWindowStyle
)
164 // new style border flags, we put them first to
165 // use them for streaming out
167 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
168 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
169 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
170 wxFLAGS_MEMBER(wxBORDER_RAISED
)
171 wxFLAGS_MEMBER(wxBORDER_STATIC
)
172 wxFLAGS_MEMBER(wxBORDER_NONE
)
174 // old style border flags
175 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
176 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
177 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
178 wxFLAGS_MEMBER(wxRAISED_BORDER
)
179 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
180 wxFLAGS_MEMBER(wxBORDER
)
182 // standard window styles
183 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
184 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
185 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
186 wxFLAGS_MEMBER(wxWANTS_CHARS
)
187 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
188 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
189 wxFLAGS_MEMBER(wxVSCROLL
)
190 wxFLAGS_MEMBER(wxHSCROLL
)
192 wxEND_FLAGS( wxWindowStyle
)
194 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
195 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
196 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
197 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
198 // Always constructor Properties first
200 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, wxEMPTY_PARAMETER_VALUE
, \
201 0 /*flags*/, wxT("Helpstring"), wxT("group"))
202 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/, 0 /*flags*/, \
203 wxT("Helpstring"), wxT("group") )
204 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, \
205 0 /*flags*/, wxT("Helpstring"), wxT("group")) // pos
206 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/, \
207 wxT("Helpstring"), wxT("group")) // size
208 wxPROPERTY( WindowStyle
, long, SetWindowStyleFlag
, GetWindowStyleFlag
, \
209 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // style
210 wxPROPERTY( Name
,wxString
, SetName
, GetName
, wxEmptyString
, 0 /*flags*/, \
211 wxT("Helpstring"), wxT("group") )
213 // Then all relations of the object graph
215 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
*, \
216 GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/, \
217 wxT("Helpstring"), wxT("group"))
219 // and finally all other properties
221 wxPROPERTY( ExtraStyle
, long, SetExtraStyle
, GetExtraStyle
, wxEMPTY_PARAMETER_VALUE
, \
222 0 /*flags*/, wxT("Helpstring"), wxT("group")) // extstyle
223 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, \
224 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // bg
225 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, \
226 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // fg
227 wxPROPERTY( Enabled
, bool, Enable
, IsEnabled
, wxAny((bool)true), 0 /*flags*/, \
228 wxT("Helpstring"), wxT("group"))
229 wxPROPERTY( Shown
, bool, Show
, IsShown
, wxAny((bool)true), 0 /*flags*/, \
230 wxT("Helpstring"), wxT("group"))
233 // possible property candidates (not in xrc) or not valid in all subclasses
234 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
235 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
236 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
237 // MaxHeight, Width, MinHeight, Width
238 // TODO switch label to control and title to toplevels
240 wxPROPERTY( ThemeEnabled
, bool, SetThemeEnabled
, GetThemeEnabled
, )
241 //wxPROPERTY( Cursor, wxCursor, SetCursor, GetCursor, )
242 // wxPROPERTY( ToolTip, wxString, SetToolTip, GetToolTipText, )
243 wxPROPERTY( AutoLayout
, bool, SetAutoLayout
, GetAutoLayout
, )
245 wxEND_PROPERTIES_TABLE()
247 wxEMPTY_HANDLERS_TABLE(wxWindow
)
249 wxCONSTRUCTOR_DUMMY(wxWindow
)
253 #ifndef __WXUNIVERSAL__
254 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
259 // ----------------------------------------------------------------------------
261 // ----------------------------------------------------------------------------
263 // the default initialization
264 wxWindowBase::wxWindowBase()
266 // no window yet, no parent nor children
268 m_windowId
= wxID_ANY
;
270 // no constraints on the minimal window size
272 m_maxWidth
= wxDefaultCoord
;
274 m_maxHeight
= wxDefaultCoord
;
276 // invalidiated cache value
277 m_bestSizeCache
= wxDefaultSize
;
279 // window are created enabled and visible by default
283 // the default event handler is just this window
284 m_eventHandler
= this;
288 m_windowValidator
= NULL
;
289 #endif // wxUSE_VALIDATORS
291 // the colours/fonts are default for now, so leave m_font,
292 // m_backgroundColour and m_foregroundColour uninitialized and set those
298 m_inheritFont
= false;
304 m_backgroundStyle
= wxBG_STYLE_ERASE
;
306 #if wxUSE_CONSTRAINTS
307 // no constraints whatsoever
308 m_constraints
= NULL
;
309 m_constraintsInvolvedIn
= NULL
;
310 #endif // wxUSE_CONSTRAINTS
312 m_windowSizer
= NULL
;
313 m_containingSizer
= NULL
;
314 m_autoLayout
= false;
316 #if wxUSE_DRAG_AND_DROP
318 #endif // wxUSE_DRAG_AND_DROP
322 #endif // wxUSE_TOOLTIPS
326 #endif // wxUSE_CARET
329 m_hasCustomPalette
= false;
330 #endif // wxUSE_PALETTE
332 #if wxUSE_ACCESSIBILITY
336 m_virtualSize
= wxDefaultSize
;
338 m_scrollHelper
= NULL
;
340 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
341 #if wxUSE_SYSTEM_OPTIONS
342 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
344 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
348 // Whether we're using the current theme for this window (wxGTK only for now)
349 m_themeEnabled
= false;
351 // This is set to true by SendDestroyEvent() which should be called by the
352 // most derived class to ensure that the destruction event is sent as soon
353 // as possible to allow its handlers to still see the undestroyed window
354 m_isBeingDeleted
= false;
359 // common part of window creation process
360 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
362 const wxPoint
& WXUNUSED(pos
),
365 const wxString
& name
)
367 // ids are limited to 16 bits under MSW so if you care about portability,
368 // it's not a good idea to use ids out of this range (and negative ids are
369 // reserved for wxWidgets own usage)
370 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767) ||
371 (id
>= wxID_AUTO_LOWEST
&& id
<= wxID_AUTO_HIGHEST
),
372 wxT("invalid id value") );
374 // generate a new id if the user doesn't care about it
375 if ( id
== wxID_ANY
)
377 m_windowId
= NewControlId();
379 else // valid id specified
384 // don't use SetWindowStyleFlag() here, this function should only be called
385 // to change the flag after creation as it tries to reflect the changes in
386 // flags by updating the window dynamically and we don't need this here
387 m_windowStyle
= style
;
389 // assume the user doesn't want this window to shrink beneath its initial
390 // size, this worked like this in wxWidgets 2.8 and before and generally
391 // often makes sense for child windows (for top level ones it definitely
392 // does not as the user should be able to resize the window)
394 // note that we can't use IsTopLevel() from ctor
395 if ( size
!= wxDefaultSize
&& !wxTopLevelWindows
.Find((wxWindow
*)this) )
404 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
409 const wxValidator
& wxVALIDATOR_PARAM(validator
),
410 const wxString
& name
)
412 if ( !CreateBase(parent
, id
, pos
, size
, style
, name
) )
416 SetValidator(validator
);
417 #endif // wxUSE_VALIDATORS
419 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
420 // have it too - like this it's possible to set it only in the top level
421 // dialog/frame and all children will inherit it by defult
422 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
424 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
430 bool wxWindowBase::ToggleWindowStyle(int flag
)
432 wxASSERT_MSG( flag
, wxT("flags with 0 value can't be toggled") );
435 long style
= GetWindowStyleFlag();
441 else // currently off
447 SetWindowStyleFlag(style
);
452 // ----------------------------------------------------------------------------
454 // ----------------------------------------------------------------------------
457 wxWindowBase::~wxWindowBase()
459 wxASSERT_MSG( !wxMouseCapture::IsInCaptureStack(this),
460 "Destroying window before releasing mouse capture: this "
461 "will result in a crash later." );
463 // FIXME if these 2 cases result from programming errors in the user code
464 // we should probably assert here instead of silently fixing them
466 // Just in case the window has been Closed, but we're then deleting
467 // immediately: don't leave dangling pointers.
468 wxPendingDelete
.DeleteObject(this);
470 // Just in case we've loaded a top-level window via LoadNativeDialog but
471 // we weren't a dialog class
472 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
474 // Any additional event handlers should be popped before the window is
475 // deleted as otherwise the last handler will be left with a dangling
476 // pointer to this window result in a difficult to diagnose crash later on.
477 wxASSERT_MSG( GetEventHandler() == this,
478 wxT("any pushed event handlers must have been removed") );
481 // The associated popup menu can still be alive, disassociate from it in
483 if ( wxCurrentPopupMenu
&& wxCurrentPopupMenu
->GetInvokingWindow() == this )
484 wxCurrentPopupMenu
->SetInvokingWindow(NULL
);
485 #endif // wxUSE_MENUS
487 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
489 // notify the parent about this window destruction
491 m_parent
->RemoveChild(this);
495 #endif // wxUSE_CARET
498 delete m_windowValidator
;
499 #endif // wxUSE_VALIDATORS
501 #if wxUSE_CONSTRAINTS
502 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
503 // at deleted windows as they delete themselves.
504 DeleteRelatedConstraints();
508 // This removes any dangling pointers to this window in other windows'
509 // constraintsInvolvedIn lists.
510 UnsetConstraints(m_constraints
);
511 wxDELETE(m_constraints
);
513 #endif // wxUSE_CONSTRAINTS
515 if ( m_containingSizer
)
516 m_containingSizer
->Detach( (wxWindow
*)this );
518 delete m_windowSizer
;
520 #if wxUSE_DRAG_AND_DROP
522 #endif // wxUSE_DRAG_AND_DROP
526 #endif // wxUSE_TOOLTIPS
528 #if wxUSE_ACCESSIBILITY
533 // NB: this has to be called unconditionally, because we don't know
534 // whether this window has associated help text or not
535 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
537 helpProvider
->RemoveHelp(this);
541 bool wxWindowBase::IsBeingDeleted() const
543 return m_isBeingDeleted
||
544 (!IsTopLevel() && m_parent
&& m_parent
->IsBeingDeleted());
547 void wxWindowBase::SendDestroyEvent()
549 if ( m_isBeingDeleted
)
551 // we could have been already called from a more derived class dtor,
552 // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call
553 // should be simply ignored
557 m_isBeingDeleted
= true;
559 wxWindowDestroyEvent event
;
560 event
.SetEventObject(this);
561 event
.SetId(GetId());
562 GetEventHandler()->ProcessEvent(event
);
565 bool wxWindowBase::Destroy()
567 // If our handle is invalid, it means that this window has never been
568 // created, either because creating it failed or, more typically, because
569 // this wxWindow object was default-constructed and its Create() method had
570 // never been called. As we didn't send wxWindowCreateEvent in this case
571 // (which is sent after successful creation), don't send the matching
572 // wxWindowDestroyEvent neither.
581 bool wxWindowBase::Close(bool force
)
583 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
584 event
.SetEventObject(this);
585 event
.SetCanVeto(!force
);
587 // return false if window wasn't closed because the application vetoed the
589 return HandleWindowEvent(event
) && !event
.GetVeto();
592 bool wxWindowBase::DestroyChildren()
594 wxWindowList::compatibility_iterator node
;
597 // we iterate until the list becomes empty
598 node
= GetChildren().GetFirst();
602 wxWindow
*child
= node
->GetData();
604 // note that we really want to delete it immediately so don't call the
605 // possible overridden Destroy() version which might not delete the
606 // child immediately resulting in problems with our (top level) child
607 // outliving its parent
608 child
->wxWindowBase::Destroy();
610 wxASSERT_MSG( !GetChildren().Find(child
),
611 wxT("child didn't remove itself using RemoveChild()") );
617 // ----------------------------------------------------------------------------
618 // size/position related methods
619 // ----------------------------------------------------------------------------
621 // centre the window with respect to its parent in either (or both) directions
622 void wxWindowBase::DoCentre(int dir
)
624 wxCHECK_RET( !(dir
& wxCENTRE_ON_SCREEN
) && GetParent(),
625 wxT("this method only implements centering child windows") );
627 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir
));
630 // fits the window around the children
631 void wxWindowBase::Fit()
633 SetSize(GetBestSize());
636 // fits virtual size (ie. scrolled area etc.) around children
637 void wxWindowBase::FitInside()
639 SetVirtualSize( GetBestVirtualSize() );
642 // On Mac, scrollbars are explicitly children.
643 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
644 static bool wxHasRealChildren(const wxWindowBase
* win
)
646 int realChildCount
= 0;
648 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
650 node
= node
->GetNext() )
652 wxWindow
*win
= node
->GetData();
653 if ( !win
->IsTopLevel() && win
->IsShown()
655 && !wxDynamicCast(win
, wxScrollBar
)
660 return (realChildCount
> 0);
664 void wxWindowBase::InvalidateBestSize()
666 m_bestSizeCache
= wxDefaultSize
;
668 // parent's best size calculation may depend on its children's
669 // as long as child window we are in is not top level window itself
670 // (because the TLW size is never resized automatically)
671 // so let's invalidate it as well to be safe:
672 if (m_parent
&& !IsTopLevel())
673 m_parent
->InvalidateBestSize();
676 // return the size best suited for the current window
677 wxSize
wxWindowBase::DoGetBestSize() const
683 best
= m_windowSizer
->GetMinSize();
685 #if wxUSE_CONSTRAINTS
686 else if ( m_constraints
)
688 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
690 // our minimal acceptable size is such that all our windows fit inside
694 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
696 node
= node
->GetNext() )
698 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
701 // it's not normal that we have an unconstrained child, but
702 // what can we do about it?
706 int x
= c
->right
.GetValue(),
707 y
= c
->bottom
.GetValue();
715 // TODO: we must calculate the overlaps somehow, otherwise we
716 // will never return a size bigger than the current one :-(
719 best
= wxSize(maxX
, maxY
);
721 #endif // wxUSE_CONSTRAINTS
722 else if ( !GetChildren().empty()
723 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
724 && wxHasRealChildren(this)
728 // our minimal acceptable size is such that all our visible child
729 // windows fit inside
733 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
735 node
= node
->GetNext() )
737 wxWindow
*win
= node
->GetData();
738 if ( win
->IsTopLevel()
741 || wxDynamicCast(win
, wxStatusBar
)
742 #endif // wxUSE_STATUSBAR
745 // dialogs and frames lie in different top level windows -
746 // don't deal with them here; as for the status bars, they
747 // don't lie in the client area at all
752 win
->GetPosition(&wx
, &wy
);
754 // if the window hadn't been positioned yet, assume that it is in
756 if ( wx
== wxDefaultCoord
)
758 if ( wy
== wxDefaultCoord
)
761 win
->GetSize(&ww
, &wh
);
762 if ( wx
+ ww
> maxX
)
764 if ( wy
+ wh
> maxY
)
768 best
= wxSize(maxX
, maxY
);
770 else // ! has children
772 wxSize size
= GetMinSize();
773 if ( !size
.IsFullySpecified() )
775 // if the window doesn't define its best size we assume that it can
776 // be arbitrarily small -- usually this is not the case, of course,
777 // but we have no way to know what the limit is, it should really
778 // override DoGetBestClientSize() itself to tell us
779 size
.SetDefaults(wxSize(1, 1));
782 // return as-is, unadjusted by the client size difference.
786 // Add any difference between size and client size
787 wxSize diff
= GetSize() - GetClientSize();
788 best
.x
+= wxMax(0, diff
.x
);
789 best
.y
+= wxMax(0, diff
.y
);
794 // helper of GetWindowBorderSize(): as many ports don't implement support for
795 // wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
796 // fallbacks in this case
797 static int wxGetMetricOrDefault(wxSystemMetric what
, const wxWindowBase
* win
)
799 int rc
= wxSystemSettings::GetMetric(
800 what
, static_cast<wxWindow
*>(const_cast<wxWindowBase
*>(win
)));
807 // 2D border is by default 1 pixel wide
813 // 3D borders are by default 2 pixels
818 wxFAIL_MSG( wxT("unexpected wxGetMetricOrDefault() argument") );
826 wxSize
wxWindowBase::GetWindowBorderSize() const
830 switch ( GetBorder() )
833 // nothing to do, size is already (0, 0)
836 case wxBORDER_SIMPLE
:
837 case wxBORDER_STATIC
:
838 size
.x
= wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
839 size
.y
= wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
842 case wxBORDER_SUNKEN
:
843 case wxBORDER_RAISED
:
844 size
.x
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X
, this),
845 wxGetMetricOrDefault(wxSYS_BORDER_X
, this));
846 size
.y
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y
, this),
847 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this));
850 case wxBORDER_DOUBLE
:
851 size
.x
= wxGetMetricOrDefault(wxSYS_EDGE_X
, this) +
852 wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
853 size
.y
= wxGetMetricOrDefault(wxSYS_EDGE_Y
, this) +
854 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
858 wxFAIL_MSG(wxT("Unknown border style."));
862 // we have borders on both sides
867 wxWindowBase::InformFirstDirection(int direction
,
869 int availableOtherDir
)
871 return GetSizer() && GetSizer()->InformFirstDirection(direction
,
876 wxSize
wxWindowBase::GetEffectiveMinSize() const
878 // merge the best size with the min size, giving priority to the min size
879 wxSize min
= GetMinSize();
881 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
883 wxSize best
= GetBestSize();
884 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
885 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
891 wxSize
wxWindowBase::DoGetBorderSize() const
893 // there is one case in which we can implement it for all ports easily
894 if ( GetBorder() == wxBORDER_NONE
)
897 // otherwise use the difference between the real size and the client size
898 // as a fallback: notice that this is incorrect in general as client size
899 // also doesn't take the scrollbars into account
900 return GetSize() - GetClientSize();
903 wxSize
wxWindowBase::GetBestSize() const
905 if ( !m_windowSizer
&& m_bestSizeCache
.IsFullySpecified() )
906 return m_bestSizeCache
;
908 // call DoGetBestClientSize() first, if a derived class overrides it wants
910 wxSize size
= DoGetBestClientSize();
911 if ( size
!= wxDefaultSize
)
912 size
+= DoGetBorderSize();
914 size
= DoGetBestSize();
916 // Ensure that the best size is at least as large as min size.
917 size
.IncTo(GetMinSize());
919 // And not larger than max size.
920 size
.DecToIfSpecified(GetMaxSize());
922 // Finally cache result and return.
927 int wxWindowBase::GetBestHeight(int width
) const
929 const int height
= DoGetBestClientHeight(width
);
931 return height
== wxDefaultCoord
933 : height
+ DoGetBorderSize().y
;
936 int wxWindowBase::GetBestWidth(int height
) const
938 const int width
= DoGetBestClientWidth(height
);
940 return width
== wxDefaultCoord
942 : width
+ DoGetBorderSize().x
;
945 void wxWindowBase::SetMinSize(const wxSize
& minSize
)
947 m_minWidth
= minSize
.x
;
948 m_minHeight
= minSize
.y
;
950 InvalidateBestSize();
953 void wxWindowBase::SetMaxSize(const wxSize
& maxSize
)
955 m_maxWidth
= maxSize
.x
;
956 m_maxHeight
= maxSize
.y
;
958 InvalidateBestSize();
961 void wxWindowBase::SetInitialSize(const wxSize
& size
)
963 // Set the min size to the size passed in. This will usually either be
964 // wxDefaultSize or the size passed to this window's ctor/Create function.
967 // Merge the size with the best size if needed
968 wxSize best
= GetEffectiveMinSize();
970 // If the current size doesn't match then change it
971 if (GetSize() != best
)
976 // by default the origin is not shifted
977 wxPoint
wxWindowBase::GetClientAreaOrigin() const
982 wxSize
wxWindowBase::ClientToWindowSize(const wxSize
& size
) const
984 const wxSize
diff(GetSize() - GetClientSize());
986 return wxSize(size
.x
== -1 ? -1 : size
.x
+ diff
.x
,
987 size
.y
== -1 ? -1 : size
.y
+ diff
.y
);
990 wxSize
wxWindowBase::WindowToClientSize(const wxSize
& size
) const
992 const wxSize
diff(GetSize() - GetClientSize());
994 return wxSize(size
.x
== -1 ? -1 : size
.x
- diff
.x
,
995 size
.y
== -1 ? -1 : size
.y
- diff
.y
);
998 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
1000 if ( m_windowVariant
!= variant
)
1002 m_windowVariant
= variant
;
1004 DoSetWindowVariant(variant
);
1008 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
1010 // adjust the font height to correspond to our new variant (notice that
1011 // we're only called if something really changed)
1012 wxFont font
= GetFont();
1013 int size
= font
.GetPointSize();
1016 case wxWINDOW_VARIANT_NORMAL
:
1019 case wxWINDOW_VARIANT_SMALL
:
1020 size
= wxRound(size
* 3.0 / 4.0);
1023 case wxWINDOW_VARIANT_MINI
:
1024 size
= wxRound(size
* 2.0 / 3.0);
1027 case wxWINDOW_VARIANT_LARGE
:
1028 size
= wxRound(size
* 5.0 / 4.0);
1032 wxFAIL_MSG(wxT("unexpected window variant"));
1036 font
.SetPointSize(size
);
1040 void wxWindowBase::DoSetSizeHints( int minW
, int minH
,
1042 int WXUNUSED(incW
), int WXUNUSED(incH
) )
1044 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
1045 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
1046 wxT("min width/height must be less than max width/height!") );
1055 #if WXWIN_COMPATIBILITY_2_8
1056 void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW
), int WXUNUSED(minH
),
1057 int WXUNUSED(maxW
), int WXUNUSED(maxH
))
1061 void wxWindowBase::SetVirtualSizeHints(const wxSize
& WXUNUSED(minsize
),
1062 const wxSize
& WXUNUSED(maxsize
))
1065 #endif // WXWIN_COMPATIBILITY_2_8
1067 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
1069 m_virtualSize
= wxSize(x
, y
);
1072 wxSize
wxWindowBase::DoGetVirtualSize() const
1074 // we should use the entire client area so if it is greater than our
1075 // virtual size, expand it to fit (otherwise if the window is big enough we
1076 // wouldn't be using parts of it)
1077 wxSize size
= GetClientSize();
1078 if ( m_virtualSize
.x
> size
.x
)
1079 size
.x
= m_virtualSize
.x
;
1081 if ( m_virtualSize
.y
>= size
.y
)
1082 size
.y
= m_virtualSize
.y
;
1087 void wxWindowBase::DoGetScreenPosition(int *x
, int *y
) const
1089 // screen position is the same as (0, 0) in client coords for non TLWs (and
1090 // TLWs override this method)
1096 ClientToScreen(x
, y
);
1099 void wxWindowBase::SendSizeEvent(int flags
)
1101 wxSizeEvent
event(GetSize(), GetId());
1102 event
.SetEventObject(this);
1103 if ( flags
& wxSEND_EVENT_POST
)
1104 wxPostEvent(GetEventHandler(), event
);
1106 HandleWindowEvent(event
);
1109 void wxWindowBase::SendSizeEventToParent(int flags
)
1111 wxWindow
* const parent
= GetParent();
1112 if ( parent
&& !parent
->IsBeingDeleted() )
1113 parent
->SendSizeEvent(flags
);
1116 bool wxWindowBase::CanScroll(int orient
) const
1118 return (m_windowStyle
&
1119 (orient
== wxHORIZONTAL
? wxHSCROLL
: wxVSCROLL
)) != 0;
1122 bool wxWindowBase::HasScrollbar(int orient
) const
1124 // if scrolling in the given direction is disabled, we can't have the
1125 // corresponding scrollbar no matter what
1126 if ( !CanScroll(orient
) )
1129 const wxSize sizeVirt
= GetVirtualSize();
1130 const wxSize sizeClient
= GetClientSize();
1132 return orient
== wxHORIZONTAL
? sizeVirt
.x
> sizeClient
.x
1133 : sizeVirt
.y
> sizeClient
.y
;
1136 // ----------------------------------------------------------------------------
1137 // show/hide/enable/disable the window
1138 // ----------------------------------------------------------------------------
1140 bool wxWindowBase::Show(bool show
)
1142 if ( show
!= m_isShown
)
1154 bool wxWindowBase::IsEnabled() const
1156 return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
1159 void wxWindowBase::NotifyWindowOnEnableChange(bool enabled
)
1161 // Under some platforms there is no need to update the window state
1162 // explicitly, it will become disabled when its parent is. On other ones we
1163 // do need to disable all windows recursively though.
1164 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
1166 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1168 // Disabling a top level window is typically done when showing a modal
1169 // dialog and we don't need to disable its children in this case, they will
1170 // be logically disabled anyhow (i.e. their IsEnabled() will return false)
1171 // and the TLW won't accept any input for them. Moreover, explicitly
1172 // disabling them would look ugly as the entire TLW would be greyed out
1173 // whenever a modal dialog is shown and no native applications under any
1174 // platform behave like this.
1175 if ( IsTopLevel() && !enabled
)
1178 // When disabling (or enabling back) a non-TLW window we need to
1179 // recursively propagate the change of the state to its children, otherwise
1180 // they would still show as enabled even though they wouldn't actually
1181 // accept any input (at least under MSW where children don't accept input
1182 // if any of the windows in their parent chain is enabled).
1183 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
1184 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1186 node
= node
->GetNext() )
1188 wxWindowBase
* const child
= node
->GetData();
1189 if ( !child
->IsTopLevel() && child
->IsThisEnabled() )
1190 child
->NotifyWindowOnEnableChange(enabled
);
1192 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1195 bool wxWindowBase::Enable(bool enable
)
1197 if ( enable
== IsThisEnabled() )
1200 m_isEnabled
= enable
;
1202 // If we call DoEnable() from NotifyWindowOnEnableChange(), we don't need
1203 // to do it from here.
1204 #ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
1206 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1208 NotifyWindowOnEnableChange(enable
);
1213 bool wxWindowBase::IsShownOnScreen() const
1215 // A window is shown on screen if it itself is shown and so are all its
1216 // parents. But if a window is toplevel one, then its always visible on
1217 // screen if IsShown() returns true, even if it has a hidden parent.
1219 (IsTopLevel() || GetParent() == NULL
|| GetParent()->IsShownOnScreen());
1222 // ----------------------------------------------------------------------------
1224 // ----------------------------------------------------------------------------
1226 bool wxWindowBase::IsTopLevel() const
1231 // ----------------------------------------------------------------------------
1233 // ----------------------------------------------------------------------------
1235 void wxWindowBase::Freeze()
1237 if ( !m_freezeCount
++ )
1239 // physically freeze this window:
1242 // and recursively freeze all children:
1243 for ( wxWindowList::iterator i
= GetChildren().begin();
1244 i
!= GetChildren().end(); ++i
)
1246 wxWindow
*child
= *i
;
1247 if ( child
->IsTopLevel() )
1255 void wxWindowBase::Thaw()
1257 wxASSERT_MSG( m_freezeCount
, "Thaw() without matching Freeze()" );
1259 if ( !--m_freezeCount
)
1261 // recursively thaw all children:
1262 for ( wxWindowList::iterator i
= GetChildren().begin();
1263 i
!= GetChildren().end(); ++i
)
1265 wxWindow
*child
= *i
;
1266 if ( child
->IsTopLevel() )
1272 // physically thaw this window:
1277 // ----------------------------------------------------------------------------
1278 // Dealing with parents and children.
1279 // ----------------------------------------------------------------------------
1281 bool wxWindowBase::IsDescendant(wxWindowBase
* win
) const
1283 // Iterate until we find this window in the parent chain or exhaust it.
1289 // Stop iterating on reaching the top level window boundary.
1290 if ( win
->IsTopLevel() )
1293 win
= win
->GetParent();
1299 void wxWindowBase::AddChild(wxWindowBase
*child
)
1301 wxCHECK_RET( child
, wxT("can't add a NULL child") );
1303 // this should never happen and it will lead to a crash later if it does
1304 // because RemoveChild() will remove only one node from the children list
1305 // and the other(s) one(s) will be left with dangling pointers in them
1306 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), wxT("AddChild() called twice") );
1308 GetChildren().Append((wxWindow
*)child
);
1309 child
->SetParent(this);
1311 // adding a child while frozen will assert when thawed, so freeze it as if
1312 // it had been already present when we were frozen
1313 if ( IsFrozen() && !child
->IsTopLevel() )
1317 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
1319 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
1321 // removing a child while frozen may result in permanently frozen window
1322 // if used e.g. from Reparent(), so thaw it
1324 // NB: IsTopLevel() doesn't return true any more when a TLW child is being
1325 // removed from its ~wxWindowBase, so check for IsBeingDeleted() too
1326 if ( IsFrozen() && !child
->IsBeingDeleted() && !child
->IsTopLevel() )
1329 GetChildren().DeleteObject((wxWindow
*)child
);
1330 child
->SetParent(NULL
);
1333 void wxWindowBase::SetParent(wxWindowBase
*parent
)
1335 // This assert catches typos which may result in using "this" instead of
1336 // "parent" when creating the window. This doesn't happen often but when it
1337 // does the results are unpleasant because the program typically just
1338 // crashes when due to a stack overflow or something similar and this
1339 // assert doesn't cost much (OTOH doing a more general check that the
1340 // parent is not one of our children would be more expensive and probably
1342 wxASSERT_MSG( parent
!= this, wxS("Can't use window as its own parent") );
1344 m_parent
= (wxWindow
*)parent
;
1347 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
1349 wxWindow
*oldParent
= GetParent();
1350 if ( newParent
== oldParent
)
1356 const bool oldEnabledState
= IsEnabled();
1358 // unlink this window from the existing parent.
1361 oldParent
->RemoveChild(this);
1365 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
1368 // add it to the new one
1371 newParent
->AddChild(this);
1375 wxTopLevelWindows
.Append((wxWindow
*)this);
1378 // We need to notify window (and its subwindows) if by changing the parent
1379 // we also change our enabled/disabled status.
1380 const bool newEnabledState
= IsEnabled();
1381 if ( newEnabledState
!= oldEnabledState
)
1383 NotifyWindowOnEnableChange(newEnabledState
);
1389 // ----------------------------------------------------------------------------
1390 // event handler stuff
1391 // ----------------------------------------------------------------------------
1393 void wxWindowBase::SetEventHandler(wxEvtHandler
*handler
)
1395 wxCHECK_RET(handler
!= NULL
, "SetEventHandler(NULL) called");
1397 m_eventHandler
= handler
;
1400 void wxWindowBase::SetNextHandler(wxEvtHandler
*WXUNUSED(handler
))
1402 // disable wxEvtHandler chain mechanism for wxWindows:
1403 // wxWindow uses its own stack mechanism which doesn't mix well with wxEvtHandler's one
1405 wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1407 void wxWindowBase::SetPreviousHandler(wxEvtHandler
*WXUNUSED(handler
))
1409 // we can't simply wxFAIL here as in SetNextHandler: in fact the last
1410 // handler of our stack when is destroyed will be Unlink()ed and thus
1411 // will call this function to update the pointer of this window...
1413 //wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1416 void wxWindowBase::PushEventHandler(wxEvtHandler
*handlerToPush
)
1418 wxCHECK_RET( handlerToPush
!= NULL
, "PushEventHandler(NULL) called" );
1420 // the new handler is going to be part of the wxWindow stack of event handlers:
1421 // it can't be part also of an event handler double-linked chain:
1422 wxASSERT_MSG(handlerToPush
->IsUnlinked(),
1423 "The handler being pushed in the wxWindow stack shouldn't be part of "
1424 "a wxEvtHandler chain; call Unlink() on it first");
1426 wxEvtHandler
*handlerOld
= GetEventHandler();
1427 wxCHECK_RET( handlerOld
, "an old event handler is NULL?" );
1429 // now use wxEvtHandler double-linked list to implement a stack:
1430 handlerToPush
->SetNextHandler(handlerOld
);
1432 if (handlerOld
!= this)
1433 handlerOld
->SetPreviousHandler(handlerToPush
);
1435 SetEventHandler(handlerToPush
);
1438 // final checks of the operations done above:
1439 wxASSERT_MSG( handlerToPush
->GetPreviousHandler() == NULL
,
1440 "the first handler of the wxWindow stack should "
1441 "have no previous handlers set" );
1442 wxASSERT_MSG( handlerToPush
->GetNextHandler() != NULL
,
1443 "the first handler of the wxWindow stack should "
1444 "have non-NULL next handler" );
1446 wxEvtHandler
* pLast
= handlerToPush
;
1447 while ( pLast
&& pLast
!= this )
1448 pLast
= pLast
->GetNextHandler();
1449 wxASSERT_MSG( pLast
->GetNextHandler() == NULL
,
1450 "the last handler of the wxWindow stack should "
1451 "have this window as next handler" );
1452 #endif // wxDEBUG_LEVEL
1455 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
1457 // we need to pop the wxWindow stack, i.e. we need to remove the first handler
1459 wxEvtHandler
*firstHandler
= GetEventHandler();
1460 wxCHECK_MSG( firstHandler
!= NULL
, NULL
, "wxWindow cannot have a NULL event handler" );
1461 wxCHECK_MSG( firstHandler
!= this, NULL
, "cannot pop the wxWindow itself" );
1462 wxCHECK_MSG( firstHandler
->GetPreviousHandler() == NULL
, NULL
,
1463 "the first handler of the wxWindow stack should have no previous handlers set" );
1465 wxEvtHandler
*secondHandler
= firstHandler
->GetNextHandler();
1466 wxCHECK_MSG( secondHandler
!= NULL
, NULL
,
1467 "the first handler of the wxWindow stack should have non-NULL next handler" );
1469 firstHandler
->SetNextHandler(NULL
);
1471 // It is harmless but useless to unset the previous handler of the window
1472 // itself as it's always NULL anyhow, so don't do this.
1473 if ( secondHandler
!= this )
1474 secondHandler
->SetPreviousHandler(NULL
);
1476 // now firstHandler is completely unlinked; set secondHandler as the new window event handler
1477 SetEventHandler(secondHandler
);
1479 if ( deleteHandler
)
1481 wxDELETE(firstHandler
);
1484 return firstHandler
;
1487 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handlerToRemove
)
1489 wxCHECK_MSG( handlerToRemove
!= NULL
, false, "RemoveEventHandler(NULL) called" );
1490 wxCHECK_MSG( handlerToRemove
!= this, false, "Cannot remove the window itself" );
1492 if (handlerToRemove
== GetEventHandler())
1494 // removing the first event handler is equivalent to "popping" the stack
1495 PopEventHandler(false);
1499 // NOTE: the wxWindow event handler list is always terminated with "this" handler
1500 wxEvtHandler
*handlerCur
= GetEventHandler()->GetNextHandler();
1501 while ( handlerCur
!= this && handlerCur
)
1503 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
1505 if ( handlerCur
== handlerToRemove
)
1507 handlerCur
->Unlink();
1509 wxASSERT_MSG( handlerCur
!= GetEventHandler(),
1510 "the case Remove == Pop should was already handled" );
1514 handlerCur
= handlerNext
;
1517 wxFAIL_MSG( wxT("where has the event handler gone?") );
1522 bool wxWindowBase::HandleWindowEvent(wxEvent
& event
) const
1524 // SafelyProcessEvent() will handle exceptions nicely
1525 return GetEventHandler()->SafelyProcessEvent(event
);
1528 // ----------------------------------------------------------------------------
1529 // colours, fonts &c
1530 // ----------------------------------------------------------------------------
1532 void wxWindowBase::InheritAttributes()
1534 const wxWindowBase
* const parent
= GetParent();
1538 // we only inherit attributes which had been explicitly set for the parent
1539 // which ensures that this only happens if the user really wants it and
1540 // not by default which wouldn't make any sense in modern GUIs where the
1541 // controls don't all use the same fonts (nor colours)
1542 if ( parent
->m_inheritFont
&& !m_hasFont
)
1543 SetFont(parent
->GetFont());
1545 // in addition, there is a possibility to explicitly forbid inheriting
1546 // colours at each class level by overriding ShouldInheritColours()
1547 if ( ShouldInheritColours() )
1549 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
1550 SetForegroundColour(parent
->GetForegroundColour());
1552 // inheriting (solid) background colour is wrong as it totally breaks
1553 // any kind of themed backgrounds
1555 // instead, the controls should use the same background as their parent
1556 // (ideally by not drawing it at all)
1558 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
1559 SetBackgroundColour(parent
->GetBackgroundColour());
1564 /* static */ wxVisualAttributes
1565 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1567 // it is important to return valid values for all attributes from here,
1568 // GetXXX() below rely on this
1569 wxVisualAttributes attrs
;
1570 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
1571 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1573 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1574 // the usual background colour than wxSYS_COLOUR_BTNFACE.
1575 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1576 // colour on other platforms.
1578 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1579 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1581 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
1586 wxColour
wxWindowBase::GetBackgroundColour() const
1588 if ( !m_backgroundColour
.IsOk() )
1590 wxASSERT_MSG( !m_hasBgCol
, wxT("we have invalid explicit bg colour?") );
1592 // get our default background colour
1593 wxColour colBg
= GetDefaultAttributes().colBg
;
1595 // we must return some valid colour to avoid redoing this every time
1596 // and also to avoid surprising the applications written for older
1597 // wxWidgets versions where GetBackgroundColour() always returned
1598 // something -- so give them something even if it doesn't make sense
1599 // for this window (e.g. it has a themed background)
1600 if ( !colBg
.IsOk() )
1601 colBg
= GetClassDefaultAttributes().colBg
;
1606 return m_backgroundColour
;
1609 wxColour
wxWindowBase::GetForegroundColour() const
1611 // logic is the same as above
1612 if ( !m_hasFgCol
&& !m_foregroundColour
.IsOk() )
1614 wxColour colFg
= GetDefaultAttributes().colFg
;
1616 if ( !colFg
.IsOk() )
1617 colFg
= GetClassDefaultAttributes().colFg
;
1622 return m_foregroundColour
;
1625 bool wxWindowBase::SetBackgroundStyle(wxBackgroundStyle style
)
1627 // The checks below shouldn't be triggered if we're not really changing the
1629 if ( style
== m_backgroundStyle
)
1632 // Transparent background style can be only set before creation because of
1633 // wxGTK limitation.
1634 wxCHECK_MSG( (style
!= wxBG_STYLE_TRANSPARENT
) || !GetHandle(),
1636 "wxBG_STYLE_TRANSPARENT style can only be set before "
1637 "Create()-ing the window." );
1639 // And once it is set, wxBG_STYLE_TRANSPARENT can't be unset.
1640 wxCHECK_MSG( (m_backgroundStyle
!= wxBG_STYLE_TRANSPARENT
) ||
1641 (style
== wxBG_STYLE_TRANSPARENT
),
1643 "wxBG_STYLE_TRANSPARENT can't be unset once it was set." );
1645 m_backgroundStyle
= style
;
1650 bool wxWindowBase::IsTransparentBackgroundSupported(wxString
*reason
) const
1653 *reason
= _("This platform does not support background transparency.");
1658 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1660 if ( colour
== m_backgroundColour
)
1663 m_hasBgCol
= colour
.IsOk();
1665 m_inheritBgCol
= m_hasBgCol
;
1666 m_backgroundColour
= colour
;
1667 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.IsOk() );
1671 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1673 if (colour
== m_foregroundColour
)
1676 m_hasFgCol
= colour
.IsOk();
1677 m_inheritFgCol
= m_hasFgCol
;
1678 m_foregroundColour
= colour
;
1679 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.IsOk() );
1683 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1685 // setting an invalid cursor is ok, it means that we don't have any special
1687 if ( m_cursor
.IsSameAs(cursor
) )
1698 wxFont
wxWindowBase::GetFont() const
1700 // logic is the same as in GetBackgroundColour()
1701 if ( !m_font
.IsOk() )
1703 wxASSERT_MSG( !m_hasFont
, wxT("we have invalid explicit font?") );
1705 wxFont font
= GetDefaultAttributes().font
;
1707 font
= GetClassDefaultAttributes().font
;
1715 bool wxWindowBase::SetFont(const wxFont
& font
)
1717 if ( font
== m_font
)
1724 m_hasFont
= font
.IsOk();
1725 m_inheritFont
= m_hasFont
;
1727 InvalidateBestSize();
1734 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1736 m_hasCustomPalette
= true;
1739 // VZ: can anyone explain me what do we do here?
1740 wxWindowDC
d((wxWindow
*) this);
1744 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1746 wxWindow
*win
= (wxWindow
*)this;
1747 while ( win
&& !win
->HasCustomPalette() )
1749 win
= win
->GetParent();
1755 #endif // wxUSE_PALETTE
1758 void wxWindowBase::SetCaret(wxCaret
*caret
)
1769 wxASSERT_MSG( m_caret
->GetWindow() == this,
1770 wxT("caret should be created associated to this window") );
1773 #endif // wxUSE_CARET
1775 #if wxUSE_VALIDATORS
1776 // ----------------------------------------------------------------------------
1778 // ----------------------------------------------------------------------------
1780 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1782 if ( m_windowValidator
)
1783 delete m_windowValidator
;
1785 m_windowValidator
= (wxValidator
*)validator
.Clone();
1787 if ( m_windowValidator
)
1788 m_windowValidator
->SetWindow(this);
1790 #endif // wxUSE_VALIDATORS
1792 // ----------------------------------------------------------------------------
1793 // update region stuff
1794 // ----------------------------------------------------------------------------
1796 wxRect
wxWindowBase::GetUpdateClientRect() const
1798 wxRegion rgnUpdate
= GetUpdateRegion();
1799 rgnUpdate
.Intersect(GetClientRect());
1800 wxRect rectUpdate
= rgnUpdate
.GetBox();
1801 wxPoint ptOrigin
= GetClientAreaOrigin();
1802 rectUpdate
.x
-= ptOrigin
.x
;
1803 rectUpdate
.y
-= ptOrigin
.y
;
1808 bool wxWindowBase::DoIsExposed(int x
, int y
) const
1810 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1813 bool wxWindowBase::DoIsExposed(int x
, int y
, int w
, int h
) const
1815 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1818 void wxWindowBase::ClearBackground()
1820 // wxGTK uses its own version, no need to add never used code
1822 wxClientDC
dc((wxWindow
*)this);
1823 wxBrush
brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
);
1824 dc
.SetBackground(brush
);
1829 // ----------------------------------------------------------------------------
1830 // find child window by id or name
1831 // ----------------------------------------------------------------------------
1833 wxWindow
*wxWindowBase::FindWindow(long id
) const
1835 if ( id
== m_windowId
)
1836 return (wxWindow
*)this;
1838 wxWindowBase
*res
= NULL
;
1839 wxWindowList::compatibility_iterator node
;
1840 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1842 wxWindowBase
*child
= node
->GetData();
1843 res
= child
->FindWindow( id
);
1846 return (wxWindow
*)res
;
1849 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1851 if ( name
== m_windowName
)
1852 return (wxWindow
*)this;
1854 wxWindowBase
*res
= NULL
;
1855 wxWindowList::compatibility_iterator node
;
1856 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1858 wxWindow
*child
= node
->GetData();
1859 res
= child
->FindWindow(name
);
1862 return (wxWindow
*)res
;
1866 // find any window by id or name or label: If parent is non-NULL, look through
1867 // children for a label or title matching the specified string. If NULL, look
1868 // through all top-level windows.
1870 // to avoid duplicating code we reuse the same helper function but with
1871 // different comparators
1873 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1874 const wxString
& label
, long id
);
1877 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1880 return win
->GetLabel() == label
;
1884 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1887 return win
->GetName() == label
;
1891 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1894 return win
->GetId() == id
;
1897 // recursive helper for the FindWindowByXXX() functions
1899 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1900 const wxString
& label
,
1902 wxFindWindowCmp cmp
)
1906 // see if this is the one we're looking for
1907 if ( (*cmp
)(parent
, label
, id
) )
1908 return (wxWindow
*)parent
;
1910 // It wasn't, so check all its children
1911 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1913 node
= node
->GetNext() )
1915 // recursively check each child
1916 wxWindow
*win
= (wxWindow
*)node
->GetData();
1917 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1927 // helper for FindWindowByXXX()
1929 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1930 const wxString
& label
,
1932 wxFindWindowCmp cmp
)
1936 // just check parent and all its children
1937 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1940 // start at very top of wx's windows
1941 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1943 node
= node
->GetNext() )
1945 // recursively check each window & its children
1946 wxWindow
*win
= node
->GetData();
1947 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1957 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1959 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1964 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1966 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1970 // fall back to the label
1971 win
= FindWindowByLabel(title
, parent
);
1979 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1981 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1984 // ----------------------------------------------------------------------------
1985 // dialog oriented functions
1986 // ----------------------------------------------------------------------------
1988 #if WXWIN_COMPATIBILITY_2_8
1989 void wxWindowBase::MakeModal(bool modal
)
1991 // Disable all other windows
1994 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1997 wxWindow
*win
= node
->GetData();
1999 win
->Enable(!modal
);
2001 node
= node
->GetNext();
2005 #endif // WXWIN_COMPATIBILITY_2_8
2007 #if wxUSE_VALIDATORS
2012 // This class encapsulates possibly recursive iteration on window children done
2013 // by Validate() and TransferData{To,From}Window() and allows to avoid code
2014 // duplication in all three functions.
2015 class ValidationTraverserBase
2018 wxEXPLICIT
ValidationTraverserBase(wxWindowBase
* win
)
2019 : m_win(static_cast<wxWindow
*>(win
))
2023 // Traverse all the direct children calling OnDo() on them and also all
2024 // grandchildren if wxWS_EX_VALIDATE_RECURSIVELY is used, calling
2025 // OnRecurse() for them.
2026 bool DoForAllChildren()
2028 const bool recurse
= m_win
->HasExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY
);
2030 wxWindowList
& children
= m_win
->GetChildren();
2031 for ( wxWindowList::iterator i
= children
.begin();
2032 i
!= children
.end();
2035 wxWindow
* const child
= static_cast<wxWindow
*>(*i
);
2036 wxValidator
* const validator
= child
->GetValidator();
2037 if ( validator
&& !OnDo(validator
) )
2042 // Notice that validation should never recurse into top level
2043 // children, e.g. some other dialog which might happen to be
2045 if ( recurse
&& !child
->IsTopLevel() && !OnRecurse(child
) )
2054 // Give it a virtual dtor just to suppress gcc warnings about a class with
2055 // virtual methods but non-virtual dtor -- even if this is completely safe
2056 // here as we never use the objects of this class polymorphically.
2057 virtual ~ValidationTraverserBase() { }
2060 // Called for each child, validator is guaranteed to be non-NULL.
2061 virtual bool OnDo(wxValidator
* validator
) = 0;
2063 // Called for each child if we need to recurse into its children.
2064 virtual bool OnRecurse(wxWindow
* child
) = 0;
2067 // The window whose children we're traversing.
2068 wxWindow
* const m_win
;
2070 wxDECLARE_NO_COPY_CLASS(ValidationTraverserBase
);
2073 } // anonymous namespace
2075 #endif // wxUSE_VALIDATORS
2077 bool wxWindowBase::Validate()
2079 #if wxUSE_VALIDATORS
2080 class ValidateTraverser
: public ValidationTraverserBase
2083 wxEXPLICIT
ValidateTraverser(wxWindowBase
* win
)
2084 : ValidationTraverserBase(win
)
2088 virtual bool OnDo(wxValidator
* validator
)
2090 return validator
->Validate(m_win
);
2093 virtual bool OnRecurse(wxWindow
* child
)
2095 return child
->Validate();
2099 return ValidateTraverser(this).DoForAllChildren();
2100 #else // !wxUSE_VALIDATORS
2102 #endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
2105 bool wxWindowBase::TransferDataToWindow()
2107 #if wxUSE_VALIDATORS
2108 class DataToWindowTraverser
: public ValidationTraverserBase
2111 wxEXPLICIT
DataToWindowTraverser(wxWindowBase
* win
)
2112 : ValidationTraverserBase(win
)
2116 virtual bool OnDo(wxValidator
* validator
)
2118 if ( !validator
->TransferToWindow() )
2120 wxLogWarning(_("Could not transfer data to window"));
2122 wxLog::FlushActive();
2131 virtual bool OnRecurse(wxWindow
* child
)
2133 return child
->TransferDataToWindow();
2137 return DataToWindowTraverser(this).DoForAllChildren();
2138 #else // !wxUSE_VALIDATORS
2140 #endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
2143 bool wxWindowBase::TransferDataFromWindow()
2145 #if wxUSE_VALIDATORS
2146 class DataFromWindowTraverser
: public ValidationTraverserBase
2149 DataFromWindowTraverser(wxWindowBase
* win
)
2150 : ValidationTraverserBase(win
)
2154 virtual bool OnDo(wxValidator
* validator
)
2156 return validator
->TransferFromWindow();
2159 virtual bool OnRecurse(wxWindow
* child
)
2161 return child
->TransferDataFromWindow();
2165 return DataFromWindowTraverser(this).DoForAllChildren();
2166 #else // !wxUSE_VALIDATORS
2168 #endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
2171 void wxWindowBase::InitDialog()
2173 wxInitDialogEvent
event(GetId());
2174 event
.SetEventObject( this );
2175 GetEventHandler()->ProcessEvent(event
);
2178 // ----------------------------------------------------------------------------
2179 // context-sensitive help support
2180 // ----------------------------------------------------------------------------
2184 // associate this help text with this window
2185 void wxWindowBase::SetHelpText(const wxString
& text
)
2187 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2190 helpProvider
->AddHelp(this, text
);
2194 #if WXWIN_COMPATIBILITY_2_8
2195 // associate this help text with all windows with the same id as this
2197 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
2199 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2202 helpProvider
->AddHelp(GetId(), text
);
2205 #endif // WXWIN_COMPATIBILITY_2_8
2207 // get the help string associated with this window (may be empty)
2208 // default implementation forwards calls to the help provider
2210 wxWindowBase::GetHelpTextAtPoint(const wxPoint
& WXUNUSED(pt
),
2211 wxHelpEvent::Origin
WXUNUSED(origin
)) const
2214 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2217 text
= helpProvider
->GetHelp(this);
2223 // show help for this window
2224 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
2226 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2229 wxPoint pos
= event
.GetPosition();
2230 const wxHelpEvent::Origin origin
= event
.GetOrigin();
2231 if ( origin
== wxHelpEvent::Origin_Keyboard
)
2233 // if the help event was generated from keyboard it shouldn't
2234 // appear at the mouse position (which is still the only position
2235 // associated with help event) if the mouse is far away, although
2236 // we still do use the mouse position if it's over the window
2237 // because we suppose the user looks approximately at the mouse
2238 // already and so it would be more convenient than showing tooltip
2239 // at some arbitrary position which can be quite far from it
2240 const wxRect rectClient
= GetClientRect();
2241 if ( !rectClient
.Contains(ScreenToClient(pos
)) )
2243 // position help slightly under and to the right of this window
2244 pos
= ClientToScreen(wxPoint(
2246 rectClient
.height
+ GetCharHeight()
2251 if ( helpProvider
->ShowHelpAtPoint(this, pos
, origin
) )
2253 // skip the event.Skip() below
2261 #endif // wxUSE_HELP
2263 // ----------------------------------------------------------------------------
2265 // ----------------------------------------------------------------------------
2269 wxString
wxWindowBase::GetToolTipText() const
2271 return m_tooltip
? m_tooltip
->GetTip() : wxString();
2274 void wxWindowBase::SetToolTip( const wxString
&tip
)
2276 // don't create the new tooltip if we already have one
2279 m_tooltip
->SetTip( tip
);
2283 SetToolTip( new wxToolTip( tip
) );
2286 // setting empty tooltip text does not remove the tooltip any more - use
2287 // SetToolTip(NULL) for this
2290 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
2292 if ( m_tooltip
!= tooltip
)
2297 m_tooltip
= tooltip
;
2301 bool wxWindowBase::CopyToolTip(wxToolTip
*tip
)
2303 SetToolTip(tip
? new wxToolTip(tip
->GetTip()) : NULL
);
2308 #endif // wxUSE_TOOLTIPS
2310 // ----------------------------------------------------------------------------
2311 // constraints and sizers
2312 // ----------------------------------------------------------------------------
2314 #if wxUSE_CONSTRAINTS
2316 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
2318 if ( m_constraints
)
2320 UnsetConstraints(m_constraints
);
2321 delete m_constraints
;
2323 m_constraints
= constraints
;
2324 if ( m_constraints
)
2326 // Make sure other windows know they're part of a 'meaningful relationship'
2327 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
2328 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
2329 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
2330 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
2331 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
2332 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
2333 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
2334 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
2335 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
2336 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
2337 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
2338 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
2339 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
2340 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
2341 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
2342 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
2346 // This removes any dangling pointers to this window in other windows'
2347 // constraintsInvolvedIn lists.
2348 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
2352 if ( c
->left
.GetOtherWindow() && (c
->left
.GetOtherWindow() != this) )
2353 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
2354 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
2355 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
2356 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
2357 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
2358 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
2359 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
2360 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
2361 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
2362 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
2363 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
2364 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
2365 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
2366 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
2367 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
2371 // Back-pointer to other windows we're involved with, so if we delete this
2372 // window, we must delete any constraints we're involved with.
2373 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
2375 if ( !m_constraintsInvolvedIn
)
2376 m_constraintsInvolvedIn
= new wxWindowList
;
2377 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
2378 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
2381 // REMOVE back-pointer to other windows we're involved with.
2382 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
2384 if ( m_constraintsInvolvedIn
)
2385 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
2388 // Reset any constraints that mention this window
2389 void wxWindowBase::DeleteRelatedConstraints()
2391 if ( m_constraintsInvolvedIn
)
2393 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
2396 wxWindow
*win
= node
->GetData();
2397 wxLayoutConstraints
*constr
= win
->GetConstraints();
2399 // Reset any constraints involving this window
2402 constr
->left
.ResetIfWin(this);
2403 constr
->top
.ResetIfWin(this);
2404 constr
->right
.ResetIfWin(this);
2405 constr
->bottom
.ResetIfWin(this);
2406 constr
->width
.ResetIfWin(this);
2407 constr
->height
.ResetIfWin(this);
2408 constr
->centreX
.ResetIfWin(this);
2409 constr
->centreY
.ResetIfWin(this);
2412 wxWindowList::compatibility_iterator next
= node
->GetNext();
2413 m_constraintsInvolvedIn
->Erase(node
);
2417 wxDELETE(m_constraintsInvolvedIn
);
2421 #endif // wxUSE_CONSTRAINTS
2423 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
2425 if ( sizer
== m_windowSizer
)
2428 if ( m_windowSizer
)
2430 m_windowSizer
->SetContainingWindow(NULL
);
2433 delete m_windowSizer
;
2436 m_windowSizer
= sizer
;
2437 if ( m_windowSizer
)
2439 m_windowSizer
->SetContainingWindow((wxWindow
*)this);
2442 SetAutoLayout(m_windowSizer
!= NULL
);
2445 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
2447 SetSizer( sizer
, deleteOld
);
2448 sizer
->SetSizeHints( (wxWindow
*) this );
2452 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
2454 // adding a window to a sizer twice is going to result in fatal and
2455 // hard to debug problems later because when deleting the second
2456 // associated wxSizerItem we're going to dereference a dangling
2457 // pointer; so try to detect this as early as possible
2458 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
2459 wxT("Adding a window to the same sizer twice?") );
2461 m_containingSizer
= sizer
;
2464 #if wxUSE_CONSTRAINTS
2466 void wxWindowBase::SatisfyConstraints()
2468 wxLayoutConstraints
*constr
= GetConstraints();
2469 bool wasOk
= constr
&& constr
->AreSatisfied();
2471 ResetConstraints(); // Mark all constraints as unevaluated
2475 // if we're a top level panel (i.e. our parent is frame/dialog), our
2476 // own constraints will never be satisfied any more unless we do it
2480 while ( noChanges
> 0 )
2482 LayoutPhase1(&noChanges
);
2486 LayoutPhase2(&noChanges
);
2489 #endif // wxUSE_CONSTRAINTS
2491 bool wxWindowBase::Layout()
2493 // If there is a sizer, use it instead of the constraints
2497 GetVirtualSize(&w
, &h
);
2498 GetSizer()->SetDimension( 0, 0, w
, h
);
2500 #if wxUSE_CONSTRAINTS
2503 SatisfyConstraints(); // Find the right constraints values
2504 SetConstraintSizes(); // Recursively set the real window sizes
2511 void wxWindowBase::InternalOnSize(wxSizeEvent
& event
)
2513 if ( GetAutoLayout() )
2519 #if wxUSE_CONSTRAINTS
2521 // first phase of the constraints evaluation: set our own constraints
2522 bool wxWindowBase::LayoutPhase1(int *noChanges
)
2524 wxLayoutConstraints
*constr
= GetConstraints();
2526 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
2529 // second phase: set the constraints for our children
2530 bool wxWindowBase::LayoutPhase2(int *noChanges
)
2537 // Layout grand children
2543 // Do a phase of evaluating child constraints
2544 bool wxWindowBase::DoPhase(int phase
)
2546 // the list containing the children for which the constraints are already
2548 wxWindowList succeeded
;
2550 // the max number of iterations we loop before concluding that we can't set
2552 static const int maxIterations
= 500;
2554 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
2558 // loop over all children setting their constraints
2559 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2561 node
= node
->GetNext() )
2563 wxWindow
*child
= node
->GetData();
2564 if ( child
->IsTopLevel() )
2566 // top level children are not inside our client area
2570 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
2572 // this one is either already ok or nothing we can do about it
2576 int tempNoChanges
= 0;
2577 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
2578 : child
->LayoutPhase2(&tempNoChanges
);
2579 noChanges
+= tempNoChanges
;
2583 succeeded
.Append(child
);
2589 // constraints are set
2597 void wxWindowBase::ResetConstraints()
2599 wxLayoutConstraints
*constr
= GetConstraints();
2602 constr
->left
.SetDone(false);
2603 constr
->top
.SetDone(false);
2604 constr
->right
.SetDone(false);
2605 constr
->bottom
.SetDone(false);
2606 constr
->width
.SetDone(false);
2607 constr
->height
.SetDone(false);
2608 constr
->centreX
.SetDone(false);
2609 constr
->centreY
.SetDone(false);
2612 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2615 wxWindow
*win
= node
->GetData();
2616 if ( !win
->IsTopLevel() )
2617 win
->ResetConstraints();
2618 node
= node
->GetNext();
2622 // Need to distinguish between setting the 'fake' size for windows and sizers,
2623 // and setting the real values.
2624 void wxWindowBase::SetConstraintSizes(bool recurse
)
2626 wxLayoutConstraints
*constr
= GetConstraints();
2627 if ( constr
&& constr
->AreSatisfied() )
2629 ChildrenRepositioningGuard
repositionGuard(this);
2631 int x
= constr
->left
.GetValue();
2632 int y
= constr
->top
.GetValue();
2633 int w
= constr
->width
.GetValue();
2634 int h
= constr
->height
.GetValue();
2636 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
2637 (constr
->height
.GetRelationship() != wxAsIs
) )
2639 // We really shouldn't set negative sizes for the windows so make
2640 // them at least of 1*1 size
2641 SetSize(x
, y
, w
> 0 ? w
: 1, h
> 0 ? h
: 1);
2645 // If we don't want to resize this window, just move it...
2651 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
2652 GetClassInfo()->GetClassName(),
2658 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2661 wxWindow
*win
= node
->GetData();
2662 if ( !win
->IsTopLevel() && win
->GetConstraints() )
2663 win
->SetConstraintSizes();
2664 node
= node
->GetNext();
2669 // Only set the size/position of the constraint (if any)
2670 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
2672 wxLayoutConstraints
*constr
= GetConstraints();
2675 if ( x
!= wxDefaultCoord
)
2677 constr
->left
.SetValue(x
);
2678 constr
->left
.SetDone(true);
2680 if ( y
!= wxDefaultCoord
)
2682 constr
->top
.SetValue(y
);
2683 constr
->top
.SetDone(true);
2685 if ( w
!= wxDefaultCoord
)
2687 constr
->width
.SetValue(w
);
2688 constr
->width
.SetDone(true);
2690 if ( h
!= wxDefaultCoord
)
2692 constr
->height
.SetValue(h
);
2693 constr
->height
.SetDone(true);
2698 void wxWindowBase::MoveConstraint(int x
, int y
)
2700 wxLayoutConstraints
*constr
= GetConstraints();
2703 if ( x
!= wxDefaultCoord
)
2705 constr
->left
.SetValue(x
);
2706 constr
->left
.SetDone(true);
2708 if ( y
!= wxDefaultCoord
)
2710 constr
->top
.SetValue(y
);
2711 constr
->top
.SetDone(true);
2716 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
2718 wxLayoutConstraints
*constr
= GetConstraints();
2721 *w
= constr
->width
.GetValue();
2722 *h
= constr
->height
.GetValue();
2728 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
2730 wxLayoutConstraints
*constr
= GetConstraints();
2733 *w
= constr
->width
.GetValue();
2734 *h
= constr
->height
.GetValue();
2737 GetClientSize(w
, h
);
2740 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
2742 wxLayoutConstraints
*constr
= GetConstraints();
2745 *x
= constr
->left
.GetValue();
2746 *y
= constr
->top
.GetValue();
2752 #endif // wxUSE_CONSTRAINTS
2754 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
2756 wxWindow
*parent
= GetParent();
2757 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
2759 wxPoint
pt(parent
->GetClientAreaOrigin());
2765 // ----------------------------------------------------------------------------
2766 // Update UI processing
2767 // ----------------------------------------------------------------------------
2769 void wxWindowBase::UpdateWindowUI(long flags
)
2771 wxUpdateUIEvent
event(GetId());
2772 event
.SetEventObject(this);
2774 if ( GetEventHandler()->ProcessEvent(event
) )
2776 DoUpdateWindowUI(event
);
2779 if (flags
& wxUPDATE_UI_RECURSE
)
2781 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2784 wxWindow
* child
= (wxWindow
*) node
->GetData();
2785 child
->UpdateWindowUI(flags
);
2786 node
= node
->GetNext();
2791 // do the window-specific processing after processing the update event
2792 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2794 if ( event
.GetSetEnabled() )
2795 Enable(event
.GetEnabled());
2797 if ( event
.GetSetShown() )
2798 Show(event
.GetShown());
2801 // ----------------------------------------------------------------------------
2803 // ----------------------------------------------------------------------------
2805 // Send idle event to window and all subwindows
2806 bool wxWindowBase::SendIdleEvents(wxIdleEvent
& event
)
2808 bool needMore
= false;
2812 // should we send idle event to this window?
2813 if (wxIdleEvent::GetMode() == wxIDLE_PROCESS_ALL
||
2814 HasExtraStyle(wxWS_EX_PROCESS_IDLE
))
2816 event
.SetEventObject(this);
2817 HandleWindowEvent(event
);
2819 if (event
.MoreRequested())
2822 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2823 for (; node
; node
= node
->GetNext())
2825 wxWindow
* child
= node
->GetData();
2826 if (child
->SendIdleEvents(event
))
2833 void wxWindowBase::OnInternalIdle()
2835 if ( wxUpdateUIEvent::CanUpdate(this) )
2836 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2839 // ----------------------------------------------------------------------------
2840 // dialog units translations
2841 // ----------------------------------------------------------------------------
2843 // Windows' computes dialog units using average character width over upper-
2844 // and lower-case ASCII alphabet and not using the average character width
2845 // metadata stored in the font; see
2846 // http://support.microsoft.com/default.aspx/kb/145994 for detailed discussion.
2847 // It's important that we perform the conversion in identical way, because
2848 // dialog units natively exist only on Windows and Windows HIG is expressed
2850 wxSize
wxWindowBase::GetDlgUnitBase() const
2852 const wxWindowBase
* const parent
= wxGetTopLevelParent((wxWindow
*)this);
2854 wxCHECK_MSG( parent
, wxDefaultSize
, wxS("Must have TLW parent") );
2856 if ( !parent
->m_font
.IsOk() )
2858 // Default GUI font is used. This is the most common case, so
2859 // cache the results.
2860 static wxSize s_defFontSize
;
2861 if ( s_defFontSize
.x
== 0 )
2862 s_defFontSize
= wxPrivate::GetAverageASCIILetterSize(*parent
);
2863 return s_defFontSize
;
2867 // Custom font, we always need to compute the result
2868 return wxPrivate::GetAverageASCIILetterSize(*parent
);
2872 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
) const
2874 const wxSize base
= GetDlgUnitBase();
2876 // NB: wxMulDivInt32() is used, because it correctly rounds the result
2878 wxPoint pt2
= wxDefaultPosition
;
2879 if (pt
.x
!= wxDefaultCoord
)
2880 pt2
.x
= wxMulDivInt32(pt
.x
, 4, base
.x
);
2881 if (pt
.y
!= wxDefaultCoord
)
2882 pt2
.y
= wxMulDivInt32(pt
.y
, 8, base
.y
);
2887 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
) const
2889 const wxSize base
= GetDlgUnitBase();
2891 wxPoint pt2
= wxDefaultPosition
;
2892 if (pt
.x
!= wxDefaultCoord
)
2893 pt2
.x
= wxMulDivInt32(pt
.x
, base
.x
, 4);
2894 if (pt
.y
!= wxDefaultCoord
)
2895 pt2
.y
= wxMulDivInt32(pt
.y
, base
.y
, 8);
2900 // ----------------------------------------------------------------------------
2902 // ----------------------------------------------------------------------------
2904 // propagate the colour change event to the subwindows
2905 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
2907 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2910 // Only propagate to non-top-level windows
2911 wxWindow
*win
= node
->GetData();
2912 if ( !win
->IsTopLevel() )
2914 wxSysColourChangedEvent event2
;
2915 event2
.SetEventObject(win
);
2916 win
->GetEventHandler()->ProcessEvent(event2
);
2919 node
= node
->GetNext();
2925 // the default action is to populate dialog with data when it's created,
2926 // and nudge the UI into displaying itself correctly in case
2927 // we've turned the wxUpdateUIEvents frequency down low.
2928 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2930 TransferDataToWindow();
2932 // Update the UI at this point
2933 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2936 // ----------------------------------------------------------------------------
2937 // menu-related functions
2938 // ----------------------------------------------------------------------------
2942 bool wxWindowBase::PopupMenu(wxMenu
*menu
, int x
, int y
)
2944 wxCHECK_MSG( menu
, false, "can't popup NULL menu" );
2946 wxMenuInvokingWindowSetter
2947 setInvokingWin(*menu
, static_cast<wxWindow
*>(this));
2949 wxCurrentPopupMenu
= menu
;
2950 const bool rc
= DoPopupMenu(menu
, x
, y
);
2951 wxCurrentPopupMenu
= NULL
;
2956 // this is used to pass the id of the selected item from the menu event handler
2957 // to the main function itself
2959 // it's ok to use a global here as there can be at most one popup menu shown at
2961 static int gs_popupMenuSelection
= wxID_NONE
;
2963 void wxWindowBase::InternalOnPopupMenu(wxCommandEvent
& event
)
2965 // store the id in a global variable where we'll retrieve it from later
2966 gs_popupMenuSelection
= event
.GetId();
2969 void wxWindowBase::InternalOnPopupMenuUpdate(wxUpdateUIEvent
& WXUNUSED(event
))
2971 // nothing to do but do not skip it
2975 wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
2977 gs_popupMenuSelection
= wxID_NONE
;
2980 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2984 // it is common to construct the menu passed to this function dynamically
2985 // using some fixed range of ids which could clash with the ids used
2986 // elsewhere in the program, which could result in some menu items being
2987 // unintentionally disabled or otherwise modified by update UI handlers
2988 // elsewhere in the program code and this is difficult to avoid in the
2989 // program itself, so instead we just temporarily suspend UI updating while
2990 // this menu is shown
2991 Connect(wxEVT_UPDATE_UI
,
2992 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2996 PopupMenu(&menu
, x
, y
);
2998 Disconnect(wxEVT_UPDATE_UI
,
2999 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
3002 Disconnect(wxEVT_MENU
,
3003 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
3007 return gs_popupMenuSelection
;
3010 #endif // wxUSE_MENUS
3012 // methods for drawing the sizers in a visible way: this is currently only
3013 // enabled for "full debug" builds with wxDEBUG_LEVEL==2 as it doesn't work
3014 // that well and also because we don't want to leave it enabled in default
3015 // builds used for production
3016 #if wxDEBUG_LEVEL > 1
3018 static void DrawSizers(wxWindowBase
*win
);
3020 static void DrawBorder(wxWindowBase
*win
, const wxRect
& rect
, bool fill
, const wxPen
* pen
)
3022 wxClientDC
dc((wxWindow
*)win
);
3024 dc
.SetBrush(fill
? wxBrush(pen
->GetColour(), wxBRUSHSTYLE_CROSSDIAG_HATCH
) :
3025 *wxTRANSPARENT_BRUSH
);
3026 dc
.DrawRectangle(rect
.Deflate(1, 1));
3029 static void DrawSizer(wxWindowBase
*win
, wxSizer
*sizer
)
3031 const wxSizerItemList
& items
= sizer
->GetChildren();
3032 for ( wxSizerItemList::const_iterator i
= items
.begin(),
3037 wxSizerItem
*item
= *i
;
3038 if ( item
->IsSizer() )
3040 DrawBorder(win
, item
->GetRect().Deflate(2), false, wxRED_PEN
);
3041 DrawSizer(win
, item
->GetSizer());
3043 else if ( item
->IsSpacer() )
3045 DrawBorder(win
, item
->GetRect().Deflate(2), true, wxBLUE_PEN
);
3047 else if ( item
->IsWindow() )
3049 DrawSizers(item
->GetWindow());
3052 wxFAIL_MSG("inconsistent wxSizerItem status!");
3056 static void DrawSizers(wxWindowBase
*win
)
3058 DrawBorder(win
, win
->GetClientSize(), false, wxGREEN_PEN
);
3060 wxSizer
*sizer
= win
->GetSizer();
3063 DrawSizer(win
, sizer
);
3065 else // no sizer, still recurse into the children
3067 const wxWindowList
& children
= win
->GetChildren();
3068 for ( wxWindowList::const_iterator i
= children
.begin(),
3069 end
= children
.end();
3076 // show all kind of sizes of this window; see the "window sizing" topic
3077 // overview for more info about the various differences:
3078 wxSize fullSz
= win
->GetSize();
3079 wxSize clientSz
= win
->GetClientSize();
3080 wxSize bestSz
= win
->GetBestSize();
3081 wxSize minSz
= win
->GetMinSize();
3082 wxSize maxSz
= win
->GetMaxSize();
3083 wxSize virtualSz
= win
->GetVirtualSize();
3085 wxMessageOutputDebug dbgout
;
3087 "%-10s => fullsz=%4d;%-4d clientsz=%4d;%-4d bestsz=%4d;%-4d minsz=%4d;%-4d maxsz=%4d;%-4d virtualsz=%4d;%-4d\n",
3090 clientSz
.x
, clientSz
.y
,
3094 virtualSz
.x
, virtualSz
.y
);
3098 #endif // wxDEBUG_LEVEL
3100 // process special middle clicks
3101 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
3103 if ( event
.ControlDown() && event
.AltDown() )
3105 #if wxDEBUG_LEVEL > 1
3106 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
3107 if ( event
.ShiftDown() )
3112 #endif // __WXDEBUG__
3115 // just Ctrl-Alt-middle click shows information about wx version
3116 ::wxInfoMessageBox((wxWindow
*)this);
3117 #endif // wxUSE_MSGDLG
3126 // ----------------------------------------------------------------------------
3128 // ----------------------------------------------------------------------------
3130 #if wxUSE_ACCESSIBILITY
3131 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
3133 if (m_accessible
&& (accessible
!= m_accessible
))
3134 delete m_accessible
;
3135 m_accessible
= accessible
;
3137 m_accessible
->SetWindow((wxWindow
*) this);
3140 // Returns the accessible object, creating if necessary.
3141 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
3144 m_accessible
= CreateAccessible();
3145 return m_accessible
;
3148 // Override to create a specific accessible object.
3149 wxAccessible
* wxWindowBase::CreateAccessible()
3151 return new wxWindowAccessible((wxWindow
*) this);
3156 // ----------------------------------------------------------------------------
3157 // list classes implementation
3158 // ----------------------------------------------------------------------------
3160 #if wxUSE_STD_CONTAINERS
3162 #include "wx/listimpl.cpp"
3163 WX_DEFINE_LIST(wxWindowList
)
3165 #else // !wxUSE_STD_CONTAINERS
3167 void wxWindowListNode::DeleteData()
3169 delete (wxWindow
*)GetData();
3172 #endif // wxUSE_STD_CONTAINERS/!wxUSE_STD_CONTAINERS
3174 // ----------------------------------------------------------------------------
3176 // ----------------------------------------------------------------------------
3178 wxBorder
wxWindowBase::GetBorder(long flags
) const
3180 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
3181 if ( border
== wxBORDER_DEFAULT
)
3183 border
= GetDefaultBorder();
3185 else if ( border
== wxBORDER_THEME
)
3187 border
= GetDefaultBorderForControl();
3193 wxBorder
wxWindowBase::GetDefaultBorder() const
3195 return wxBORDER_NONE
;
3198 // ----------------------------------------------------------------------------
3200 // ----------------------------------------------------------------------------
3202 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
3204 // here we just check if the point is inside the window or not
3206 // check the top and left border first
3207 bool outside
= x
< 0 || y
< 0;
3210 // check the right and bottom borders too
3211 wxSize size
= GetSize();
3212 outside
= x
>= size
.x
|| y
>= size
.y
;
3215 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
3218 // ----------------------------------------------------------------------------
3220 // ----------------------------------------------------------------------------
3222 // Private data used for mouse capture tracking.
3223 namespace wxMouseCapture
3226 // Stack of the windows which previously had the capture, the top most element
3227 // is the window that has the mouse capture now.
3229 // NB: We use wxVector and not wxStack to be able to examine all of the stack
3230 // elements for debug checks, but only the stack operations should be
3231 // performed with this vector.
3232 wxVector
<wxWindow
*> stack
;
3234 // Flag preventing reentrancy in {Capture,Release}Mouse().
3235 wxRecursionGuardFlag changing
;
3237 bool IsInCaptureStack(wxWindowBase
* win
)
3239 for ( wxVector
<wxWindow
*>::const_iterator it
= stack
.begin();
3252 void wxWindowBase::CaptureMouse()
3254 wxLogTrace(wxT("mousecapture"), wxT("CaptureMouse(%p)"), static_cast<void*>(this));
3256 wxRecursionGuard
guard(wxMouseCapture::changing
);
3257 wxASSERT_MSG( !guard
.IsInside(), wxT("recursive CaptureMouse call?") );
3259 wxASSERT_MSG( !wxMouseCapture::IsInCaptureStack(this),
3260 "Recapturing the mouse in the same window?" );
3262 wxWindow
*winOld
= GetCapture();
3264 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
3268 wxMouseCapture::stack
.push_back(static_cast<wxWindow
*>(this));
3271 void wxWindowBase::ReleaseMouse()
3273 wxLogTrace(wxT("mousecapture"), wxT("ReleaseMouse(%p)"), static_cast<void*>(this));
3275 wxRecursionGuard
guard(wxMouseCapture::changing
);
3276 wxASSERT_MSG( !guard
.IsInside(), wxT("recursive ReleaseMouse call?") );
3279 wxWindow
* const winCapture
= GetCapture();
3286 "Releasing mouse in %p(%s) but it is not captured",
3287 this, GetClassInfo()->GetClassName()
3291 else if ( winCapture
!= this )
3297 "Releasing mouse in %p(%s) but it is captured by %p(%s)",
3298 this, GetClassInfo()->GetClassName(),
3299 winCapture
, winCapture
->GetClassInfo()->GetClassName()
3303 #endif // wxDEBUG_LEVEL
3307 wxCHECK_RET( !wxMouseCapture::stack
.empty(),
3308 "Releasing mouse capture but capture stack empty?" );
3309 wxCHECK_RET( wxMouseCapture::stack
.back() == this,
3310 "Window releasing mouse capture not top of capture stack?" );
3312 wxMouseCapture::stack
.pop_back();
3314 // Restore the capture to the previous window, if any.
3315 if ( !wxMouseCapture::stack
.empty() )
3317 ((wxWindowBase
*)wxMouseCapture::stack
.back())->DoCaptureMouse();
3320 wxLogTrace(wxT("mousecapture"),
3321 wxT("After ReleaseMouse() mouse is captured by %p"),
3322 static_cast<void*>(GetCapture()));
3325 static void DoNotifyWindowAboutCaptureLost(wxWindow
*win
)
3327 wxMouseCaptureLostEvent
event(win
->GetId());
3328 event
.SetEventObject(win
);
3329 if ( !win
->GetEventHandler()->ProcessEvent(event
) )
3331 // windows must handle this event, otherwise the app wouldn't behave
3332 // correctly if it loses capture unexpectedly; see the discussion here:
3333 // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
3334 // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
3335 wxFAIL_MSG( wxT("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
3340 void wxWindowBase::NotifyCaptureLost()
3342 // don't do anything if capture lost was expected, i.e. resulted from
3343 // a wx call to ReleaseMouse or CaptureMouse:
3344 wxRecursionGuard
guard(wxMouseCapture::changing
);
3345 if ( guard
.IsInside() )
3348 // if the capture was lost unexpectedly, notify every window that has
3349 // capture (on stack or current) about it and clear the stack:
3350 while ( !wxMouseCapture::stack
.empty() )
3352 DoNotifyWindowAboutCaptureLost(wxMouseCapture::stack
.back());
3354 wxMouseCapture::stack
.pop_back();
3361 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
3362 int WXUNUSED(modifiers
),
3363 int WXUNUSED(keycode
))
3369 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
3375 #endif // wxUSE_HOTKEY
3377 // ----------------------------------------------------------------------------
3379 // ----------------------------------------------------------------------------
3381 bool wxWindowBase::TryBefore(wxEvent
& event
)
3383 #if wxUSE_VALIDATORS
3384 // Can only use the validator of the window which
3385 // is receiving the event
3386 if ( event
.GetEventObject() == this )
3388 wxValidator
* const validator
= GetValidator();
3389 if ( validator
&& validator
->ProcessEventLocally(event
) )
3394 #endif // wxUSE_VALIDATORS
3396 return wxEvtHandler::TryBefore(event
);
3399 bool wxWindowBase::TryAfter(wxEvent
& event
)
3401 // carry on up the parent-child hierarchy if the propagation count hasn't
3403 if ( event
.ShouldPropagate() )
3405 // honour the requests to stop propagation at this window: this is
3406 // used by the dialogs, for example, to prevent processing the events
3407 // from the dialog controls in the parent frame which rarely, if ever,
3409 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
3411 wxWindow
*parent
= GetParent();
3412 if ( parent
&& !parent
->IsBeingDeleted() )
3414 wxPropagateOnce
propagateOnce(event
, this);
3416 return parent
->GetEventHandler()->ProcessEvent(event
);
3421 return wxEvtHandler::TryAfter(event
);
3424 // ----------------------------------------------------------------------------
3425 // window relationships
3426 // ----------------------------------------------------------------------------
3428 wxWindow
*wxWindowBase::DoGetSibling(WindowOrder order
) const
3430 wxCHECK_MSG( GetParent(), NULL
,
3431 wxT("GetPrev/NextSibling() don't work for TLWs!") );
3433 wxWindowList
& siblings
= GetParent()->GetChildren();
3434 wxWindowList::compatibility_iterator i
= siblings
.Find((wxWindow
*)this);
3435 wxCHECK_MSG( i
, NULL
, wxT("window not a child of its parent?") );
3437 if ( order
== OrderBefore
)
3438 i
= i
->GetPrevious();
3442 return i
? i
->GetData() : NULL
;
3445 // ----------------------------------------------------------------------------
3446 // keyboard navigation
3447 // ----------------------------------------------------------------------------
3449 // Navigates in the specified direction inside this window
3450 bool wxWindowBase::DoNavigateIn(int flags
)
3452 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
3453 // native code doesn't process our wxNavigationKeyEvents anyhow
3456 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
3457 wxNavigationKeyEvent eventNav
;
3458 wxWindow
*focused
= FindFocus();
3459 eventNav
.SetCurrentFocus(focused
);
3460 eventNav
.SetEventObject(focused
);
3461 eventNav
.SetFlags(flags
);
3462 return GetEventHandler()->ProcessEvent(eventNav
);
3463 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
3466 bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent
& event
)
3468 if ( event
.GetKeyCode() != WXK_TAB
)
3471 int flags
= wxNavigationKeyEvent::FromTab
;
3473 if ( event
.ShiftDown() )
3474 flags
|= wxNavigationKeyEvent::IsBackward
;
3476 flags
|= wxNavigationKeyEvent::IsForward
;
3478 if ( event
.ControlDown() )
3479 flags
|= wxNavigationKeyEvent::WinChange
;
3485 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3487 // check that we're not a top level window
3488 wxCHECK_RET( GetParent(),
3489 wxT("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
3491 // detect the special case when we have nothing to do anyhow and when the
3492 // code below wouldn't work
3496 // find the target window in the siblings list
3497 wxWindowList
& siblings
= GetParent()->GetChildren();
3498 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
3499 wxCHECK_RET( i
, wxT("MoveBefore/AfterInTabOrder(): win is not a sibling") );
3501 // unfortunately, when wxUSE_STD_CONTAINERS == 1 DetachNode() is not
3502 // implemented so we can't just move the node around
3503 wxWindow
*self
= (wxWindow
*)this;
3504 siblings
.DeleteObject(self
);
3505 if ( move
== OrderAfter
)
3512 siblings
.Insert(i
, self
);
3514 else // OrderAfter and win was the last sibling
3516 siblings
.Append(self
);
3520 // ----------------------------------------------------------------------------
3522 // ----------------------------------------------------------------------------
3524 /*static*/ wxWindow
* wxWindowBase::FindFocus()
3526 wxWindowBase
*win
= DoFindFocus();
3527 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
3530 bool wxWindowBase::HasFocus() const
3532 wxWindowBase
* const win
= DoFindFocus();
3534 (this == win
|| this == win
->GetMainWindowOfCompositeControl());
3537 // ----------------------------------------------------------------------------
3539 // ----------------------------------------------------------------------------
3541 #if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3546 class DragAcceptFilesTarget
: public wxFileDropTarget
3549 DragAcceptFilesTarget(wxWindowBase
*win
) : m_win(win
) {}
3551 virtual bool OnDropFiles(wxCoord x
, wxCoord y
,
3552 const wxArrayString
& filenames
)
3554 wxDropFilesEvent
event(wxEVT_DROP_FILES
,
3556 wxCArrayString(filenames
).Release());
3557 event
.SetEventObject(m_win
);
3561 return m_win
->HandleWindowEvent(event
);
3565 wxWindowBase
* const m_win
;
3567 wxDECLARE_NO_COPY_CLASS(DragAcceptFilesTarget
);
3571 } // anonymous namespace
3573 // Generic version of DragAcceptFiles(). It works by installing a simple
3574 // wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used
3575 // together with explicit SetDropTarget() calls.
3576 void wxWindowBase::DragAcceptFiles(bool accept
)
3580 wxASSERT_MSG( !GetDropTarget(),
3581 "cannot use DragAcceptFiles() and SetDropTarget() together" );
3582 SetDropTarget(new DragAcceptFilesTarget(this));
3586 SetDropTarget(NULL
);
3590 #endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3592 // ----------------------------------------------------------------------------
3594 // ----------------------------------------------------------------------------
3596 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
3598 while ( win
&& !win
->IsTopLevel() )
3599 win
= win
->GetParent();
3604 #if wxUSE_ACCESSIBILITY
3605 // ----------------------------------------------------------------------------
3606 // accessible object for windows
3607 // ----------------------------------------------------------------------------
3609 // Can return either a child object, or an integer
3610 // representing the child element, starting from 1.
3611 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
3613 wxASSERT( GetWindow() != NULL
);
3617 return wxACC_NOT_IMPLEMENTED
;
3620 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
3621 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
3623 wxASSERT( GetWindow() != NULL
);
3627 wxWindow
* win
= NULL
;
3634 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
3636 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
3643 rect
= win
->GetRect();
3644 if (win
->GetParent() && !wxDynamicCast(win
, wxTopLevelWindow
))
3645 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
3649 return wxACC_NOT_IMPLEMENTED
;
3652 // Navigates from fromId to toId/toObject.
3653 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
3654 int* WXUNUSED(toId
), wxAccessible
** toObject
)
3656 wxASSERT( GetWindow() != NULL
);
3662 case wxNAVDIR_FIRSTCHILD
:
3664 if (GetWindow()->GetChildren().GetCount() == 0)
3666 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
3667 *toObject
= childWindow
->GetOrCreateAccessible();
3671 case wxNAVDIR_LASTCHILD
:
3673 if (GetWindow()->GetChildren().GetCount() == 0)
3675 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
3676 *toObject
= childWindow
->GetOrCreateAccessible();
3680 case wxNAVDIR_RIGHT
:
3684 wxWindowList::compatibility_iterator node
=
3685 wxWindowList::compatibility_iterator();
3688 // Can't navigate to sibling of this window
3689 // if we're a top-level window.
3690 if (!GetWindow()->GetParent())
3691 return wxACC_NOT_IMPLEMENTED
;
3693 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3697 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3698 node
= GetWindow()->GetChildren().Item(fromId
-1);
3701 if (node
&& node
->GetNext())
3703 wxWindow
* nextWindow
= node
->GetNext()->GetData();
3704 *toObject
= nextWindow
->GetOrCreateAccessible();
3712 case wxNAVDIR_PREVIOUS
:
3714 wxWindowList::compatibility_iterator node
=
3715 wxWindowList::compatibility_iterator();
3718 // Can't navigate to sibling of this window
3719 // if we're a top-level window.
3720 if (!GetWindow()->GetParent())
3721 return wxACC_NOT_IMPLEMENTED
;
3723 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3727 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3728 node
= GetWindow()->GetChildren().Item(fromId
-1);
3731 if (node
&& node
->GetPrevious())
3733 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
3734 *toObject
= previousWindow
->GetOrCreateAccessible();
3742 return wxACC_NOT_IMPLEMENTED
;
3745 // Gets the name of the specified object.
3746 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
3748 wxASSERT( GetWindow() != NULL
);
3754 // If a child, leave wxWidgets to call the function on the actual
3757 return wxACC_NOT_IMPLEMENTED
;
3759 // This will eventually be replaced by specialised
3760 // accessible classes, one for each kind of wxWidgets
3761 // control or window.
3763 if (wxDynamicCast(GetWindow(), wxButton
))
3764 title
= ((wxButton
*) GetWindow())->GetLabel();
3767 title
= GetWindow()->GetName();
3775 return wxACC_NOT_IMPLEMENTED
;
3778 // Gets the number of children.
3779 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
3781 wxASSERT( GetWindow() != NULL
);
3785 *childId
= (int) GetWindow()->GetChildren().GetCount();
3789 // Gets the specified child (starting from 1).
3790 // If *child is NULL and return value is wxACC_OK,
3791 // this means that the child is a simple element and
3792 // not an accessible object.
3793 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
3795 wxASSERT( GetWindow() != NULL
);
3805 if (childId
> (int) GetWindow()->GetChildren().GetCount())
3808 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
3809 *child
= childWindow
->GetOrCreateAccessible();
3816 // Gets the parent, or NULL.
3817 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
3819 wxASSERT( GetWindow() != NULL
);
3823 wxWindow
* parentWindow
= GetWindow()->GetParent();
3831 *parent
= parentWindow
->GetOrCreateAccessible();
3839 // Performs the default action. childId is 0 (the action for this object)
3840 // or > 0 (the action for a child).
3841 // Return wxACC_NOT_SUPPORTED if there is no default action for this
3842 // window (e.g. an edit control).
3843 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
3845 wxASSERT( GetWindow() != NULL
);
3849 return wxACC_NOT_IMPLEMENTED
;
3852 // Gets the default action for this object (0) or > 0 (the action for a child).
3853 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
3854 // string if there is no action.
3855 // The retrieved string describes the action that is performed on an object,
3856 // not what the object does as a result. For example, a toolbar button that prints
3857 // a document has a default action of "Press" rather than "Prints the current document."
3858 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
3860 wxASSERT( GetWindow() != NULL
);
3864 return wxACC_NOT_IMPLEMENTED
;
3867 // Returns the description for this object or a child.
3868 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
3870 wxASSERT( GetWindow() != NULL
);
3874 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3880 return wxACC_NOT_IMPLEMENTED
;
3883 // Returns help text for this object or a child, similar to tooltip text.
3884 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
3886 wxASSERT( GetWindow() != NULL
);
3890 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3896 return wxACC_NOT_IMPLEMENTED
;
3899 // Returns the keyboard shortcut for this object or child.
3900 // Return e.g. ALT+K
3901 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
3903 wxASSERT( GetWindow() != NULL
);
3907 return wxACC_NOT_IMPLEMENTED
;
3910 // Returns a role constant.
3911 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
3913 wxASSERT( GetWindow() != NULL
);
3917 // If a child, leave wxWidgets to call the function on the actual
3920 return wxACC_NOT_IMPLEMENTED
;
3922 if (wxDynamicCast(GetWindow(), wxControl
))
3923 return wxACC_NOT_IMPLEMENTED
;
3925 if (wxDynamicCast(GetWindow(), wxStatusBar
))
3926 return wxACC_NOT_IMPLEMENTED
;
3929 if (wxDynamicCast(GetWindow(), wxToolBar
))
3930 return wxACC_NOT_IMPLEMENTED
;
3933 //*role = wxROLE_SYSTEM_CLIENT;
3934 *role
= wxROLE_SYSTEM_CLIENT
;
3938 return wxACC_NOT_IMPLEMENTED
;
3942 // Returns a state constant.
3943 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
3945 wxASSERT( GetWindow() != NULL
);
3949 // If a child, leave wxWidgets to call the function on the actual
3952 return wxACC_NOT_IMPLEMENTED
;
3954 if (wxDynamicCast(GetWindow(), wxControl
))
3955 return wxACC_NOT_IMPLEMENTED
;
3958 if (wxDynamicCast(GetWindow(), wxStatusBar
))
3959 return wxACC_NOT_IMPLEMENTED
;
3962 if (wxDynamicCast(GetWindow(), wxToolBar
))
3963 return wxACC_NOT_IMPLEMENTED
;
3970 return wxACC_NOT_IMPLEMENTED
;
3974 // Returns a localized string representing the value for the object
3976 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
3978 wxASSERT( GetWindow() != NULL
);
3982 return wxACC_NOT_IMPLEMENTED
;
3985 // Selects the object or child.
3986 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
3988 wxASSERT( GetWindow() != NULL
);
3992 return wxACC_NOT_IMPLEMENTED
;
3995 // Gets the window with the keyboard focus.
3996 // If childId is 0 and child is NULL, no object in
3997 // this subhierarchy has the focus.
3998 // If this object has the focus, child should be 'this'.
3999 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
4001 wxASSERT( GetWindow() != NULL
);
4005 return wxACC_NOT_IMPLEMENTED
;
4009 // Gets a variant representing the selected children
4011 // Acceptable values:
4012 // - a null variant (IsNull() returns true)
4013 // - a list variant (GetType() == wxT("list")
4014 // - an integer representing the selected child element,
4015 // or 0 if this object is selected (GetType() == wxT("long")
4016 // - a "void*" pointer to a wxAccessible child object
4017 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
4019 wxASSERT( GetWindow() != NULL
);
4023 return wxACC_NOT_IMPLEMENTED
;
4025 #endif // wxUSE_VARIANT
4027 #endif // wxUSE_ACCESSIBILITY
4029 // ----------------------------------------------------------------------------
4031 // ----------------------------------------------------------------------------
4034 wxWindowBase::AdjustForLayoutDirection(wxCoord x
,
4036 wxCoord widthTotal
) const
4038 if ( GetLayoutDirection() == wxLayout_RightToLeft
)
4040 x
= widthTotal
- x
- width
;