1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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"
33 #include "wx/window.h"
34 #include "wx/control.h"
35 #include "wx/checkbox.h"
36 #include "wx/radiobut.h"
37 #include "wx/statbox.h"
38 #include "wx/textctrl.h"
39 #include "wx/settings.h"
40 #include "wx/dialog.h"
41 #include "wx/msgdlg.h"
42 #include "wx/statusbr.h"
43 #include "wx/toolbar.h"
44 #include "wx/dcclient.h"
47 #if defined(__WXMAC__) && wxUSE_SCROLLBAR
48 #include "wx/scrolbar.h"
52 #include "wx/layout.h"
53 #endif // wxUSE_CONSTRAINTS
57 #if wxUSE_DRAG_AND_DROP
59 #endif // wxUSE_DRAG_AND_DROP
61 #if wxUSE_ACCESSIBILITY
62 #include "wx/access.h"
66 #include "wx/cshelp.h"
70 #include "wx/tooltip.h"
71 #endif // wxUSE_TOOLTIPS
78 #include "wx/display.h"
81 #if wxUSE_SYSTEM_OPTIONS
82 #include "wx/sysopt.h"
85 // ----------------------------------------------------------------------------
87 // ----------------------------------------------------------------------------
89 #if defined(__WXPALMOS__)
90 int wxWindowBase::ms_lastControlId
= 32767;
91 #elif defined(__WXPM__)
92 int wxWindowBase::ms_lastControlId
= 2000;
94 int wxWindowBase::ms_lastControlId
= -200;
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
)
114 // ============================================================================
115 // implementation of the common functionality of the wxWindow class
116 // ============================================================================
118 // ----------------------------------------------------------------------------
120 // ----------------------------------------------------------------------------
122 // the default initialization
123 wxWindowBase::wxWindowBase()
125 // no window yet, no parent nor children
126 m_parent
= (wxWindow
*)NULL
;
127 m_windowId
= wxID_ANY
;
129 // no constraints on the minimal window size
131 m_maxWidth
= wxDefaultCoord
;
133 m_maxHeight
= wxDefaultCoord
;
135 // invalidiated cache value
136 m_bestSizeCache
= wxDefaultSize
;
138 // window are created enabled and visible by default
142 // the default event handler is just this window
143 m_eventHandler
= this;
147 m_windowValidator
= (wxValidator
*) NULL
;
148 #endif // wxUSE_VALIDATORS
150 // the colours/fonts are default for now, so leave m_font,
151 // m_backgroundColour and m_foregroundColour uninitialized and set those
157 m_inheritFont
= false;
163 m_backgroundStyle
= wxBG_STYLE_SYSTEM
;
165 #if wxUSE_CONSTRAINTS
166 // no constraints whatsoever
167 m_constraints
= (wxLayoutConstraints
*) NULL
;
168 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
169 #endif // wxUSE_CONSTRAINTS
171 m_windowSizer
= (wxSizer
*) NULL
;
172 m_containingSizer
= (wxSizer
*) NULL
;
173 m_autoLayout
= false;
175 #if wxUSE_DRAG_AND_DROP
176 m_dropTarget
= (wxDropTarget
*)NULL
;
177 #endif // wxUSE_DRAG_AND_DROP
180 m_tooltip
= (wxToolTip
*)NULL
;
181 #endif // wxUSE_TOOLTIPS
184 m_caret
= (wxCaret
*)NULL
;
185 #endif // wxUSE_CARET
188 m_hasCustomPalette
= false;
189 #endif // wxUSE_PALETTE
191 #if wxUSE_ACCESSIBILITY
195 m_virtualSize
= wxDefaultSize
;
198 m_maxVirtualWidth
= wxDefaultCoord
;
200 m_maxVirtualHeight
= wxDefaultCoord
;
202 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
203 #if wxUSE_SYSTEM_OPTIONS
204 if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT
) )
206 m_windowVariant
= (wxWindowVariant
) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT
) ;
210 // Whether we're using the current theme for this window (wxGTK only for now)
211 m_themeEnabled
= false;
213 // VZ: this one shouldn't exist...
214 m_isBeingDeleted
= false;
216 // Reserved for future use
217 m_windowReserved
= NULL
;
220 // common part of window creation process
221 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
223 const wxPoint
& WXUNUSED(pos
),
224 const wxSize
& WXUNUSED(size
),
226 const wxValidator
& wxVALIDATOR_PARAM(validator
),
227 const wxString
& name
)
230 // wxGTK doesn't allow to create controls with static box as the parent so
231 // this will result in a crash when the program is ported to wxGTK so warn
234 // if you get this assert, the correct solution is to create the controls
235 // as siblings of the static box
236 wxASSERT_MSG( !parent
|| !wxDynamicCast(parent
, wxStaticBox
),
237 _T("wxStaticBox can't be used as a window parent!") );
238 #endif // wxUSE_STATBOX
240 // ids are limited to 16 bits under MSW so if you care about portability,
241 // it's not a good idea to use ids out of this range (and negative ids are
242 // reserved for wxWidgets own usage)
243 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767),
244 _T("invalid id value") );
246 // generate a new id if the user doesn't care about it
247 m_windowId
= id
== wxID_ANY
? NewControlId() : id
;
250 SetWindowStyleFlag(style
);
254 SetValidator(validator
);
255 #endif // wxUSE_VALIDATORS
257 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
258 // have it too - like this it's possible to set it only in the top level
259 // dialog/frame and all children will inherit it by defult
260 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
262 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
268 // ----------------------------------------------------------------------------
270 // ----------------------------------------------------------------------------
273 wxWindowBase::~wxWindowBase()
275 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
277 // FIXME if these 2 cases result from programming errors in the user code
278 // we should probably assert here instead of silently fixing them
280 // Just in case the window has been Closed, but we're then deleting
281 // immediately: don't leave dangling pointers.
282 wxPendingDelete
.DeleteObject(this);
284 // Just in case we've loaded a top-level window via LoadNativeDialog but
285 // we weren't a dialog class
286 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
288 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
290 // reset the dangling pointer our parent window may keep to us
293 if ( m_parent
->GetDefaultItem() == this )
295 m_parent
->SetDefaultItem(NULL
);
298 m_parent
->RemoveChild(this);
303 #endif // wxUSE_CARET
306 delete m_windowValidator
;
307 #endif // wxUSE_VALIDATORS
309 #if wxUSE_CONSTRAINTS
310 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
311 // at deleted windows as they delete themselves.
312 DeleteRelatedConstraints();
316 // This removes any dangling pointers to this window in other windows'
317 // constraintsInvolvedIn lists.
318 UnsetConstraints(m_constraints
);
319 delete m_constraints
;
320 m_constraints
= NULL
;
322 #endif // wxUSE_CONSTRAINTS
324 if ( m_containingSizer
)
325 m_containingSizer
->Detach( (wxWindow
*)this );
327 delete m_windowSizer
;
329 #if wxUSE_DRAG_AND_DROP
331 #endif // wxUSE_DRAG_AND_DROP
335 #endif // wxUSE_TOOLTIPS
337 #if wxUSE_ACCESSIBILITY
342 bool wxWindowBase::Destroy()
349 bool wxWindowBase::Close(bool force
)
351 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
352 event
.SetEventObject(this);
353 event
.SetCanVeto(!force
);
355 // return false if window wasn't closed because the application vetoed the
357 return GetEventHandler()->ProcessEvent(event
) && !event
.GetVeto();
360 bool wxWindowBase::DestroyChildren()
362 wxWindowList::compatibility_iterator node
;
365 // we iterate until the list becomes empty
366 node
= GetChildren().GetFirst();
370 wxWindow
*child
= node
->GetData();
372 // note that we really want to call delete and not ->Destroy() here
373 // because we want to delete the child immediately, before we are
374 // deleted, and delayed deletion would result in problems as our (top
375 // level) child could outlive its parent
378 wxASSERT_MSG( !GetChildren().Find(child
),
379 wxT("child didn't remove itself using RemoveChild()") );
385 // ----------------------------------------------------------------------------
386 // size/position related methods
387 // ----------------------------------------------------------------------------
389 // centre the window with respect to its parent in either (or both) directions
390 void wxWindowBase::Centre(int direction
)
392 // the position/size of the parent window or of the entire screen
394 int widthParent
, heightParent
;
396 wxWindow
*parent
= NULL
;
397 wxTopLevelWindow
*winTop
= NULL
;
399 if ( !(direction
& wxCENTRE_ON_SCREEN
) )
401 // find the parent to centre this window on: it should be the
402 // immediate parent for the controls but the top level parent for the
403 // top level windows (like dialogs)
404 parent
= GetParent();
407 while ( parent
&& !parent
->IsTopLevel() )
409 parent
= parent
->GetParent();
413 // there is no wxTopLevelWindow under wxMotif yet
415 // we shouldn't center the dialog on the iconized window: under
416 // Windows, for example, this places it completely off the screen
419 winTop
= wxDynamicCast(parent
, wxTopLevelWindow
);
420 if ( winTop
&& winTop
->IsIconized() )
426 #endif // __WXMOTIF__
428 // did we find the parent?
432 direction
|= wxCENTRE_ON_SCREEN
;
436 if ( direction
& wxCENTRE_ON_SCREEN
)
438 //RN: If we are using wxDisplay we get
439 //the dimensions of the monitor the window is on,
440 //otherwise we get the dimensions of the primary monitor
441 //FIXME: wxDisplay::GetFromWindow only implemented on MSW
442 #if wxUSE_DISPLAY && defined(__WXMSW__)
443 int nDisplay
= wxDisplay::GetFromWindow((wxWindow
*)this);
444 if(nDisplay
!= wxNOT_FOUND
)
446 wxDisplay
windowDisplay(nDisplay
);
447 wxRect displayRect
= windowDisplay
.GetGeometry();
448 widthParent
= displayRect
.width
;
449 heightParent
= displayRect
.height
;
453 // centre with respect to the whole screen
454 wxDisplaySize(&widthParent
, &heightParent
);
461 winTop
->GetRectForTopLevelChildren(&posParent
.x
, &posParent
.y
, &widthParent
, &heightParent
);
464 // centre on the parent
465 parent
->GetSize(&widthParent
, &heightParent
);
467 // adjust to the parents position
468 posParent
= parent
->GetPosition();
473 // centre inside the parents client rectangle
474 parent
->GetClientSize(&widthParent
, &heightParent
);
479 GetSize(&width
, &height
);
481 int xNew
= wxDefaultCoord
,
482 yNew
= wxDefaultCoord
;
484 if ( direction
& wxHORIZONTAL
)
485 xNew
= (widthParent
- width
)/2;
487 if ( direction
& wxVERTICAL
)
488 yNew
= (heightParent
- height
)/2;
493 // FIXME: This needs to get the client display rect of the display
494 // the window is (via wxDisplay::GetFromWindow).
496 // Base size of the visible dimensions of the display
497 // to take into account the taskbar. And the Mac menu bar at top.
498 wxRect clientrect
= wxGetClientDisplayRect();
500 // NB: in wxMSW, negative position may not necessarily mean "out of screen",
501 // but it may mean that the window is placed on other than the main
502 // display. Therefore we only make sure centered window is on the main display
503 // if the parent is at least partially present here.
504 if (posParent
.x
+ widthParent
>= 0) // if parent is (partially) on the main display
506 if (xNew
< clientrect
.GetLeft())
507 xNew
= clientrect
.GetLeft();
508 else if (xNew
+ width
> clientrect
.GetRight())
509 xNew
= clientrect
.GetRight() - width
;
511 if (posParent
.y
+ heightParent
>= 0) // if parent is (partially) on the main display
513 if (yNew
+ height
> clientrect
.GetBottom())
514 yNew
= clientrect
.GetBottom() - height
;
516 // Make certain that the title bar is initially visible
517 // always, even if this would push the bottom of the
518 // dialog off the visible area of the display
519 if (yNew
< clientrect
.GetTop())
520 yNew
= clientrect
.GetTop();
523 // move the window to this position (keeping the old size but using
524 // SetSize() and not Move() to allow xNew and/or yNew to be wxDefaultCoord)
525 SetSize(xNew
, yNew
, width
, height
, wxSIZE_ALLOW_MINUS_ONE
);
528 // fits the window around the children
529 void wxWindowBase::Fit()
531 if ( GetChildren().GetCount() > 0 )
533 SetSize(GetBestSize());
535 //else: do nothing if we have no children
538 // fits virtual size (ie. scrolled area etc.) around children
539 void wxWindowBase::FitInside()
541 if ( GetChildren().GetCount() > 0 )
543 SetVirtualSize( GetBestVirtualSize() );
547 // On Mac, scrollbars are explicitly children.
549 static bool wxHasRealChildren(const wxWindowBase
* win
)
551 int realChildCount
= 0;
553 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
555 node
= node
->GetNext() )
557 wxWindow
*win
= node
->GetData();
558 if ( !win
->IsTopLevel() && win
->IsShown() && !win
->IsKindOf(CLASSINFO(wxScrollBar
)))
561 return (realChildCount
> 0);
565 void wxWindowBase::InvalidateBestSize()
567 m_bestSizeCache
= wxDefaultSize
;
569 // parent's best size calculation may depend on its children's
570 // best sizes, so let's invalidate it as well to be safe:
572 m_parent
->InvalidateBestSize();
575 // return the size best suited for the current window
576 wxSize
wxWindowBase::DoGetBestSize() const
582 best
= GetWindowSizeForVirtualSize(m_windowSizer
->GetMinSize());
584 #if wxUSE_CONSTRAINTS
585 else if ( m_constraints
)
587 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
589 // our minimal acceptable size is such that all our windows fit inside
593 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
595 node
= node
->GetNext() )
597 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
600 // it's not normal that we have an unconstrained child, but
601 // what can we do about it?
605 int x
= c
->right
.GetValue(),
606 y
= c
->bottom
.GetValue();
614 // TODO: we must calculate the overlaps somehow, otherwise we
615 // will never return a size bigger than the current one :-(
618 best
= wxSize(maxX
, maxY
);
620 #endif // wxUSE_CONSTRAINTS
621 else if ( !GetChildren().empty()
623 && wxHasRealChildren(this)
627 // our minimal acceptable size is such that all our visible child windows fit inside
631 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
633 node
= node
->GetNext() )
635 wxWindow
*win
= node
->GetData();
636 if ( win
->IsTopLevel() || ( ! win
->IsShown() )
638 || wxDynamicCast(win
, wxStatusBar
)
639 #endif // wxUSE_STATUSBAR
642 // dialogs and frames lie in different top level windows -
643 // don't deal with them here; as for the status bars, they
644 // don't lie in the client area at all
649 win
->GetPosition(&wx
, &wy
);
651 // if the window hadn't been positioned yet, assume that it is in
653 if ( wx
== wxDefaultCoord
)
655 if ( wy
== wxDefaultCoord
)
658 win
->GetSize(&ww
, &wh
);
659 if ( wx
+ ww
> maxX
)
661 if ( wy
+ wh
> maxY
)
665 // for compatibility with the old versions and because it really looks
666 // slightly more pretty like this, add a pad
670 best
= wxSize(maxX
, maxY
);
672 else // ! has children
674 // for a generic window there is no natural best size so, if the
675 // minimal size is not set, use the current size but take care to
676 // remember it as minimal size for the next time because our best size
677 // should be constant: otherwise we could get into a situation when the
678 // window is initially at some size, then expanded to a larger size and
679 // then, when the containing window is shrunk back (because our initial
680 // best size had been used for computing the parent min size), we can't
681 // be shrunk back any more because our best size is now bigger
682 wxSize size
= GetMinSize();
683 if ( !size
.IsFullySpecified() )
685 size
.SetDefaults(GetSize());
686 wxConstCast(this, wxWindowBase
)->SetMinSize(size
);
689 // return as-is, unadjusted by the client size difference.
693 // Add any difference between size and client size
694 wxSize diff
= GetSize() - GetClientSize();
695 best
.x
+= wxMax(0, diff
.x
);
696 best
.y
+= wxMax(0, diff
.y
);
702 wxSize
wxWindowBase::GetBestFittingSize() const
704 // merge the best size with the min size, giving priority to the min size
705 wxSize min
= GetMinSize();
706 if (min
.x
== wxDefaultCoord
|| min
.y
== wxDefaultCoord
)
708 wxSize best
= GetBestSize();
709 if (min
.x
== wxDefaultCoord
) min
.x
= best
.x
;
710 if (min
.y
== wxDefaultCoord
) min
.y
= best
.y
;
716 void wxWindowBase::SetBestFittingSize(const wxSize
& size
)
718 // Set the min size to the size passed in. This will usually either be
719 // wxDefaultSize or the size passed to this window's ctor/Create function.
722 // Merge the size with the best size if needed
723 wxSize best
= GetBestFittingSize();
725 // If the current size doesn't match then change it
726 if (GetSize() != best
)
731 // by default the origin is not shifted
732 wxPoint
wxWindowBase::GetClientAreaOrigin() const
737 // set the min/max size of the window
738 void wxWindowBase::DoSetSizeHints(int minW
, int minH
,
740 int WXUNUSED(incW
), int WXUNUSED(incH
))
742 // setting min width greater than max width leads to infinite loops under
743 // X11 and generally doesn't make any sense, so don't allow it
744 wxCHECK_RET( (minW
== wxDefaultCoord
|| maxW
== wxDefaultCoord
|| minW
<= maxW
) &&
745 (minH
== wxDefaultCoord
|| maxH
== wxDefaultCoord
|| minH
<= maxH
),
746 _T("min width/height must be less than max width/height!") );
754 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
756 if ( m_windowVariant
!= variant
)
758 m_windowVariant
= variant
;
760 DoSetWindowVariant(variant
);
764 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
766 // adjust the font height to correspond to our new variant (notice that
767 // we're only called if something really changed)
768 wxFont font
= GetFont();
769 int size
= font
.GetPointSize();
772 case wxWINDOW_VARIANT_NORMAL
:
775 case wxWINDOW_VARIANT_SMALL
:
780 case wxWINDOW_VARIANT_MINI
:
785 case wxWINDOW_VARIANT_LARGE
:
791 wxFAIL_MSG(_T("unexpected window variant"));
795 font
.SetPointSize(size
);
799 void wxWindowBase::SetVirtualSizeHints( int minW
, int minH
,
802 m_minVirtualWidth
= minW
;
803 m_maxVirtualWidth
= maxW
;
804 m_minVirtualHeight
= minH
;
805 m_maxVirtualHeight
= maxH
;
808 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
810 if ( m_minVirtualWidth
!= wxDefaultCoord
&& m_minVirtualWidth
> x
)
811 x
= m_minVirtualWidth
;
812 if ( m_maxVirtualWidth
!= wxDefaultCoord
&& m_maxVirtualWidth
< x
)
813 x
= m_maxVirtualWidth
;
814 if ( m_minVirtualHeight
!= wxDefaultCoord
&& m_minVirtualHeight
> y
)
815 y
= m_minVirtualHeight
;
816 if ( m_maxVirtualHeight
!= wxDefaultCoord
&& m_maxVirtualHeight
< y
)
817 y
= m_maxVirtualHeight
;
819 m_virtualSize
= wxSize(x
, y
);
822 wxSize
wxWindowBase::DoGetVirtualSize() const
824 if ( m_virtualSize
.IsFullySpecified() )
825 return m_virtualSize
;
827 wxSize size
= GetClientSize();
828 if ( m_virtualSize
.x
!= wxDefaultCoord
)
829 size
.x
= m_virtualSize
.x
;
831 if ( m_virtualSize
.y
!= wxDefaultCoord
)
832 size
.y
= m_virtualSize
.y
;
837 // ----------------------------------------------------------------------------
838 // show/hide/enable/disable the window
839 // ----------------------------------------------------------------------------
841 bool wxWindowBase::Show(bool show
)
843 if ( show
!= m_isShown
)
855 bool wxWindowBase::Enable(bool enable
)
857 if ( enable
!= m_isEnabled
)
859 m_isEnabled
= enable
;
868 // ----------------------------------------------------------------------------
870 // ----------------------------------------------------------------------------
872 bool wxWindowBase::IsTopLevel() const
877 // ----------------------------------------------------------------------------
878 // reparenting the window
879 // ----------------------------------------------------------------------------
881 void wxWindowBase::AddChild(wxWindowBase
*child
)
883 wxCHECK_RET( child
, wxT("can't add a NULL child") );
885 // this should never happen and it will lead to a crash later if it does
886 // because RemoveChild() will remove only one node from the children list
887 // and the other(s) one(s) will be left with dangling pointers in them
888 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), _T("AddChild() called twice") );
890 GetChildren().Append((wxWindow
*)child
);
891 child
->SetParent(this);
894 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
896 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
898 GetChildren().DeleteObject((wxWindow
*)child
);
899 child
->SetParent(NULL
);
902 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
904 wxWindow
*oldParent
= GetParent();
905 if ( newParent
== oldParent
)
911 // unlink this window from the existing parent.
914 oldParent
->RemoveChild(this);
918 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
921 // add it to the new one
924 newParent
->AddChild(this);
928 wxTopLevelWindows
.Append((wxWindow
*)this);
934 // ----------------------------------------------------------------------------
935 // event handler stuff
936 // ----------------------------------------------------------------------------
938 void wxWindowBase::PushEventHandler(wxEvtHandler
*handler
)
940 wxEvtHandler
*handlerOld
= GetEventHandler();
942 handler
->SetNextHandler(handlerOld
);
945 GetEventHandler()->SetPreviousHandler(handler
);
947 SetEventHandler(handler
);
950 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
952 wxEvtHandler
*handlerA
= GetEventHandler();
955 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
956 handlerA
->SetNextHandler((wxEvtHandler
*)NULL
);
959 handlerB
->SetPreviousHandler((wxEvtHandler
*)NULL
);
960 SetEventHandler(handlerB
);
965 handlerA
= (wxEvtHandler
*)NULL
;
972 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handler
)
974 wxCHECK_MSG( handler
, false, _T("RemoveEventHandler(NULL) called") );
976 wxEvtHandler
*handlerPrev
= NULL
,
977 *handlerCur
= GetEventHandler();
980 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
982 if ( handlerCur
== handler
)
986 handlerPrev
->SetNextHandler(handlerNext
);
990 SetEventHandler(handlerNext
);
995 handlerNext
->SetPreviousHandler ( handlerPrev
);
998 handler
->SetNextHandler(NULL
);
999 handler
->SetPreviousHandler(NULL
);
1004 handlerPrev
= handlerCur
;
1005 handlerCur
= handlerNext
;
1008 wxFAIL_MSG( _T("where has the event handler gone?") );
1013 // ----------------------------------------------------------------------------
1014 // colours, fonts &c
1015 // ----------------------------------------------------------------------------
1017 void wxWindowBase::InheritAttributes()
1019 const wxWindowBase
* const parent
= GetParent();
1023 // we only inherit attributes which had been explicitly set for the parent
1024 // which ensures that this only happens if the user really wants it and
1025 // not by default which wouldn't make any sense in modern GUIs where the
1026 // controls don't all use the same fonts (nor colours)
1027 if ( parent
->m_inheritFont
&& !m_hasFont
)
1028 SetFont(parent
->GetFont());
1030 // in addition, there is a possibility to explicitly forbid inheriting
1031 // colours at each class level by overriding ShouldInheritColours()
1032 if ( ShouldInheritColours() )
1034 if ( parent
->m_inheritFgCol
&& !m_hasFgCol
)
1035 SetForegroundColour(parent
->GetForegroundColour());
1037 // inheriting (solid) background colour is wrong as it totally breaks
1038 // any kind of themed backgrounds
1040 // instead, the controls should use the same background as their parent
1041 // (ideally by not drawing it at all)
1043 if ( parent
->m_inheritBgCol
&& !m_hasBgCol
)
1044 SetBackgroundColour(parent
->GetBackgroundColour());
1049 /* static */ wxVisualAttributes
1050 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
1052 // it is important to return valid values for all attributes from here,
1053 // GetXXX() below rely on this
1054 wxVisualAttributes attrs
;
1055 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
1056 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
1058 // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
1059 // the usual background colour than wxSYS_COLOUR_BTNFACE.
1060 // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
1061 // colour on other platforms.
1063 #if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
1064 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW
);
1066 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
1071 wxColour
wxWindowBase::GetBackgroundColour() const
1073 if ( !m_backgroundColour
.Ok() )
1075 wxASSERT_MSG( !m_hasBgCol
, _T("we have invalid explicit bg colour?") );
1077 // get our default background colour
1078 wxColour colBg
= GetDefaultAttributes().colBg
;
1080 // we must return some valid colour to avoid redoing this every time
1081 // and also to avoid surprizing the applications written for older
1082 // wxWidgets versions where GetBackgroundColour() always returned
1083 // something -- so give them something even if it doesn't make sense
1084 // for this window (e.g. it has a themed background)
1086 colBg
= GetClassDefaultAttributes().colBg
;
1091 return m_backgroundColour
;
1094 wxColour
wxWindowBase::GetForegroundColour() const
1096 // logic is the same as above
1097 if ( !m_hasFgCol
&& !m_foregroundColour
.Ok() )
1099 wxASSERT_MSG( !m_hasFgCol
, _T("we have invalid explicit fg colour?") );
1101 wxColour colFg
= GetDefaultAttributes().colFg
;
1104 colFg
= GetClassDefaultAttributes().colFg
;
1109 return m_foregroundColour
;
1112 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1114 if ( colour
== m_backgroundColour
)
1117 m_hasBgCol
= colour
.Ok();
1118 if ( m_backgroundStyle
!= wxBG_STYLE_CUSTOM
)
1119 m_backgroundStyle
= m_hasBgCol
? wxBG_STYLE_COLOUR
: wxBG_STYLE_SYSTEM
;
1121 m_inheritBgCol
= m_hasBgCol
;
1122 m_backgroundColour
= colour
;
1123 SetThemeEnabled( !m_hasBgCol
&& !m_foregroundColour
.Ok() );
1127 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1129 if (colour
== m_foregroundColour
)
1132 m_hasFgCol
= colour
.Ok();
1133 m_inheritFgCol
= m_hasFgCol
;
1134 m_foregroundColour
= colour
;
1135 SetThemeEnabled( !m_hasFgCol
&& !m_backgroundColour
.Ok() );
1139 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1141 // setting an invalid cursor is ok, it means that we don't have any special
1143 if ( m_cursor
== cursor
)
1154 wxFont
wxWindowBase::GetFont() const
1156 // logic is the same as in GetBackgroundColour()
1159 wxASSERT_MSG( !m_hasFont
, _T("we have invalid explicit font?") );
1161 wxFont font
= GetDefaultAttributes().font
;
1163 font
= GetClassDefaultAttributes().font
;
1171 bool wxWindowBase::SetFont(const wxFont
& font
)
1173 if ( font
== m_font
)
1180 m_hasFont
= font
.Ok();
1181 m_inheritFont
= m_hasFont
;
1183 InvalidateBestSize();
1190 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1192 m_hasCustomPalette
= true;
1195 // VZ: can anyone explain me what do we do here?
1196 wxWindowDC
d((wxWindow
*) this);
1200 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1202 wxWindow
*win
= (wxWindow
*)this;
1203 while ( win
&& !win
->HasCustomPalette() )
1205 win
= win
->GetParent();
1211 #endif // wxUSE_PALETTE
1214 void wxWindowBase::SetCaret(wxCaret
*caret
)
1225 wxASSERT_MSG( m_caret
->GetWindow() == this,
1226 wxT("caret should be created associated to this window") );
1229 #endif // wxUSE_CARET
1231 #if wxUSE_VALIDATORS
1232 // ----------------------------------------------------------------------------
1234 // ----------------------------------------------------------------------------
1236 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1238 if ( m_windowValidator
)
1239 delete m_windowValidator
;
1241 m_windowValidator
= (wxValidator
*)validator
.Clone();
1243 if ( m_windowValidator
)
1244 m_windowValidator
->SetWindow(this);
1246 #endif // wxUSE_VALIDATORS
1248 // ----------------------------------------------------------------------------
1249 // update region stuff
1250 // ----------------------------------------------------------------------------
1252 wxRect
wxWindowBase::GetUpdateClientRect() const
1254 wxRegion rgnUpdate
= GetUpdateRegion();
1255 rgnUpdate
.Intersect(GetClientRect());
1256 wxRect rectUpdate
= rgnUpdate
.GetBox();
1257 wxPoint ptOrigin
= GetClientAreaOrigin();
1258 rectUpdate
.x
-= ptOrigin
.x
;
1259 rectUpdate
.y
-= ptOrigin
.y
;
1264 bool wxWindowBase::IsExposed(int x
, int y
) const
1266 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1269 bool wxWindowBase::IsExposed(int x
, int y
, int w
, int h
) const
1271 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1274 void wxWindowBase::ClearBackground()
1276 // wxGTK uses its own version, no need to add never used code
1278 wxClientDC
dc((wxWindow
*)this);
1279 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1280 dc
.SetBackground(brush
);
1285 // ----------------------------------------------------------------------------
1286 // find child window by id or name
1287 // ----------------------------------------------------------------------------
1289 wxWindow
*wxWindowBase::FindWindow(long id
) const
1291 if ( id
== m_windowId
)
1292 return (wxWindow
*)this;
1294 wxWindowBase
*res
= (wxWindow
*)NULL
;
1295 wxWindowList::compatibility_iterator node
;
1296 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1298 wxWindowBase
*child
= node
->GetData();
1299 res
= child
->FindWindow( id
);
1302 return (wxWindow
*)res
;
1305 wxWindow
*wxWindowBase::FindWindow(const wxString
& name
) const
1307 if ( name
== m_windowName
)
1308 return (wxWindow
*)this;
1310 wxWindowBase
*res
= (wxWindow
*)NULL
;
1311 wxWindowList::compatibility_iterator node
;
1312 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1314 wxWindow
*child
= node
->GetData();
1315 res
= child
->FindWindow(name
);
1318 return (wxWindow
*)res
;
1322 // find any window by id or name or label: If parent is non-NULL, look through
1323 // children for a label or title matching the specified string. If NULL, look
1324 // through all top-level windows.
1326 // to avoid duplicating code we reuse the same helper function but with
1327 // different comparators
1329 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1330 const wxString
& label
, long id
);
1333 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1336 return win
->GetLabel() == label
;
1340 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1343 return win
->GetName() == label
;
1347 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1350 return win
->GetId() == id
;
1353 // recursive helper for the FindWindowByXXX() functions
1355 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1356 const wxString
& label
,
1358 wxFindWindowCmp cmp
)
1362 // see if this is the one we're looking for
1363 if ( (*cmp
)(parent
, label
, id
) )
1364 return (wxWindow
*)parent
;
1366 // It wasn't, so check all its children
1367 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1369 node
= node
->GetNext() )
1371 // recursively check each child
1372 wxWindow
*win
= (wxWindow
*)node
->GetData();
1373 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1383 // helper for FindWindowByXXX()
1385 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1386 const wxString
& label
,
1388 wxFindWindowCmp cmp
)
1392 // just check parent and all its children
1393 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1396 // start at very top of wx's windows
1397 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1399 node
= node
->GetNext() )
1401 // recursively check each window & its children
1402 wxWindow
*win
= node
->GetData();
1403 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1413 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1415 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1420 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1422 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1426 // fall back to the label
1427 win
= FindWindowByLabel(title
, parent
);
1435 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1437 return wxFindWindowHelper(parent
, wxEmptyString
, id
, wxFindWindowCmpIds
);
1440 // ----------------------------------------------------------------------------
1441 // dialog oriented functions
1442 // ----------------------------------------------------------------------------
1444 void wxWindowBase::MakeModal(bool modal
)
1446 // Disable all other windows
1449 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1452 wxWindow
*win
= node
->GetData();
1454 win
->Enable(!modal
);
1456 node
= node
->GetNext();
1461 bool wxWindowBase::Validate()
1463 #if wxUSE_VALIDATORS
1464 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1466 wxWindowList::compatibility_iterator node
;
1467 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1469 wxWindowBase
*child
= node
->GetData();
1470 wxValidator
*validator
= child
->GetValidator();
1471 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1476 if ( recurse
&& !child
->Validate() )
1481 #endif // wxUSE_VALIDATORS
1486 bool wxWindowBase::TransferDataToWindow()
1488 #if wxUSE_VALIDATORS
1489 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1491 wxWindowList::compatibility_iterator node
;
1492 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1494 wxWindowBase
*child
= node
->GetData();
1495 wxValidator
*validator
= child
->GetValidator();
1496 if ( validator
&& !validator
->TransferToWindow() )
1498 wxLogWarning(_("Could not transfer data to window"));
1500 wxLog::FlushActive();
1508 if ( !child
->TransferDataToWindow() )
1510 // warning already given
1515 #endif // wxUSE_VALIDATORS
1520 bool wxWindowBase::TransferDataFromWindow()
1522 #if wxUSE_VALIDATORS
1523 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1525 wxWindowList::compatibility_iterator node
;
1526 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1528 wxWindow
*child
= node
->GetData();
1529 wxValidator
*validator
= child
->GetValidator();
1530 if ( validator
&& !validator
->TransferFromWindow() )
1532 // nop warning here because the application is supposed to give
1533 // one itself - we don't know here what might have gone wrongly
1540 if ( !child
->TransferDataFromWindow() )
1542 // warning already given
1547 #endif // wxUSE_VALIDATORS
1552 void wxWindowBase::InitDialog()
1554 wxInitDialogEvent
event(GetId());
1555 event
.SetEventObject( this );
1556 GetEventHandler()->ProcessEvent(event
);
1559 // ----------------------------------------------------------------------------
1560 // context-sensitive help support
1561 // ----------------------------------------------------------------------------
1565 // associate this help text with this window
1566 void wxWindowBase::SetHelpText(const wxString
& text
)
1568 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1571 helpProvider
->AddHelp(this, text
);
1575 // associate this help text with all windows with the same id as this
1577 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
1579 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1582 helpProvider
->AddHelp(GetId(), text
);
1586 // get the help string associated with this window (may be empty)
1587 wxString
wxWindowBase::GetHelpText() const
1590 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1593 text
= helpProvider
->GetHelp(this);
1599 // show help for this window
1600 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
1602 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1605 if ( helpProvider
->ShowHelp(this) )
1607 // skip the event.Skip() below
1615 #endif // wxUSE_HELP
1617 // ----------------------------------------------------------------------------
1618 // tooltipsroot.Replace("\\", "/");
1619 // ----------------------------------------------------------------------------
1623 void wxWindowBase::SetToolTip( const wxString
&tip
)
1625 // don't create the new tooltip if we already have one
1628 m_tooltip
->SetTip( tip
);
1632 SetToolTip( new wxToolTip( tip
) );
1635 // setting empty tooltip text does not remove the tooltip any more - use
1636 // SetToolTip((wxToolTip *)NULL) for this
1639 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
1644 m_tooltip
= tooltip
;
1647 #endif // wxUSE_TOOLTIPS
1649 // ----------------------------------------------------------------------------
1650 // constraints and sizers
1651 // ----------------------------------------------------------------------------
1653 #if wxUSE_CONSTRAINTS
1655 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
1657 if ( m_constraints
)
1659 UnsetConstraints(m_constraints
);
1660 delete m_constraints
;
1662 m_constraints
= constraints
;
1663 if ( m_constraints
)
1665 // Make sure other windows know they're part of a 'meaningful relationship'
1666 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
1667 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
1668 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
1669 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
1670 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
1671 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
1672 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
1673 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
1674 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
1675 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
1676 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
1677 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
1678 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
1679 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
1680 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
1681 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
1685 // This removes any dangling pointers to this window in other windows'
1686 // constraintsInvolvedIn lists.
1687 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
1691 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1692 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
1693 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1694 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
1695 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
1696 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
1697 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
1698 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
1699 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
1700 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
1701 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
1702 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
1703 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
1704 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
1705 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
1706 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
1710 // Back-pointer to other windows we're involved with, so if we delete this
1711 // window, we must delete any constraints we're involved with.
1712 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
1714 if ( !m_constraintsInvolvedIn
)
1715 m_constraintsInvolvedIn
= new wxWindowList
;
1716 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
1717 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
1720 // REMOVE back-pointer to other windows we're involved with.
1721 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
1723 if ( m_constraintsInvolvedIn
)
1724 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
1727 // Reset any constraints that mention this window
1728 void wxWindowBase::DeleteRelatedConstraints()
1730 if ( m_constraintsInvolvedIn
)
1732 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
1735 wxWindow
*win
= node
->GetData();
1736 wxLayoutConstraints
*constr
= win
->GetConstraints();
1738 // Reset any constraints involving this window
1741 constr
->left
.ResetIfWin(this);
1742 constr
->top
.ResetIfWin(this);
1743 constr
->right
.ResetIfWin(this);
1744 constr
->bottom
.ResetIfWin(this);
1745 constr
->width
.ResetIfWin(this);
1746 constr
->height
.ResetIfWin(this);
1747 constr
->centreX
.ResetIfWin(this);
1748 constr
->centreY
.ResetIfWin(this);
1751 wxWindowList::compatibility_iterator next
= node
->GetNext();
1752 m_constraintsInvolvedIn
->Erase(node
);
1756 delete m_constraintsInvolvedIn
;
1757 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
1761 #endif // wxUSE_CONSTRAINTS
1763 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
1765 if ( sizer
== m_windowSizer
)
1769 delete m_windowSizer
;
1771 m_windowSizer
= sizer
;
1773 SetAutoLayout( sizer
!= NULL
);
1776 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
1778 SetSizer( sizer
, deleteOld
);
1779 sizer
->SetSizeHints( (wxWindow
*) this );
1783 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
1785 // adding a window to a sizer twice is going to result in fatal and
1786 // hard to debug problems later because when deleting the second
1787 // associated wxSizerItem we're going to dereference a dangling
1788 // pointer; so try to detect this as early as possible
1789 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
1790 _T("Adding a window to the same sizer twice?") );
1792 m_containingSizer
= sizer
;
1795 #if wxUSE_CONSTRAINTS
1797 void wxWindowBase::SatisfyConstraints()
1799 wxLayoutConstraints
*constr
= GetConstraints();
1800 bool wasOk
= constr
&& constr
->AreSatisfied();
1802 ResetConstraints(); // Mark all constraints as unevaluated
1806 // if we're a top level panel (i.e. our parent is frame/dialog), our
1807 // own constraints will never be satisfied any more unless we do it
1811 while ( noChanges
> 0 )
1813 LayoutPhase1(&noChanges
);
1817 LayoutPhase2(&noChanges
);
1820 #endif // wxUSE_CONSTRAINTS
1822 bool wxWindowBase::Layout()
1824 // If there is a sizer, use it instead of the constraints
1828 GetVirtualSize(&w
, &h
);
1829 GetSizer()->SetDimension( 0, 0, w
, h
);
1831 #if wxUSE_CONSTRAINTS
1834 SatisfyConstraints(); // Find the right constraints values
1835 SetConstraintSizes(); // Recursively set the real window sizes
1842 #if wxUSE_CONSTRAINTS
1844 // first phase of the constraints evaluation: set our own constraints
1845 bool wxWindowBase::LayoutPhase1(int *noChanges
)
1847 wxLayoutConstraints
*constr
= GetConstraints();
1849 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
1852 // second phase: set the constraints for our children
1853 bool wxWindowBase::LayoutPhase2(int *noChanges
)
1860 // Layout grand children
1866 // Do a phase of evaluating child constraints
1867 bool wxWindowBase::DoPhase(int phase
)
1869 // the list containing the children for which the constraints are already
1871 wxWindowList succeeded
;
1873 // the max number of iterations we loop before concluding that we can't set
1875 static const int maxIterations
= 500;
1877 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
1881 // loop over all children setting their constraints
1882 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1884 node
= node
->GetNext() )
1886 wxWindow
*child
= node
->GetData();
1887 if ( child
->IsTopLevel() )
1889 // top level children are not inside our client area
1893 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
1895 // this one is either already ok or nothing we can do about it
1899 int tempNoChanges
= 0;
1900 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
1901 : child
->LayoutPhase2(&tempNoChanges
);
1902 noChanges
+= tempNoChanges
;
1906 succeeded
.Append(child
);
1912 // constraints are set
1920 void wxWindowBase::ResetConstraints()
1922 wxLayoutConstraints
*constr
= GetConstraints();
1925 constr
->left
.SetDone(false);
1926 constr
->top
.SetDone(false);
1927 constr
->right
.SetDone(false);
1928 constr
->bottom
.SetDone(false);
1929 constr
->width
.SetDone(false);
1930 constr
->height
.SetDone(false);
1931 constr
->centreX
.SetDone(false);
1932 constr
->centreY
.SetDone(false);
1935 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1938 wxWindow
*win
= node
->GetData();
1939 if ( !win
->IsTopLevel() )
1940 win
->ResetConstraints();
1941 node
= node
->GetNext();
1945 // Need to distinguish between setting the 'fake' size for windows and sizers,
1946 // and setting the real values.
1947 void wxWindowBase::SetConstraintSizes(bool recurse
)
1949 wxLayoutConstraints
*constr
= GetConstraints();
1950 if ( constr
&& constr
->AreSatisfied() )
1952 int x
= constr
->left
.GetValue();
1953 int y
= constr
->top
.GetValue();
1954 int w
= constr
->width
.GetValue();
1955 int h
= constr
->height
.GetValue();
1957 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
1958 (constr
->height
.GetRelationship() != wxAsIs
) )
1960 SetSize(x
, y
, w
, h
);
1964 // If we don't want to resize this window, just move it...
1970 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1971 GetClassInfo()->GetClassName(),
1977 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1980 wxWindow
*win
= node
->GetData();
1981 if ( !win
->IsTopLevel() && win
->GetConstraints() )
1982 win
->SetConstraintSizes();
1983 node
= node
->GetNext();
1988 // Only set the size/position of the constraint (if any)
1989 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
1991 wxLayoutConstraints
*constr
= GetConstraints();
1994 if ( x
!= wxDefaultCoord
)
1996 constr
->left
.SetValue(x
);
1997 constr
->left
.SetDone(true);
1999 if ( y
!= wxDefaultCoord
)
2001 constr
->top
.SetValue(y
);
2002 constr
->top
.SetDone(true);
2004 if ( w
!= wxDefaultCoord
)
2006 constr
->width
.SetValue(w
);
2007 constr
->width
.SetDone(true);
2009 if ( h
!= wxDefaultCoord
)
2011 constr
->height
.SetValue(h
);
2012 constr
->height
.SetDone(true);
2017 void wxWindowBase::MoveConstraint(int x
, int y
)
2019 wxLayoutConstraints
*constr
= GetConstraints();
2022 if ( x
!= wxDefaultCoord
)
2024 constr
->left
.SetValue(x
);
2025 constr
->left
.SetDone(true);
2027 if ( y
!= wxDefaultCoord
)
2029 constr
->top
.SetValue(y
);
2030 constr
->top
.SetDone(true);
2035 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
2037 wxLayoutConstraints
*constr
= GetConstraints();
2040 *w
= constr
->width
.GetValue();
2041 *h
= constr
->height
.GetValue();
2047 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
2049 wxLayoutConstraints
*constr
= GetConstraints();
2052 *w
= constr
->width
.GetValue();
2053 *h
= constr
->height
.GetValue();
2056 GetClientSize(w
, h
);
2059 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
2061 wxLayoutConstraints
*constr
= GetConstraints();
2064 *x
= constr
->left
.GetValue();
2065 *y
= constr
->top
.GetValue();
2071 #endif // wxUSE_CONSTRAINTS
2073 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
2075 // don't do it for the dialogs/frames - they float independently of their
2077 if ( !IsTopLevel() )
2079 wxWindow
*parent
= GetParent();
2080 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
2082 wxPoint
pt(parent
->GetClientAreaOrigin());
2089 // ----------------------------------------------------------------------------
2090 // do Update UI processing for child controls
2091 // ----------------------------------------------------------------------------
2093 void wxWindowBase::UpdateWindowUI(long flags
)
2095 wxUpdateUIEvent
event(GetId());
2096 event
.SetEventObject(this);
2098 if ( GetEventHandler()->ProcessEvent(event
) )
2100 DoUpdateWindowUI(event
);
2103 if (flags
& wxUPDATE_UI_RECURSE
)
2105 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2108 wxWindow
* child
= (wxWindow
*) node
->GetData();
2109 child
->UpdateWindowUI(flags
);
2110 node
= node
->GetNext();
2115 // do the window-specific processing after processing the update event
2116 // TODO: take specific knowledge out of this function and
2117 // put in each control's base class. Unfortunately we don't
2118 // yet have base implementation files for wxCheckBox and wxRadioButton.
2119 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2121 if ( event
.GetSetEnabled() )
2122 Enable(event
.GetEnabled());
2125 if ( event
.GetSetText() )
2127 wxControl
*control
= wxDynamicCastThis(wxControl
);
2130 if ( event
.GetText() != control
->GetLabel() )
2131 control
->SetLabel(event
.GetText());
2134 #endif // wxUSE_CONTROLS
2136 if ( event
.GetSetChecked() )
2139 wxCheckBox
*checkbox
= wxDynamicCastThis(wxCheckBox
);
2142 checkbox
->SetValue(event
.GetChecked());
2144 #endif // wxUSE_CHECKBOX
2147 wxRadioButton
*radiobtn
= wxDynamicCastThis(wxRadioButton
);
2150 radiobtn
->SetValue(event
.GetChecked());
2152 #endif // wxUSE_RADIOBTN
2157 // call internal idle recursively
2158 // may be obsolete (wait until OnIdle scheme stabilises)
2159 void wxWindowBase::ProcessInternalIdle()
2163 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2166 wxWindow
*child
= node
->GetData();
2167 child
->ProcessInternalIdle();
2168 node
= node
->GetNext();
2173 // ----------------------------------------------------------------------------
2174 // dialog units translations
2175 // ----------------------------------------------------------------------------
2177 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
)
2179 int charWidth
= GetCharWidth();
2180 int charHeight
= GetCharHeight();
2181 wxPoint pt2
= wxDefaultPosition
;
2182 if (pt
.x
!= wxDefaultCoord
)
2183 pt2
.x
= (int) ((pt
.x
* 4) / charWidth
);
2184 if (pt
.y
!= wxDefaultCoord
)
2185 pt2
.y
= (int) ((pt
.y
* 8) / charHeight
);
2190 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
)
2192 int charWidth
= GetCharWidth();
2193 int charHeight
= GetCharHeight();
2194 wxPoint pt2
= wxDefaultPosition
;
2195 if (pt
.x
!= wxDefaultCoord
)
2196 pt2
.x
= (int) ((pt
.x
* charWidth
) / 4);
2197 if (pt
.y
!= wxDefaultCoord
)
2198 pt2
.y
= (int) ((pt
.y
* charHeight
) / 8);
2203 // ----------------------------------------------------------------------------
2205 // ----------------------------------------------------------------------------
2207 // propagate the colour change event to the subwindows
2208 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& event
)
2210 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2213 // Only propagate to non-top-level windows
2214 wxWindow
*win
= node
->GetData();
2215 if ( !win
->IsTopLevel() )
2217 wxSysColourChangedEvent event2
;
2218 event
.SetEventObject(win
);
2219 win
->GetEventHandler()->ProcessEvent(event2
);
2222 node
= node
->GetNext();
2228 // the default action is to populate dialog with data when it's created,
2229 // and nudge the UI into displaying itself correctly in case
2230 // we've turned the wxUpdateUIEvents frequency down low.
2231 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2233 TransferDataToWindow();
2235 // Update the UI at this point
2236 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2239 // process Ctrl-Alt-mclick
2240 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2243 if ( event
.ControlDown() && event
.AltDown() )
2245 // don't translate these strings
2248 #ifdef __WXUNIVERSAL__
2250 #endif // __WXUNIVERSAL__
2252 switch ( wxGetOsVersion() )
2254 case wxMOTIF_X
: port
+= _T("Motif"); break;
2256 case wxMAC_DARWIN
: port
+= _T("Mac"); break;
2257 case wxBEOS
: port
+= _T("BeOS"); break;
2261 case wxGTK_BEOS
: port
+= _T("GTK"); break;
2267 case wxWIN386
: port
+= _T("MS Windows"); break;
2271 case wxMGL_OS2
: port
+= _T("MGL"); break;
2273 case wxOS2_PM
: port
+= _T("OS/2"); break;
2274 case wxPALMOS
: port
+= _T("Palm OS"); break;
2275 case wxWINDOWS_CE
: port
+= _T("Windows CE (generic)"); break;
2276 case wxWINDOWS_POCKETPC
: port
+= _T("Windows CE PocketPC"); break;
2277 case wxWINDOWS_SMARTPHONE
: port
+= _T("Windows CE Smartphone"); break;
2278 default: port
+= _T("unknown"); break;
2281 wxMessageBox(wxString::Format(
2283 " wxWidgets Library (%s port)\nVersion %d.%d.%d%s%s, compiled at %s %s\n Copyright (c) 1995-2005 wxWidgets team"
2302 _T("wxWidgets information"),
2303 wxICON_INFORMATION
| wxOK
,
2307 #endif // wxUSE_MSGDLG
2313 // ----------------------------------------------------------------------------
2315 // ----------------------------------------------------------------------------
2317 #if wxUSE_ACCESSIBILITY
2318 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2320 if (m_accessible
&& (accessible
!= m_accessible
))
2321 delete m_accessible
;
2322 m_accessible
= accessible
;
2324 m_accessible
->SetWindow((wxWindow
*) this);
2327 // Returns the accessible object, creating if necessary.
2328 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2331 m_accessible
= CreateAccessible();
2332 return m_accessible
;
2335 // Override to create a specific accessible object.
2336 wxAccessible
* wxWindowBase::CreateAccessible()
2338 return new wxWindowAccessible((wxWindow
*) this);
2343 // ----------------------------------------------------------------------------
2344 // list classes implementation
2345 // ----------------------------------------------------------------------------
2349 #include <wx/listimpl.cpp>
2350 WX_DEFINE_LIST(wxWindowList
);
2354 void wxWindowListNode::DeleteData()
2356 delete (wxWindow
*)GetData();
2361 // ----------------------------------------------------------------------------
2363 // ----------------------------------------------------------------------------
2365 wxBorder
wxWindowBase::GetBorder(long flags
) const
2367 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
2368 if ( border
== wxBORDER_DEFAULT
)
2370 border
= GetDefaultBorder();
2376 wxBorder
wxWindowBase::GetDefaultBorder() const
2378 return wxBORDER_NONE
;
2381 // ----------------------------------------------------------------------------
2383 // ----------------------------------------------------------------------------
2385 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
2387 // here we just check if the point is inside the window or not
2389 // check the top and left border first
2390 bool outside
= x
< 0 || y
< 0;
2393 // check the right and bottom borders too
2394 wxSize size
= GetSize();
2395 outside
= x
>= size
.x
|| y
>= size
.y
;
2398 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
2401 // ----------------------------------------------------------------------------
2403 // ----------------------------------------------------------------------------
2405 struct WXDLLEXPORT wxWindowNext
2409 } *wxWindowBase::ms_winCaptureNext
= NULL
;
2411 void wxWindowBase::CaptureMouse()
2413 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
2415 wxWindow
*winOld
= GetCapture();
2418 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
2421 wxWindowNext
*item
= new wxWindowNext
;
2423 item
->next
= ms_winCaptureNext
;
2424 ms_winCaptureNext
= item
;
2426 //else: no mouse capture to save
2431 void wxWindowBase::ReleaseMouse()
2433 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
2435 wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2439 if ( ms_winCaptureNext
)
2441 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
2443 wxWindowNext
*item
= ms_winCaptureNext
;
2444 ms_winCaptureNext
= item
->next
;
2447 //else: stack is empty, no previous capture
2449 wxLogTrace(_T("mousecapture"),
2450 (const wxChar
*) _T("After ReleaseMouse() mouse is captured by %p"),
2457 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
2458 int WXUNUSED(modifiers
),
2459 int WXUNUSED(keycode
))
2465 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
2471 #endif // wxUSE_HOTKEY
2473 void wxWindowBase::SendDestroyEvent()
2475 wxWindowDestroyEvent event
;
2476 event
.SetEventObject(this);
2477 event
.SetId(GetId());
2478 GetEventHandler()->ProcessEvent(event
);
2481 // ----------------------------------------------------------------------------
2483 // ----------------------------------------------------------------------------
2485 bool wxWindowBase::TryValidator(wxEvent
& wxVALIDATOR_PARAM(event
))
2487 #if wxUSE_VALIDATORS
2488 // Can only use the validator of the window which
2489 // is receiving the event
2490 if ( event
.GetEventObject() == this )
2492 wxValidator
*validator
= GetValidator();
2493 if ( validator
&& validator
->ProcessEvent(event
) )
2498 #endif // wxUSE_VALIDATORS
2503 bool wxWindowBase::TryParent(wxEvent
& event
)
2505 // carry on up the parent-child hierarchy if the propgation count hasn't
2507 if ( event
.ShouldPropagate() )
2509 // honour the requests to stop propagation at this window: this is
2510 // used by the dialogs, for example, to prevent processing the events
2511 // from the dialog controls in the parent frame which rarely, if ever,
2513 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
2515 wxWindow
*parent
= GetParent();
2516 if ( parent
&& !parent
->IsBeingDeleted() )
2518 wxPropagateOnce
propagateOnce(event
);
2520 return parent
->GetEventHandler()->ProcessEvent(event
);
2525 return wxEvtHandler::TryParent(event
);
2528 // ----------------------------------------------------------------------------
2529 // keyboard navigation
2530 // ----------------------------------------------------------------------------
2532 // Navigates in the specified direction.
2533 bool wxWindowBase::Navigate(int flags
)
2535 wxNavigationKeyEvent eventNav
;
2536 eventNav
.SetFlags(flags
);
2537 eventNav
.SetEventObject(this);
2538 if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav
) )
2545 void wxWindowBase::DoMoveInTabOrder(wxWindow
*win
, MoveKind move
)
2547 // check that we're not a top level window
2548 wxCHECK_RET( GetParent(),
2549 _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") );
2551 // detect the special case when we have nothing to do anyhow and when the
2552 // code below wouldn't work
2556 // find the target window in the siblings list
2557 wxWindowList
& siblings
= GetParent()->GetChildren();
2558 wxWindowList::compatibility_iterator i
= siblings
.Find(win
);
2559 wxCHECK_RET( i
, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") );
2561 // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we
2562 // can't just move the node around
2563 wxWindow
*self
= (wxWindow
*)this;
2564 siblings
.DeleteObject(self
);
2565 if ( move
== MoveAfter
)
2572 siblings
.Insert(i
, self
);
2574 else // MoveAfter and win was the last sibling
2576 siblings
.Append(self
);
2580 // ----------------------------------------------------------------------------
2582 // ----------------------------------------------------------------------------
2584 /*static*/ wxWindow
* wxWindowBase::FindFocus()
2586 wxWindowBase
*win
= DoFindFocus();
2587 return win
? win
->GetMainWindowOfCompositeControl() : NULL
;
2590 // ----------------------------------------------------------------------------
2592 // ----------------------------------------------------------------------------
2594 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
2596 while ( win
&& !win
->IsTopLevel() )
2597 win
= win
->GetParent();
2602 #if wxUSE_ACCESSIBILITY
2603 // ----------------------------------------------------------------------------
2604 // accessible object for windows
2605 // ----------------------------------------------------------------------------
2607 // Can return either a child object, or an integer
2608 // representing the child element, starting from 1.
2609 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
2611 wxASSERT( GetWindow() != NULL
);
2615 return wxACC_NOT_IMPLEMENTED
;
2618 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
2619 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
2621 wxASSERT( GetWindow() != NULL
);
2625 wxWindow
* win
= NULL
;
2632 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
2634 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
2641 rect
= win
->GetRect();
2642 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
2643 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
2647 return wxACC_NOT_IMPLEMENTED
;
2650 // Navigates from fromId to toId/toObject.
2651 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
2652 int* WXUNUSED(toId
), wxAccessible
** toObject
)
2654 wxASSERT( GetWindow() != NULL
);
2660 case wxNAVDIR_FIRSTCHILD
:
2662 if (GetWindow()->GetChildren().GetCount() == 0)
2664 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
2665 *toObject
= childWindow
->GetOrCreateAccessible();
2669 case wxNAVDIR_LASTCHILD
:
2671 if (GetWindow()->GetChildren().GetCount() == 0)
2673 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
2674 *toObject
= childWindow
->GetOrCreateAccessible();
2678 case wxNAVDIR_RIGHT
:
2682 wxWindowList::compatibility_iterator node
=
2683 wxWindowList::compatibility_iterator();
2686 // Can't navigate to sibling of this window
2687 // if we're a top-level window.
2688 if (!GetWindow()->GetParent())
2689 return wxACC_NOT_IMPLEMENTED
;
2691 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2695 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2696 node
= GetWindow()->GetChildren().Item(fromId
-1);
2699 if (node
&& node
->GetNext())
2701 wxWindow
* nextWindow
= node
->GetNext()->GetData();
2702 *toObject
= nextWindow
->GetOrCreateAccessible();
2710 case wxNAVDIR_PREVIOUS
:
2712 wxWindowList::compatibility_iterator node
=
2713 wxWindowList::compatibility_iterator();
2716 // Can't navigate to sibling of this window
2717 // if we're a top-level window.
2718 if (!GetWindow()->GetParent())
2719 return wxACC_NOT_IMPLEMENTED
;
2721 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2725 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2726 node
= GetWindow()->GetChildren().Item(fromId
-1);
2729 if (node
&& node
->GetPrevious())
2731 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
2732 *toObject
= previousWindow
->GetOrCreateAccessible();
2740 return wxACC_NOT_IMPLEMENTED
;
2743 // Gets the name of the specified object.
2744 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
2746 wxASSERT( GetWindow() != NULL
);
2752 // If a child, leave wxWidgets to call the function on the actual
2755 return wxACC_NOT_IMPLEMENTED
;
2757 // This will eventually be replaced by specialised
2758 // accessible classes, one for each kind of wxWidgets
2759 // control or window.
2761 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
2762 title
= ((wxButton
*) GetWindow())->GetLabel();
2765 title
= GetWindow()->GetName();
2773 return wxACC_NOT_IMPLEMENTED
;
2776 // Gets the number of children.
2777 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
2779 wxASSERT( GetWindow() != NULL
);
2783 *childId
= (int) GetWindow()->GetChildren().GetCount();
2787 // Gets the specified child (starting from 1).
2788 // If *child is NULL and return value is wxACC_OK,
2789 // this means that the child is a simple element and
2790 // not an accessible object.
2791 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
2793 wxASSERT( GetWindow() != NULL
);
2803 if (childId
> (int) GetWindow()->GetChildren().GetCount())
2806 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
2807 *child
= childWindow
->GetOrCreateAccessible();
2814 // Gets the parent, or NULL.
2815 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
2817 wxASSERT( GetWindow() != NULL
);
2821 wxWindow
* parentWindow
= GetWindow()->GetParent();
2829 *parent
= parentWindow
->GetOrCreateAccessible();
2837 // Performs the default action. childId is 0 (the action for this object)
2838 // or > 0 (the action for a child).
2839 // Return wxACC_NOT_SUPPORTED if there is no default action for this
2840 // window (e.g. an edit control).
2841 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
2843 wxASSERT( GetWindow() != NULL
);
2847 return wxACC_NOT_IMPLEMENTED
;
2850 // Gets the default action for this object (0) or > 0 (the action for a child).
2851 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
2852 // string if there is no action.
2853 // The retrieved string describes the action that is performed on an object,
2854 // not what the object does as a result. For example, a toolbar button that prints
2855 // a document has a default action of "Press" rather than "Prints the current document."
2856 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
2858 wxASSERT( GetWindow() != NULL
);
2862 return wxACC_NOT_IMPLEMENTED
;
2865 // Returns the description for this object or a child.
2866 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
2868 wxASSERT( GetWindow() != NULL
);
2872 wxString
ht(GetWindow()->GetHelpText());
2878 return wxACC_NOT_IMPLEMENTED
;
2881 // Returns help text for this object or a child, similar to tooltip text.
2882 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
2884 wxASSERT( GetWindow() != NULL
);
2888 wxString
ht(GetWindow()->GetHelpText());
2894 return wxACC_NOT_IMPLEMENTED
;
2897 // Returns the keyboard shortcut for this object or child.
2898 // Return e.g. ALT+K
2899 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
2901 wxASSERT( GetWindow() != NULL
);
2905 return wxACC_NOT_IMPLEMENTED
;
2908 // Returns a role constant.
2909 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
2911 wxASSERT( GetWindow() != NULL
);
2915 // If a child, leave wxWidgets to call the function on the actual
2918 return wxACC_NOT_IMPLEMENTED
;
2920 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2921 return wxACC_NOT_IMPLEMENTED
;
2923 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2924 return wxACC_NOT_IMPLEMENTED
;
2927 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2928 return wxACC_NOT_IMPLEMENTED
;
2931 //*role = wxROLE_SYSTEM_CLIENT;
2932 *role
= wxROLE_SYSTEM_CLIENT
;
2936 return wxACC_NOT_IMPLEMENTED
;
2940 // Returns a state constant.
2941 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
2943 wxASSERT( GetWindow() != NULL
);
2947 // If a child, leave wxWidgets to call the function on the actual
2950 return wxACC_NOT_IMPLEMENTED
;
2952 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2953 return wxACC_NOT_IMPLEMENTED
;
2956 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2957 return wxACC_NOT_IMPLEMENTED
;
2960 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2961 return wxACC_NOT_IMPLEMENTED
;
2968 return wxACC_NOT_IMPLEMENTED
;
2972 // Returns a localized string representing the value for the object
2974 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
2976 wxASSERT( GetWindow() != NULL
);
2980 return wxACC_NOT_IMPLEMENTED
;
2983 // Selects the object or child.
2984 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
2986 wxASSERT( GetWindow() != NULL
);
2990 return wxACC_NOT_IMPLEMENTED
;
2993 // Gets the window with the keyboard focus.
2994 // If childId is 0 and child is NULL, no object in
2995 // this subhierarchy has the focus.
2996 // If this object has the focus, child should be 'this'.
2997 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
2999 wxASSERT( GetWindow() != NULL
);
3003 return wxACC_NOT_IMPLEMENTED
;
3006 // Gets a variant representing the selected children
3008 // Acceptable values:
3009 // - a null variant (IsNull() returns true)
3010 // - a list variant (GetType() == wxT("list")
3011 // - an integer representing the selected child element,
3012 // or 0 if this object is selected (GetType() == wxT("long")
3013 // - a "void*" pointer to a wxAccessible child object
3014 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
3016 wxASSERT( GetWindow() != NULL
);
3020 return wxACC_NOT_IMPLEMENTED
;
3023 #endif // wxUSE_ACCESSIBILITY