1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/common/window.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
8 // Copyright: (c) wxWidgets team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
28 #include "wx/string.h"
32 #include "wx/window.h"
33 #include "wx/control.h"
34 #include "wx/checkbox.h"
35 #include "wx/radiobut.h"
36 #include "wx/statbox.h"
37 #include "wx/textctrl.h"
38 #include "wx/settings.h"
39 #include "wx/dialog.h"
40 #include "wx/msgdlg.h"
41 #include "wx/statusbr.h"
42 #include "wx/toolbar.h"
43 #include "wx/dcclient.h"
44 #include "wx/scrolbar.h"
45 #include "wx/layout.h"
49 #if wxUSE_DRAG_AND_DROP
51 #endif // wxUSE_DRAG_AND_DROP
53 #if wxUSE_ACCESSIBILITY
54 #include "wx/access.h"
58 #include "wx/cshelp.h"
62 #include "wx/tooltip.h"
63 #endif // wxUSE_TOOLTIPS
69 #if wxUSE_SYSTEM_OPTIONS
70 #include "wx/sysopt.h"
73 // For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
74 // The gtk includes don't pull any other headers in, at least not on my system - MR
77 #include <gtk/gtkversion.h>
79 #include <gtk/gtkfeatures.h>
81 extern const unsigned int gtk_major_version
;
82 extern const unsigned int gtk_minor_version
;
83 extern const unsigned int gtk_micro_version
;
86 #include "wx/platinfo.h"
89 WXDLLIMPEXP_DATA_CORE(wxWindowList
) wxTopLevelWindows
;
91 // ----------------------------------------------------------------------------
93 // ----------------------------------------------------------------------------
95 #if defined(__WXPALMOS__)
96 int wxWindowBase::ms_lastControlId
= 32767;
97 #elif defined(__WXPM__)
98 int wxWindowBase::ms_lastControlId
= 2000;
100 int wxWindowBase::ms_lastControlId
= -200;
103 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
105 // ----------------------------------------------------------------------------
107 // ----------------------------------------------------------------------------
109 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
110 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
111 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
112 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
115 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
120 // ============================================================================
121 // implementation of the common functionality of the wxWindow class
122 // ============================================================================
124 // ----------------------------------------------------------------------------
126 // ----------------------------------------------------------------------------
128 // the default initialization
129 wxWindowBase::wxWindowBase()
131 // no window yet, no parent nor children
132 m_parent
= (wxWindow
*)NULL
;
133 m_windowId
= wxID_ANY
;
135 // no constraints on the minimal window size
137 m_maxWidth
= wxDefaultCoord
;
139 m_maxHeight
= wxDefaultCoord
;
141 // invalidiated cache value
142 m_bestSizeCache
= wxDefaultSize
;
144 // window are created enabled and visible by default
148 // the default event handler is just this window
149 m_eventHandler
= this;
153 m_windowValidator
= (wxValidator
*) NULL
;
154 #endif // wxUSE_VALIDATORS
156 // the colours/fonts are default for now, so leave m_font,
157 // m_backgroundColour and m_foregroundColour uninitialized and set those
163 m_inheritFont
= false;
169 m_backgroundStyle
= wxBG_STYLE_SYSTEM
;
171 #if wxUSE_CONSTRAINTS
172 // no constraints whatsoever
173 m_constraints
= (wxLayoutConstraints
*) NULL
;
174 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
175 #endif // wxUSE_CONSTRAINTS
177 m_windowSizer
= (wxSizer
*) NULL
;
178 m_containingSizer
= (wxSizer
*) NULL
;
179 m_autoLayout
= false;
181 #if wxUSE_DRAG_AND_DROP
182 m_dropTarget
= (wxDropTarget
*)NULL
;
183 #endif // wxUSE_DRAG_AND_DROP
186 m_tooltip
= (wxToolTip
*)NULL
;
187 #endif // wxUSE_TOOLTIPS
190 m_caret
= (wxCaret
*)NULL
;
191 #endif // wxUSE_CARET
194 m_hasCustomPalette
= false;
195 #endif // wxUSE_PALETTE
197 #if wxUSE_ACCESSIBILITY
201 m_virtualSize
= wxDefaultSize
;
204 m_maxVirtualWidth
= wxDefaultCoord
;
206 m_maxVirtualHeight
= wxDefaultCoord
;
208 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
209 #if wxUSE_SYSTEM_OPTIONS
210 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
212 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
216 // Whether we're using the current theme for this window (wxGTK only for now)
217 m_themeEnabled
= false;
219 // VZ: this one shouldn't exist...
220 m_isBeingDeleted
= false;
223 // common part of window creation process
224 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
226 const wxPoint
& WXUNUSED(pos
),
227 const wxSize
& WXUNUSED(size
),
229 const wxValidator
& wxVALIDATOR_PARAM(validator
),
230 const wxString
& name
)
233 // wxGTK doesn't allow to create controls with static box as the parent so
234 // this will result in a crash when the program is ported to wxGTK so warn
237 // if you get this assert, the correct solution is to create the controls
238 // as siblings of the static box
239 wxASSERT_MSG( !parent
|| !wxDynamicCast(parent
, wxStaticBox
),
240 _T("wxStaticBox can't be used as a window parent!") );
241 #endif // wxUSE_STATBOX
243 // ids are limited to 16 bits under MSW so if you care about portability,
244 // it's not a good idea to use ids out of this range (and negative ids are
245 // reserved for wxWidgets own usage)
246 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767),
247 _T("invalid id value") );
249 // generate a new id if the user doesn't care about it
250 m_windowId
= id
== wxID_ANY
? NewControlId() : id
;
253 SetWindowStyleFlag(style
);
257 SetValidator(validator
);
258 #endif // wxUSE_VALIDATORS
260 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
261 // have it too - like this it's possible to set it only in the top level
262 // dialog/frame and all children will inherit it by defult
263 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
265 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
271 // ----------------------------------------------------------------------------
273 // ----------------------------------------------------------------------------
276 wxWindowBase::~wxWindowBase()
278 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
280 // FIXME if these 2 cases result from programming errors in the user code
281 // we should probably assert here instead of silently fixing them
283 // Just in case the window has been Closed, but we're then deleting
284 // immediately: don't leave dangling pointers.
285 wxPendingDelete
.DeleteObject(this);
287 // Just in case we've loaded a top-level window via LoadNativeDialog but
288 // we weren't a dialog class
289 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
291 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
293 // reset the dangling pointer our parent window may keep to us
296 m_parent
->RemoveChild(this);
301 #endif // wxUSE_CARET
304 delete m_windowValidator
;
305 #endif // wxUSE_VALIDATORS
307 #if wxUSE_CONSTRAINTS
308 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
309 // at deleted windows as they delete themselves.
310 DeleteRelatedConstraints();
314 // This removes any dangling pointers to this window in other windows'
315 // constraintsInvolvedIn lists.
316 UnsetConstraints(m_constraints
);
317 delete m_constraints
;
318 m_constraints
= NULL
;
320 #endif // wxUSE_CONSTRAINTS
322 if ( m_containingSizer
)
323 m_containingSizer
->Detach( (wxWindow
*)this );
325 delete m_windowSizer
;
327 #if wxUSE_DRAG_AND_DROP
329 #endif // wxUSE_DRAG_AND_DROP
333 #endif // wxUSE_TOOLTIPS
335 #if wxUSE_ACCESSIBILITY
340 bool wxWindowBase::Destroy()
347 bool wxWindowBase::Close(bool force
)
349 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
350 event
.SetEventObject(this);
351 event
.SetCanVeto(!force
);
353 // return false if window wasn't closed because the application vetoed the
355 return GetEventHandler()->ProcessEvent(event
) && !event
.GetVeto();
358 bool wxWindowBase::DestroyChildren()
360 wxWindowList::compatibility_iterator node
;
363 // we iterate until the list becomes empty
364 node
= GetChildren().GetFirst();
368 wxWindow
*child
= node
->GetData();
370 // note that we really want to call delete and not ->Destroy() here
371 // because we want to delete the child immediately, before we are
372 // deleted, and delayed deletion would result in problems as our (top
373 // level) child could outlive its parent
376 wxASSERT_MSG( !GetChildren().Find(child
),
377 wxT("child didn't remove itself using RemoveChild()") );
383 // ----------------------------------------------------------------------------
384 // size/position related methods
385 // ----------------------------------------------------------------------------
387 // centre the window with respect to its parent in either (or both) directions
388 void wxWindowBase::DoCentre(int dir
)
390 wxCHECK_RET( !(dir
& wxCENTRE_ON_SCREEN
) && GetParent(),
391 _T("this method only implements centering child windows") );
393 SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir
));
396 // fits the window around the children
397 void wxWindowBase::Fit()
399 if ( !GetChildren().empty() )
401 SetSize(GetBestSize());
403 //else: do nothing if we have no children
406 // fits virtual size (ie. scrolled area etc.) around children
407 void wxWindowBase::FitInside()
409 if ( GetChildren().GetCount() > 0 )
411 SetVirtualSize( GetBestVirtualSize() );
415 // On Mac, scrollbars are explicitly children.
417 static bool wxHasRealChildren(const wxWindowBase
* win
)
419 int realChildCount
= 0;
421 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
423 node
= node
->GetNext() )
425 wxWindow
*win
= node
->GetData();
426 if ( !win
->IsTopLevel() && win
->IsShown() && !win
->IsKindOf(CLASSINFO(wxScrollBar
)))
429 return (realChildCount
> 0);
433 void wxWindowBase::InvalidateBestSize()
435 m_bestSizeCache
= wxDefaultSize
;
437 // parent's best size calculation may depend on its children's
438 // as long as child window we are in is not top level window itself
439 // (because the TLW size is never resized automatically)
440 // so let's invalidate it as well to be safe:
441 if (m_parent
&& !IsTopLevel())
442 m_parent
->InvalidateBestSize();
445 // return the size best suited for the current window
446 wxSize
wxWindowBase::DoGetBestSize() const
452 best
= GetWindowSizeForVirtualSize(m_windowSizer
->GetMinSize());
454 #if wxUSE_CONSTRAINTS
455 else if ( m_constraints
)
457 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
459 // our minimal acceptable size is such that all our windows fit inside
463 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
465 node
= node
->GetNext() )
467 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
470 // it's not normal that we have an unconstrained child, but
471 // what can we do about it?
475 int x
= c
->right
.GetValue(),
476 y
= c
->bottom
.GetValue();
484 // TODO: we must calculate the overlaps somehow, otherwise we
485 // will never return a size bigger than the current one :-(
488 best
= wxSize(maxX
, maxY
);
490 #endif // wxUSE_CONSTRAINTS
491 else if ( !GetChildren().empty()
493 && wxHasRealChildren(this)
497 // our minimal acceptable size is such that all our visible child
498 // windows fit inside
502 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
504 node
= node
->GetNext() )
506 wxWindow
*win
= node
->GetData();
507 if ( win
->IsTopLevel()
510 || wxDynamicCast(win
, wxStatusBar
)
511 #endif // wxUSE_STATUSBAR
514 // dialogs and frames lie in different top level windows -
515 // don't deal with them here; as for the status bars, they
516 // don't lie in the client area at all
521 win
->GetPosition(&wx
, &wy
);
523 // if the window hadn't been positioned yet, assume that it is in
525 if ( wx
== wxDefaultCoord
)
527 if ( wy
== wxDefaultCoord
)
530 win
->GetSize(&ww
, &wh
);
531 if ( wx
+ ww
> maxX
)
533 if ( wy
+ wh
> maxY
)
537 best
= wxSize(maxX
, maxY
);
539 else // ! has children
541 // for a generic window there is no natural best size so, if the
542 // minimal size is not set, use the current size but take care to
543 // remember it as minimal size for the next time because our best size
544 // should be constant: otherwise we could get into a situation when the
545 // window is initially at some size, then expanded to a larger size and
546 // then, when the containing window is shrunk back (because our initial
547 // best size had been used for computing the parent min size), we can't
548 // be shrunk back any more because our best size is now bigger
549 wxSize size
= GetMinSize();
550 if ( !size
.IsFullySpecified() )
552 size
.SetDefaults(GetSize());
553 wxConstCast(this, wxWindowBase
)->SetMinSize(size
);
556 // return as-is, unadjusted by the client size difference.
560 // Add any difference between size and client size
561 wxSize diff
= GetSize() - GetClientSize();
562 best
.x
+= wxMax(0, diff
.x
);
563 best
.y
+= wxMax(0, diff
.y
);
569 wxSize
wxWindowBase::GetBestFittingSize() const
571 // merge the best size with the min size, giving priority to the min size
572 wxSize min
= GetMinSize();
573 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
575 wxSize best
= GetBestSize();
576 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
577 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
583 void wxWindowBase::SetBestFittingSize(const wxSize
& size
)
585 // Set the min size to the size passed in. This will usually either be
586 // wxDefaultSize or the size passed to this window's ctor/Create function.
589 // Merge the size with the best size if needed
590 wxSize best
= GetBestFittingSize();
592 // If the current size doesn't match then change it
593 if (GetSize() != best
)
598 // by default the origin is not shifted
599 wxPoint
wxWindowBase::GetClientAreaOrigin() const
604 // set the min/max size of the window
605 void wxWindowBase::DoSetSizeHints(int minW
, int minH
,
607 int WXUNUSED(incW
), int WXUNUSED(incH
))
609 // setting min width greater than max width leads to infinite loops under
610 // X11 and generally doesn't make any sense, so don't allow it
611 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
612 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
613 _T("min width/height must be less than max width/height!") );
621 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
623 if ( m_windowVariant
!= variant
)
625 m_windowVariant
= variant
;
627 DoSetWindowVariant(variant
);
631 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
633 // adjust the font height to correspond to our new variant (notice that
634 // we're only called if something really changed)
635 wxFont font
= GetFont();
636 int size
= font
.GetPointSize();
639 case wxWINDOW_VARIANT_NORMAL
:
642 case wxWINDOW_VARIANT_SMALL
:
647 case wxWINDOW_VARIANT_MINI
:
652 case wxWINDOW_VARIANT_LARGE
:
658 wxFAIL_MSG(_T("unexpected window variant"));
662 font
.SetPointSize(size
);
666 void wxWindowBase::SetVirtualSizeHints( int minW
, int minH
,
669 m_minVirtualWidth
= minW
;
670 m_maxVirtualWidth
= maxW
;
671 m_minVirtualHeight
= minH
;
672 m_maxVirtualHeight
= maxH
;
675 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
677 if ( m_minVirtualWidth
!= wxDefaultCoord
&& m_minVirtualWidth
> x
)
678 x
= m_minVirtualWidth
;
679 if ( m_maxVirtualWidth
!= wxDefaultCoord
&& m_maxVirtualWidth
< x
)
680 x
= m_maxVirtualWidth
;
681 if ( m_minVirtualHeight
!= wxDefaultCoord
&& m_minVirtualHeight
> y
)
682 y
= m_minVirtualHeight
;
683 if ( m_maxVirtualHeight
!= wxDefaultCoord
&& m_maxVirtualHeight
< y
)
684 y
= m_maxVirtualHeight
;
686 m_virtualSize
= wxSize(x
, y
);
689 wxSize
wxWindowBase::DoGetVirtualSize() const
691 // we should use the entire client area so if it is greater than our
692 // virtual size, expand it to fit (otherwise if the window is big enough we
693 // wouldn't be using parts of it)
694 wxSize size
= GetClientSize();
695 if ( m_virtualSize
.x
> size
.x
)
696 size
.x
= m_virtualSize
.x
;
698 if ( m_virtualSize
.y
>= size
.y
)
699 size
.y
= m_virtualSize
.y
;
704 void wxWindowBase::DoGetScreenPosition(int *x
, int *y
) const
706 // screen position is the same as (0, 0) in client coords for non TLWs (and
707 // TLWs override this method)
713 ClientToScreen(x
, y
);
716 // ----------------------------------------------------------------------------
717 // show/hide/enable/disable the window
718 // ----------------------------------------------------------------------------
720 bool wxWindowBase::Show(bool show
)
722 if ( show
!= m_isShown
)
734 bool wxWindowBase::Enable(bool enable
)
736 if ( enable
!= m_isEnabled
)
738 m_isEnabled
= enable
;
748 bool wxWindowBase::IsVisible() const
750 return IsShown() && (GetParent() == NULL
|| GetParent()->IsVisible());
753 // ----------------------------------------------------------------------------
755 // ----------------------------------------------------------------------------
757 bool wxWindowBase::IsTopLevel() const
762 // ----------------------------------------------------------------------------
763 // reparenting the window
764 // ----------------------------------------------------------------------------
766 void wxWindowBase::AddChild(wxWindowBase
*child
)
768 wxCHECK_RET( child
, wxT("can't add a NULL child") );
770 // this should never happen and it will lead to a crash later if it does
771 // because RemoveChild() will remove only one node from the children list
772 // and the other(s) one(s) will be left with dangling pointers in them
773 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), _T("AddChild() called twice") );
775 GetChildren().Append((wxWindow
*)child
);
776 child
->SetParent(this);
779 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
781 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
783 GetChildren().DeleteObject((wxWindow
*)child
);
784 child
->SetParent(NULL
);
787 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
789 wxWindow
*oldParent
= GetParent();
790 if ( newParent
== oldParent
)
796 // unlink this window from the existing parent.
799 oldParent
->RemoveChild(this);
803 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
806 // add it to the new one
809 newParent
->AddChild(this);
813 wxTopLevelWindows
.Append((wxWindow
*)this);
819 // ----------------------------------------------------------------------------
820 // event handler stuff
821 // ----------------------------------------------------------------------------
823 void wxWindowBase::PushEventHandler(wxEvtHandler
*handler
)
825 wxEvtHandler
*handlerOld
= GetEventHandler();
827 handler
->SetNextHandler(handlerOld
);
830 GetEventHandler()->SetPreviousHandler(handler
);
832 SetEventHandler(handler
);
835 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
837 wxEvtHandler
*handlerA
= GetEventHandler();
840 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
841 handlerA
->SetNextHandler((wxEvtHandler
*)NULL
);
844 handlerB
->SetPreviousHandler((wxEvtHandler
*)NULL
);
845 SetEventHandler(handlerB
);
850 handlerA
= (wxEvtHandler
*)NULL
;
857 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handler
)
859 wxCHECK_MSG( handler
, false, _T("RemoveEventHandler(NULL) called") );
861 wxEvtHandler
*handlerPrev
= NULL
,
862 *handlerCur
= GetEventHandler();
865 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
867 if ( handlerCur
== handler
)
871 handlerPrev
->SetNextHandler(handlerNext
);
875 SetEventHandler(handlerNext
);
880 handlerNext
->SetPreviousHandler ( handlerPrev
);
883 handler
->SetNextHandler(NULL
);
884 handler
->SetPreviousHandler(NULL
);
889 handlerPrev
= handlerCur
;
890 handlerCur
= handlerNext
;
893 wxFAIL_MSG( _T("where has the event handler gone?") );
898 // ----------------------------------------------------------------------------
900 // ----------------------------------------------------------------------------
902 void wxWindowBase::InheritAttributes()
904 const wxWindowBase
* const parent
= GetParent();
908 // we only inherit attributes which had been explicitly set for the parent
909 // which ensures that this only happens if the user really wants it and
910 // not by default which wouldn't make any sense in modern GUIs where the
911 // controls don't all use the same fonts (nor colours)
912 if ( parent
->m_inheritFont
&& !m_hasFont
)
913 SetFont(parent
->GetFont());
915 // in addition, there is a possibility to explicitly forbid inheriting
916 // colours at each class level by overriding ShouldInheritColours()
917 if ( ShouldInheritColours() )
919 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
920 SetForegroundColour(parent
->GetForegroundColour());
922 // inheriting (solid) background colour is wrong as it totally breaks
923 // any kind of themed backgrounds
925 // instead, the controls should use the same background as their parent
926 // (ideally by not drawing it at all)
928 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
929 SetBackgroundColour(parent
->GetBackgroundColour());
934 /* static */ wxVisualAttributes
935 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
937 // it is important to return valid values for all attributes from here,
938 // GetXXX() below rely on this
939 wxVisualAttributes attrs
;
940 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
941 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
943 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
944 // the usual background colour than wxSYS_COLOUR_BTNFACE.
945 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
946 // colour on other platforms.
948 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
949 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
951 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
956 wxColour
wxWindowBase::GetBackgroundColour() const
958 if ( !m_backgroundColour
.Ok() )
960 wxASSERT_MSG( !m_hasBgCol
, _T("we have invalid explicit bg colour?") );
962 // get our default background colour
963 wxColour colBg
= GetDefaultAttributes().colBg
;
965 // we must return some valid colour to avoid redoing this every time
966 // and also to avoid surprizing the applications written for older
967 // wxWidgets versions where GetBackgroundColour() always returned
968 // something -- so give them something even if it doesn't make sense
969 // for this window (e.g. it has a themed background)
971 colBg
= GetClassDefaultAttributes().colBg
;
976 return m_backgroundColour
;
979 wxColour
wxWindowBase::GetForegroundColour() const
981 // logic is the same as above
982 if ( !m_hasFgCol
&& !m_foregroundColour
.Ok() )
984 wxASSERT_MSG( !m_hasFgCol
, _T("we have invalid explicit fg colour?") );
986 wxColour colFg
= GetDefaultAttributes().colFg
;
989 colFg
= GetClassDefaultAttributes().colFg
;
994 return m_foregroundColour
;
997 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
999 if ( colour
== m_backgroundColour
)
1002 m_hasBgCol
= colour
.Ok();
1003 if ( m_backgroundStyle
!= wxBG_STYLE_CUSTOM
)
1004 m_backgroundStyle
= m_hasBgCol
? wxBG_STYLE_COLOUR
: wxBG_STYLE_SYSTEM
;
1006 m_inheritBgCol
= m_hasBgCol
;
1007 m_backgroundColour
= colour
;
1008 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.Ok() );
1012 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1014 if (colour
== m_foregroundColour
)
1017 m_hasFgCol
= colour
.Ok();
1018 m_inheritFgCol
= m_hasFgCol
;
1019 m_foregroundColour
= colour
;
1020 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.Ok() );
1024 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1026 // setting an invalid cursor is ok, it means that we don't have any special
1028 if ( m_cursor
== cursor
)
1039 wxFont
wxWindowBase::GetFont() const
1041 // logic is the same as in GetBackgroundColour()
1044 wxASSERT_MSG( !m_hasFont
, _T("we have invalid explicit font?") );
1046 wxFont font
= GetDefaultAttributes().font
;
1048 font
= GetClassDefaultAttributes().font
;
1056 bool wxWindowBase::SetFont(const wxFont
& font
)
1058 if ( font
== m_font
)
1065 m_hasFont
= font
.Ok();
1066 m_inheritFont
= m_hasFont
;
1068 InvalidateBestSize();
1075 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1077 m_hasCustomPalette
= true;
1080 // VZ: can anyone explain me what do we do here?
1081 wxWindowDC
d((wxWindow
*) this);
1085 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1087 wxWindow
*win
= (wxWindow
*)this;
1088 while ( win
&& !win
->HasCustomPalette() )
1090 win
= win
->GetParent();
1096 #endif // wxUSE_PALETTE
1099 void wxWindowBase::SetCaret(wxCaret
*caret
)
1110 wxASSERT_MSG( m_caret
->GetWindow() == this,
1111 wxT("caret should be created associated to this window") );
1114 #endif // wxUSE_CARET
1116 #if wxUSE_VALIDATORS
1117 // ----------------------------------------------------------------------------
1119 // ----------------------------------------------------------------------------
1121 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1123 if ( m_windowValidator
)
1124 delete m_windowValidator
;
1126 m_windowValidator
= (wxValidator
*)validator
.Clone();
1128 if ( m_windowValidator
)
1129 m_windowValidator
->SetWindow(this);
1131 #endif // wxUSE_VALIDATORS
1133 // ----------------------------------------------------------------------------
1134 // update region stuff
1135 // ----------------------------------------------------------------------------
1137 wxRect
wxWindowBase::GetUpdateClientRect() const
1139 wxRegion rgnUpdate
= GetUpdateRegion();
1140 rgnUpdate
.Intersect(GetClientRect());
1141 wxRect rectUpdate
= rgnUpdate
.GetBox();
1142 wxPoint ptOrigin
= GetClientAreaOrigin();
1143 rectUpdate
.x
-= ptOrigin
.x
;
1144 rectUpdate
.y
-= ptOrigin
.y
;
1149 bool wxWindowBase::IsExposed(int x
, int y
) const
1151 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1154 bool wxWindowBase::IsExposed(int x
, int y
, int w
, int h
) const
1156 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1159 void wxWindowBase::ClearBackground()
1161 // wxGTK uses its own version, no need to add never used code
1163 wxClientDC
dc((wxWindow
*)this);
1164 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1165 dc
.SetBackground(brush
);
1170 // ----------------------------------------------------------------------------
1171 // find child window by id or name
1172 // ----------------------------------------------------------------------------
1174 wxWindow
*wxWindowBase::FindWindow(long id
) const
1176 if ( id
== m_windowId
)
1177 return (wxWindow
*)this;
1179 wxWindowBase
*res
= (wxWindow
*)NULL
;
1180 wxWindowList::compatibility_iterator node
;
1181 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1183 wxWindowBase
*child
= node
->GetData();
1184 res
= child
->FindWindow( id
);
1187 return (wxWindow
*)res
;
1190 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1192 if ( name
== m_windowName
)
1193 return (wxWindow
*)this;
1195 wxWindowBase
*res
= (wxWindow
*)NULL
;
1196 wxWindowList::compatibility_iterator node
;
1197 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1199 wxWindow
*child
= node
->GetData();
1200 res
= child
->FindWindow(name
);
1203 return (wxWindow
*)res
;
1207 // find any window by id or name or label: If parent is non-NULL, look through
1208 // children for a label or title matching the specified string. If NULL, look
1209 // through all top-level windows.
1211 // to avoid duplicating code we reuse the same helper function but with
1212 // different comparators
1214 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1215 const wxString
& label
, long id
);
1218 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1221 return win
->GetLabel() == label
;
1225 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1228 return win
->GetName() == label
;
1232 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1235 return win
->GetId() == id
;
1238 // recursive helper for the FindWindowByXXX() functions
1240 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1241 const wxString
& label
,
1243 wxFindWindowCmp cmp
)
1247 // see if this is the one we're looking for
1248 if ( (*cmp
)(parent
, label
, id
) )
1249 return (wxWindow
*)parent
;
1251 // It wasn't, so check all its children
1252 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1254 node
= node
->GetNext() )
1256 // recursively check each child
1257 wxWindow
*win
= (wxWindow
*)node
->GetData();
1258 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1268 // helper for FindWindowByXXX()
1270 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1271 const wxString
& label
,
1273 wxFindWindowCmp cmp
)
1277 // just check parent and all its children
1278 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1281 // start at very top of wx's windows
1282 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1284 node
= node
->GetNext() )
1286 // recursively check each window & its children
1287 wxWindow
*win
= node
->GetData();
1288 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1298 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1300 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1305 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1307 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1311 // fall back to the label
1312 win
= FindWindowByLabel(title
, parent
);
1320 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1322 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1325 // ----------------------------------------------------------------------------
1326 // dialog oriented functions
1327 // ----------------------------------------------------------------------------
1329 void wxWindowBase::MakeModal(bool modal
)
1331 // Disable all other windows
1334 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1337 wxWindow
*win
= node
->GetData();
1339 win
->Enable(!modal
);
1341 node
= node
->GetNext();
1346 bool wxWindowBase::Validate()
1348 #if wxUSE_VALIDATORS
1349 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1351 wxWindowList::compatibility_iterator node
;
1352 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1354 wxWindowBase
*child
= node
->GetData();
1355 wxValidator
*validator
= child
->GetValidator();
1356 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1361 if ( recurse
&& !child
->Validate() )
1366 #endif // wxUSE_VALIDATORS
1371 bool wxWindowBase::TransferDataToWindow()
1373 #if wxUSE_VALIDATORS
1374 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1376 wxWindowList::compatibility_iterator node
;
1377 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1379 wxWindowBase
*child
= node
->GetData();
1380 wxValidator
*validator
= child
->GetValidator();
1381 if ( validator
&& !validator
->TransferToWindow() )
1383 wxLogWarning(_("Could not transfer data to window"));
1385 wxLog::FlushActive();
1393 if ( !child
->TransferDataToWindow() )
1395 // warning already given
1400 #endif // wxUSE_VALIDATORS
1405 bool wxWindowBase::TransferDataFromWindow()
1407 #if wxUSE_VALIDATORS
1408 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1410 wxWindowList::compatibility_iterator node
;
1411 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1413 wxWindow
*child
= node
->GetData();
1414 wxValidator
*validator
= child
->GetValidator();
1415 if ( validator
&& !validator
->TransferFromWindow() )
1417 // nop warning here because the application is supposed to give
1418 // one itself - we don't know here what might have gone wrongly
1425 if ( !child
->TransferDataFromWindow() )
1427 // warning already given
1432 #endif // wxUSE_VALIDATORS
1437 void wxWindowBase::InitDialog()
1439 wxInitDialogEvent
event(GetId());
1440 event
.SetEventObject( this );
1441 GetEventHandler()->ProcessEvent(event
);
1444 // ----------------------------------------------------------------------------
1445 // context-sensitive help support
1446 // ----------------------------------------------------------------------------
1450 // associate this help text with this window
1451 void wxWindowBase::SetHelpText(const wxString
& text
)
1453 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1456 helpProvider
->AddHelp(this, text
);
1460 // associate this help text with all windows with the same id as this
1462 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
1464 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1467 helpProvider
->AddHelp(GetId(), text
);
1471 // get the help string associated with this window (may be empty)
1472 // default implementation forwards calls to the help provider
1474 wxWindowBase::GetHelpTextAtPoint(const wxPoint
& WXUNUSED(pt
),
1475 wxHelpEvent::Origin
WXUNUSED(origin
)) const
1478 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1481 text
= helpProvider
->GetHelp(this);
1487 // show help for this window
1488 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
1490 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1493 if ( helpProvider
->ShowHelpAtPoint(this, event
.GetPosition(), event
.GetOrigin()) )
1495 // skip the event.Skip() below
1503 #endif // wxUSE_HELP
1505 // ----------------------------------------------------------------------------
1506 // tooltipsroot.Replace("\\", "/");
1507 // ----------------------------------------------------------------------------
1511 void wxWindowBase::SetToolTip( const wxString
&tip
)
1513 // don't create the new tooltip if we already have one
1516 m_tooltip
->SetTip( tip
);
1520 SetToolTip( new wxToolTip( tip
) );
1523 // setting empty tooltip text does not remove the tooltip any more - use
1524 // SetToolTip((wxToolTip *)NULL) for this
1527 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
1529 if ( m_tooltip
!= tooltip
)
1534 m_tooltip
= tooltip
;
1538 #endif // wxUSE_TOOLTIPS
1540 // ----------------------------------------------------------------------------
1541 // constraints and sizers
1542 // ----------------------------------------------------------------------------
1544 #if wxUSE_CONSTRAINTS
1546 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
1548 if ( m_constraints
)
1550 UnsetConstraints(m_constraints
);
1551 delete m_constraints
;
1553 m_constraints
= constraints
;
1554 if ( m_constraints
)
1556 // Make sure other windows know they're part of a 'meaningful relationship'
1557 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
1558 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
1559 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
1560 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
1561 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
1562 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
1563 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
1564 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
1565 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
1566 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
1567 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
1568 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
1569 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
1570 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
1571 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
1572 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
1576 // This removes any dangling pointers to this window in other windows'
1577 // constraintsInvolvedIn lists.
1578 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
1582 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1583 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
1584 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1585 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
1586 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
1587 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
1588 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
1589 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
1590 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
1591 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
1592 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
1593 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
1594 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
1595 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
1596 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
1597 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
1601 // Back-pointer to other windows we're involved with, so if we delete this
1602 // window, we must delete any constraints we're involved with.
1603 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
1605 if ( !m_constraintsInvolvedIn
)
1606 m_constraintsInvolvedIn
= new wxWindowList
;
1607 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
1608 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
1611 // REMOVE back-pointer to other windows we're involved with.
1612 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
1614 if ( m_constraintsInvolvedIn
)
1615 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
1618 // Reset any constraints that mention this window
1619 void wxWindowBase::DeleteRelatedConstraints()
1621 if ( m_constraintsInvolvedIn
)
1623 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
1626 wxWindow
*win
= node
->GetData();
1627 wxLayoutConstraints
*constr
= win
->GetConstraints();
1629 // Reset any constraints involving this window
1632 constr
->left
.ResetIfWin(this);
1633 constr
->top
.ResetIfWin(this);
1634 constr
->right
.ResetIfWin(this);
1635 constr
->bottom
.ResetIfWin(this);
1636 constr
->width
.ResetIfWin(this);
1637 constr
->height
.ResetIfWin(this);
1638 constr
->centreX
.ResetIfWin(this);
1639 constr
->centreY
.ResetIfWin(this);
1642 wxWindowList::compatibility_iterator next
= node
->GetNext();
1643 m_constraintsInvolvedIn
->Erase(node
);
1647 delete m_constraintsInvolvedIn
;
1648 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
1652 #endif // wxUSE_CONSTRAINTS
1654 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
1656 if ( sizer
== m_windowSizer
)
1659 if ( m_windowSizer
)
1661 m_windowSizer
->SetContainingWindow(NULL
);
1664 delete m_windowSizer
;
1667 m_windowSizer
= sizer
;
1668 if ( m_windowSizer
)
1670 m_windowSizer
->SetContainingWindow((wxWindow
*)this);
1673 SetAutoLayout(m_windowSizer
!= NULL
);
1676 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
1678 SetSizer( sizer
, deleteOld
);
1679 sizer
->SetSizeHints( (wxWindow
*) this );
1683 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
1685 // adding a window to a sizer twice is going to result in fatal and
1686 // hard to debug problems later because when deleting the second
1687 // associated wxSizerItem we're going to dereference a dangling
1688 // pointer; so try to detect this as early as possible
1689 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
1690 _T("Adding a window to the same sizer twice?") );
1692 m_containingSizer
= sizer
;
1695 #if wxUSE_CONSTRAINTS
1697 void wxWindowBase::SatisfyConstraints()
1699 wxLayoutConstraints
*constr
= GetConstraints();
1700 bool wasOk
= constr
&& constr
->AreSatisfied();
1702 ResetConstraints(); // Mark all constraints as unevaluated
1706 // if we're a top level panel (i.e. our parent is frame/dialog), our
1707 // own constraints will never be satisfied any more unless we do it
1711 while ( noChanges
> 0 )
1713 LayoutPhase1(&noChanges
);
1717 LayoutPhase2(&noChanges
);
1720 #endif // wxUSE_CONSTRAINTS
1722 bool wxWindowBase::Layout()
1724 // If there is a sizer, use it instead of the constraints
1728 GetVirtualSize(&w
, &h
);
1729 GetSizer()->SetDimension( 0, 0, w
, h
);
1731 #if wxUSE_CONSTRAINTS
1734 SatisfyConstraints(); // Find the right constraints values
1735 SetConstraintSizes(); // Recursively set the real window sizes
1742 #if wxUSE_CONSTRAINTS
1744 // first phase of the constraints evaluation: set our own constraints
1745 bool wxWindowBase::LayoutPhase1(int *noChanges
)
1747 wxLayoutConstraints
*constr
= GetConstraints();
1749 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
1752 // second phase: set the constraints for our children
1753 bool wxWindowBase::LayoutPhase2(int *noChanges
)
1760 // Layout grand children
1766 // Do a phase of evaluating child constraints
1767 bool wxWindowBase::DoPhase(int phase
)
1769 // the list containing the children for which the constraints are already
1771 wxWindowList succeeded
;
1773 // the max number of iterations we loop before concluding that we can't set
1775 static const int maxIterations
= 500;
1777 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
1781 // loop over all children setting their constraints
1782 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1784 node
= node
->GetNext() )
1786 wxWindow
*child
= node
->GetData();
1787 if ( child
->IsTopLevel() )
1789 // top level children are not inside our client area
1793 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
1795 // this one is either already ok or nothing we can do about it
1799 int tempNoChanges
= 0;
1800 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
1801 : child
->LayoutPhase2(&tempNoChanges
);
1802 noChanges
+= tempNoChanges
;
1806 succeeded
.Append(child
);
1812 // constraints are set
1820 void wxWindowBase::ResetConstraints()
1822 wxLayoutConstraints
*constr
= GetConstraints();
1825 constr
->left
.SetDone(false);
1826 constr
->top
.SetDone(false);
1827 constr
->right
.SetDone(false);
1828 constr
->bottom
.SetDone(false);
1829 constr
->width
.SetDone(false);
1830 constr
->height
.SetDone(false);
1831 constr
->centreX
.SetDone(false);
1832 constr
->centreY
.SetDone(false);
1835 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1838 wxWindow
*win
= node
->GetData();
1839 if ( !win
->IsTopLevel() )
1840 win
->ResetConstraints();
1841 node
= node
->GetNext();
1845 // Need to distinguish between setting the 'fake' size for windows and sizers,
1846 // and setting the real values.
1847 void wxWindowBase::SetConstraintSizes(bool recurse
)
1849 wxLayoutConstraints
*constr
= GetConstraints();
1850 if ( constr
&& constr
->AreSatisfied() )
1852 int x
= constr
->left
.GetValue();
1853 int y
= constr
->top
.GetValue();
1854 int w
= constr
->width
.GetValue();
1855 int h
= constr
->height
.GetValue();
1857 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
1858 (constr
->height
.GetRelationship() != wxAsIs
) )
1860 SetSize(x
, y
, w
, h
);
1864 // If we don't want to resize this window, just move it...
1870 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1871 GetClassInfo()->GetClassName(),
1877 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1880 wxWindow
*win
= node
->GetData();
1881 if ( !win
->IsTopLevel() && win
->GetConstraints() )
1882 win
->SetConstraintSizes();
1883 node
= node
->GetNext();
1888 // Only set the size/position of the constraint (if any)
1889 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
1891 wxLayoutConstraints
*constr
= GetConstraints();
1894 if ( x
!= wxDefaultCoord
)
1896 constr
->left
.SetValue(x
);
1897 constr
->left
.SetDone(true);
1899 if ( y
!= wxDefaultCoord
)
1901 constr
->top
.SetValue(y
);
1902 constr
->top
.SetDone(true);
1904 if ( w
!= wxDefaultCoord
)
1906 constr
->width
.SetValue(w
);
1907 constr
->width
.SetDone(true);
1909 if ( h
!= wxDefaultCoord
)
1911 constr
->height
.SetValue(h
);
1912 constr
->height
.SetDone(true);
1917 void wxWindowBase::MoveConstraint(int x
, int y
)
1919 wxLayoutConstraints
*constr
= GetConstraints();
1922 if ( x
!= wxDefaultCoord
)
1924 constr
->left
.SetValue(x
);
1925 constr
->left
.SetDone(true);
1927 if ( y
!= wxDefaultCoord
)
1929 constr
->top
.SetValue(y
);
1930 constr
->top
.SetDone(true);
1935 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
1937 wxLayoutConstraints
*constr
= GetConstraints();
1940 *w
= constr
->width
.GetValue();
1941 *h
= constr
->height
.GetValue();
1947 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
1949 wxLayoutConstraints
*constr
= GetConstraints();
1952 *w
= constr
->width
.GetValue();
1953 *h
= constr
->height
.GetValue();
1956 GetClientSize(w
, h
);
1959 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
1961 wxLayoutConstraints
*constr
= GetConstraints();
1964 *x
= constr
->left
.GetValue();
1965 *y
= constr
->top
.GetValue();
1971 #endif // wxUSE_CONSTRAINTS
1973 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
1975 // don't do it for the dialogs/frames - they float independently of their
1977 if ( !IsTopLevel() )
1979 wxWindow
*parent
= GetParent();
1980 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
1982 wxPoint
pt(parent
->GetClientAreaOrigin());
1989 // ----------------------------------------------------------------------------
1990 // do Update UI processing for child controls
1991 // ----------------------------------------------------------------------------
1993 void wxWindowBase::UpdateWindowUI(long flags
)
1995 wxUpdateUIEvent
event(GetId());
1996 event
.SetEventObject(this);
1998 if ( GetEventHandler()->ProcessEvent(event
) )
2000 DoUpdateWindowUI(event
);
2003 if (flags
& wxUPDATE_UI_RECURSE
)
2005 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2008 wxWindow
* child
= (wxWindow
*) node
->GetData();
2009 child
->UpdateWindowUI(flags
);
2010 node
= node
->GetNext();
2015 // do the window-specific processing after processing the update event
2016 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2018 if ( event
.GetSetEnabled() )
2019 Enable(event
.GetEnabled());
2021 if ( event
.GetSetShown() )
2022 Show(event
.GetShown());
2026 // call internal idle recursively
2027 // may be obsolete (wait until OnIdle scheme stabilises)
2028 void wxWindowBase::ProcessInternalIdle()
2032 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2035 wxWindow
*child
= node
->GetData();
2036 child
->ProcessInternalIdle();
2037 node
= node
->GetNext();
2042 // ----------------------------------------------------------------------------
2043 // dialog units translations
2044 // ----------------------------------------------------------------------------
2046 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
)
2048 int charWidth
= GetCharWidth();
2049 int charHeight
= GetCharHeight();
2050 wxPoint pt2
= wxDefaultPosition
;
2051 if (pt
.x
!= wxDefaultCoord
)
2052 pt2
.x
= (int) ((pt
.x
* 4) / charWidth
);
2053 if (pt
.y
!= wxDefaultCoord
)
2054 pt2
.y
= (int) ((pt
.y
* 8) / charHeight
);
2059 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
)
2061 int charWidth
= GetCharWidth();
2062 int charHeight
= GetCharHeight();
2063 wxPoint pt2
= wxDefaultPosition
;
2064 if (pt
.x
!= wxDefaultCoord
)
2065 pt2
.x
= (int) ((pt
.x
* charWidth
) / 4);
2066 if (pt
.y
!= wxDefaultCoord
)
2067 pt2
.y
= (int) ((pt
.y
* charHeight
) / 8);
2072 // ----------------------------------------------------------------------------
2074 // ----------------------------------------------------------------------------
2076 // propagate the colour change event to the subwindows
2077 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& event
)
2079 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2082 // Only propagate to non-top-level windows
2083 wxWindow
*win
= node
->GetData();
2084 if ( !win
->IsTopLevel() )
2086 wxSysColourChangedEvent event2
;
2087 event
.SetEventObject(win
);
2088 win
->GetEventHandler()->ProcessEvent(event2
);
2091 node
= node
->GetNext();
2097 // the default action is to populate dialog with data when it's created,
2098 // and nudge the UI into displaying itself correctly in case
2099 // we've turned the wxUpdateUIEvents frequency down low.
2100 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2102 TransferDataToWindow();
2104 // Update the UI at this point
2105 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2108 // methods for drawing the sizers in a visible way
2111 static void DrawSizers(wxWindowBase
*win
);
2113 static void DrawBorder(wxWindowBase
*win
, const wxRect
& rect
, bool fill
= false)
2115 wxClientDC
dc((wxWindow
*)win
);
2116 dc
.SetPen(*wxRED_PEN
);
2117 dc
.SetBrush(fill
? wxBrush(*wxRED
, wxCROSSDIAG_HATCH
): *wxTRANSPARENT_BRUSH
);
2118 dc
.DrawRectangle(rect
.Deflate(1, 1));
2121 static void DrawSizer(wxWindowBase
*win
, wxSizer
*sizer
)
2123 const wxSizerItemList
& items
= sizer
->GetChildren();
2124 for ( wxSizerItemList::const_iterator i
= items
.begin(),
2129 wxSizerItem
*item
= *i
;
2130 if ( item
->IsSizer() )
2132 DrawBorder(win
, item
->GetRect().Deflate(2));
2133 DrawSizer(win
, item
->GetSizer());
2135 else if ( item
->IsSpacer() )
2137 DrawBorder(win
, item
->GetRect().Deflate(2), true);
2139 else if ( item
->IsWindow() )
2141 DrawSizers(item
->GetWindow());
2146 static void DrawSizers(wxWindowBase
*win
)
2148 wxSizer
*sizer
= win
->GetSizer();
2151 DrawBorder(win
, win
->GetClientSize());
2152 DrawSizer(win
, sizer
);
2154 else // no sizer, still recurse into the children
2156 const wxWindowList
& children
= win
->GetChildren();
2157 for ( wxWindowList::const_iterator i
= children
.begin(),
2158 end
= children
.end();
2167 #endif // __WXDEBUG__
2169 // process special middle clicks
2170 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2172 if ( event
.ControlDown() && event
.AltDown() )
2175 // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
2176 if ( event
.ShiftDown() )
2181 #endif // __WXDEBUG__
2184 // don't translate these strings, they're for diagnostics purposes only
2186 msg
.Printf(_T("wxWidgets Library (%s port)\n")
2187 _T("Version %d.%d.%d%s%s, compiled at %s %s%s\n")
2188 _T("Copyright (c) 1995-2006 wxWidgets team"),
2189 wxPlatformInfo().GetPortIdName().c_str(),
2206 wxString::Format(_T("\nagainst GTK+ %d.%d.%d. Runtime GTK+ version: %d.%d.%d"), GTK_MAJOR_VERSION
, GTK_MINOR_VERSION
, GTK_MICRO_VERSION
, gtk_major_version
, gtk_minor_version
, gtk_micro_version
).c_str()
2212 wxMessageBox(msg
, _T("wxWidgets information"),
2213 wxICON_INFORMATION
| wxOK
,
2217 #endif // wxUSE_MSGDLG
2223 // ----------------------------------------------------------------------------
2225 // ----------------------------------------------------------------------------
2227 #if wxUSE_ACCESSIBILITY
2228 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2230 if (m_accessible
&& (accessible
!= m_accessible
))
2231 delete m_accessible
;
2232 m_accessible
= accessible
;
2234 m_accessible
->SetWindow((wxWindow
*) this);
2237 // Returns the accessible object, creating if necessary.
2238 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2241 m_accessible
= CreateAccessible();
2242 return m_accessible
;
2245 // Override to create a specific accessible object.
2246 wxAccessible
* wxWindowBase::CreateAccessible()
2248 return new wxWindowAccessible((wxWindow
*) this);
2253 // ----------------------------------------------------------------------------
2254 // list classes implementation
2255 // ----------------------------------------------------------------------------
2259 #include "wx/listimpl.cpp"
2260 WX_DEFINE_LIST(wxWindowList
)
2264 void wxWindowListNode::DeleteData()
2266 delete (wxWindow
*)GetData();
2271 // ----------------------------------------------------------------------------
2273 // ----------------------------------------------------------------------------
2275 wxBorder
wxWindowBase::GetBorder(long flags
) const
2277 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
2278 if ( border
== wxBORDER_DEFAULT
)
2280 border
= GetDefaultBorder();
2286 wxBorder
wxWindowBase::GetDefaultBorder() const
2288 return wxBORDER_NONE
;
2291 // ----------------------------------------------------------------------------
2293 // ----------------------------------------------------------------------------
2295 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
2297 // here we just check if the point is inside the window or not
2299 // check the top and left border first
2300 bool outside
= x
< 0 || y
< 0;
2303 // check the right and bottom borders too
2304 wxSize size
= GetSize();
2305 outside
= x
>= size
.x
|| y
>= size
.y
;
2308 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
2311 // ----------------------------------------------------------------------------
2313 // ----------------------------------------------------------------------------
2315 struct WXDLLEXPORT wxWindowNext
2319 } *wxWindowBase::ms_winCaptureNext
= NULL
;
2320 wxWindow
*wxWindowBase::ms_winCaptureCurrent
= NULL
;
2321 bool wxWindowBase::ms_winCaptureChanging
= false;
2323 void wxWindowBase::CaptureMouse()
2325 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), wx_static_cast(void*, this));
2327 wxASSERT_MSG( !ms_winCaptureChanging
, _T("recursive CaptureMouse call?") );
2329 ms_winCaptureChanging
= true;
2331 wxWindow
*winOld
= GetCapture();
2334 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
2337 wxWindowNext
*item
= new wxWindowNext
;
2339 item
->next
= ms_winCaptureNext
;
2340 ms_winCaptureNext
= item
;
2342 //else: no mouse capture to save
2345 ms_winCaptureCurrent
= (wxWindow
*)this;
2347 ms_winCaptureChanging
= false;
2350 void wxWindowBase::ReleaseMouse()
2352 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), wx_static_cast(void*, this));
2354 wxASSERT_MSG( !ms_winCaptureChanging
, _T("recursive ReleaseMouse call?") );
2356 wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2358 ms_winCaptureChanging
= true;
2361 ms_winCaptureCurrent
= NULL
;
2363 if ( ms_winCaptureNext
)
2365 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
2366 ms_winCaptureCurrent
= ms_winCaptureNext
->win
;
2368 wxWindowNext
*item
= ms_winCaptureNext
;
2369 ms_winCaptureNext
= item
->next
;
2372 //else: stack is empty, no previous capture
2374 ms_winCaptureChanging
= false;
2376 wxLogTrace(_T("mousecapture"),
2377 (const wxChar
*) _T("After ReleaseMouse() mouse is captured by %p"),
2378 wx_static_cast(void*, GetCapture()));
2381 static void DoNotifyWindowAboutCaptureLost(wxWindow
*win
)
2383 wxMouseCaptureLostEvent
event(win
->GetId());
2384 event
.SetEventObject(win
);
2385 if ( !win
->GetEventHandler()->ProcessEvent(event
) )
2387 wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") );
2392 void wxWindowBase::NotifyCaptureLost()
2394 // don't do anything if capture lost was expected, i.e. resulted from
2395 // a wx call to ReleaseMouse or CaptureMouse:
2396 if ( ms_winCaptureChanging
)
2399 // if the capture was lost unexpectedly, notify every window that has
2400 // capture (on stack or current) about it and clear the stack:
2402 if ( ms_winCaptureCurrent
)
2404 DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent
);
2405 ms_winCaptureCurrent
= NULL
;
2408 while ( ms_winCaptureNext
)
2410 wxWindowNext
*item
= ms_winCaptureNext
;
2411 ms_winCaptureNext
= item
->next
;
2413 DoNotifyWindowAboutCaptureLost(item
->win
);
2422 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
2423 int WXUNUSED(modifiers
),
2424 int WXUNUSED(keycode
))
2430 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
2436 #endif // wxUSE_HOTKEY
2438 void wxWindowBase::SendDestroyEvent()
2440 wxWindowDestroyEvent event
;
2441 event
.SetEventObject(this);
2442 event
.SetId(GetId());
2443 GetEventHandler()->ProcessEvent(event
);
2446 // ----------------------------------------------------------------------------
2448 // ----------------------------------------------------------------------------
2450 bool wxWindowBase::TryValidator(wxEvent
& wxVALIDATOR_PARAM(event
))
2452 #if wxUSE_VALIDATORS
2453 // Can only use the validator of the window which
2454 // is receiving the event
2455 if ( event
.GetEventObject() == this )
2457 wxValidator
*validator
= GetValidator();
2458 if ( validator
&& validator
->ProcessEvent(event
) )
2463 #endif // wxUSE_VALIDATORS
2468 bool wxWindowBase::TryParent(wxEvent
& event
)
2470 // carry on up the parent-child hierarchy if the propagation count hasn't
2472 if ( event
.ShouldPropagate() )
2474 // honour the requests to stop propagation at this window: this is
2475 // used by the dialogs, for example, to prevent processing the events
2476 // from the dialog controls in the parent frame which rarely, if ever,
2478 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
2480 wxWindow
*parent
= GetParent();
2481 if ( parent
&& !parent
->IsBeingDeleted() )
2483 wxPropagateOnce
propagateOnce(event
);
2485 return parent
->GetEventHandler()->ProcessEvent(event
);
2490 return wxEvtHandler::TryParent(event
);
2493 // ----------------------------------------------------------------------------
2494 // keyboard navigation
2495 // ----------------------------------------------------------------------------
2497 // Navigates in the specified direction.
2498 bool wxWindowBase::Navigate(int flags
)
2500 wxNavigationKeyEvent eventNav
;
2501 eventNav
.SetFlags(flags
);
2502 eventNav
.SetEventObject(this);
2503 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
2510 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
2512 // check that we're not a top level window
2513 wxCHECK_RET( GetParent(),
2514 _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
2516 // detect the special case when we have nothing to do anyhow and when the
2517 // code below wouldn't work
2521 // find the target window in the siblings list
2522 wxWindowList
& siblings
= GetParent()->GetChildren();
2523 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
2524 wxCHECK_RET( i
, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
2526 // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
2527 // can't just move the node around
2528 wxWindow
*self
= (wxWindow
*)this;
2529 siblings
.DeleteObject(self
);
2530 if ( move
== MoveAfter
)
2537 siblings
.Insert(i
, self
);
2539 else // MoveAfter and win was the last sibling
2541 siblings
.Append(self
);
2545 // ----------------------------------------------------------------------------
2547 // ----------------------------------------------------------------------------
2549 /*static*/ wxWindow
* wxWindowBase::FindFocus()
2551 wxWindowBase
*win
= DoFindFocus();
2552 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
2555 // ----------------------------------------------------------------------------
2557 // ----------------------------------------------------------------------------
2559 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
2561 while ( win
&& !win
->IsTopLevel() )
2562 win
= win
->GetParent();
2567 #if wxUSE_ACCESSIBILITY
2568 // ----------------------------------------------------------------------------
2569 // accessible object for windows
2570 // ----------------------------------------------------------------------------
2572 // Can return either a child object, or an integer
2573 // representing the child element, starting from 1.
2574 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
2576 wxASSERT( GetWindow() != NULL
);
2580 return wxACC_NOT_IMPLEMENTED
;
2583 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
2584 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
2586 wxASSERT( GetWindow() != NULL
);
2590 wxWindow
* win
= NULL
;
2597 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
2599 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
2606 rect
= win
->GetRect();
2607 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
2608 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
2612 return wxACC_NOT_IMPLEMENTED
;
2615 // Navigates from fromId to toId/toObject.
2616 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
2617 int* WXUNUSED(toId
), wxAccessible
** toObject
)
2619 wxASSERT( GetWindow() != NULL
);
2625 case wxNAVDIR_FIRSTCHILD
:
2627 if (GetWindow()->GetChildren().GetCount() == 0)
2629 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
2630 *toObject
= childWindow
->GetOrCreateAccessible();
2634 case wxNAVDIR_LASTCHILD
:
2636 if (GetWindow()->GetChildren().GetCount() == 0)
2638 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
2639 *toObject
= childWindow
->GetOrCreateAccessible();
2643 case wxNAVDIR_RIGHT
:
2647 wxWindowList::compatibility_iterator node
=
2648 wxWindowList::compatibility_iterator();
2651 // Can't navigate to sibling of this window
2652 // if we're a top-level window.
2653 if (!GetWindow()->GetParent())
2654 return wxACC_NOT_IMPLEMENTED
;
2656 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2660 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2661 node
= GetWindow()->GetChildren().Item(fromId
-1);
2664 if (node
&& node
->GetNext())
2666 wxWindow
* nextWindow
= node
->GetNext()->GetData();
2667 *toObject
= nextWindow
->GetOrCreateAccessible();
2675 case wxNAVDIR_PREVIOUS
:
2677 wxWindowList::compatibility_iterator node
=
2678 wxWindowList::compatibility_iterator();
2681 // Can't navigate to sibling of this window
2682 // if we're a top-level window.
2683 if (!GetWindow()->GetParent())
2684 return wxACC_NOT_IMPLEMENTED
;
2686 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2690 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2691 node
= GetWindow()->GetChildren().Item(fromId
-1);
2694 if (node
&& node
->GetPrevious())
2696 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
2697 *toObject
= previousWindow
->GetOrCreateAccessible();
2705 return wxACC_NOT_IMPLEMENTED
;
2708 // Gets the name of the specified object.
2709 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
2711 wxASSERT( GetWindow() != NULL
);
2717 // If a child, leave wxWidgets to call the function on the actual
2720 return wxACC_NOT_IMPLEMENTED
;
2722 // This will eventually be replaced by specialised
2723 // accessible classes, one for each kind of wxWidgets
2724 // control or window.
2726 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
2727 title
= ((wxButton
*) GetWindow())->GetLabel();
2730 title
= GetWindow()->GetName();
2738 return wxACC_NOT_IMPLEMENTED
;
2741 // Gets the number of children.
2742 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
2744 wxASSERT( GetWindow() != NULL
);
2748 *childId
= (int) GetWindow()->GetChildren().GetCount();
2752 // Gets the specified child (starting from 1).
2753 // If *child is NULL and return value is wxACC_OK,
2754 // this means that the child is a simple element and
2755 // not an accessible object.
2756 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
2758 wxASSERT( GetWindow() != NULL
);
2768 if (childId
> (int) GetWindow()->GetChildren().GetCount())
2771 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
2772 *child
= childWindow
->GetOrCreateAccessible();
2779 // Gets the parent, or NULL.
2780 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
2782 wxASSERT( GetWindow() != NULL
);
2786 wxWindow
* parentWindow
= GetWindow()->GetParent();
2794 *parent
= parentWindow
->GetOrCreateAccessible();
2802 // Performs the default action. childId is 0 (the action for this object)
2803 // or > 0 (the action for a child).
2804 // Return wxACC_NOT_SUPPORTED if there is no default action for this
2805 // window (e.g. an edit control).
2806 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
2808 wxASSERT( GetWindow() != NULL
);
2812 return wxACC_NOT_IMPLEMENTED
;
2815 // Gets the default action for this object (0) or > 0 (the action for a child).
2816 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
2817 // string if there is no action.
2818 // The retrieved string describes the action that is performed on an object,
2819 // not what the object does as a result. For example, a toolbar button that prints
2820 // a document has a default action of "Press" rather than "Prints the current document."
2821 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
2823 wxASSERT( GetWindow() != NULL
);
2827 return wxACC_NOT_IMPLEMENTED
;
2830 // Returns the description for this object or a child.
2831 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
2833 wxASSERT( GetWindow() != NULL
);
2837 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
2843 return wxACC_NOT_IMPLEMENTED
;
2846 // Returns help text for this object or a child, similar to tooltip text.
2847 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
2849 wxASSERT( GetWindow() != NULL
);
2853 wxString
ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition
, wxHelpEvent::Origin_Keyboard
));
2859 return wxACC_NOT_IMPLEMENTED
;
2862 // Returns the keyboard shortcut for this object or child.
2863 // Return e.g. ALT+K
2864 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
2866 wxASSERT( GetWindow() != NULL
);
2870 return wxACC_NOT_IMPLEMENTED
;
2873 // Returns a role constant.
2874 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
2876 wxASSERT( GetWindow() != NULL
);
2880 // If a child, leave wxWidgets to call the function on the actual
2883 return wxACC_NOT_IMPLEMENTED
;
2885 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2886 return wxACC_NOT_IMPLEMENTED
;
2888 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2889 return wxACC_NOT_IMPLEMENTED
;
2892 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2893 return wxACC_NOT_IMPLEMENTED
;
2896 //*role = wxROLE_SYSTEM_CLIENT;
2897 *role
= wxROLE_SYSTEM_CLIENT
;
2901 return wxACC_NOT_IMPLEMENTED
;
2905 // Returns a state constant.
2906 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
2908 wxASSERT( GetWindow() != NULL
);
2912 // If a child, leave wxWidgets to call the function on the actual
2915 return wxACC_NOT_IMPLEMENTED
;
2917 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2918 return wxACC_NOT_IMPLEMENTED
;
2921 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2922 return wxACC_NOT_IMPLEMENTED
;
2925 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2926 return wxACC_NOT_IMPLEMENTED
;
2933 return wxACC_NOT_IMPLEMENTED
;
2937 // Returns a localized string representing the value for the object
2939 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
2941 wxASSERT( GetWindow() != NULL
);
2945 return wxACC_NOT_IMPLEMENTED
;
2948 // Selects the object or child.
2949 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
2951 wxASSERT( GetWindow() != NULL
);
2955 return wxACC_NOT_IMPLEMENTED
;
2958 // Gets the window with the keyboard focus.
2959 // If childId is 0 and child is NULL, no object in
2960 // this subhierarchy has the focus.
2961 // If this object has the focus, child should be 'this'.
2962 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
2964 wxASSERT( GetWindow() != NULL
);
2968 return wxACC_NOT_IMPLEMENTED
;
2971 // Gets a variant representing the selected children
2973 // Acceptable values:
2974 // - a null variant (IsNull() returns true)
2975 // - a list variant (GetType() == wxT("list")
2976 // - an integer representing the selected child element,
2977 // or 0 if this object is selected (GetType() == wxT("long")
2978 // - a "void*" pointer to a wxAccessible child object
2979 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
2981 wxASSERT( GetWindow() != NULL
);
2985 return wxACC_NOT_IMPLEMENTED
;
2988 #endif // wxUSE_ACCESSIBILITY
2990 // ----------------------------------------------------------------------------
2992 // ----------------------------------------------------------------------------
2995 wxWindowBase::AdjustForLayoutDirection(wxCoord x
,
2997 wxCoord widthTotal
) const
2999 if ( GetLayoutDirection() == wxLayout_RightToLeft
)
3001 x
= widthTotal
- x
- width
;