1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/wincmn.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
28 #include "wx/string.h"
32 #include "wx/window.h"
33 #include "wx/control.h"
34 #include "wx/checkbox.h"
35 #include "wx/radiobut.h"
36 #include "wx/statbox.h"
37 #include "wx/textctrl.h"
38 #include "wx/settings.h"
39 #include "wx/dialog.h"
40 #include "wx/msgdlg.h"
41 #include "wx/msgout.h"
42 #include "wx/statusbr.h"
43 #include "wx/toolbar.h"
44 #include "wx/dcclient.h"
45 #include "wx/scrolbar.h"
46 #include "wx/layout.h"
51 #if wxUSE_DRAG_AND_DROP
53 #endif // wxUSE_DRAG_AND_DROP
55 #if wxUSE_ACCESSIBILITY
56 #include "wx/access.h"
60 #include "wx/cshelp.h"
64 #include "wx/tooltip.h"
65 #endif // wxUSE_TOOLTIPS
71 #if wxUSE_SYSTEM_OPTIONS
72 #include "wx/sysopt.h"
75 #include "wx/platinfo.h"
76 #include "wx/private/window.h"
79 #include "wx/msw/wrapwin.h"
83 WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
87 wxMenu
*wxCurrentPopupMenu
= NULL
;
90 extern WXDLLEXPORT_DATA(const char) wxPanelNameStr
[] = "panel";
92 // ----------------------------------------------------------------------------
94 // ----------------------------------------------------------------------------
97 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
99 // ----------------------------------------------------------------------------
101 // ----------------------------------------------------------------------------
103 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
104 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
105 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
106 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
109 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
112 EVT_SIZE(wxWindowBase::InternalOnSize
)
115 // ============================================================================
116 // implementation of the common functionality of the wxWindow class
117 // ============================================================================
119 // ----------------------------------------------------------------------------
121 // ----------------------------------------------------------------------------
123 #if wxUSE_EXTENDED_RTTI
125 // windows that are created from a parent window during its Create method,
126 // eg. spin controls in a calendar controls must never been streamed out
127 // separately otherwise chaos occurs. Right now easiest is to test for negative ids,
128 // as windows with negative ids never can be recreated anyway
131 bool wxWindowStreamingCallback( const wxObject
*object
, wxObjectWriter
*,
132 wxObjectWriterCallback
*, const wxStringToAnyHashMap
& )
134 const wxWindow
* win
= wx_dynamic_cast(const wxWindow
*, object
);
135 if ( win
&& win
->GetId() < 0 )
140 wxIMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxWindow
, wxWindowBase
, "wx/window.h", \
141 wxWindowStreamingCallback
)
143 // make wxWindowList known before the property is used
145 wxCOLLECTION_TYPE_INFO( wxWindow
*, wxWindowList
);
147 template<> void wxCollectionToVariantArray( wxWindowList
const &theList
,
150 wxListCollectionToAnyList
<wxWindowList::compatibility_iterator
>( theList
, value
);
153 wxDEFINE_FLAGS( wxWindowStyle
)
155 wxBEGIN_FLAGS( wxWindowStyle
)
156 // new style border flags, we put them first to
157 // use them for streaming out
159 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
160 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
161 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
162 wxFLAGS_MEMBER(wxBORDER_RAISED
)
163 wxFLAGS_MEMBER(wxBORDER_STATIC
)
164 wxFLAGS_MEMBER(wxBORDER_NONE
)
166 // old style border flags
167 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
168 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
169 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
170 wxFLAGS_MEMBER(wxRAISED_BORDER
)
171 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
172 wxFLAGS_MEMBER(wxBORDER
)
174 // standard window styles
175 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
176 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
177 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
178 wxFLAGS_MEMBER(wxWANTS_CHARS
)
179 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
180 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
181 wxFLAGS_MEMBER(wxVSCROLL
)
182 wxFLAGS_MEMBER(wxHSCROLL
)
184 wxEND_FLAGS( wxWindowStyle
)
186 wxBEGIN_PROPERTIES_TABLE(wxWindow
)
187 wxEVENT_PROPERTY( Close
, wxEVT_CLOSE_WINDOW
, wxCloseEvent
)
188 wxEVENT_PROPERTY( Create
, wxEVT_CREATE
, wxWindowCreateEvent
)
189 wxEVENT_PROPERTY( Destroy
, wxEVT_DESTROY
, wxWindowDestroyEvent
)
190 // Always constructor Properties first
192 wxREADONLY_PROPERTY( Parent
,wxWindow
*, GetParent
, wxEMPTY_PARAMETER_VALUE
, \
193 0 /*flags*/, wxT("Helpstring"), wxT("group"))
194 wxPROPERTY( Id
,wxWindowID
, SetId
, GetId
, -1 /*wxID_ANY*/, 0 /*flags*/, \
195 wxT("Helpstring"), wxT("group") )
196 wxPROPERTY( Position
,wxPoint
, SetPosition
, GetPosition
, wxDefaultPosition
, \
197 0 /*flags*/, wxT("Helpstring"), wxT("group")) // pos
198 wxPROPERTY( Size
,wxSize
, SetSize
, GetSize
, wxDefaultSize
, 0 /*flags*/, \
199 wxT("Helpstring"), wxT("group")) // size
200 wxPROPERTY( WindowStyle
, long, SetWindowStyleFlag
, GetWindowStyleFlag
, \
201 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // style
202 wxPROPERTY( Name
,wxString
, SetName
, GetName
, wxEmptyString
, 0 /*flags*/, \
203 wxT("Helpstring"), wxT("group") )
205 // Then all relations of the object graph
207 wxREADONLY_PROPERTY_COLLECTION( Children
, wxWindowList
, wxWindowBase
*, \
208 GetWindowChildren
, wxPROP_OBJECT_GRAPH
/*flags*/, \
209 wxT("Helpstring"), wxT("group"))
211 // and finally all other properties
213 wxPROPERTY( ExtraStyle
, long, SetExtraStyle
, GetExtraStyle
, wxEMPTY_PARAMETER_VALUE
, \
214 0 /*flags*/, wxT("Helpstring"), wxT("group")) // extstyle
215 wxPROPERTY( BackgroundColour
, wxColour
, SetBackgroundColour
, GetBackgroundColour
, \
216 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // bg
217 wxPROPERTY( ForegroundColour
, wxColour
, SetForegroundColour
, GetForegroundColour
, \
218 wxEMPTY_PARAMETER_VALUE
, 0 /*flags*/, wxT("Helpstring"), wxT("group")) // fg
219 wxPROPERTY( Enabled
, bool, Enable
, IsEnabled
, wxAny((bool)true), 0 /*flags*/, \
220 wxT("Helpstring"), wxT("group"))
221 wxPROPERTY( Shown
, bool, Show
, IsShown
, wxAny((bool)true), 0 /*flags*/, \
222 wxT("Helpstring"), wxT("group"))
225 // possible property candidates (not in xrc) or not valid in all subclasses
226 wxPROPERTY( Title
,wxString
, SetTitle
, GetTitle
, wxEmptyString
)
227 wxPROPERTY( Font
, wxFont
, SetFont
, GetWindowFont
, )
228 wxPROPERTY( Label
,wxString
, SetLabel
, GetLabel
, wxEmptyString
)
229 // MaxHeight, Width, MinHeight, Width
230 // TODO switch label to control and title to toplevels
232 wxPROPERTY( ThemeEnabled
, bool, SetThemeEnabled
, GetThemeEnabled
, )
233 //wxPROPERTY( Cursor, wxCursor, SetCursor, GetCursor, )
234 // wxPROPERTY( ToolTip, wxString, SetToolTip, GetToolTipText, )
235 wxPROPERTY( AutoLayout
, bool, SetAutoLayout
, GetAutoLayout
, )
237 wxEND_PROPERTIES_TABLE()
239 wxEMPTY_HANDLERS_TABLE(wxWindow
)
241 wxCONSTRUCTOR_DUMMY(wxWindow
)
245 #ifndef __WXUNIVERSAL__
246 IMPLEMENT_DYNAMIC_CLASS(wxWindow
, wxWindowBase
)
251 // ----------------------------------------------------------------------------
253 // ----------------------------------------------------------------------------
255 // the default initialization
256 wxWindowBase::wxWindowBase()
258 // no window yet, no parent nor children
260 m_windowId
= wxID_ANY
;
262 // no constraints on the minimal window size
264 m_maxWidth
= wxDefaultCoord
;
266 m_maxHeight
= wxDefaultCoord
;
268 // invalidiated cache value
269 m_bestSizeCache
= wxDefaultSize
;
271 // window are created enabled and visible by default
275 // the default event handler is just this window
276 m_eventHandler
= this;
280 m_windowValidator
= NULL
;
281 #endif // wxUSE_VALIDATORS
283 // the colours/fonts are default for now, so leave m_font,
284 // m_backgroundColour and m_foregroundColour uninitialized and set those
290 m_inheritFont
= false;
296 m_backgroundStyle
= wxBG_STYLE_ERASE
;
298 #if wxUSE_CONSTRAINTS
299 // no constraints whatsoever
300 m_constraints
= NULL
;
301 m_constraintsInvolvedIn
= NULL
;
302 #endif // wxUSE_CONSTRAINTS
304 m_windowSizer
= NULL
;
305 m_containingSizer
= NULL
;
306 m_autoLayout
= false;
308 #if wxUSE_DRAG_AND_DROP
310 #endif // wxUSE_DRAG_AND_DROP
314 #endif // wxUSE_TOOLTIPS
318 #endif // wxUSE_CARET
321 m_hasCustomPalette
= false;
322 #endif // wxUSE_PALETTE
324 #if wxUSE_ACCESSIBILITY
328 m_virtualSize
= wxDefaultSize
;
330 m_scrollHelper
= NULL
;
332 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
333 #if wxUSE_SYSTEM_OPTIONS
334 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
336 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
340 // Whether we're using the current theme for this window (wxGTK only for now)
341 m_themeEnabled
= false;
343 // This is set to true by SendDestroyEvent() which should be called by the
344 // most derived class to ensure that the destruction event is sent as soon
345 // as possible to allow its handlers to still see the undestroyed window
346 m_isBeingDeleted
= false;
351 // common part of window creation process
352 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
354 const wxPoint
& WXUNUSED(pos
),
357 const wxString
& name
)
359 // ids are limited to 16 bits under MSW so if you care about portability,
360 // it's not a good idea to use ids out of this range (and negative ids are
361 // reserved for wxWidgets own usage)
362 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767) ||
363 (id
>= wxID_AUTO_LOWEST
&& id
<= wxID_AUTO_HIGHEST
),
364 wxT("invalid id value") );
366 // generate a new id if the user doesn't care about it
367 if ( id
== wxID_ANY
)
369 m_windowId
= NewControlId();
371 else // valid id specified
376 // don't use SetWindowStyleFlag() here, this function should only be called
377 // to change the flag after creation as it tries to reflect the changes in
378 // flags by updating the window dynamically and we don't need this here
379 m_windowStyle
= style
;
381 // assume the user doesn't want this window to shrink beneath its initial
382 // size, this worked like this in wxWidgets 2.8 and before and generally
383 // often makes sense for child windows (for top level ones it definitely
384 // does not as the user should be able to resize the window)
386 // note that we can't use IsTopLevel() from ctor
387 if ( size
!= wxDefaultSize
&& !wxTopLevelWindows
.Find((wxWindow
*)this) )
396 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
401 const wxValidator
& wxVALIDATOR_PARAM(validator
),
402 const wxString
& name
)
404 if ( !CreateBase(parent
, id
, pos
, size
, style
, name
) )
408 SetValidator(validator
);
409 #endif // wxUSE_VALIDATORS
411 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
412 // have it too - like this it's possible to set it only in the top level
413 // dialog/frame and all children will inherit it by defult
414 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
416 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
422 bool wxWindowBase::ToggleWindowStyle(int flag
)
424 wxASSERT_MSG( flag
, wxT("flags with 0 value can't be toggled") );
427 long style
= GetWindowStyleFlag();
433 else // currently off
439 SetWindowStyleFlag(style
);
444 // ----------------------------------------------------------------------------
446 // ----------------------------------------------------------------------------
449 wxWindowBase::~wxWindowBase()
451 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
453 // FIXME if these 2 cases result from programming errors in the user code
454 // we should probably assert here instead of silently fixing them
456 // Just in case the window has been Closed, but we're then deleting
457 // immediately: don't leave dangling pointers.
458 wxPendingDelete
.DeleteObject(this);
460 // Just in case we've loaded a top-level window via LoadNativeDialog but
461 // we weren't a dialog class
462 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
464 // Any additional event handlers should be popped before the window is
465 // deleted as otherwise the last handler will be left with a dangling
466 // pointer to this window result in a difficult to diagnose crash later on.
467 wxASSERT_MSG( GetEventHandler() == this,
468 wxT("any pushed event handlers must have been removed") );
471 // The associated popup menu can still be alive, disassociate from it in
473 if ( wxCurrentPopupMenu
&& wxCurrentPopupMenu
->GetInvokingWindow() == this )
474 wxCurrentPopupMenu
->SetInvokingWindow(NULL
);
475 #endif // wxUSE_MENUS
477 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
479 // notify the parent about this window destruction
481 m_parent
->RemoveChild(this);
485 #endif // wxUSE_CARET
488 delete m_windowValidator
;
489 #endif // wxUSE_VALIDATORS
491 #if wxUSE_CONSTRAINTS
492 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
493 // at deleted windows as they delete themselves.
494 DeleteRelatedConstraints();
498 // This removes any dangling pointers to this window in other windows'
499 // constraintsInvolvedIn lists.
500 UnsetConstraints(m_constraints
);
501 wxDELETE(m_constraints
);
503 #endif // wxUSE_CONSTRAINTS
505 if ( m_containingSizer
)
506 m_containingSizer
->Detach( (wxWindow
*)this );
508 delete m_windowSizer
;
510 #if wxUSE_DRAG_AND_DROP
512 #endif // wxUSE_DRAG_AND_DROP
516 #endif // wxUSE_TOOLTIPS
518 #if wxUSE_ACCESSIBILITY
523 // NB: this has to be called unconditionally, because we don't know
524 // whether this window has associated help text or not
525 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
527 helpProvider
->RemoveHelp(this);
531 bool wxWindowBase::IsBeingDeleted() const
533 return m_isBeingDeleted
||
534 (!IsTopLevel() && m_parent
&& m_parent
->IsBeingDeleted());
537 void wxWindowBase::SendDestroyEvent()
539 if ( m_isBeingDeleted
)
541 // we could have been already called from a more derived class dtor,
542 // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call
543 // should be simply ignored
547 m_isBeingDeleted
= true;
549 wxWindowDestroyEvent event
;
550 event
.SetEventObject(this);
551 event
.SetId(GetId());
552 GetEventHandler()->ProcessEvent(event
);
555 bool wxWindowBase::Destroy()
557 // If our handle is invalid, it means that this window has never been
558 // created, either because creating it failed or, more typically, because
559 // this wxWindow object was default-constructed and its Create() method had
560 // never been called. As we didn't send wxWindowCreateEvent in this case
561 // (which is sent after successful creation), don't send the matching
562 // wxWindowDestroyEvent neither.
571 bool wxWindowBase::Close(bool force
)
573 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
574 event
.SetEventObject(this);
575 event
.SetCanVeto(!force
);
577 // return false if window wasn't closed because the application vetoed the
579 return HandleWindowEvent(event
) && !event
.GetVeto();
582 bool wxWindowBase::DestroyChildren()
584 wxWindowList::compatibility_iterator node
;
587 // we iterate until the list becomes empty
588 node
= GetChildren().GetFirst();
592 wxWindow
*child
= node
->GetData();
594 // note that we really want to delete it immediately so don't call the
595 // possible overridden Destroy() version which might not delete the
596 // child immediately resulting in problems with our (top level) child
597 // outliving its parent
598 child
->wxWindowBase::Destroy();
600 wxASSERT_MSG( !GetChildren().Find(child
),
601 wxT("child didn't remove itself using RemoveChild()") );
607 // ----------------------------------------------------------------------------
608 // size/position related methods
609 // ----------------------------------------------------------------------------
611 // centre the window with respect to its parent in either (or both) directions
612 void wxWindowBase::DoCentre(int dir
)
614 wxCHECK_RET( !(dir
& wxCENTRE_ON_SCREEN
) && GetParent(),
615 wxT("this method only implements centering child windows") );
617 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir
));
620 // fits the window around the children
621 void wxWindowBase::Fit()
623 if ( !GetChildren().empty() )
625 SetSize(GetBestSize());
627 //else: do nothing if we have no children
630 // fits virtual size (ie. scrolled area etc.) around children
631 void wxWindowBase::FitInside()
633 if ( GetChildren().GetCount() > 0 )
635 SetVirtualSize( GetBestVirtualSize() );
639 // On Mac, scrollbars are explicitly children.
640 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
641 static bool wxHasRealChildren(const wxWindowBase
* win
)
643 int realChildCount
= 0;
645 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
647 node
= node
->GetNext() )
649 wxWindow
*win
= node
->GetData();
650 if ( !win
->IsTopLevel() && win
->IsShown()
652 && !win
->IsKindOf(CLASSINFO(wxScrollBar
))
657 return (realChildCount
> 0);
661 void wxWindowBase::InvalidateBestSize()
663 m_bestSizeCache
= wxDefaultSize
;
665 // parent's best size calculation may depend on its children's
666 // as long as child window we are in is not top level window itself
667 // (because the TLW size is never resized automatically)
668 // so let's invalidate it as well to be safe:
669 if (m_parent
&& !IsTopLevel())
670 m_parent
->InvalidateBestSize();
673 // return the size best suited for the current window
674 wxSize
wxWindowBase::DoGetBestSize() const
680 best
= m_windowSizer
->GetMinSize();
682 #if wxUSE_CONSTRAINTS
683 else if ( m_constraints
)
685 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
687 // our minimal acceptable size is such that all our windows fit inside
691 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
693 node
= node
->GetNext() )
695 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
698 // it's not normal that we have an unconstrained child, but
699 // what can we do about it?
703 int x
= c
->right
.GetValue(),
704 y
= c
->bottom
.GetValue();
712 // TODO: we must calculate the overlaps somehow, otherwise we
713 // will never return a size bigger than the current one :-(
716 best
= wxSize(maxX
, maxY
);
718 #endif // wxUSE_CONSTRAINTS
719 else if ( !GetChildren().empty()
720 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
721 && wxHasRealChildren(this)
725 // our minimal acceptable size is such that all our visible child
726 // windows fit inside
730 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
732 node
= node
->GetNext() )
734 wxWindow
*win
= node
->GetData();
735 if ( win
->IsTopLevel()
738 || wxDynamicCast(win
, wxStatusBar
)
739 #endif // wxUSE_STATUSBAR
742 // dialogs and frames lie in different top level windows -
743 // don't deal with them here; as for the status bars, they
744 // don't lie in the client area at all
749 win
->GetPosition(&wx
, &wy
);
751 // if the window hadn't been positioned yet, assume that it is in
753 if ( wx
== wxDefaultCoord
)
755 if ( wy
== wxDefaultCoord
)
758 win
->GetSize(&ww
, &wh
);
759 if ( wx
+ ww
> maxX
)
761 if ( wy
+ wh
> maxY
)
765 best
= wxSize(maxX
, maxY
);
767 else // ! has children
769 wxSize size
= GetMinSize();
770 if ( !size
.IsFullySpecified() )
772 // if the window doesn't define its best size we assume that it can
773 // be arbitrarily small -- usually this is not the case, of course,
774 // but we have no way to know what the limit is, it should really
775 // override DoGetBestClientSize() itself to tell us
776 size
.SetDefaults(wxSize(1, 1));
779 // return as-is, unadjusted by the client size difference.
783 // Add any difference between size and client size
784 wxSize diff
= GetSize() - GetClientSize();
785 best
.x
+= wxMax(0, diff
.x
);
786 best
.y
+= wxMax(0, diff
.y
);
791 // helper of GetWindowBorderSize(): as many ports don't implement support for
792 // wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
793 // fallbacks in this case
794 static int wxGetMetricOrDefault(wxSystemMetric what
, const wxWindowBase
* win
)
796 int rc
= wxSystemSettings::GetMetric(
797 what
, static_cast<wxWindow
*>(const_cast<wxWindowBase
*>(win
)));
804 // 2D border is by default 1 pixel wide
810 // 3D borders are by default 2 pixels
815 wxFAIL_MSG( wxT("unexpected wxGetMetricOrDefault() argument") );
823 wxSize
wxWindowBase::GetWindowBorderSize() const
827 switch ( GetBorder() )
830 // nothing to do, size is already (0, 0)
833 case wxBORDER_SIMPLE
:
834 case wxBORDER_STATIC
:
835 size
.x
= wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
836 size
.y
= wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
839 case wxBORDER_SUNKEN
:
840 case wxBORDER_RAISED
:
841 size
.x
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X
, this),
842 wxGetMetricOrDefault(wxSYS_BORDER_X
, this));
843 size
.y
= wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y
, this),
844 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this));
847 case wxBORDER_DOUBLE
:
848 size
.x
= wxGetMetricOrDefault(wxSYS_EDGE_X
, this) +
849 wxGetMetricOrDefault(wxSYS_BORDER_X
, this);
850 size
.y
= wxGetMetricOrDefault(wxSYS_EDGE_Y
, this) +
851 wxGetMetricOrDefault(wxSYS_BORDER_Y
, this);
855 wxFAIL_MSG(wxT("Unknown border style."));
859 // we have borders on both sides
864 wxWindowBase::InformFirstDirection(int direction
,
866 int availableOtherDir
)
868 return GetSizer() && GetSizer()->InformFirstDirection(direction
,
873 wxSize
wxWindowBase::GetEffectiveMinSize() const
875 // merge the best size with the min size, giving priority to the min size
876 wxSize min
= GetMinSize();
878 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
880 wxSize best
= GetBestSize();
881 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
882 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
888 wxSize
wxWindowBase::DoGetBorderSize() const
890 // there is one case in which we can implement it for all ports easily
891 if ( GetBorder() == wxBORDER_NONE
)
894 // otherwise use the difference between the real size and the client size
895 // as a fallback: notice that this is incorrect in general as client size
896 // also doesn't take the scrollbars into account
897 return GetSize() - GetClientSize();
900 wxSize
wxWindowBase::GetBestSize() const
902 if ( !m_windowSizer
&& m_bestSizeCache
.IsFullySpecified() )
903 return m_bestSizeCache
;
905 // call DoGetBestClientSize() first, if a derived class overrides it wants
907 wxSize size
= DoGetBestClientSize();
908 if ( size
!= wxDefaultSize
)
910 size
+= DoGetBorderSize();
916 return DoGetBestSize();
919 void wxWindowBase::SetMinSize(const wxSize
& minSize
)
921 m_minWidth
= minSize
.x
;
922 m_minHeight
= minSize
.y
;
925 void wxWindowBase::SetMaxSize(const wxSize
& maxSize
)
927 m_maxWidth
= maxSize
.x
;
928 m_maxHeight
= maxSize
.y
;
931 void wxWindowBase::SetInitialSize(const wxSize
& size
)
933 // Set the min size to the size passed in. This will usually either be
934 // wxDefaultSize or the size passed to this window's ctor/Create function.
937 // Merge the size with the best size if needed
938 wxSize best
= GetEffectiveMinSize();
940 // If the current size doesn't match then change it
941 if (GetSize() != best
)
946 // by default the origin is not shifted
947 wxPoint
wxWindowBase::GetClientAreaOrigin() const
952 wxSize
wxWindowBase::ClientToWindowSize(const wxSize
& size
) const
954 const wxSize
diff(GetSize() - GetClientSize());
956 return wxSize(size
.x
== -1 ? -1 : size
.x
+ diff
.x
,
957 size
.y
== -1 ? -1 : size
.y
+ diff
.y
);
960 wxSize
wxWindowBase::WindowToClientSize(const wxSize
& size
) const
962 const wxSize
diff(GetSize() - GetClientSize());
964 return wxSize(size
.x
== -1 ? -1 : size
.x
- diff
.x
,
965 size
.y
== -1 ? -1 : size
.y
- diff
.y
);
968 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
970 if ( m_windowVariant
!= variant
)
972 m_windowVariant
= variant
;
974 DoSetWindowVariant(variant
);
978 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
980 // adjust the font height to correspond to our new variant (notice that
981 // we're only called if something really changed)
982 wxFont font
= GetFont();
983 int size
= font
.GetPointSize();
986 case wxWINDOW_VARIANT_NORMAL
:
989 case wxWINDOW_VARIANT_SMALL
:
990 size
= wxRound(size
* 3.0 / 4.0);
993 case wxWINDOW_VARIANT_MINI
:
994 size
= wxRound(size
* 2.0 / 3.0);
997 case wxWINDOW_VARIANT_LARGE
:
998 size
= wxRound(size
* 5.0 / 4.0);
1002 wxFAIL_MSG(wxT("unexpected window variant"));
1006 font
.SetPointSize(size
);
1010 void wxWindowBase::DoSetSizeHints( int minW
, int minH
,
1012 int WXUNUSED(incW
), int WXUNUSED(incH
) )
1014 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
1015 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
1016 wxT("min width/height must be less than max width/height!") );
1025 #if WXWIN_COMPATIBILITY_2_8
1026 void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW
), int WXUNUSED(minH
),
1027 int WXUNUSED(maxW
), int WXUNUSED(maxH
))
1031 void wxWindowBase::SetVirtualSizeHints(const wxSize
& WXUNUSED(minsize
),
1032 const wxSize
& WXUNUSED(maxsize
))
1035 #endif // WXWIN_COMPATIBILITY_2_8
1037 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
1039 m_virtualSize
= wxSize(x
, y
);
1042 wxSize
wxWindowBase::DoGetVirtualSize() const
1044 // we should use the entire client area so if it is greater than our
1045 // virtual size, expand it to fit (otherwise if the window is big enough we
1046 // wouldn't be using parts of it)
1047 wxSize size
= GetClientSize();
1048 if ( m_virtualSize
.x
> size
.x
)
1049 size
.x
= m_virtualSize
.x
;
1051 if ( m_virtualSize
.y
>= size
.y
)
1052 size
.y
= m_virtualSize
.y
;
1057 void wxWindowBase::DoGetScreenPosition(int *x
, int *y
) const
1059 // screen position is the same as (0, 0) in client coords for non TLWs (and
1060 // TLWs override this method)
1066 ClientToScreen(x
, y
);
1069 void wxWindowBase::SendSizeEvent(int flags
)
1071 wxSizeEvent
event(GetSize(), GetId());
1072 event
.SetEventObject(this);
1073 if ( flags
& wxSEND_EVENT_POST
)
1074 wxPostEvent(GetEventHandler(), event
);
1076 HandleWindowEvent(event
);
1079 void wxWindowBase::SendSizeEventToParent(int flags
)
1081 wxWindow
* const parent
= GetParent();
1082 if ( parent
&& !parent
->IsBeingDeleted() )
1083 parent
->SendSizeEvent(flags
);
1086 bool wxWindowBase::HasScrollbar(int orient
) const
1088 // if scrolling in the given direction is disabled, we can't have the
1089 // corresponding scrollbar no matter what
1090 if ( !CanScroll(orient
) )
1093 const wxSize sizeVirt
= GetVirtualSize();
1094 const wxSize sizeClient
= GetClientSize();
1096 return orient
== wxHORIZONTAL
? sizeVirt
.x
> sizeClient
.x
1097 : sizeVirt
.y
> sizeClient
.y
;
1100 // ----------------------------------------------------------------------------
1101 // show/hide/enable/disable the window
1102 // ----------------------------------------------------------------------------
1104 bool wxWindowBase::Show(bool show
)
1106 if ( show
!= m_isShown
)
1118 bool wxWindowBase::IsEnabled() const
1120 return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
1123 void wxWindowBase::NotifyWindowOnEnableChange(bool enabled
)
1125 // Under some platforms there is no need to update the window state
1126 // explicitly, it will become disabled when its parent is. On other ones we
1127 // do need to disable all windows recursively though.
1128 #ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
1130 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1134 // Disabling a top level window is typically done when showing a modal
1135 // dialog and we don't need to disable its children in this case, they will
1136 // be logically disabled anyhow (i.e. their IsEnabled() will return false)
1137 // and the TLW won't accept any input for them. Moreover, explicitly
1138 // disabling them would look ugly as the entire TLW would be greyed out
1139 // whenever a modal dialog is shown and no native applications under any
1140 // platform behave like this.
1141 if ( IsTopLevel() && !enabled
)
1144 // When disabling (or enabling back) a non-TLW window we need to
1145 // recursively propagate the change of the state to its children, otherwise
1146 // they would still show as enabled even though they wouldn't actually
1147 // accept any input (at least under MSW where children don't accept input
1148 // if any of the windows in their parent chain is enabled).
1150 // Notice that we must do this even for wxHAS_NATIVE_ENABLED_MANAGEMENT
1151 // platforms as we still need to call the children OnEnabled() recursively.
1152 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1154 node
= node
->GetNext() )
1156 wxWindowBase
* const child
= node
->GetData();
1157 if ( !child
->IsTopLevel() && child
->IsThisEnabled() )
1158 child
->NotifyWindowOnEnableChange(enabled
);
1162 bool wxWindowBase::Enable(bool enable
)
1164 if ( enable
== IsThisEnabled() )
1167 m_isEnabled
= enable
;
1169 // If we call DoEnable() from NotifyWindowOnEnableChange(), we don't need
1170 // to do it from here.
1171 #ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
1173 #endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
1175 NotifyWindowOnEnableChange(enable
);
1180 bool wxWindowBase::IsShownOnScreen() const
1182 // A window is shown on screen if it itself is shown and so are all its
1183 // parents. But if a window is toplevel one, then its always visible on
1184 // screen if IsShown() returns true, even if it has a hidden parent.
1186 (IsTopLevel() || GetParent() == NULL
|| GetParent()->IsShownOnScreen());
1189 // ----------------------------------------------------------------------------
1191 // ----------------------------------------------------------------------------
1193 bool wxWindowBase::IsTopLevel() const
1198 // ----------------------------------------------------------------------------
1200 // ----------------------------------------------------------------------------
1202 void wxWindowBase::Freeze()
1204 if ( !m_freezeCount
++ )
1206 // physically freeze this window:
1209 // and recursively freeze all children:
1210 for ( wxWindowList::iterator i
= GetChildren().begin();
1211 i
!= GetChildren().end(); ++i
)
1213 wxWindow
*child
= *i
;
1214 if ( child
->IsTopLevel() )
1222 void wxWindowBase::Thaw()
1224 wxASSERT_MSG( m_freezeCount
, "Thaw() without matching Freeze()" );
1226 if ( !--m_freezeCount
)
1228 // recursively thaw all children:
1229 for ( wxWindowList::iterator i
= GetChildren().begin();
1230 i
!= GetChildren().end(); ++i
)
1232 wxWindow
*child
= *i
;
1233 if ( child
->IsTopLevel() )
1239 // physically thaw this window:
1244 // ----------------------------------------------------------------------------
1245 // reparenting the window
1246 // ----------------------------------------------------------------------------
1248 void wxWindowBase::AddChild(wxWindowBase
*child
)
1250 wxCHECK_RET( child
, wxT("can't add a NULL child") );
1252 // this should never happen and it will lead to a crash later if it does
1253 // because RemoveChild() will remove only one node from the children list
1254 // and the other(s) one(s) will be left with dangling pointers in them
1255 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), wxT("AddChild() called twice") );
1257 GetChildren().Append((wxWindow
*)child
);
1258 child
->SetParent(this);
1260 // adding a child while frozen will assert when thawed, so freeze it as if
1261 // it had been already present when we were frozen
1262 if ( IsFrozen() && !child
->IsTopLevel() )
1266 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
1268 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
1270 // removing a child while frozen may result in permanently frozen window
1271 // if used e.g. from Reparent(), so thaw it
1273 // NB: IsTopLevel() doesn't return true any more when a TLW child is being
1274 // removed from its ~wxWindowBase, so check for IsBeingDeleted() too
1275 if ( IsFrozen() && !child
->IsBeingDeleted() && !child
->IsTopLevel() )
1278 GetChildren().DeleteObject((wxWindow
*)child
);
1279 child
->SetParent(NULL
);
1282 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
1284 wxWindow
*oldParent
= GetParent();
1285 if ( newParent
== oldParent
)
1291 const bool oldEnabledState
= IsEnabled();
1293 // unlink this window from the existing parent.
1296 oldParent
->RemoveChild(this);
1300 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
1303 // add it to the new one
1306 newParent
->AddChild(this);
1310 wxTopLevelWindows
.Append((wxWindow
*)this);
1313 // We need to notify window (and its subwindows) if by changing the parent
1314 // we also change our enabled/disabled status.
1315 const bool newEnabledState
= IsEnabled();
1316 if ( newEnabledState
!= oldEnabledState
)
1318 NotifyWindowOnEnableChange(newEnabledState
);
1324 // ----------------------------------------------------------------------------
1325 // event handler stuff
1326 // ----------------------------------------------------------------------------
1328 void wxWindowBase::SetEventHandler(wxEvtHandler
*handler
)
1330 wxCHECK_RET(handler
!= NULL
, "SetEventHandler(NULL) called");
1332 m_eventHandler
= handler
;
1335 void wxWindowBase::SetNextHandler(wxEvtHandler
*WXUNUSED(handler
))
1337 // disable wxEvtHandler chain mechanism for wxWindows:
1338 // wxWindow uses its own stack mechanism which doesn't mix well with wxEvtHandler's one
1340 wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1342 void wxWindowBase::SetPreviousHandler(wxEvtHandler
*WXUNUSED(handler
))
1344 // we can't simply wxFAIL here as in SetNextHandler: in fact the last
1345 // handler of our stack when is destroyed will be Unlink()ed and thus
1346 // will call this function to update the pointer of this window...
1348 //wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain");
1351 void wxWindowBase::PushEventHandler(wxEvtHandler
*handlerToPush
)
1353 wxCHECK_RET( handlerToPush
!= NULL
, "PushEventHandler(NULL) called" );
1355 // the new handler is going to be part of the wxWindow stack of event handlers:
1356 // it can't be part also of an event handler double-linked chain:
1357 wxASSERT_MSG(handlerToPush
->IsUnlinked(),
1358 "The handler being pushed in the wxWindow stack shouldn't be part of "
1359 "a wxEvtHandler chain; call Unlink() on it first");
1361 wxEvtHandler
*handlerOld
= GetEventHandler();
1362 wxCHECK_RET( handlerOld
, "an old event handler is NULL?" );
1364 // now use wxEvtHandler double-linked list to implement a stack:
1365 handlerToPush
->SetNextHandler(handlerOld
);
1367 if (handlerOld
!= this)
1368 handlerOld
->SetPreviousHandler(handlerToPush
);
1370 SetEventHandler(handlerToPush
);
1373 // final checks of the operations done above:
1374 wxASSERT_MSG( handlerToPush
->GetPreviousHandler() == NULL
,
1375 "the first handler of the wxWindow stack should "
1376 "have no previous handlers set" );
1377 wxASSERT_MSG( handlerToPush
->GetNextHandler() != NULL
,
1378 "the first handler of the wxWindow stack should "
1379 "have non-NULL next handler" );
1381 wxEvtHandler
* pLast
= handlerToPush
;
1382 while ( pLast
&& pLast
!= this )
1383 pLast
= pLast
->GetNextHandler();
1384 wxASSERT_MSG( pLast
->GetNextHandler() == NULL
,
1385 "the last handler of the wxWindow stack should "
1386 "have this window as next handler" );
1387 #endif // wxDEBUG_LEVEL
1390 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
1392 // we need to pop the wxWindow stack, i.e. we need to remove the first handler
1394 wxEvtHandler
*firstHandler
= GetEventHandler();
1395 wxCHECK_MSG( firstHandler
!= NULL
, NULL
, "wxWindow cannot have a NULL event handler" );
1396 wxCHECK_MSG( firstHandler
!= this, NULL
, "cannot pop the wxWindow itself" );
1397 wxCHECK_MSG( firstHandler
->GetPreviousHandler() == NULL
, NULL
,
1398 "the first handler of the wxWindow stack should have no previous handlers set" );
1400 wxEvtHandler
*secondHandler
= firstHandler
->GetNextHandler();
1401 wxCHECK_MSG( secondHandler
!= NULL
, NULL
,
1402 "the first handler of the wxWindow stack should have non-NULL next handler" );
1404 firstHandler
->SetNextHandler(NULL
);
1405 secondHandler
->SetPreviousHandler(NULL
);
1407 // now firstHandler is completely unlinked; set secondHandler as the new window event handler
1408 SetEventHandler(secondHandler
);
1410 if ( deleteHandler
)
1412 wxDELETE(firstHandler
);
1415 return firstHandler
;
1418 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handlerToRemove
)
1420 wxCHECK_MSG( handlerToRemove
!= NULL
, false, "RemoveEventHandler(NULL) called" );
1421 wxCHECK_MSG( handlerToRemove
!= this, false, "Cannot remove the window itself" );
1423 if (handlerToRemove
== GetEventHandler())
1425 // removing the first event handler is equivalent to "popping" the stack
1426 PopEventHandler(false);
1430 // NOTE: the wxWindow event handler list is always terminated with "this" handler
1431 wxEvtHandler
*handlerCur
= GetEventHandler()->GetNextHandler();
1432 while ( handlerCur
!= this && handlerCur
)
1434 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
1436 if ( handlerCur
== handlerToRemove
)
1438 handlerCur
->Unlink();
1440 wxASSERT_MSG( handlerCur
!= GetEventHandler(),
1441 "the case Remove == Pop should was already handled" );
1445 handlerCur
= handlerNext
;
1448 wxFAIL_MSG( wxT("where has the event handler gone?") );
1453 bool wxWindowBase::HandleWindowEvent(wxEvent
& event
) const
1455 // SafelyProcessEvent() will handle exceptions nicely
1456 return GetEventHandler()->SafelyProcessEvent(event
);
1459 // ----------------------------------------------------------------------------
1460 // colours, fonts &c
1461 // ----------------------------------------------------------------------------
1463 void wxWindowBase::InheritAttributes()
1465 const wxWindowBase
* const parent
= GetParent();
1469 // we only inherit attributes which had been explicitly set for the parent
1470 // which ensures that this only happens if the user really wants it and
1471 // not by default which wouldn't make any sense in modern GUIs where the
1472 // controls don't all use the same fonts (nor colours)
1473 if ( parent
->m_inheritFont
&& !m_hasFont
)
1474 SetFont(parent
->GetFont());
1476 // in addition, there is a possibility to explicitly forbid inheriting
1477 // colours at each class level by overriding ShouldInheritColours()
1478 if ( ShouldInheritColours() )
1480 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
1481 SetForegroundColour(parent
->GetForegroundColour());
1483 // inheriting (solid) background colour is wrong as it totally breaks
1484 // any kind of themed backgrounds
1486 // instead, the controls should use the same background as their parent
1487 // (ideally by not drawing it at all)
1489 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
1490 SetBackgroundColour(parent
->GetBackgroundColour());
1495 /* static */ wxVisualAttributes
1496 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1498 // it is important to return valid values for all attributes from here,
1499 // GetXXX() below rely on this
1500 wxVisualAttributes attrs
;
1501 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
1502 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1504 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1505 // the usual background colour than wxSYS_COLOUR_BTNFACE.
1506 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1507 // colour on other platforms.
1509 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1510 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1512 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
1517 wxColour
wxWindowBase::GetBackgroundColour() const
1519 if ( !m_backgroundColour
.IsOk() )
1521 wxASSERT_MSG( !m_hasBgCol
, wxT("we have invalid explicit bg colour?") );
1523 // get our default background colour
1524 wxColour colBg
= GetDefaultAttributes().colBg
;
1526 // we must return some valid colour to avoid redoing this every time
1527 // and also to avoid surprising the applications written for older
1528 // wxWidgets versions where GetBackgroundColour() always returned
1529 // something -- so give them something even if it doesn't make sense
1530 // for this window (e.g. it has a themed background)
1531 if ( !colBg
.IsOk() )
1532 colBg
= GetClassDefaultAttributes().colBg
;
1537 return m_backgroundColour
;
1540 wxColour
wxWindowBase::GetForegroundColour() const
1542 // logic is the same as above
1543 if ( !m_hasFgCol
&& !m_foregroundColour
.IsOk() )
1545 wxColour colFg
= GetDefaultAttributes().colFg
;
1547 if ( !colFg
.IsOk() )
1548 colFg
= GetClassDefaultAttributes().colFg
;
1553 return m_foregroundColour
;
1556 bool wxWindowBase::SetBackgroundStyle(wxBackgroundStyle style
)
1558 // The checks below shouldn't be triggered if we're not really changing the
1560 if ( style
== m_backgroundStyle
)
1563 // Transparent background style can be only set before creation because of
1564 // wxGTK limitation.
1565 wxCHECK_MSG( (style
!= wxBG_STYLE_TRANSPARENT
) || !GetHandle(),
1567 "wxBG_STYLE_TRANSPARENT style can only be set before "
1568 "Create()-ing the window." );
1570 // And once it is set, wxBG_STYLE_TRANSPARENT can't be unset.
1571 wxCHECK_MSG( (m_backgroundStyle
!= wxBG_STYLE_TRANSPARENT
) ||
1572 (style
== wxBG_STYLE_TRANSPARENT
),
1574 "wxBG_STYLE_TRANSPARENT can't be unset once it was set." );
1576 m_backgroundStyle
= style
;
1581 bool wxWindowBase::IsTransparentBackgroundSupported(wxString
*reason
) const
1584 *reason
= _("This platform does not support background transparency.");
1589 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1591 if ( colour
== m_backgroundColour
)
1594 m_hasBgCol
= colour
.IsOk();
1596 m_inheritBgCol
= m_hasBgCol
;
1597 m_backgroundColour
= colour
;
1598 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.IsOk() );
1602 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1604 if (colour
== m_foregroundColour
)
1607 m_hasFgCol
= colour
.IsOk();
1608 m_inheritFgCol
= m_hasFgCol
;
1609 m_foregroundColour
= colour
;
1610 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.IsOk() );
1614 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1616 // setting an invalid cursor is ok, it means that we don't have any special
1618 if ( m_cursor
.IsSameAs(cursor
) )
1629 wxFont
wxWindowBase::GetFont() const
1631 // logic is the same as in GetBackgroundColour()
1632 if ( !m_font
.IsOk() )
1634 wxASSERT_MSG( !m_hasFont
, wxT("we have invalid explicit font?") );
1636 wxFont font
= GetDefaultAttributes().font
;
1638 font
= GetClassDefaultAttributes().font
;
1646 bool wxWindowBase::SetFont(const wxFont
& font
)
1648 if ( font
== m_font
)
1655 m_hasFont
= font
.IsOk();
1656 m_inheritFont
= m_hasFont
;
1658 InvalidateBestSize();
1665 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1667 m_hasCustomPalette
= true;
1670 // VZ: can anyone explain me what do we do here?
1671 wxWindowDC
d((wxWindow
*) this);
1675 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1677 wxWindow
*win
= (wxWindow
*)this;
1678 while ( win
&& !win
->HasCustomPalette() )
1680 win
= win
->GetParent();
1686 #endif // wxUSE_PALETTE
1689 void wxWindowBase::SetCaret(wxCaret
*caret
)
1700 wxASSERT_MSG( m_caret
->GetWindow() == this,
1701 wxT("caret should be created associated to this window") );
1704 #endif // wxUSE_CARET
1706 #if wxUSE_VALIDATORS
1707 // ----------------------------------------------------------------------------
1709 // ----------------------------------------------------------------------------
1711 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1713 if ( m_windowValidator
)
1714 delete m_windowValidator
;
1716 m_windowValidator
= (wxValidator
*)validator
.Clone();
1718 if ( m_windowValidator
)
1719 m_windowValidator
->SetWindow(this);
1721 #endif // wxUSE_VALIDATORS
1723 // ----------------------------------------------------------------------------
1724 // update region stuff
1725 // ----------------------------------------------------------------------------
1727 wxRect
wxWindowBase::GetUpdateClientRect() const
1729 wxRegion rgnUpdate
= GetUpdateRegion();
1730 rgnUpdate
.Intersect(GetClientRect());
1731 wxRect rectUpdate
= rgnUpdate
.GetBox();
1732 wxPoint ptOrigin
= GetClientAreaOrigin();
1733 rectUpdate
.x
-= ptOrigin
.x
;
1734 rectUpdate
.y
-= ptOrigin
.y
;
1739 bool wxWindowBase::DoIsExposed(int x
, int y
) const
1741 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1744 bool wxWindowBase::DoIsExposed(int x
, int y
, int w
, int h
) const
1746 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1749 void wxWindowBase::ClearBackground()
1751 // wxGTK uses its own version, no need to add never used code
1753 wxClientDC
dc((wxWindow
*)this);
1754 wxBrush
brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID
);
1755 dc
.SetBackground(brush
);
1760 // ----------------------------------------------------------------------------
1761 // find child window by id or name
1762 // ----------------------------------------------------------------------------
1764 wxWindow
*wxWindowBase::FindWindow(long id
) const
1766 if ( id
== m_windowId
)
1767 return (wxWindow
*)this;
1769 wxWindowBase
*res
= NULL
;
1770 wxWindowList::compatibility_iterator node
;
1771 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1773 wxWindowBase
*child
= node
->GetData();
1774 res
= child
->FindWindow( id
);
1777 return (wxWindow
*)res
;
1780 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1782 if ( name
== m_windowName
)
1783 return (wxWindow
*)this;
1785 wxWindowBase
*res
= NULL
;
1786 wxWindowList::compatibility_iterator node
;
1787 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1789 wxWindow
*child
= node
->GetData();
1790 res
= child
->FindWindow(name
);
1793 return (wxWindow
*)res
;
1797 // find any window by id or name or label: If parent is non-NULL, look through
1798 // children for a label or title matching the specified string. If NULL, look
1799 // through all top-level windows.
1801 // to avoid duplicating code we reuse the same helper function but with
1802 // different comparators
1804 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1805 const wxString
& label
, long id
);
1808 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1811 return win
->GetLabel() == label
;
1815 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1818 return win
->GetName() == label
;
1822 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1825 return win
->GetId() == id
;
1828 // recursive helper for the FindWindowByXXX() functions
1830 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1831 const wxString
& label
,
1833 wxFindWindowCmp cmp
)
1837 // see if this is the one we're looking for
1838 if ( (*cmp
)(parent
, label
, id
) )
1839 return (wxWindow
*)parent
;
1841 // It wasn't, so check all its children
1842 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1844 node
= node
->GetNext() )
1846 // recursively check each child
1847 wxWindow
*win
= (wxWindow
*)node
->GetData();
1848 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1858 // helper for FindWindowByXXX()
1860 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1861 const wxString
& label
,
1863 wxFindWindowCmp cmp
)
1867 // just check parent and all its children
1868 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1871 // start at very top of wx's windows
1872 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1874 node
= node
->GetNext() )
1876 // recursively check each window & its children
1877 wxWindow
*win
= node
->GetData();
1878 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1888 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1890 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1895 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1897 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1901 // fall back to the label
1902 win
= FindWindowByLabel(title
, parent
);
1910 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1912 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1915 // ----------------------------------------------------------------------------
1916 // dialog oriented functions
1917 // ----------------------------------------------------------------------------
1919 #if WXWIN_COMPATIBILITY_2_8
1920 void wxWindowBase::MakeModal(bool modal
)
1922 // Disable all other windows
1925 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1928 wxWindow
*win
= node
->GetData();
1930 win
->Enable(!modal
);
1932 node
= node
->GetNext();
1936 #endif // WXWIN_COMPATIBILITY_2_8
1938 bool wxWindowBase::Validate()
1940 #if wxUSE_VALIDATORS
1941 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1943 wxWindowList::compatibility_iterator node
;
1944 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1946 wxWindowBase
*child
= node
->GetData();
1947 wxValidator
*validator
= child
->GetValidator();
1948 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1953 if ( recurse
&& !child
->Validate() )
1958 #endif // wxUSE_VALIDATORS
1963 bool wxWindowBase::TransferDataToWindow()
1965 #if wxUSE_VALIDATORS
1966 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1968 wxWindowList::compatibility_iterator node
;
1969 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1971 wxWindowBase
*child
= node
->GetData();
1972 wxValidator
*validator
= child
->GetValidator();
1973 if ( validator
&& !validator
->TransferToWindow() )
1975 wxLogWarning(_("Could not transfer data to window"));
1977 wxLog::FlushActive();
1985 if ( !child
->TransferDataToWindow() )
1987 // warning already given
1992 #endif // wxUSE_VALIDATORS
1997 bool wxWindowBase::TransferDataFromWindow()
1999 #if wxUSE_VALIDATORS
2000 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
2002 wxWindowList::compatibility_iterator node
;
2003 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
2005 wxWindow
*child
= node
->GetData();
2006 wxValidator
*validator
= child
->GetValidator();
2007 if ( validator
&& !validator
->TransferFromWindow() )
2009 // nop warning here because the application is supposed to give
2010 // one itself - we don't know here what might have gone wrongly
2017 if ( !child
->TransferDataFromWindow() )
2019 // warning already given
2024 #endif // wxUSE_VALIDATORS
2029 void wxWindowBase::InitDialog()
2031 wxInitDialogEvent
event(GetId());
2032 event
.SetEventObject( this );
2033 GetEventHandler()->ProcessEvent(event
);
2036 // ----------------------------------------------------------------------------
2037 // context-sensitive help support
2038 // ----------------------------------------------------------------------------
2042 // associate this help text with this window
2043 void wxWindowBase::SetHelpText(const wxString
& text
)
2045 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2048 helpProvider
->AddHelp(this, text
);
2052 #if WXWIN_COMPATIBILITY_2_8
2053 // associate this help text with all windows with the same id as this
2055 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
2057 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2060 helpProvider
->AddHelp(GetId(), text
);
2063 #endif // WXWIN_COMPATIBILITY_2_8
2065 // get the help string associated with this window (may be empty)
2066 // default implementation forwards calls to the help provider
2068 wxWindowBase::GetHelpTextAtPoint(const wxPoint
& WXUNUSED(pt
),
2069 wxHelpEvent::Origin
WXUNUSED(origin
)) const
2072 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2075 text
= helpProvider
->GetHelp(this);
2081 // show help for this window
2082 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
2084 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
2087 wxPoint pos
= event
.GetPosition();
2088 const wxHelpEvent::Origin origin
= event
.GetOrigin();
2089 if ( origin
== wxHelpEvent::Origin_Keyboard
)
2091 // if the help event was generated from keyboard it shouldn't
2092 // appear at the mouse position (which is still the only position
2093 // associated with help event) if the mouse is far away, although
2094 // we still do use the mouse position if it's over the window
2095 // because we suppose the user looks approximately at the mouse
2096 // already and so it would be more convenient than showing tooltip
2097 // at some arbitrary position which can be quite far from it
2098 const wxRect rectClient
= GetClientRect();
2099 if ( !rectClient
.Contains(ScreenToClient(pos
)) )
2101 // position help slightly under and to the right of this window
2102 pos
= ClientToScreen(wxPoint(
2104 rectClient
.height
+ GetCharHeight()
2109 if ( helpProvider
->ShowHelpAtPoint(this, pos
, origin
) )
2111 // skip the event.Skip() below
2119 #endif // wxUSE_HELP
2121 // ----------------------------------------------------------------------------
2123 // ----------------------------------------------------------------------------
2127 wxString
wxWindowBase::GetToolTipText() const
2129 return m_tooltip
? m_tooltip
->GetTip() : wxString();
2132 void wxWindowBase::SetToolTip( const wxString
&tip
)
2134 // don't create the new tooltip if we already have one
2137 m_tooltip
->SetTip( tip
);
2141 SetToolTip( new wxToolTip( tip
) );
2144 // setting empty tooltip text does not remove the tooltip any more - use
2145 // SetToolTip(NULL) for this
2148 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
2150 if ( m_tooltip
!= tooltip
)
2155 m_tooltip
= tooltip
;
2159 bool wxWindowBase::CopyToolTip(wxToolTip
*tip
)
2161 SetToolTip(tip
? new wxToolTip(tip
->GetTip()) : NULL
);
2166 #endif // wxUSE_TOOLTIPS
2168 // ----------------------------------------------------------------------------
2169 // constraints and sizers
2170 // ----------------------------------------------------------------------------
2172 #if wxUSE_CONSTRAINTS
2174 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
2176 if ( m_constraints
)
2178 UnsetConstraints(m_constraints
);
2179 delete m_constraints
;
2181 m_constraints
= constraints
;
2182 if ( m_constraints
)
2184 // Make sure other windows know they're part of a 'meaningful relationship'
2185 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
2186 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
2187 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
2188 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
2189 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
2190 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
2191 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
2192 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
2193 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
2194 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
2195 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
2196 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
2197 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
2198 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
2199 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
2200 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
2204 // This removes any dangling pointers to this window in other windows'
2205 // constraintsInvolvedIn lists.
2206 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
2210 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
2211 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
2212 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
2213 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
2214 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
2215 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
2216 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
2217 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
2218 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
2219 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
2220 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
2221 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
2222 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
2223 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
2224 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
2225 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
2229 // Back-pointer to other windows we're involved with, so if we delete this
2230 // window, we must delete any constraints we're involved with.
2231 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
2233 if ( !m_constraintsInvolvedIn
)
2234 m_constraintsInvolvedIn
= new wxWindowList
;
2235 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
2236 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
2239 // REMOVE back-pointer to other windows we're involved with.
2240 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
2242 if ( m_constraintsInvolvedIn
)
2243 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
2246 // Reset any constraints that mention this window
2247 void wxWindowBase::DeleteRelatedConstraints()
2249 if ( m_constraintsInvolvedIn
)
2251 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
2254 wxWindow
*win
= node
->GetData();
2255 wxLayoutConstraints
*constr
= win
->GetConstraints();
2257 // Reset any constraints involving this window
2260 constr
->left
.ResetIfWin(this);
2261 constr
->top
.ResetIfWin(this);
2262 constr
->right
.ResetIfWin(this);
2263 constr
->bottom
.ResetIfWin(this);
2264 constr
->width
.ResetIfWin(this);
2265 constr
->height
.ResetIfWin(this);
2266 constr
->centreX
.ResetIfWin(this);
2267 constr
->centreY
.ResetIfWin(this);
2270 wxWindowList::compatibility_iterator next
= node
->GetNext();
2271 m_constraintsInvolvedIn
->Erase(node
);
2275 wxDELETE(m_constraintsInvolvedIn
);
2279 #endif // wxUSE_CONSTRAINTS
2281 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
2283 if ( sizer
== m_windowSizer
)
2286 if ( m_windowSizer
)
2288 m_windowSizer
->SetContainingWindow(NULL
);
2291 delete m_windowSizer
;
2294 m_windowSizer
= sizer
;
2295 if ( m_windowSizer
)
2297 m_windowSizer
->SetContainingWindow((wxWindow
*)this);
2300 SetAutoLayout(m_windowSizer
!= NULL
);
2303 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
2305 SetSizer( sizer
, deleteOld
);
2306 sizer
->SetSizeHints( (wxWindow
*) this );
2310 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
2312 // adding a window to a sizer twice is going to result in fatal and
2313 // hard to debug problems later because when deleting the second
2314 // associated wxSizerItem we're going to dereference a dangling
2315 // pointer; so try to detect this as early as possible
2316 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
2317 wxT("Adding a window to the same sizer twice?") );
2319 m_containingSizer
= sizer
;
2322 #if wxUSE_CONSTRAINTS
2324 void wxWindowBase::SatisfyConstraints()
2326 wxLayoutConstraints
*constr
= GetConstraints();
2327 bool wasOk
= constr
&& constr
->AreSatisfied();
2329 ResetConstraints(); // Mark all constraints as unevaluated
2333 // if we're a top level panel (i.e. our parent is frame/dialog), our
2334 // own constraints will never be satisfied any more unless we do it
2338 while ( noChanges
> 0 )
2340 LayoutPhase1(&noChanges
);
2344 LayoutPhase2(&noChanges
);
2347 #endif // wxUSE_CONSTRAINTS
2349 bool wxWindowBase::Layout()
2351 // If there is a sizer, use it instead of the constraints
2355 GetVirtualSize(&w
, &h
);
2356 GetSizer()->SetDimension( 0, 0, w
, h
);
2358 #if wxUSE_CONSTRAINTS
2361 SatisfyConstraints(); // Find the right constraints values
2362 SetConstraintSizes(); // Recursively set the real window sizes
2369 void wxWindowBase::InternalOnSize(wxSizeEvent
& event
)
2371 if ( GetAutoLayout() )
2377 #if wxUSE_CONSTRAINTS
2379 // first phase of the constraints evaluation: set our own constraints
2380 bool wxWindowBase::LayoutPhase1(int *noChanges
)
2382 wxLayoutConstraints
*constr
= GetConstraints();
2384 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
2387 // second phase: set the constraints for our children
2388 bool wxWindowBase::LayoutPhase2(int *noChanges
)
2395 // Layout grand children
2401 // Do a phase of evaluating child constraints
2402 bool wxWindowBase::DoPhase(int phase
)
2404 // the list containing the children for which the constraints are already
2406 wxWindowList succeeded
;
2408 // the max number of iterations we loop before concluding that we can't set
2410 static const int maxIterations
= 500;
2412 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
2416 // loop over all children setting their constraints
2417 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2419 node
= node
->GetNext() )
2421 wxWindow
*child
= node
->GetData();
2422 if ( child
->IsTopLevel() )
2424 // top level children are not inside our client area
2428 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
2430 // this one is either already ok or nothing we can do about it
2434 int tempNoChanges
= 0;
2435 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
2436 : child
->LayoutPhase2(&tempNoChanges
);
2437 noChanges
+= tempNoChanges
;
2441 succeeded
.Append(child
);
2447 // constraints are set
2455 void wxWindowBase::ResetConstraints()
2457 wxLayoutConstraints
*constr
= GetConstraints();
2460 constr
->left
.SetDone(false);
2461 constr
->top
.SetDone(false);
2462 constr
->right
.SetDone(false);
2463 constr
->bottom
.SetDone(false);
2464 constr
->width
.SetDone(false);
2465 constr
->height
.SetDone(false);
2466 constr
->centreX
.SetDone(false);
2467 constr
->centreY
.SetDone(false);
2470 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2473 wxWindow
*win
= node
->GetData();
2474 if ( !win
->IsTopLevel() )
2475 win
->ResetConstraints();
2476 node
= node
->GetNext();
2480 // Need to distinguish between setting the 'fake' size for windows and sizers,
2481 // and setting the real values.
2482 void wxWindowBase::SetConstraintSizes(bool recurse
)
2484 wxLayoutConstraints
*constr
= GetConstraints();
2485 if ( constr
&& constr
->AreSatisfied() )
2487 int x
= constr
->left
.GetValue();
2488 int y
= constr
->top
.GetValue();
2489 int w
= constr
->width
.GetValue();
2490 int h
= constr
->height
.GetValue();
2492 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
2493 (constr
->height
.GetRelationship() != wxAsIs
) )
2495 // We really shouldn't set negative sizes for the windows so make
2496 // them at least of 1*1 size
2497 SetSize(x
, y
, w
> 0 ? w
: 1, h
> 0 ? h
: 1);
2501 // If we don't want to resize this window, just move it...
2507 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
2508 GetClassInfo()->GetClassName(),
2514 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2517 wxWindow
*win
= node
->GetData();
2518 if ( !win
->IsTopLevel() && win
->GetConstraints() )
2519 win
->SetConstraintSizes();
2520 node
= node
->GetNext();
2525 // Only set the size/position of the constraint (if any)
2526 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
2528 wxLayoutConstraints
*constr
= GetConstraints();
2531 if ( x
!= wxDefaultCoord
)
2533 constr
->left
.SetValue(x
);
2534 constr
->left
.SetDone(true);
2536 if ( y
!= wxDefaultCoord
)
2538 constr
->top
.SetValue(y
);
2539 constr
->top
.SetDone(true);
2541 if ( w
!= wxDefaultCoord
)
2543 constr
->width
.SetValue(w
);
2544 constr
->width
.SetDone(true);
2546 if ( h
!= wxDefaultCoord
)
2548 constr
->height
.SetValue(h
);
2549 constr
->height
.SetDone(true);
2554 void wxWindowBase::MoveConstraint(int x
, int y
)
2556 wxLayoutConstraints
*constr
= GetConstraints();
2559 if ( x
!= wxDefaultCoord
)
2561 constr
->left
.SetValue(x
);
2562 constr
->left
.SetDone(true);
2564 if ( y
!= wxDefaultCoord
)
2566 constr
->top
.SetValue(y
);
2567 constr
->top
.SetDone(true);
2572 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
2574 wxLayoutConstraints
*constr
= GetConstraints();
2577 *w
= constr
->width
.GetValue();
2578 *h
= constr
->height
.GetValue();
2584 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
2586 wxLayoutConstraints
*constr
= GetConstraints();
2589 *w
= constr
->width
.GetValue();
2590 *h
= constr
->height
.GetValue();
2593 GetClientSize(w
, h
);
2596 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
2598 wxLayoutConstraints
*constr
= GetConstraints();
2601 *x
= constr
->left
.GetValue();
2602 *y
= constr
->top
.GetValue();
2608 #endif // wxUSE_CONSTRAINTS
2610 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
2612 wxWindow
*parent
= GetParent();
2613 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
2615 wxPoint
pt(parent
->GetClientAreaOrigin());
2621 // ----------------------------------------------------------------------------
2622 // Update UI processing
2623 // ----------------------------------------------------------------------------
2625 void wxWindowBase::UpdateWindowUI(long flags
)
2627 wxUpdateUIEvent
event(GetId());
2628 event
.SetEventObject(this);
2630 if ( GetEventHandler()->ProcessEvent(event
) )
2632 DoUpdateWindowUI(event
);
2635 if (flags
& wxUPDATE_UI_RECURSE
)
2637 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2640 wxWindow
* child
= (wxWindow
*) node
->GetData();
2641 child
->UpdateWindowUI(flags
);
2642 node
= node
->GetNext();
2647 // do the window-specific processing after processing the update event
2648 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2650 if ( event
.GetSetEnabled() )
2651 Enable(event
.GetEnabled());
2653 if ( event
.GetSetShown() )
2654 Show(event
.GetShown());
2657 // ----------------------------------------------------------------------------
2659 // ----------------------------------------------------------------------------
2661 // Send idle event to window and all subwindows
2662 bool wxWindowBase::SendIdleEvents(wxIdleEvent
& event
)
2664 bool needMore
= false;
2668 // should we send idle event to this window?
2669 if (wxIdleEvent::GetMode() == wxIDLE_PROCESS_ALL
||
2670 HasExtraStyle(wxWS_EX_PROCESS_IDLE
))
2672 event
.SetEventObject(this);
2673 HandleWindowEvent(event
);
2675 if (event
.MoreRequested())
2678 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2679 for (; node
; node
= node
->GetNext())
2681 wxWindow
* child
= node
->GetData();
2682 if (child
->SendIdleEvents(event
))
2689 void wxWindowBase::OnInternalIdle()
2691 if ( wxUpdateUIEvent::CanUpdate(this) )
2692 UpdateWindowUI(wxUPDATE_UI_FROMIDLE
);
2695 // ----------------------------------------------------------------------------
2696 // dialog units translations
2697 // ----------------------------------------------------------------------------
2699 // Windows' computes dialog units using average character width over upper-
2700 // and lower-case ASCII alphabet and not using the average character width
2701 // metadata stored in the font; see
2702 // http://support.microsoft.com/default.aspx/kb/145994 for detailed discussion.
2703 // It's important that we perform the conversion in identical way, because
2704 // dialog units natively exist only on Windows and Windows HIG is expressed
2706 wxSize
wxWindowBase::GetDlgUnitBase() const
2708 const wxWindowBase
* const parent
= wxGetTopLevelParent((wxWindow
*)this);
2710 if ( !parent
->m_font
.IsOk() )
2712 // Default GUI font is used. This is the most common case, so
2713 // cache the results.
2714 static wxSize s_defFontSize
;
2715 if ( s_defFontSize
.x
== 0 )
2716 s_defFontSize
= wxPrivate::GetAverageASCIILetterSize(*parent
);
2717 return s_defFontSize
;
2721 // Custom font, we always need to compute the result
2722 return wxPrivate::GetAverageASCIILetterSize(*parent
);
2726 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
) const
2728 const wxSize base
= GetDlgUnitBase();
2730 // NB: wxMulDivInt32() is used, because it correctly rounds the result
2732 wxPoint pt2
= wxDefaultPosition
;
2733 if (pt
.x
!= wxDefaultCoord
)
2734 pt2
.x
= wxMulDivInt32(pt
.x
, 4, base
.x
);
2735 if (pt
.y
!= wxDefaultCoord
)
2736 pt2
.y
= wxMulDivInt32(pt
.y
, 8, base
.y
);
2741 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
) const
2743 const wxSize base
= GetDlgUnitBase();
2745 wxPoint pt2
= wxDefaultPosition
;
2746 if (pt
.x
!= wxDefaultCoord
)
2747 pt2
.x
= wxMulDivInt32(pt
.x
, base
.x
, 4);
2748 if (pt
.y
!= wxDefaultCoord
)
2749 pt2
.y
= wxMulDivInt32(pt
.y
, base
.y
, 8);
2754 // ----------------------------------------------------------------------------
2756 // ----------------------------------------------------------------------------
2758 // propagate the colour change event to the subwindows
2759 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& WXUNUSED(event
))
2761 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2764 // Only propagate to non-top-level windows
2765 wxWindow
*win
= node
->GetData();
2766 if ( !win
->IsTopLevel() )
2768 wxSysColourChangedEvent event2
;
2769 event2
.SetEventObject(win
);
2770 win
->GetEventHandler()->ProcessEvent(event2
);
2773 node
= node
->GetNext();
2779 // the default action is to populate dialog with data when it's created,
2780 // and nudge the UI into displaying itself correctly in case
2781 // we've turned the wxUpdateUIEvents frequency down low.
2782 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2784 TransferDataToWindow();
2786 // Update the UI at this point
2787 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2790 // ----------------------------------------------------------------------------
2791 // menu-related functions
2792 // ----------------------------------------------------------------------------
2796 bool wxWindowBase::PopupMenu(wxMenu
*menu
, int x
, int y
)
2798 wxCHECK_MSG( menu
, false, "can't popup NULL menu" );
2800 wxMenuInvokingWindowSetter
2801 setInvokingWin(*menu
, static_cast<wxWindow
*>(this));
2803 wxCurrentPopupMenu
= menu
;
2804 const bool rc
= DoPopupMenu(menu
, x
, y
);
2805 wxCurrentPopupMenu
= NULL
;
2810 // this is used to pass the id of the selected item from the menu event handler
2811 // to the main function itself
2813 // it's ok to use a global here as there can be at most one popup menu shown at
2815 static int gs_popupMenuSelection
= wxID_NONE
;
2817 void wxWindowBase::InternalOnPopupMenu(wxCommandEvent
& event
)
2819 // store the id in a global variable where we'll retrieve it from later
2820 gs_popupMenuSelection
= event
.GetId();
2823 void wxWindowBase::InternalOnPopupMenuUpdate(wxUpdateUIEvent
& WXUNUSED(event
))
2825 // nothing to do but do not skip it
2829 wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu
& menu
, int x
, int y
)
2831 gs_popupMenuSelection
= wxID_NONE
;
2833 Connect(wxEVT_COMMAND_MENU_SELECTED
,
2834 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2838 // it is common to construct the menu passed to this function dynamically
2839 // using some fixed range of ids which could clash with the ids used
2840 // elsewhere in the program, which could result in some menu items being
2841 // unintentionally disabled or otherwise modified by update UI handlers
2842 // elsewhere in the program code and this is difficult to avoid in the
2843 // program itself, so instead we just temporarily suspend UI updating while
2844 // this menu is shown
2845 Connect(wxEVT_UPDATE_UI
,
2846 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2850 PopupMenu(&menu
, x
, y
);
2852 Disconnect(wxEVT_UPDATE_UI
,
2853 wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate
),
2856 Disconnect(wxEVT_COMMAND_MENU_SELECTED
,
2857 wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu
),
2861 return gs_popupMenuSelection
;
2864 #endif // wxUSE_MENUS
2866 // methods for drawing the sizers in a visible way: this is currently only
2867 // enabled for "full debug" builds with wxDEBUG_LEVEL==2 as it doesn't work
2868 // that well and also because we don't want to leave it enabled in default
2869 // builds used for production
2870 #if wxDEBUG_LEVEL > 1
2872 static void DrawSizers(wxWindowBase
*win
);
2874 static void DrawBorder(wxWindowBase
*win
, const wxRect
& rect
, bool fill
, const wxPen
* pen
)
2876 wxClientDC
dc((wxWindow
*)win
);
2878 dc
.SetBrush(fill
? wxBrush(pen
->GetColour(), wxBRUSHSTYLE_CROSSDIAG_HATCH
) :
2879 *wxTRANSPARENT_BRUSH
);
2880 dc
.DrawRectangle(rect
.Deflate(1, 1));
2883 static void DrawSizer(wxWindowBase
*win
, wxSizer
*sizer
)
2885 const wxSizerItemList
& items
= sizer
->GetChildren();
2886 for ( wxSizerItemList::const_iterator i
= items
.begin(),
2891 wxSizerItem
*item
= *i
;
2892 if ( item
->IsSizer() )
2894 DrawBorder(win
, item
->GetRect().Deflate(2), false, wxRED_PEN
);
2895 DrawSizer(win
, item
->GetSizer());
2897 else if ( item
->IsSpacer() )
2899 DrawBorder(win
, item
->GetRect().Deflate(2), true, wxBLUE_PEN
);
2901 else if ( item
->IsWindow() )
2903 DrawSizers(item
->GetWindow());
2906 wxFAIL_MSG("inconsistent wxSizerItem status!");
2910 static void DrawSizers(wxWindowBase
*win
)
2912 DrawBorder(win
, win
->GetClientSize(), false, wxGREEN_PEN
);
2914 wxSizer
*sizer
= win
->GetSizer();
2917 DrawSizer(win
, sizer
);
2919 else // no sizer, still recurse into the children
2921 const wxWindowList
& children
= win
->GetChildren();
2922 for ( wxWindowList::const_iterator i
= children
.begin(),
2923 end
= children
.end();
2930 // show all kind of sizes of this window; see the "window sizing" topic
2931 // overview for more info about the various differences:
2932 wxSize fullSz
= win
->GetSize();
2933 wxSize clientSz
= win
->GetClientSize();
2934 wxSize bestSz
= win
->GetBestSize();
2935 wxSize minSz
= win
->GetMinSize();
2936 wxSize maxSz
= win
->GetMaxSize();
2937 wxSize virtualSz
= win
->GetVirtualSize();
2939 wxMessageOutputDebug dbgout
;
2941 "%-10s => fullsz=%4d;%-4d clientsz=%4d;%-4d bestsz=%4d;%-4d minsz=%4d;%-4d maxsz=%4d;%-4d virtualsz=%4d;%-4d\n",
2944 clientSz
.x
, clientSz
.y
,
2948 virtualSz
.x
, virtualSz
.y
);
2952 #endif // wxDEBUG_LEVEL
2954 // process special middle clicks
2955 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2957 if ( event
.ControlDown() && event
.AltDown() )
2959 #if wxDEBUG_LEVEL > 1
2960 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2961 if ( event
.ShiftDown() )
2966 #endif // __WXDEBUG__
2969 // just Ctrl-Alt-middle click shows information about wx version
2970 ::wxInfoMessageBox((wxWindow
*)this);
2971 #endif // wxUSE_MSGDLG
2980 // ----------------------------------------------------------------------------
2982 // ----------------------------------------------------------------------------
2984 #if wxUSE_ACCESSIBILITY
2985 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2987 if (m_accessible
&& (accessible
!= m_accessible
))
2988 delete m_accessible
;
2989 m_accessible
= accessible
;
2991 m_accessible
->SetWindow((wxWindow
*) this);
2994 // Returns the accessible object, creating if necessary.
2995 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2998 m_accessible
= CreateAccessible();
2999 return m_accessible
;
3002 // Override to create a specific accessible object.
3003 wxAccessible
* wxWindowBase::CreateAccessible()
3005 return new wxWindowAccessible((wxWindow
*) this);
3010 // ----------------------------------------------------------------------------
3011 // list classes implementation
3012 // ----------------------------------------------------------------------------
3014 #if wxUSE_STD_CONTAINERS
3016 #include "wx/listimpl.cpp"
3017 WX_DEFINE_LIST(wxWindowList
)
3019 #else // !wxUSE_STD_CONTAINERS
3021 void wxWindowListNode::DeleteData()
3023 delete (wxWindow
*)GetData();
3026 #endif // wxUSE_STD_CONTAINERS/!wxUSE_STD_CONTAINERS
3028 // ----------------------------------------------------------------------------
3030 // ----------------------------------------------------------------------------
3032 wxBorder
wxWindowBase::GetBorder(long flags
) const
3034 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
3035 if ( border
== wxBORDER_DEFAULT
)
3037 border
= GetDefaultBorder();
3039 else if ( border
== wxBORDER_THEME
)
3041 border
= GetDefaultBorderForControl();
3047 wxBorder
wxWindowBase::GetDefaultBorder() const
3049 return wxBORDER_NONE
;
3052 // ----------------------------------------------------------------------------
3054 // ----------------------------------------------------------------------------
3056 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
3058 // here we just check if the point is inside the window or not
3060 // check the top and left border first
3061 bool outside
= x
< 0 || y
< 0;
3064 // check the right and bottom borders too
3065 wxSize size
= GetSize();
3066 outside
= x
>= size
.x
|| y
>= size
.y
;
3069 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
3072 // ----------------------------------------------------------------------------
3074 // ----------------------------------------------------------------------------
3076 struct WXDLLEXPORT wxWindowNext
3080 } *wxWindowBase::ms_winCaptureNext
= NULL
;
3081 wxWindow
*wxWindowBase::ms_winCaptureCurrent
= NULL
;
3082 bool wxWindowBase::ms_winCaptureChanging
= false;
3084 void wxWindowBase::CaptureMouse()
3086 wxLogTrace(wxT("mousecapture"), wxT("CaptureMouse(%p)"), static_cast<void*>(this));
3088 wxASSERT_MSG( !ms_winCaptureChanging
, wxT("recursive CaptureMouse call?") );
3090 ms_winCaptureChanging
= true;
3092 wxWindow
*winOld
= GetCapture();
3095 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
3098 wxWindowNext
*item
= new wxWindowNext
;
3100 item
->next
= ms_winCaptureNext
;
3101 ms_winCaptureNext
= item
;
3103 //else: no mouse capture to save
3106 ms_winCaptureCurrent
= (wxWindow
*)this;
3108 ms_winCaptureChanging
= false;
3111 void wxWindowBase::ReleaseMouse()
3113 wxLogTrace(wxT("mousecapture"), wxT("ReleaseMouse(%p)"), static_cast<void*>(this));
3115 wxASSERT_MSG( !ms_winCaptureChanging
, wxT("recursive ReleaseMouse call?") );
3117 wxASSERT_MSG( GetCapture() == this,
3118 "attempt to release mouse, but this window hasn't captured it" );
3119 wxASSERT_MSG( ms_winCaptureCurrent
== this,
3120 "attempt to release mouse, but this window hasn't captured it" );
3122 ms_winCaptureChanging
= true;
3125 ms_winCaptureCurrent
= NULL
;
3127 if ( ms_winCaptureNext
)
3129 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
3130 ms_winCaptureCurrent
= ms_winCaptureNext
->win
;
3132 wxWindowNext
*item
= ms_winCaptureNext
;
3133 ms_winCaptureNext
= item
->next
;
3136 //else: stack is empty, no previous capture
3138 ms_winCaptureChanging
= false;
3140 wxLogTrace(wxT("mousecapture"),
3141 (const wxChar
*) wxT("After ReleaseMouse() mouse is captured by %p"),
3142 static_cast<void*>(GetCapture()));
3145 static void DoNotifyWindowAboutCaptureLost(wxWindow
*win
)
3147 wxMouseCaptureLostEvent
event(win
->GetId());
3148 event
.SetEventObject(win
);
3149 if ( !win
->GetEventHandler()->ProcessEvent(event
) )
3151 // windows must handle this event, otherwise the app wouldn't behave
3152 // correctly if it loses capture unexpectedly; see the discussion here:
3153 // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863
3154 // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376
3155 wxFAIL_MSG( wxT("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
3160 void wxWindowBase::NotifyCaptureLost()
3162 // don't do anything if capture lost was expected, i.e. resulted from
3163 // a wx call to ReleaseMouse or CaptureMouse:
3164 if ( ms_winCaptureChanging
)
3167 // if the capture was lost unexpectedly, notify every window that has
3168 // capture (on stack or current) about it and clear the stack:
3170 if ( ms_winCaptureCurrent
)
3172 DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent
);
3173 ms_winCaptureCurrent
= NULL
;
3176 while ( ms_winCaptureNext
)
3178 wxWindowNext
*item
= ms_winCaptureNext
;
3179 ms_winCaptureNext
= item
->next
;
3181 DoNotifyWindowAboutCaptureLost(item
->win
);
3190 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
3191 int WXUNUSED(modifiers
),
3192 int WXUNUSED(keycode
))
3198 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
3204 #endif // wxUSE_HOTKEY
3206 // ----------------------------------------------------------------------------
3208 // ----------------------------------------------------------------------------
3210 bool wxWindowBase::TryBefore(wxEvent
& event
)
3212 #if wxUSE_VALIDATORS
3213 // Can only use the validator of the window which
3214 // is receiving the event
3215 if ( event
.GetEventObject() == this )
3217 wxValidator
* const validator
= GetValidator();
3218 if ( validator
&& validator
->ProcessEventLocally(event
) )
3223 #endif // wxUSE_VALIDATORS
3225 return wxEvtHandler::TryBefore(event
);
3228 bool wxWindowBase::TryAfter(wxEvent
& event
)
3230 // carry on up the parent-child hierarchy if the propagation count hasn't
3232 if ( event
.ShouldPropagate() )
3234 // honour the requests to stop propagation at this window: this is
3235 // used by the dialogs, for example, to prevent processing the events
3236 // from the dialog controls in the parent frame which rarely, if ever,
3238 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
3240 wxWindow
*parent
= GetParent();
3241 if ( parent
&& !parent
->IsBeingDeleted() )
3243 wxPropagateOnce
propagateOnce(event
);
3245 return parent
->GetEventHandler()->ProcessEvent(event
);
3250 return wxEvtHandler::TryAfter(event
);
3253 // ----------------------------------------------------------------------------
3254 // window relationships
3255 // ----------------------------------------------------------------------------
3257 wxWindow
*wxWindowBase::DoGetSibling(WindowOrder order
) const
3259 wxCHECK_MSG( GetParent(), NULL
,
3260 wxT("GetPrev/NextSibling() don't work for TLWs!") );
3262 wxWindowList
& siblings
= GetParent()->GetChildren();
3263 wxWindowList::compatibility_iterator i
= siblings
.Find((wxWindow
*)this);
3264 wxCHECK_MSG( i
, NULL
, wxT("window not a child of its parent?") );
3266 if ( order
== OrderBefore
)
3267 i
= i
->GetPrevious();
3271 return i
? i
->GetData() : NULL
;
3274 // ----------------------------------------------------------------------------
3275 // keyboard navigation
3276 // ----------------------------------------------------------------------------
3278 // Navigates in the specified direction inside this window
3279 bool wxWindowBase::DoNavigateIn(int flags
)
3281 #ifdef wxHAS_NATIVE_TAB_TRAVERSAL
3282 // native code doesn't process our wxNavigationKeyEvents anyhow
3285 #else // !wxHAS_NATIVE_TAB_TRAVERSAL
3286 wxNavigationKeyEvent eventNav
;
3287 wxWindow
*focused
= FindFocus();
3288 eventNav
.SetCurrentFocus(focused
);
3289 eventNav
.SetEventObject(focused
);
3290 eventNav
.SetFlags(flags
);
3291 return GetEventHandler()->ProcessEvent(eventNav
);
3292 #endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL
3295 bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent
& event
)
3297 if ( event
.GetKeyCode() != WXK_TAB
)
3300 int flags
= wxNavigationKeyEvent::FromTab
;
3302 if ( event
.ShiftDown() )
3303 flags
|= wxNavigationKeyEvent::IsBackward
;
3305 flags
|= wxNavigationKeyEvent::IsForward
;
3307 if ( event
.ControlDown() )
3308 flags
|= wxNavigationKeyEvent::WinChange
;
3314 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, WindowOrder move
)
3316 // check that we're not a top level window
3317 wxCHECK_RET( GetParent(),
3318 wxT("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
3320 // detect the special case when we have nothing to do anyhow and when the
3321 // code below wouldn't work
3325 // find the target window in the siblings list
3326 wxWindowList
& siblings
= GetParent()->GetChildren();
3327 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
3328 wxCHECK_RET( i
, wxT("MoveBefore/AfterInTabOrder(): win is not a sibling") );
3330 // unfortunately, when wxUSE_STD_CONTAINERS == 1 DetachNode() is not
3331 // implemented so we can't just move the node around
3332 wxWindow
*self
= (wxWindow
*)this;
3333 siblings
.DeleteObject(self
);
3334 if ( move
== OrderAfter
)
3341 siblings
.Insert(i
, self
);
3343 else // OrderAfter and win was the last sibling
3345 siblings
.Append(self
);
3349 // ----------------------------------------------------------------------------
3351 // ----------------------------------------------------------------------------
3353 /*static*/ wxWindow
* wxWindowBase::FindFocus()
3355 wxWindowBase
*win
= DoFindFocus();
3356 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
3359 bool wxWindowBase::HasFocus() const
3361 wxWindowBase
* const win
= DoFindFocus();
3363 (this == win
|| this == win
->GetMainWindowOfCompositeControl());
3366 // ----------------------------------------------------------------------------
3368 // ----------------------------------------------------------------------------
3370 #if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3375 class DragAcceptFilesTarget
: public wxFileDropTarget
3378 DragAcceptFilesTarget(wxWindowBase
*win
) : m_win(win
) {}
3380 virtual bool OnDropFiles(wxCoord x
, wxCoord y
,
3381 const wxArrayString
& filenames
)
3383 wxDropFilesEvent
event(wxEVT_DROP_FILES
,
3385 wxCArrayString(filenames
).Release());
3386 event
.SetEventObject(m_win
);
3390 return m_win
->HandleWindowEvent(event
);
3394 wxWindowBase
* const m_win
;
3396 wxDECLARE_NO_COPY_CLASS(DragAcceptFilesTarget
);
3400 } // anonymous namespace
3402 // Generic version of DragAcceptFiles(). It works by installing a simple
3403 // wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used
3404 // together with explicit SetDropTarget() calls.
3405 void wxWindowBase::DragAcceptFiles(bool accept
)
3409 wxASSERT_MSG( !GetDropTarget(),
3410 "cannot use DragAcceptFiles() and SetDropTarget() together" );
3411 SetDropTarget(new DragAcceptFilesTarget(this));
3415 SetDropTarget(NULL
);
3419 #endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__)
3421 // ----------------------------------------------------------------------------
3423 // ----------------------------------------------------------------------------
3425 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
3427 while ( win
&& !win
->IsTopLevel() )
3428 win
= win
->GetParent();
3433 #if wxUSE_ACCESSIBILITY
3434 // ----------------------------------------------------------------------------
3435 // accessible object for windows
3436 // ----------------------------------------------------------------------------
3438 // Can return either a child object, or an integer
3439 // representing the child element, starting from 1.
3440 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
3442 wxASSERT( GetWindow() != NULL
);
3446 return wxACC_NOT_IMPLEMENTED
;
3449 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
3450 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
3452 wxASSERT( GetWindow() != NULL
);
3456 wxWindow
* win
= NULL
;
3463 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
3465 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
3472 rect
= win
->GetRect();
3473 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
3474 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
3478 return wxACC_NOT_IMPLEMENTED
;
3481 // Navigates from fromId to toId/toObject.
3482 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
3483 int* WXUNUSED(toId
), wxAccessible
** toObject
)
3485 wxASSERT( GetWindow() != NULL
);
3491 case wxNAVDIR_FIRSTCHILD
:
3493 if (GetWindow()->GetChildren().GetCount() == 0)
3495 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
3496 *toObject
= childWindow
->GetOrCreateAccessible();
3500 case wxNAVDIR_LASTCHILD
:
3502 if (GetWindow()->GetChildren().GetCount() == 0)
3504 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
3505 *toObject
= childWindow
->GetOrCreateAccessible();
3509 case wxNAVDIR_RIGHT
:
3513 wxWindowList::compatibility_iterator node
=
3514 wxWindowList::compatibility_iterator();
3517 // Can't navigate to sibling of this window
3518 // if we're a top-level window.
3519 if (!GetWindow()->GetParent())
3520 return wxACC_NOT_IMPLEMENTED
;
3522 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3526 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3527 node
= GetWindow()->GetChildren().Item(fromId
-1);
3530 if (node
&& node
->GetNext())
3532 wxWindow
* nextWindow
= node
->GetNext()->GetData();
3533 *toObject
= nextWindow
->GetOrCreateAccessible();
3541 case wxNAVDIR_PREVIOUS
:
3543 wxWindowList::compatibility_iterator node
=
3544 wxWindowList::compatibility_iterator();
3547 // Can't navigate to sibling of this window
3548 // if we're a top-level window.
3549 if (!GetWindow()->GetParent())
3550 return wxACC_NOT_IMPLEMENTED
;
3552 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
3556 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
3557 node
= GetWindow()->GetChildren().Item(fromId
-1);
3560 if (node
&& node
->GetPrevious())
3562 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
3563 *toObject
= previousWindow
->GetOrCreateAccessible();
3571 return wxACC_NOT_IMPLEMENTED
;
3574 // Gets the name of the specified object.
3575 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
3577 wxASSERT( GetWindow() != NULL
);
3583 // If a child, leave wxWidgets to call the function on the actual
3586 return wxACC_NOT_IMPLEMENTED
;
3588 // This will eventually be replaced by specialised
3589 // accessible classes, one for each kind of wxWidgets
3590 // control or window.
3592 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
3593 title
= ((wxButton
*) GetWindow())->GetLabel();
3596 title
= GetWindow()->GetName();
3604 return wxACC_NOT_IMPLEMENTED
;
3607 // Gets the number of children.
3608 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
3610 wxASSERT( GetWindow() != NULL
);
3614 *childId
= (int) GetWindow()->GetChildren().GetCount();
3618 // Gets the specified child (starting from 1).
3619 // If *child is NULL and return value is wxACC_OK,
3620 // this means that the child is a simple element and
3621 // not an accessible object.
3622 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
3624 wxASSERT( GetWindow() != NULL
);
3634 if (childId
> (int) GetWindow()->GetChildren().GetCount())
3637 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
3638 *child
= childWindow
->GetOrCreateAccessible();
3645 // Gets the parent, or NULL.
3646 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
3648 wxASSERT( GetWindow() != NULL
);
3652 wxWindow
* parentWindow
= GetWindow()->GetParent();
3660 *parent
= parentWindow
->GetOrCreateAccessible();
3668 // Performs the default action. childId is 0 (the action for this object)
3669 // or > 0 (the action for a child).
3670 // Return wxACC_NOT_SUPPORTED if there is no default action for this
3671 // window (e.g. an edit control).
3672 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
3674 wxASSERT( GetWindow() != NULL
);
3678 return wxACC_NOT_IMPLEMENTED
;
3681 // Gets the default action for this object (0) or > 0 (the action for a child).
3682 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
3683 // string if there is no action.
3684 // The retrieved string describes the action that is performed on an object,
3685 // not what the object does as a result. For example, a toolbar button that prints
3686 // a document has a default action of "Press" rather than "Prints the current document."
3687 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
3689 wxASSERT( GetWindow() != NULL
);
3693 return wxACC_NOT_IMPLEMENTED
;
3696 // Returns the description for this object or a child.
3697 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
3699 wxASSERT( GetWindow() != NULL
);
3703 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3709 return wxACC_NOT_IMPLEMENTED
;
3712 // Returns help text for this object or a child, similar to tooltip text.
3713 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
3715 wxASSERT( GetWindow() != NULL
);
3719 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
3725 return wxACC_NOT_IMPLEMENTED
;
3728 // Returns the keyboard shortcut for this object or child.
3729 // Return e.g. ALT+K
3730 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
3732 wxASSERT( GetWindow() != NULL
);
3736 return wxACC_NOT_IMPLEMENTED
;
3739 // Returns a role constant.
3740 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
3742 wxASSERT( GetWindow() != NULL
);
3746 // If a child, leave wxWidgets to call the function on the actual
3749 return wxACC_NOT_IMPLEMENTED
;
3751 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3752 return wxACC_NOT_IMPLEMENTED
;
3754 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3755 return wxACC_NOT_IMPLEMENTED
;
3758 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3759 return wxACC_NOT_IMPLEMENTED
;
3762 //*role = wxROLE_SYSTEM_CLIENT;
3763 *role
= wxROLE_SYSTEM_CLIENT
;
3767 return wxACC_NOT_IMPLEMENTED
;
3771 // Returns a state constant.
3772 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
3774 wxASSERT( GetWindow() != NULL
);
3778 // If a child, leave wxWidgets to call the function on the actual
3781 return wxACC_NOT_IMPLEMENTED
;
3783 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
3784 return wxACC_NOT_IMPLEMENTED
;
3787 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
3788 return wxACC_NOT_IMPLEMENTED
;
3791 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
3792 return wxACC_NOT_IMPLEMENTED
;
3799 return wxACC_NOT_IMPLEMENTED
;
3803 // Returns a localized string representing the value for the object
3805 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
3807 wxASSERT( GetWindow() != NULL
);
3811 return wxACC_NOT_IMPLEMENTED
;
3814 // Selects the object or child.
3815 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
3817 wxASSERT( GetWindow() != NULL
);
3821 return wxACC_NOT_IMPLEMENTED
;
3824 // Gets the window with the keyboard focus.
3825 // If childId is 0 and child is NULL, no object in
3826 // this subhierarchy has the focus.
3827 // If this object has the focus, child should be 'this'.
3828 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
3830 wxASSERT( GetWindow() != NULL
);
3834 return wxACC_NOT_IMPLEMENTED
;
3838 // Gets a variant representing the selected children
3840 // Acceptable values:
3841 // - a null variant (IsNull() returns true)
3842 // - a list variant (GetType() == wxT("list")
3843 // - an integer representing the selected child element,
3844 // or 0 if this object is selected (GetType() == wxT("long")
3845 // - a "void*" pointer to a wxAccessible child object
3846 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
3848 wxASSERT( GetWindow() != NULL
);
3852 return wxACC_NOT_IMPLEMENTED
;
3854 #endif // wxUSE_VARIANT
3856 #endif // wxUSE_ACCESSIBILITY
3858 // ----------------------------------------------------------------------------
3860 // ----------------------------------------------------------------------------
3863 wxWindowBase::AdjustForLayoutDirection(wxCoord x
,
3865 wxCoord widthTotal
) const
3867 if ( GetLayoutDirection() == wxLayout_RightToLeft
)
3869 x
= widthTotal
- x
- width
;