1 /////////////////////////////////////////////////////////////////////////////
2 // Name: common/window.cpp
3 // Purpose: common (to all ports) wxWindow functions
4 // Author: Julian Smart, Vadim Zeitlin
8 // Copyright: (c) wxWindows team
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
21 #pragma implementation "windowbase.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/string.h"
37 #include "wx/window.h"
38 #include "wx/control.h"
39 #include "wx/checkbox.h"
40 #include "wx/radiobut.h"
41 #include "wx/statbox.h"
42 #include "wx/textctrl.h"
43 #include "wx/settings.h"
44 #include "wx/dialog.h"
45 #include "wx/msgdlg.h"
46 #include "wx/statusbr.h"
47 #include "wx/dcclient.h"
50 #if defined(__WXMAC__) && wxUSE_SCROLLBAR
51 #include "wx/scrolbar.h"
55 #include "wx/layout.h"
56 #endif // wxUSE_CONSTRAINTS
60 #if wxUSE_DRAG_AND_DROP
62 #endif // wxUSE_DRAG_AND_DROP
64 #if wxUSE_ACCESSIBILITY
65 #include "wx/access.h"
69 #include "wx/cshelp.h"
73 #include "wx/tooltip.h"
74 #endif // wxUSE_TOOLTIPS
80 // ----------------------------------------------------------------------------
82 // ----------------------------------------------------------------------------
85 int wxWindowBase::ms_lastControlId
= 2000;
87 int wxWindowBase::ms_lastControlId
= -200;
90 IMPLEMENT_ABSTRACT_CLASS(wxWindowBase
, wxEvtHandler
)
92 // ----------------------------------------------------------------------------
94 // ----------------------------------------------------------------------------
96 BEGIN_EVENT_TABLE(wxWindowBase
, wxEvtHandler
)
97 EVT_SYS_COLOUR_CHANGED(wxWindowBase::OnSysColourChanged
)
98 EVT_INIT_DIALOG(wxWindowBase::OnInitDialog
)
99 EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick
)
102 EVT_HELP(wxID_ANY
, wxWindowBase::OnHelp
)
107 // ============================================================================
108 // implementation of the common functionality of the wxWindow class
109 // ============================================================================
111 // ----------------------------------------------------------------------------
113 // ----------------------------------------------------------------------------
115 // the default initialization
116 wxWindowBase::wxWindowBase()
118 // no window yet, no parent nor children
119 m_parent
= (wxWindow
*)NULL
;
120 m_windowId
= wxID_ANY
;
122 // no constraints on the minimal window size
128 // window are created enabled and visible by default
132 // the default event handler is just this window
133 m_eventHandler
= this;
137 m_windowValidator
= (wxValidator
*) NULL
;
138 #endif // wxUSE_VALIDATORS
140 // the colours/fonts are default for now, so leave m_font,
141 // m_backgroundColour and m_foregroundColour uninitialized and set those
150 #if wxUSE_CONSTRAINTS
151 // no constraints whatsoever
152 m_constraints
= (wxLayoutConstraints
*) NULL
;
153 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
154 #endif // wxUSE_CONSTRAINTS
156 m_windowSizer
= (wxSizer
*) NULL
;
157 m_containingSizer
= (wxSizer
*) NULL
;
158 m_autoLayout
= false;
160 #if wxUSE_DRAG_AND_DROP
161 m_dropTarget
= (wxDropTarget
*)NULL
;
162 #endif // wxUSE_DRAG_AND_DROP
165 m_tooltip
= (wxToolTip
*)NULL
;
166 #endif // wxUSE_TOOLTIPS
169 m_caret
= (wxCaret
*)NULL
;
170 #endif // wxUSE_CARET
173 m_hasCustomPalette
= false;
174 #endif // wxUSE_PALETTE
176 #if wxUSE_ACCESSIBILITY
180 m_virtualSize
= wxDefaultSize
;
185 m_maxVirtualHeight
= -1;
187 m_windowVariant
= wxWINDOW_VARIANT_NORMAL
;
189 // Whether we're using the current theme for this window (wxGTK only for now)
190 m_themeEnabled
= false;
192 // VZ: this one shouldn't exist...
193 m_isBeingDeleted
= false;
196 // common part of window creation process
197 bool wxWindowBase::CreateBase(wxWindowBase
*parent
,
199 const wxPoint
& WXUNUSED(pos
),
200 const wxSize
& WXUNUSED(size
),
202 const wxValidator
& wxVALIDATOR_PARAM(validator
),
203 const wxString
& name
)
206 // wxGTK doesn't allow to create controls with static box as the parent so
207 // this will result in a crash when the program is ported to wxGTK so warn
210 // if you get this assert, the correct solution is to create the controls
211 // as siblings of the static box
212 wxASSERT_MSG( !parent
|| !wxDynamicCast(parent
, wxStaticBox
),
213 _T("wxStaticBox can't be used as a window parent!") );
214 #endif // wxUSE_STATBOX
216 // ids are limited to 16 bits under MSW so if you care about portability,
217 // it's not a good idea to use ids out of this range (and negative ids are
218 // reserved for wxWindows own usage)
219 wxASSERT_MSG( id
== wxID_ANY
|| (id
>= 0 && id
< 32767),
220 _T("invalid id value") );
222 // generate a new id if the user doesn't care about it
223 m_windowId
= id
== wxID_ANY
? NewControlId() : id
;
226 SetWindowStyleFlag(style
);
230 SetValidator(validator
);
231 #endif // wxUSE_VALIDATORS
233 // if the parent window has wxWS_EX_VALIDATE_RECURSIVELY set, we want to
234 // have it too - like this it's possible to set it only in the top level
235 // dialog/frame and all children will inherit it by defult
236 if ( parent
&& (parent
->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) )
238 SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY
);
244 // ----------------------------------------------------------------------------
246 // ----------------------------------------------------------------------------
249 wxWindowBase::~wxWindowBase()
251 wxASSERT_MSG( GetCapture() != this, wxT("attempt to destroy window with mouse capture") );
253 // FIXME if these 2 cases result from programming errors in the user code
254 // we should probably assert here instead of silently fixing them
256 // Just in case the window has been Closed, but we're then deleting
257 // immediately: don't leave dangling pointers.
258 wxPendingDelete
.DeleteObject(this);
260 // Just in case we've loaded a top-level window via LoadNativeDialog but
261 // we weren't a dialog class
262 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
264 wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
266 // reset the dangling pointer our parent window may keep to us
269 if ( m_parent
->GetDefaultItem() == this )
271 m_parent
->SetDefaultItem(NULL
);
274 m_parent
->RemoveChild(this);
279 #endif // wxUSE_CARET
282 delete m_windowValidator
;
283 #endif // wxUSE_VALIDATORS
285 #if wxUSE_CONSTRAINTS
286 // Have to delete constraints/sizer FIRST otherwise sizers may try to look
287 // at deleted windows as they delete themselves.
288 DeleteRelatedConstraints();
292 // This removes any dangling pointers to this window in other windows'
293 // constraintsInvolvedIn lists.
294 UnsetConstraints(m_constraints
);
295 delete m_constraints
;
296 m_constraints
= NULL
;
298 #endif // wxUSE_CONSTRAINTS
300 if ( m_containingSizer
)
301 m_containingSizer
->Detach( (wxWindow
*)this );
303 delete m_windowSizer
;
305 #if wxUSE_DRAG_AND_DROP
307 #endif // wxUSE_DRAG_AND_DROP
311 #endif // wxUSE_TOOLTIPS
313 #if wxUSE_ACCESSIBILITY
318 bool wxWindowBase::Destroy()
325 bool wxWindowBase::Close(bool force
)
327 wxCloseEvent
event(wxEVT_CLOSE_WINDOW
, m_windowId
);
328 event
.SetEventObject(this);
329 event
.SetCanVeto(!force
);
331 // return false if window wasn't closed because the application vetoed the
333 return GetEventHandler()->ProcessEvent(event
) && !event
.GetVeto();
336 bool wxWindowBase::DestroyChildren()
338 wxWindowList::compatibility_iterator node
;
341 // we iterate until the list becomes empty
342 node
= GetChildren().GetFirst();
346 wxWindow
*child
= node
->GetData();
348 // note that we really want to call delete and not ->Destroy() here
349 // because we want to delete the child immediately, before we are
350 // deleted, and delayed deletion would result in problems as our (top
351 // level) child could outlive its parent
354 wxASSERT_MSG( !GetChildren().Find(child
),
355 wxT("child didn't remove itself using RemoveChild()") );
361 // ----------------------------------------------------------------------------
362 // size/position related methods
363 // ----------------------------------------------------------------------------
365 // centre the window with respect to its parent in either (or both) directions
366 void wxWindowBase::Centre(int direction
)
368 // the position/size of the parent window or of the entire screen
370 int widthParent
, heightParent
;
372 wxWindow
*parent
= NULL
;
374 if ( !(direction
& wxCENTRE_ON_SCREEN
) )
376 // find the parent to centre this window on: it should be the
377 // immediate parent for the controls but the top level parent for the
378 // top level windows (like dialogs)
379 parent
= GetParent();
382 while ( parent
&& !parent
->IsTopLevel() )
384 parent
= parent
->GetParent();
388 // there is no wxTopLevelWindow under wxMotif yet
390 // we shouldn't center the dialog on the iconized window: under
391 // Windows, for example, this places it completely off the screen
394 wxTopLevelWindow
*winTop
= wxDynamicCast(parent
, wxTopLevelWindow
);
395 if ( winTop
&& winTop
->IsIconized() )
400 #endif // __WXMOTIF__
402 // did we find the parent?
406 direction
|= wxCENTRE_ON_SCREEN
;
410 if ( direction
& wxCENTRE_ON_SCREEN
)
412 // centre with respect to the whole screen
413 wxDisplaySize(&widthParent
, &heightParent
);
419 // centre on the parent
420 parent
->GetSize(&widthParent
, &heightParent
);
422 // adjust to the parents position
423 posParent
= parent
->GetPosition();
427 // centre inside the parents client rectangle
428 parent
->GetClientSize(&widthParent
, &heightParent
);
433 GetSize(&width
, &height
);
438 if ( direction
& wxHORIZONTAL
)
439 xNew
= (widthParent
- width
)/2;
441 if ( direction
& wxVERTICAL
)
442 yNew
= (heightParent
- height
)/2;
447 // Base size of the visible dimensions of the display
448 // to take into account the taskbar
449 wxRect rect
= wxGetClientDisplayRect();
450 wxSize
size (rect
.width
,rect
.height
);
452 // NB: in wxMSW, negative position may not neccessary mean "out of screen",
453 // but it may mean that the window is placed on other than the main
454 // display. Therefore we only make sure centered window is on the main display
455 // if the parent is at least partially present here.
456 if (posParent
.x
+ widthParent
>= 0) // if parent is (partially) on the main display
460 else if (xNew
+width
> size
.x
)
461 xNew
= size
.x
-width
-1;
463 if (posParent
.y
+ heightParent
>= 0) // if parent is (partially) on the main display
465 if (yNew
+height
> size
.y
)
466 yNew
= size
.y
-height
-1;
468 // Make certain that the title bar is initially visible
469 // always, even if this would push the bottom of the
470 // dialog of the visible area of the display
475 // move the window to this position (keeping the old size but using
476 // SetSize() and not Move() to allow xNew and/or yNew to be -1)
477 SetSize(xNew
, yNew
, width
, height
, wxSIZE_ALLOW_MINUS_ONE
);
480 // fits the window around the children
481 void wxWindowBase::Fit()
483 if ( GetChildren().GetCount() > 0 )
485 SetClientSize(DoGetBestSize());
487 //else: do nothing if we have no children
490 // fits virtual size (ie. scrolled area etc.) around children
491 void wxWindowBase::FitInside()
493 if ( GetChildren().GetCount() > 0 )
495 SetVirtualSize( GetBestVirtualSize() );
499 // On Mac, scrollbars are explicitly children.
501 static bool wxHasRealChildren(const wxWindowBase
* win
)
503 int realChildCount
= 0;
505 for ( wxWindowList::compatibility_iterator node
= win
->GetChildren().GetFirst();
507 node
= node
->GetNext() )
509 wxWindow
*win
= node
->GetData();
510 if ( !win
->IsTopLevel() && win
->IsShown() && !win
->IsKindOf(CLASSINFO(wxScrollBar
)))
513 return (realChildCount
> 0);
517 // return the size best suited for the current window
518 wxSize
wxWindowBase::DoGetBestSize() const
522 return m_windowSizer
->GetMinSize();
524 #if wxUSE_CONSTRAINTS
525 else if ( m_constraints
)
527 wxConstCast(this, wxWindowBase
)->SatisfyConstraints();
529 // our minimal acceptable size is such that all our windows fit inside
533 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
535 node
= node
->GetNext() )
537 wxLayoutConstraints
*c
= node
->GetData()->GetConstraints();
540 // it's not normal that we have an unconstrained child, but
541 // what can we do about it?
545 int x
= c
->right
.GetValue(),
546 y
= c
->bottom
.GetValue();
554 // TODO: we must calculate the overlaps somehow, otherwise we
555 // will never return a size bigger than the current one :-(
558 return wxSize(maxX
, maxY
);
560 #endif // wxUSE_CONSTRAINTS
561 else if ( !GetChildren().empty()
563 && wxHasRealChildren(this)
567 // our minimal acceptable size is such that all our visible child windows fit inside
571 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
573 node
= node
->GetNext() )
575 wxWindow
*win
= node
->GetData();
576 if ( win
->IsTopLevel() || ( ! win
->IsShown() )
578 || wxDynamicCast(win
, wxStatusBar
)
579 #endif // wxUSE_STATUSBAR
582 // dialogs and frames lie in different top level windows -
583 // don't deal with them here; as for the status bars, they
584 // don't lie in the client area at all
589 win
->GetPosition(&wx
, &wy
);
591 // if the window hadn't been positioned yet, assume that it is in
598 win
->GetSize(&ww
, &wh
);
599 if ( wx
+ ww
> maxX
)
601 if ( wy
+ wh
> maxY
)
605 // for compatibility with the old versions and because it really looks
606 // slightly more pretty like this, add a pad
610 return wxSize(maxX
, maxY
);
612 else // ! has children
614 // for a generic window there is no natural best size - just use either the
615 // minimum size if there is one, or the current size
616 if ( GetMinSize().IsFullySpecified() )
623 void wxWindowBase::SetBestSize(const wxSize
& size
)
625 // If the given size is incomplete then merge with the best size.
627 if ( size
.x
== -1 || size
.y
== -1 )
629 sizeBest
= DoGetBestSize();
635 else // have complete explicit size
640 // Change the size if needed
641 if (GetSize() != sizeBest
)
644 // don't shrink the control below its best size
645 m_minWidth
= sizeBest
.x
;
646 m_minHeight
= sizeBest
.y
;
649 // by default the origin is not shifted
650 wxPoint
wxWindowBase::GetClientAreaOrigin() const
652 return wxPoint(0, 0);
655 // set the min/max size of the window
656 void wxWindowBase::SetSizeHints(int minW
, int minH
,
658 int WXUNUSED(incW
), int WXUNUSED(incH
))
660 // setting min width greater than max width leads to infinite loops under
661 // X11 and generally doesn't make any sense, so don't allow it
662 wxCHECK_RET( (minW
== -1 || maxW
== -1 || minW
<= maxW
) &&
663 (minH
== -1 || maxH
== -1 || minH
<= maxH
),
664 _T("min width/height must be less than max width/height!") );
672 void wxWindowBase::SetWindowVariant( wxWindowVariant variant
)
674 if ( m_windowVariant
!= variant
)
676 m_windowVariant
= variant
;
678 DoSetWindowVariant(variant
);
682 void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant
)
684 // adjust the font height to correspond to our new variant (notice that
685 // we're only called if something really changed)
686 wxFont font
= GetFont();
687 int size
= font
.GetPointSize();
690 case wxWINDOW_VARIANT_NORMAL
:
693 case wxWINDOW_VARIANT_SMALL
:
698 case wxWINDOW_VARIANT_MINI
:
703 case wxWINDOW_VARIANT_LARGE
:
709 wxFAIL_MSG(_T("unexpected window variant"));
713 font
.SetPointSize(size
);
717 void wxWindowBase::SetVirtualSizeHints( int minW
, int minH
,
720 m_minVirtualWidth
= minW
;
721 m_maxVirtualWidth
= maxW
;
722 m_minVirtualHeight
= minH
;
723 m_maxVirtualHeight
= maxH
;
726 void wxWindowBase::DoSetVirtualSize( int x
, int y
)
728 if ( m_minVirtualWidth
!= -1 && m_minVirtualWidth
> x
)
729 x
= m_minVirtualWidth
;
730 if ( m_maxVirtualWidth
!= -1 && m_maxVirtualWidth
< x
)
731 x
= m_maxVirtualWidth
;
732 if ( m_minVirtualHeight
!= -1 && m_minVirtualHeight
> y
)
733 y
= m_minVirtualHeight
;
734 if ( m_maxVirtualHeight
!= -1 && m_maxVirtualHeight
< y
)
735 y
= m_maxVirtualHeight
;
737 m_virtualSize
= wxSize(x
, y
);
740 wxSize
wxWindowBase::DoGetVirtualSize() const
742 wxSize
s( GetClientSize() );
744 return wxSize( wxMax( m_virtualSize
.GetWidth(), s
.GetWidth() ),
745 wxMax( m_virtualSize
.GetHeight(), s
.GetHeight() ) );
748 // ----------------------------------------------------------------------------
749 // show/hide/enable/disable the window
750 // ----------------------------------------------------------------------------
752 bool wxWindowBase::Show(bool show
)
754 if ( show
!= m_isShown
)
766 bool wxWindowBase::Enable(bool enable
)
768 if ( enable
!= m_isEnabled
)
770 m_isEnabled
= enable
;
779 // ----------------------------------------------------------------------------
781 // ----------------------------------------------------------------------------
783 bool wxWindowBase::IsTopLevel() const
788 // ----------------------------------------------------------------------------
789 // reparenting the window
790 // ----------------------------------------------------------------------------
792 void wxWindowBase::AddChild(wxWindowBase
*child
)
794 wxCHECK_RET( child
, wxT("can't add a NULL child") );
796 // this should never happen and it will lead to a crash later if it does
797 // because RemoveChild() will remove only one node from the children list
798 // and the other(s) one(s) will be left with dangling pointers in them
799 wxASSERT_MSG( !GetChildren().Find((wxWindow
*)child
), _T("AddChild() called twice") );
801 GetChildren().Append((wxWindow
*)child
);
802 child
->SetParent(this);
805 void wxWindowBase::RemoveChild(wxWindowBase
*child
)
807 wxCHECK_RET( child
, wxT("can't remove a NULL child") );
809 GetChildren().DeleteObject((wxWindow
*)child
);
810 child
->SetParent(NULL
);
813 bool wxWindowBase::Reparent(wxWindowBase
*newParent
)
815 wxWindow
*oldParent
= GetParent();
816 if ( newParent
== oldParent
)
822 // unlink this window from the existing parent.
825 oldParent
->RemoveChild(this);
829 wxTopLevelWindows
.DeleteObject((wxWindow
*)this);
832 // add it to the new one
835 newParent
->AddChild(this);
839 wxTopLevelWindows
.Append((wxWindow
*)this);
845 // ----------------------------------------------------------------------------
846 // event handler stuff
847 // ----------------------------------------------------------------------------
849 void wxWindowBase::PushEventHandler(wxEvtHandler
*handler
)
851 wxEvtHandler
*handlerOld
= GetEventHandler();
853 handler
->SetNextHandler(handlerOld
);
856 GetEventHandler()->SetPreviousHandler(handler
);
858 SetEventHandler(handler
);
861 wxEvtHandler
*wxWindowBase::PopEventHandler(bool deleteHandler
)
863 wxEvtHandler
*handlerA
= GetEventHandler();
866 wxEvtHandler
*handlerB
= handlerA
->GetNextHandler();
867 handlerA
->SetNextHandler((wxEvtHandler
*)NULL
);
870 handlerB
->SetPreviousHandler((wxEvtHandler
*)NULL
);
871 SetEventHandler(handlerB
);
876 handlerA
= (wxEvtHandler
*)NULL
;
883 bool wxWindowBase::RemoveEventHandler(wxEvtHandler
*handler
)
885 wxCHECK_MSG( handler
, false, _T("RemoveEventHandler(NULL) called") );
887 wxEvtHandler
*handlerPrev
= NULL
,
888 *handlerCur
= GetEventHandler();
891 wxEvtHandler
*handlerNext
= handlerCur
->GetNextHandler();
893 if ( handlerCur
== handler
)
897 handlerPrev
->SetNextHandler(handlerNext
);
901 SetEventHandler(handlerNext
);
906 handlerNext
->SetPreviousHandler ( handlerPrev
);
909 handler
->SetNextHandler(NULL
);
910 handler
->SetPreviousHandler(NULL
);
915 handlerPrev
= handlerCur
;
916 handlerCur
= handlerNext
;
919 wxFAIL_MSG( _T("where has the event handler gone?") );
924 // ----------------------------------------------------------------------------
926 // ----------------------------------------------------------------------------
928 void wxWindowBase::InheritAttributes()
930 const wxWindowBase
* const parent
= GetParent();
934 // we only inherit attributes which had been explicitly set for the parent
935 // which ensures that this only happens if the user really wants it and
936 // not by default which wouldn't make any sense in modern GUIs where the
937 // controls don't all use the same fonts (nor colours)
938 if ( parent
->m_hasFont
&& !m_hasFont
)
939 SetFont(parent
->GetFont());
941 // in addition, there is a possibility to explicitly forbid inheriting
942 // colours at each class level by overriding ShouldInheritColours()
943 if ( ShouldInheritColours() )
945 if ( parent
->m_hasFgCol
&& !m_hasFgCol
)
946 SetForegroundColour(parent
->GetForegroundColour());
948 if ( parent
->m_hasBgCol
&& !m_hasBgCol
)
949 SetBackgroundColour(parent
->GetBackgroundColour());
953 /* static */ wxVisualAttributes
954 wxWindowBase::GetClassDefaultAttributes(wxWindowVariant
WXUNUSED(variant
))
956 // it is important to return valid values for all attributes from here,
957 // GetXXX() below rely on this
958 wxVisualAttributes attrs
;
959 attrs
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
960 attrs
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
961 attrs
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
);
966 wxColour
wxWindowBase::GetBackgroundColour() const
968 if ( !m_backgroundColour
.Ok() )
970 wxASSERT_MSG( !m_hasBgCol
, _T("we have invalid explicit bg colour?") );
972 // get our default background colour
973 wxColour colBg
= GetDefaultAttributes().colBg
;
975 // we must return some valid colour to avoid redoing this every time
976 // and also to avoid surprizing the applications written for older
977 // wxWindows versions where GetBackgroundColour() always returned
978 // something -- so give them something even if it doesn't make sense
979 // for this window (e.g. it has a themed background)
981 colBg
= GetClassDefaultAttributes().colBg
;
983 // cache it for the next call
984 wxConstCast(this, wxWindowBase
)->m_backgroundColour
= colBg
;
987 return m_backgroundColour
;
990 wxColour
wxWindowBase::GetForegroundColour() const
992 // logic is the same as above
993 if ( !m_hasFgCol
&& !m_foregroundColour
.Ok() )
995 wxASSERT_MSG( !m_hasFgCol
, _T("we have invalid explicit fg colour?") );
997 wxColour colFg
= GetDefaultAttributes().colFg
;
1000 colFg
= GetClassDefaultAttributes().colFg
;
1002 wxConstCast(this, wxWindowBase
)->m_foregroundColour
= colFg
;
1005 return m_foregroundColour
;
1008 bool wxWindowBase::SetBackgroundColour( const wxColour
&colour
)
1010 if ( !colour
.Ok() || (colour
== m_backgroundColour
) )
1013 m_backgroundColour
= colour
;
1020 bool wxWindowBase::SetForegroundColour( const wxColour
&colour
)
1022 if ( !colour
.Ok() || (colour
== m_foregroundColour
) )
1025 m_foregroundColour
= colour
;
1032 bool wxWindowBase::SetCursor(const wxCursor
& cursor
)
1034 // setting an invalid cursor is ok, it means that we don't have any special
1036 if ( m_cursor
== cursor
)
1047 wxFont
& wxWindowBase::DoGetFont() const
1049 // logic is the same as in GetBackgroundColour()
1052 wxASSERT_MSG( !m_hasFont
, _T("we have invalid explicit font?") );
1054 wxFont font
= GetDefaultAttributes().font
;
1056 font
= GetClassDefaultAttributes().font
;
1058 wxConstCast(this, wxWindowBase
)->m_font
= font
;
1061 // cast is here for non-const GetFont() convenience
1062 return wxConstCast(this, wxWindowBase
)->m_font
;
1065 bool wxWindowBase::SetFont(const wxFont
& font
)
1070 if ( font
== m_font
)
1085 void wxWindowBase::SetPalette(const wxPalette
& pal
)
1087 m_hasCustomPalette
= true;
1090 // VZ: can anyone explain me what do we do here?
1091 wxWindowDC
d((wxWindow
*) this);
1095 wxWindow
*wxWindowBase::GetAncestorWithCustomPalette() const
1097 wxWindow
*win
= (wxWindow
*)this;
1098 while ( win
&& !win
->HasCustomPalette() )
1100 win
= win
->GetParent();
1106 #endif // wxUSE_PALETTE
1109 void wxWindowBase::SetCaret(wxCaret
*caret
)
1120 wxASSERT_MSG( m_caret
->GetWindow() == this,
1121 wxT("caret should be created associated to this window") );
1124 #endif // wxUSE_CARET
1126 #if wxUSE_VALIDATORS
1127 // ----------------------------------------------------------------------------
1129 // ----------------------------------------------------------------------------
1131 void wxWindowBase::SetValidator(const wxValidator
& validator
)
1133 if ( m_windowValidator
)
1134 delete m_windowValidator
;
1136 m_windowValidator
= (wxValidator
*)validator
.Clone();
1138 if ( m_windowValidator
)
1139 m_windowValidator
->SetWindow(this);
1141 #endif // wxUSE_VALIDATORS
1143 // ----------------------------------------------------------------------------
1144 // update region stuff
1145 // ----------------------------------------------------------------------------
1147 wxRect
wxWindowBase::GetUpdateClientRect() const
1149 wxRegion rgnUpdate
= GetUpdateRegion();
1150 rgnUpdate
.Intersect(GetClientRect());
1151 wxRect rectUpdate
= rgnUpdate
.GetBox();
1152 wxPoint ptOrigin
= GetClientAreaOrigin();
1153 rectUpdate
.x
-= ptOrigin
.x
;
1154 rectUpdate
.y
-= ptOrigin
.y
;
1159 bool wxWindowBase::IsExposed(int x
, int y
) const
1161 return m_updateRegion
.Contains(x
, y
) != wxOutRegion
;
1164 bool wxWindowBase::IsExposed(int x
, int y
, int w
, int h
) const
1166 return m_updateRegion
.Contains(x
, y
, w
, h
) != wxOutRegion
;
1169 void wxWindowBase::ClearBackground()
1171 // wxGTK uses its own version, no need to add never used code
1173 wxClientDC
dc((wxWindow
*)this);
1174 wxBrush
brush(GetBackgroundColour(), wxSOLID
);
1175 dc
.SetBackground(brush
);
1180 // ----------------------------------------------------------------------------
1181 // find child window by id or name
1182 // ----------------------------------------------------------------------------
1184 wxWindow
*wxWindowBase::FindWindow( long id
)
1186 if ( id
== m_windowId
)
1187 return (wxWindow
*)this;
1189 wxWindowBase
*res
= (wxWindow
*)NULL
;
1190 wxWindowList::compatibility_iterator node
;
1191 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1193 wxWindowBase
*child
= node
->GetData();
1194 res
= child
->FindWindow( id
);
1197 return (wxWindow
*)res
;
1200 wxWindow
*wxWindowBase::FindWindow( const wxString
& name
)
1202 if ( name
== m_windowName
)
1203 return (wxWindow
*)this;
1205 wxWindowBase
*res
= (wxWindow
*)NULL
;
1206 wxWindowList::compatibility_iterator node
;
1207 for ( node
= m_children
.GetFirst(); node
&& !res
; node
= node
->GetNext() )
1209 wxWindow
*child
= node
->GetData();
1210 res
= child
->FindWindow(name
);
1213 return (wxWindow
*)res
;
1217 // find any window by id or name or label: If parent is non-NULL, look through
1218 // children for a label or title matching the specified string. If NULL, look
1219 // through all top-level windows.
1221 // to avoid duplicating code we reuse the same helper function but with
1222 // different comparators
1224 typedef bool (*wxFindWindowCmp
)(const wxWindow
*win
,
1225 const wxString
& label
, long id
);
1228 bool wxFindWindowCmpLabels(const wxWindow
*win
, const wxString
& label
,
1231 return win
->GetLabel() == label
;
1235 bool wxFindWindowCmpNames(const wxWindow
*win
, const wxString
& label
,
1238 return win
->GetName() == label
;
1242 bool wxFindWindowCmpIds(const wxWindow
*win
, const wxString
& WXUNUSED(label
),
1245 return win
->GetId() == id
;
1248 // recursive helper for the FindWindowByXXX() functions
1250 wxWindow
*wxFindWindowRecursively(const wxWindow
*parent
,
1251 const wxString
& label
,
1253 wxFindWindowCmp cmp
)
1257 // see if this is the one we're looking for
1258 if ( (*cmp
)(parent
, label
, id
) )
1259 return (wxWindow
*)parent
;
1261 // It wasn't, so check all its children
1262 for ( wxWindowList::compatibility_iterator node
= parent
->GetChildren().GetFirst();
1264 node
= node
->GetNext() )
1266 // recursively check each child
1267 wxWindow
*win
= (wxWindow
*)node
->GetData();
1268 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1278 // helper for FindWindowByXXX()
1280 wxWindow
*wxFindWindowHelper(const wxWindow
*parent
,
1281 const wxString
& label
,
1283 wxFindWindowCmp cmp
)
1287 // just check parent and all its children
1288 return wxFindWindowRecursively(parent
, label
, id
, cmp
);
1291 // start at very top of wx's windows
1292 for ( wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1294 node
= node
->GetNext() )
1296 // recursively check each window & its children
1297 wxWindow
*win
= node
->GetData();
1298 wxWindow
*retwin
= wxFindWindowRecursively(win
, label
, id
, cmp
);
1308 wxWindowBase::FindWindowByLabel(const wxString
& title
, const wxWindow
*parent
)
1310 return wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpLabels
);
1315 wxWindowBase::FindWindowByName(const wxString
& title
, const wxWindow
*parent
)
1317 wxWindow
*win
= wxFindWindowHelper(parent
, title
, 0, wxFindWindowCmpNames
);
1321 // fall back to the label
1322 win
= FindWindowByLabel(title
, parent
);
1330 wxWindowBase::FindWindowById( long id
, const wxWindow
* parent
)
1332 return wxFindWindowHelper(parent
, _T(""), id
, wxFindWindowCmpIds
);
1335 // ----------------------------------------------------------------------------
1336 // dialog oriented functions
1337 // ----------------------------------------------------------------------------
1339 void wxWindowBase::MakeModal(bool modal
)
1341 // Disable all other windows
1344 wxWindowList::compatibility_iterator node
= wxTopLevelWindows
.GetFirst();
1347 wxWindow
*win
= node
->GetData();
1349 win
->Enable(!modal
);
1351 node
= node
->GetNext();
1356 bool wxWindowBase::Validate()
1358 #if wxUSE_VALIDATORS
1359 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1361 wxWindowList::compatibility_iterator node
;
1362 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1364 wxWindowBase
*child
= node
->GetData();
1365 wxValidator
*validator
= child
->GetValidator();
1366 if ( validator
&& !validator
->Validate((wxWindow
*)this) )
1371 if ( recurse
&& !child
->Validate() )
1376 #endif // wxUSE_VALIDATORS
1381 bool wxWindowBase::TransferDataToWindow()
1383 #if wxUSE_VALIDATORS
1384 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1386 wxWindowList::compatibility_iterator node
;
1387 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1389 wxWindowBase
*child
= node
->GetData();
1390 wxValidator
*validator
= child
->GetValidator();
1391 if ( validator
&& !validator
->TransferToWindow() )
1393 wxLogWarning(_("Could not transfer data to window"));
1395 wxLog::FlushActive();
1403 if ( !child
->TransferDataToWindow() )
1405 // warning already given
1410 #endif // wxUSE_VALIDATORS
1415 bool wxWindowBase::TransferDataFromWindow()
1417 #if wxUSE_VALIDATORS
1418 bool recurse
= (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY
) != 0;
1420 wxWindowList::compatibility_iterator node
;
1421 for ( node
= m_children
.GetFirst(); node
; node
= node
->GetNext() )
1423 wxWindow
*child
= node
->GetData();
1424 wxValidator
*validator
= child
->GetValidator();
1425 if ( validator
&& !validator
->TransferFromWindow() )
1427 // nop warning here because the application is supposed to give
1428 // one itself - we don't know here what might have gone wrongly
1435 if ( !child
->TransferDataFromWindow() )
1437 // warning already given
1442 #endif // wxUSE_VALIDATORS
1447 void wxWindowBase::InitDialog()
1449 wxInitDialogEvent
event(GetId());
1450 event
.SetEventObject( this );
1451 GetEventHandler()->ProcessEvent(event
);
1454 // ----------------------------------------------------------------------------
1455 // context-sensitive help support
1456 // ----------------------------------------------------------------------------
1460 // associate this help text with this window
1461 void wxWindowBase::SetHelpText(const wxString
& text
)
1463 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1466 helpProvider
->AddHelp(this, text
);
1470 // associate this help text with all windows with the same id as this
1472 void wxWindowBase::SetHelpTextForId(const wxString
& text
)
1474 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1477 helpProvider
->AddHelp(GetId(), text
);
1481 // get the help string associated with this window (may be empty)
1482 wxString
wxWindowBase::GetHelpText() const
1485 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1488 text
= helpProvider
->GetHelp(this);
1494 // show help for this window
1495 void wxWindowBase::OnHelp(wxHelpEvent
& event
)
1497 wxHelpProvider
*helpProvider
= wxHelpProvider::Get();
1500 if ( helpProvider
->ShowHelp(this) )
1502 // skip the event.Skip() below
1510 #endif // wxUSE_HELP
1512 // ----------------------------------------------------------------------------
1513 // tooltipsroot.Replace("\\", "/");
1514 // ----------------------------------------------------------------------------
1518 void wxWindowBase::SetToolTip( const wxString
&tip
)
1520 // don't create the new tooltip if we already have one
1523 m_tooltip
->SetTip( tip
);
1527 SetToolTip( new wxToolTip( tip
) );
1530 // setting empty tooltip text does not remove the tooltip any more - use
1531 // SetToolTip((wxToolTip *)NULL) for this
1534 void wxWindowBase::DoSetToolTip(wxToolTip
*tooltip
)
1539 m_tooltip
= tooltip
;
1542 #endif // wxUSE_TOOLTIPS
1544 // ----------------------------------------------------------------------------
1545 // constraints and sizers
1546 // ----------------------------------------------------------------------------
1548 #if wxUSE_CONSTRAINTS
1550 void wxWindowBase::SetConstraints( wxLayoutConstraints
*constraints
)
1552 if ( m_constraints
)
1554 UnsetConstraints(m_constraints
);
1555 delete m_constraints
;
1557 m_constraints
= constraints
;
1558 if ( m_constraints
)
1560 // Make sure other windows know they're part of a 'meaningful relationship'
1561 if ( m_constraints
->left
.GetOtherWindow() && (m_constraints
->left
.GetOtherWindow() != this) )
1562 m_constraints
->left
.GetOtherWindow()->AddConstraintReference(this);
1563 if ( m_constraints
->top
.GetOtherWindow() && (m_constraints
->top
.GetOtherWindow() != this) )
1564 m_constraints
->top
.GetOtherWindow()->AddConstraintReference(this);
1565 if ( m_constraints
->right
.GetOtherWindow() && (m_constraints
->right
.GetOtherWindow() != this) )
1566 m_constraints
->right
.GetOtherWindow()->AddConstraintReference(this);
1567 if ( m_constraints
->bottom
.GetOtherWindow() && (m_constraints
->bottom
.GetOtherWindow() != this) )
1568 m_constraints
->bottom
.GetOtherWindow()->AddConstraintReference(this);
1569 if ( m_constraints
->width
.GetOtherWindow() && (m_constraints
->width
.GetOtherWindow() != this) )
1570 m_constraints
->width
.GetOtherWindow()->AddConstraintReference(this);
1571 if ( m_constraints
->height
.GetOtherWindow() && (m_constraints
->height
.GetOtherWindow() != this) )
1572 m_constraints
->height
.GetOtherWindow()->AddConstraintReference(this);
1573 if ( m_constraints
->centreX
.GetOtherWindow() && (m_constraints
->centreX
.GetOtherWindow() != this) )
1574 m_constraints
->centreX
.GetOtherWindow()->AddConstraintReference(this);
1575 if ( m_constraints
->centreY
.GetOtherWindow() && (m_constraints
->centreY
.GetOtherWindow() != this) )
1576 m_constraints
->centreY
.GetOtherWindow()->AddConstraintReference(this);
1580 // This removes any dangling pointers to this window in other windows'
1581 // constraintsInvolvedIn lists.
1582 void wxWindowBase::UnsetConstraints(wxLayoutConstraints
*c
)
1586 if ( c
->left
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1587 c
->left
.GetOtherWindow()->RemoveConstraintReference(this);
1588 if ( c
->top
.GetOtherWindow() && (c
->top
.GetOtherWindow() != this) )
1589 c
->top
.GetOtherWindow()->RemoveConstraintReference(this);
1590 if ( c
->right
.GetOtherWindow() && (c
->right
.GetOtherWindow() != this) )
1591 c
->right
.GetOtherWindow()->RemoveConstraintReference(this);
1592 if ( c
->bottom
.GetOtherWindow() && (c
->bottom
.GetOtherWindow() != this) )
1593 c
->bottom
.GetOtherWindow()->RemoveConstraintReference(this);
1594 if ( c
->width
.GetOtherWindow() && (c
->width
.GetOtherWindow() != this) )
1595 c
->width
.GetOtherWindow()->RemoveConstraintReference(this);
1596 if ( c
->height
.GetOtherWindow() && (c
->height
.GetOtherWindow() != this) )
1597 c
->height
.GetOtherWindow()->RemoveConstraintReference(this);
1598 if ( c
->centreX
.GetOtherWindow() && (c
->centreX
.GetOtherWindow() != this) )
1599 c
->centreX
.GetOtherWindow()->RemoveConstraintReference(this);
1600 if ( c
->centreY
.GetOtherWindow() && (c
->centreY
.GetOtherWindow() != this) )
1601 c
->centreY
.GetOtherWindow()->RemoveConstraintReference(this);
1605 // Back-pointer to other windows we're involved with, so if we delete this
1606 // window, we must delete any constraints we're involved with.
1607 void wxWindowBase::AddConstraintReference(wxWindowBase
*otherWin
)
1609 if ( !m_constraintsInvolvedIn
)
1610 m_constraintsInvolvedIn
= new wxWindowList
;
1611 if ( !m_constraintsInvolvedIn
->Find((wxWindow
*)otherWin
) )
1612 m_constraintsInvolvedIn
->Append((wxWindow
*)otherWin
);
1615 // REMOVE back-pointer to other windows we're involved with.
1616 void wxWindowBase::RemoveConstraintReference(wxWindowBase
*otherWin
)
1618 if ( m_constraintsInvolvedIn
)
1619 m_constraintsInvolvedIn
->DeleteObject((wxWindow
*)otherWin
);
1622 // Reset any constraints that mention this window
1623 void wxWindowBase::DeleteRelatedConstraints()
1625 if ( m_constraintsInvolvedIn
)
1627 wxWindowList::compatibility_iterator node
= m_constraintsInvolvedIn
->GetFirst();
1630 wxWindow
*win
= node
->GetData();
1631 wxLayoutConstraints
*constr
= win
->GetConstraints();
1633 // Reset any constraints involving this window
1636 constr
->left
.ResetIfWin(this);
1637 constr
->top
.ResetIfWin(this);
1638 constr
->right
.ResetIfWin(this);
1639 constr
->bottom
.ResetIfWin(this);
1640 constr
->width
.ResetIfWin(this);
1641 constr
->height
.ResetIfWin(this);
1642 constr
->centreX
.ResetIfWin(this);
1643 constr
->centreY
.ResetIfWin(this);
1646 wxWindowList::compatibility_iterator next
= node
->GetNext();
1647 m_constraintsInvolvedIn
->Erase(node
);
1651 delete m_constraintsInvolvedIn
;
1652 m_constraintsInvolvedIn
= (wxWindowList
*) NULL
;
1656 #endif // wxUSE_CONSTRAINTS
1658 void wxWindowBase::SetSizer(wxSizer
*sizer
, bool deleteOld
)
1660 if ( sizer
== m_windowSizer
)
1664 delete m_windowSizer
;
1666 m_windowSizer
= sizer
;
1668 SetAutoLayout( sizer
!= NULL
);
1671 void wxWindowBase::SetSizerAndFit(wxSizer
*sizer
, bool deleteOld
)
1673 SetSizer( sizer
, deleteOld
);
1674 sizer
->SetSizeHints( (wxWindow
*) this );
1678 void wxWindowBase::SetContainingSizer(wxSizer
* sizer
)
1680 // adding a window to a sizer twice is going to result in fatal and
1681 // hard to debug problems later because when deleting the second
1682 // associated wxSizerItem we're going to dereference a dangling
1683 // pointer; so try to detect this as early as possible
1684 wxASSERT_MSG( !sizer
|| m_containingSizer
!= sizer
,
1685 _T("Adding a window to the same sizer twice?") );
1687 m_containingSizer
= sizer
;
1690 #if wxUSE_CONSTRAINTS
1692 void wxWindowBase::SatisfyConstraints()
1694 wxLayoutConstraints
*constr
= GetConstraints();
1695 bool wasOk
= constr
&& constr
->AreSatisfied();
1697 ResetConstraints(); // Mark all constraints as unevaluated
1701 // if we're a top level panel (i.e. our parent is frame/dialog), our
1702 // own constraints will never be satisfied any more unless we do it
1706 while ( noChanges
> 0 )
1708 LayoutPhase1(&noChanges
);
1712 LayoutPhase2(&noChanges
);
1715 #endif // wxUSE_CONSTRAINTS
1717 bool wxWindowBase::Layout()
1719 // If there is a sizer, use it instead of the constraints
1723 GetVirtualSize(&w
, &h
);
1724 GetSizer()->SetDimension( 0, 0, w
, h
);
1726 #if wxUSE_CONSTRAINTS
1729 SatisfyConstraints(); // Find the right constraints values
1730 SetConstraintSizes(); // Recursively set the real window sizes
1737 #if wxUSE_CONSTRAINTS
1739 // first phase of the constraints evaluation: set our own constraints
1740 bool wxWindowBase::LayoutPhase1(int *noChanges
)
1742 wxLayoutConstraints
*constr
= GetConstraints();
1744 return !constr
|| constr
->SatisfyConstraints(this, noChanges
);
1747 // second phase: set the constraints for our children
1748 bool wxWindowBase::LayoutPhase2(int *noChanges
)
1755 // Layout grand children
1761 // Do a phase of evaluating child constraints
1762 bool wxWindowBase::DoPhase(int phase
)
1764 // the list containing the children for which the constraints are already
1766 wxWindowList succeeded
;
1768 // the max number of iterations we loop before concluding that we can't set
1770 static const int maxIterations
= 500;
1772 for ( int noIterations
= 0; noIterations
< maxIterations
; noIterations
++ )
1776 // loop over all children setting their constraints
1777 for ( wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1779 node
= node
->GetNext() )
1781 wxWindow
*child
= node
->GetData();
1782 if ( child
->IsTopLevel() )
1784 // top level children are not inside our client area
1788 if ( !child
->GetConstraints() || succeeded
.Find(child
) )
1790 // this one is either already ok or nothing we can do about it
1794 int tempNoChanges
= 0;
1795 bool success
= phase
== 1 ? child
->LayoutPhase1(&tempNoChanges
)
1796 : child
->LayoutPhase2(&tempNoChanges
);
1797 noChanges
+= tempNoChanges
;
1801 succeeded
.Append(child
);
1807 // constraints are set
1815 void wxWindowBase::ResetConstraints()
1817 wxLayoutConstraints
*constr
= GetConstraints();
1820 constr
->left
.SetDone(false);
1821 constr
->top
.SetDone(false);
1822 constr
->right
.SetDone(false);
1823 constr
->bottom
.SetDone(false);
1824 constr
->width
.SetDone(false);
1825 constr
->height
.SetDone(false);
1826 constr
->centreX
.SetDone(false);
1827 constr
->centreY
.SetDone(false);
1830 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1833 wxWindow
*win
= node
->GetData();
1834 if ( !win
->IsTopLevel() )
1835 win
->ResetConstraints();
1836 node
= node
->GetNext();
1840 // Need to distinguish between setting the 'fake' size for windows and sizers,
1841 // and setting the real values.
1842 void wxWindowBase::SetConstraintSizes(bool recurse
)
1844 wxLayoutConstraints
*constr
= GetConstraints();
1845 if ( constr
&& constr
->AreSatisfied() )
1847 int x
= constr
->left
.GetValue();
1848 int y
= constr
->top
.GetValue();
1849 int w
= constr
->width
.GetValue();
1850 int h
= constr
->height
.GetValue();
1852 if ( (constr
->width
.GetRelationship() != wxAsIs
) ||
1853 (constr
->height
.GetRelationship() != wxAsIs
) )
1855 SetSize(x
, y
, w
, h
);
1859 // If we don't want to resize this window, just move it...
1865 wxLogDebug(wxT("Constraints not satisfied for %s named '%s'."),
1866 GetClassInfo()->GetClassName(),
1872 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
1875 wxWindow
*win
= node
->GetData();
1876 if ( !win
->IsTopLevel() && win
->GetConstraints() )
1877 win
->SetConstraintSizes();
1878 node
= node
->GetNext();
1883 // Only set the size/position of the constraint (if any)
1884 void wxWindowBase::SetSizeConstraint(int x
, int y
, int w
, int h
)
1886 wxLayoutConstraints
*constr
= GetConstraints();
1891 constr
->left
.SetValue(x
);
1892 constr
->left
.SetDone(true);
1896 constr
->top
.SetValue(y
);
1897 constr
->top
.SetDone(true);
1901 constr
->width
.SetValue(w
);
1902 constr
->width
.SetDone(true);
1906 constr
->height
.SetValue(h
);
1907 constr
->height
.SetDone(true);
1912 void wxWindowBase::MoveConstraint(int x
, int y
)
1914 wxLayoutConstraints
*constr
= GetConstraints();
1919 constr
->left
.SetValue(x
);
1920 constr
->left
.SetDone(true);
1924 constr
->top
.SetValue(y
);
1925 constr
->top
.SetDone(true);
1930 void wxWindowBase::GetSizeConstraint(int *w
, int *h
) const
1932 wxLayoutConstraints
*constr
= GetConstraints();
1935 *w
= constr
->width
.GetValue();
1936 *h
= constr
->height
.GetValue();
1942 void wxWindowBase::GetClientSizeConstraint(int *w
, int *h
) const
1944 wxLayoutConstraints
*constr
= GetConstraints();
1947 *w
= constr
->width
.GetValue();
1948 *h
= constr
->height
.GetValue();
1951 GetClientSize(w
, h
);
1954 void wxWindowBase::GetPositionConstraint(int *x
, int *y
) const
1956 wxLayoutConstraints
*constr
= GetConstraints();
1959 *x
= constr
->left
.GetValue();
1960 *y
= constr
->top
.GetValue();
1966 #endif // wxUSE_CONSTRAINTS
1968 void wxWindowBase::AdjustForParentClientOrigin(int& x
, int& y
, int sizeFlags
) const
1970 // don't do it for the dialogs/frames - they float independently of their
1972 if ( !IsTopLevel() )
1974 wxWindow
*parent
= GetParent();
1975 if ( !(sizeFlags
& wxSIZE_NO_ADJUSTMENTS
) && parent
)
1977 wxPoint
pt(parent
->GetClientAreaOrigin());
1984 // ----------------------------------------------------------------------------
1985 // do Update UI processing for child controls
1986 // ----------------------------------------------------------------------------
1988 void wxWindowBase::UpdateWindowUI(long flags
)
1990 wxUpdateUIEvent
event(GetId());
1991 event
.m_eventObject
= this;
1993 if ( GetEventHandler()->ProcessEvent(event
) )
1995 DoUpdateWindowUI(event
);
1998 if (flags
& wxUPDATE_UI_RECURSE
)
2000 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2003 wxWindow
* child
= (wxWindow
*) node
->GetData();
2004 child
->UpdateWindowUI(flags
);
2005 node
= node
->GetNext();
2010 // do the window-specific processing after processing the update event
2011 // TODO: take specific knowledge out of this function and
2012 // put in each control's base class. Unfortunately we don't
2013 // yet have base implementation files for wxCheckBox and wxRadioButton.
2014 void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent
& event
)
2016 if ( event
.GetSetEnabled() )
2017 Enable(event
.GetEnabled());
2020 if ( event
.GetSetText() )
2022 wxControl
*control
= wxDynamicCastThis(wxControl
);
2025 if ( event
.GetText() != control
->GetLabel() )
2026 control
->SetLabel(event
.GetText());
2029 wxCheckBox
*checkbox
= wxDynamicCastThis(wxCheckBox
);
2032 if ( event
.GetSetChecked() )
2033 checkbox
->SetValue(event
.GetChecked());
2035 #endif // wxUSE_CHECKBOX
2038 wxRadioButton
*radiobtn
= wxDynamicCastThis(wxRadioButton
);
2041 if ( event
.GetSetChecked() )
2042 radiobtn
->SetValue(event
.GetChecked());
2044 #endif // wxUSE_RADIOBTN
2050 // call internal idle recursively
2051 // may be obsolete (wait until OnIdle scheme stabilises)
2052 void wxWindowBase::ProcessInternalIdle()
2056 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2059 wxWindow
*child
= node
->GetData();
2060 child
->ProcessInternalIdle();
2061 node
= node
->GetNext();
2066 // ----------------------------------------------------------------------------
2067 // dialog units translations
2068 // ----------------------------------------------------------------------------
2070 wxPoint
wxWindowBase::ConvertPixelsToDialog(const wxPoint
& pt
)
2072 int charWidth
= GetCharWidth();
2073 int charHeight
= GetCharHeight();
2074 wxPoint
pt2(-1, -1);
2076 pt2
.x
= (int) ((pt
.x
* 4) / charWidth
);
2078 pt2
.y
= (int) ((pt
.y
* 8) / charHeight
);
2083 wxPoint
wxWindowBase::ConvertDialogToPixels(const wxPoint
& pt
)
2085 int charWidth
= GetCharWidth();
2086 int charHeight
= GetCharHeight();
2087 wxPoint
pt2(-1, -1);
2089 pt2
.x
= (int) ((pt
.x
* charWidth
) / 4);
2091 pt2
.y
= (int) ((pt
.y
* charHeight
) / 8);
2096 // ----------------------------------------------------------------------------
2098 // ----------------------------------------------------------------------------
2100 // propagate the colour change event to the subwindows
2101 void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent
& event
)
2103 wxWindowList::compatibility_iterator node
= GetChildren().GetFirst();
2106 // Only propagate to non-top-level windows
2107 wxWindow
*win
= node
->GetData();
2108 if ( !win
->IsTopLevel() )
2110 wxSysColourChangedEvent event2
;
2111 event
.m_eventObject
= win
;
2112 win
->GetEventHandler()->ProcessEvent(event2
);
2115 node
= node
->GetNext();
2119 // the default action is to populate dialog with data when it's created,
2120 // and nudge the UI into displaying itself correctly in case
2121 // we've turned the wxUpdateUIEvents frequency down low.
2122 void wxWindowBase::OnInitDialog( wxInitDialogEvent
&WXUNUSED(event
) )
2124 TransferDataToWindow();
2126 // Update the UI at this point
2127 UpdateWindowUI(wxUPDATE_UI_RECURSE
);
2130 // process Ctrl-Alt-mclick
2131 void wxWindowBase::OnMiddleClick( wxMouseEvent
& event
)
2134 if ( event
.ControlDown() && event
.AltDown() )
2136 // don't translate these strings
2139 #ifdef __WXUNIVERSAL__
2141 #endif // __WXUNIVERSAL__
2143 switch ( wxGetOsVersion() )
2145 case wxMOTIF_X
: port
+= _T("Motif"); break;
2147 case wxMAC_DARWIN
: port
+= _T("Mac"); break;
2148 case wxBEOS
: port
+= _T("BeOS"); break;
2152 case wxGTK_BEOS
: port
+= _T("GTK"); break;
2158 case wxWIN386
: port
+= _T("MS Windows"); break;
2162 case wxMGL_OS2
: port
+= _T("MGL"); break;
2164 case wxOS2_PM
: port
+= _T("OS/2"); break;
2165 default: port
+= _T("unknown"); break;
2168 wxMessageBox(wxString::Format(
2170 " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2002 wxWindows team"
2184 _T("wxWindows information"),
2185 wxICON_INFORMATION
| wxOK
,
2189 #endif // wxUSE_MSGDLG
2195 // ----------------------------------------------------------------------------
2197 // ----------------------------------------------------------------------------
2199 #if wxUSE_ACCESSIBILITY
2200 void wxWindowBase::SetAccessible(wxAccessible
* accessible
)
2202 if (m_accessible
&& (accessible
!= m_accessible
))
2203 delete m_accessible
;
2204 m_accessible
= accessible
;
2206 m_accessible
->SetWindow((wxWindow
*) this);
2209 // Returns the accessible object, creating if necessary.
2210 wxAccessible
* wxWindowBase::GetOrCreateAccessible()
2213 m_accessible
= CreateAccessible();
2214 return m_accessible
;
2217 // Override to create a specific accessible object.
2218 wxAccessible
* wxWindowBase::CreateAccessible()
2220 return new wxWindowAccessible((wxWindow
*) this);
2226 // ----------------------------------------------------------------------------
2227 // list classes implementation
2228 // ----------------------------------------------------------------------------
2230 void wxWindowListNode::DeleteData()
2232 delete (wxWindow
*)GetData();
2236 // ----------------------------------------------------------------------------
2238 // ----------------------------------------------------------------------------
2240 wxBorder
wxWindowBase::GetBorder(long flags
) const
2242 wxBorder border
= (wxBorder
)(flags
& wxBORDER_MASK
);
2243 if ( border
== wxBORDER_DEFAULT
)
2245 border
= GetDefaultBorder();
2251 wxBorder
wxWindowBase::GetDefaultBorder() const
2253 return wxBORDER_NONE
;
2256 // ----------------------------------------------------------------------------
2258 // ----------------------------------------------------------------------------
2260 wxHitTest
wxWindowBase::DoHitTest(wxCoord x
, wxCoord y
) const
2262 // here we just check if the point is inside the window or not
2264 // check the top and left border first
2265 bool outside
= x
< 0 || y
< 0;
2268 // check the right and bottom borders too
2269 wxSize size
= GetSize();
2270 outside
= x
>= size
.x
|| y
>= size
.y
;
2273 return outside
? wxHT_WINDOW_OUTSIDE
: wxHT_WINDOW_INSIDE
;
2276 // ----------------------------------------------------------------------------
2278 // ----------------------------------------------------------------------------
2280 struct WXDLLEXPORT wxWindowNext
2284 } *wxWindowBase::ms_winCaptureNext
= NULL
;
2286 void wxWindowBase::CaptureMouse()
2288 wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this);
2290 wxWindow
*winOld
= GetCapture();
2293 ((wxWindowBase
*) winOld
)->DoReleaseMouse();
2296 wxWindowNext
*item
= new wxWindowNext
;
2298 item
->next
= ms_winCaptureNext
;
2299 ms_winCaptureNext
= item
;
2301 //else: no mouse capture to save
2306 void wxWindowBase::ReleaseMouse()
2308 wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
2310 wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
2314 if ( ms_winCaptureNext
)
2316 ((wxWindowBase
*)ms_winCaptureNext
->win
)->DoCaptureMouse();
2318 wxWindowNext
*item
= ms_winCaptureNext
;
2319 ms_winCaptureNext
= item
->next
;
2322 //else: stack is empty, no previous capture
2324 wxLogTrace(_T("mousecapture"),
2325 (const wxChar
*) _T("After ReleaseMouse() mouse is captured by %p"),
2332 wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId
),
2333 int WXUNUSED(modifiers
),
2334 int WXUNUSED(keycode
))
2340 bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId
))
2346 #endif // wxUSE_HOTKEY
2348 void wxWindowBase::SendDestroyEvent()
2350 wxWindowDestroyEvent event
;
2351 event
.SetEventObject(this);
2352 event
.SetId(GetId());
2353 GetEventHandler()->ProcessEvent(event
);
2356 // ----------------------------------------------------------------------------
2358 // ----------------------------------------------------------------------------
2360 bool wxWindowBase::TryValidator(wxEvent
& wxVALIDATOR_PARAM(event
))
2362 #if wxUSE_VALIDATORS
2363 // Can only use the validator of the window which
2364 // is receiving the event
2365 if ( event
.GetEventObject() == this )
2367 wxValidator
*validator
= GetValidator();
2368 if ( validator
&& validator
->ProcessEvent(event
) )
2373 #endif // wxUSE_VALIDATORS
2378 bool wxWindowBase::TryParent(wxEvent
& event
)
2380 // carry on up the parent-child hierarchy if the propgation count hasn't
2382 if ( event
.ShouldPropagate() )
2384 // honour the requests to stop propagation at this window: this is
2385 // used by the dialogs, for example, to prevent processing the events
2386 // from the dialog controls in the parent frame which rarely, if ever,
2388 if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS
) )
2390 wxWindow
*parent
= GetParent();
2391 if ( parent
&& !parent
->IsBeingDeleted() )
2393 wxPropagateOnce
propagateOnce(event
);
2395 return parent
->GetEventHandler()->ProcessEvent(event
);
2400 return wxEvtHandler::TryParent(event
);
2403 // ----------------------------------------------------------------------------
2405 // ----------------------------------------------------------------------------
2407 wxWindow
* wxGetTopLevelParent(wxWindow
*win
)
2409 while ( win
&& !win
->IsTopLevel() )
2410 win
= win
->GetParent();
2415 #if wxUSE_ACCESSIBILITY
2416 // ----------------------------------------------------------------------------
2417 // accessible object for windows
2418 // ----------------------------------------------------------------------------
2420 // Can return either a child object, or an integer
2421 // representing the child element, starting from 1.
2422 wxAccStatus
wxWindowAccessible::HitTest(const wxPoint
& WXUNUSED(pt
), int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(childObject
))
2424 wxASSERT( GetWindow() != NULL
);
2428 return wxACC_NOT_IMPLEMENTED
;
2431 // Returns the rectangle for this object (id = 0) or a child element (id > 0).
2432 wxAccStatus
wxWindowAccessible::GetLocation(wxRect
& rect
, int elementId
)
2434 wxASSERT( GetWindow() != NULL
);
2438 wxWindow
* win
= NULL
;
2445 if (elementId
<= (int) GetWindow()->GetChildren().GetCount())
2447 win
= GetWindow()->GetChildren().Item(elementId
-1)->GetData();
2454 rect
= win
->GetRect();
2455 if (win
->GetParent() && !win
->IsKindOf(CLASSINFO(wxTopLevelWindow
)))
2456 rect
.SetPosition(win
->GetParent()->ClientToScreen(rect
.GetPosition()));
2460 return wxACC_NOT_IMPLEMENTED
;
2463 // Navigates from fromId to toId/toObject.
2464 wxAccStatus
wxWindowAccessible::Navigate(wxNavDir navDir
, int fromId
,
2465 int* WXUNUSED(toId
), wxAccessible
** toObject
)
2467 wxASSERT( GetWindow() != NULL
);
2473 case wxNAVDIR_FIRSTCHILD
:
2475 if (GetWindow()->GetChildren().GetCount() == 0)
2477 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetFirst()->GetData();
2478 *toObject
= childWindow
->GetOrCreateAccessible();
2482 case wxNAVDIR_LASTCHILD
:
2484 if (GetWindow()->GetChildren().GetCount() == 0)
2486 wxWindow
* childWindow
= (wxWindow
*) GetWindow()->GetChildren().GetLast()->GetData();
2487 *toObject
= childWindow
->GetOrCreateAccessible();
2491 case wxNAVDIR_RIGHT
:
2495 wxWindowList::compatibility_iterator node
=
2496 wxWindowList::compatibility_iterator();
2499 // Can't navigate to sibling of this window
2500 // if we're a top-level window.
2501 if (!GetWindow()->GetParent())
2502 return wxACC_NOT_IMPLEMENTED
;
2504 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2508 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2509 node
= GetWindow()->GetChildren().Item(fromId
-1);
2512 if (node
&& node
->GetNext())
2514 wxWindow
* nextWindow
= node
->GetNext()->GetData();
2515 *toObject
= nextWindow
->GetOrCreateAccessible();
2523 case wxNAVDIR_PREVIOUS
:
2525 wxWindowList::compatibility_iterator node
=
2526 wxWindowList::compatibility_iterator();
2529 // Can't navigate to sibling of this window
2530 // if we're a top-level window.
2531 if (!GetWindow()->GetParent())
2532 return wxACC_NOT_IMPLEMENTED
;
2534 node
= GetWindow()->GetParent()->GetChildren().Find(GetWindow());
2538 if (fromId
<= (int) GetWindow()->GetChildren().GetCount())
2539 node
= GetWindow()->GetChildren().Item(fromId
-1);
2542 if (node
&& node
->GetPrevious())
2544 wxWindow
* previousWindow
= node
->GetPrevious()->GetData();
2545 *toObject
= previousWindow
->GetOrCreateAccessible();
2553 return wxACC_NOT_IMPLEMENTED
;
2556 // Gets the name of the specified object.
2557 wxAccStatus
wxWindowAccessible::GetName(int childId
, wxString
* name
)
2559 wxASSERT( GetWindow() != NULL
);
2565 // If a child, leave wxWindows to call the function on the actual
2568 return wxACC_NOT_IMPLEMENTED
;
2570 // This will eventually be replaced by specialised
2571 // accessible classes, one for each kind of wxWindows
2572 // control or window.
2573 if (GetWindow()->IsKindOf(CLASSINFO(wxButton
)))
2574 title
= ((wxButton
*) GetWindow())->GetLabel();
2576 title
= GetWindow()->GetName();
2578 if (!title
.IsEmpty())
2584 return wxACC_NOT_IMPLEMENTED
;
2587 // Gets the number of children.
2588 wxAccStatus
wxWindowAccessible::GetChildCount(int* childId
)
2590 wxASSERT( GetWindow() != NULL
);
2594 *childId
= (int) GetWindow()->GetChildren().GetCount();
2598 // Gets the specified child (starting from 1).
2599 // If *child is NULL and return value is wxACC_OK,
2600 // this means that the child is a simple element and
2601 // not an accessible object.
2602 wxAccStatus
wxWindowAccessible::GetChild(int childId
, wxAccessible
** child
)
2604 wxASSERT( GetWindow() != NULL
);
2614 if (childId
> (int) GetWindow()->GetChildren().GetCount())
2617 wxWindow
* childWindow
= GetWindow()->GetChildren().Item(childId
-1)->GetData();
2618 *child
= childWindow
->GetOrCreateAccessible();
2625 // Gets the parent, or NULL.
2626 wxAccStatus
wxWindowAccessible::GetParent(wxAccessible
** parent
)
2628 wxASSERT( GetWindow() != NULL
);
2632 wxWindow
* parentWindow
= GetWindow()->GetParent();
2640 *parent
= parentWindow
->GetOrCreateAccessible();
2648 // Performs the default action. childId is 0 (the action for this object)
2649 // or > 0 (the action for a child).
2650 // Return wxACC_NOT_SUPPORTED if there is no default action for this
2651 // window (e.g. an edit control).
2652 wxAccStatus
wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId
))
2654 wxASSERT( GetWindow() != NULL
);
2658 return wxACC_NOT_IMPLEMENTED
;
2661 // Gets the default action for this object (0) or > 0 (the action for a child).
2662 // Return wxACC_OK even if there is no action. actionName is the action, or the empty
2663 // string if there is no action.
2664 // The retrieved string describes the action that is performed on an object,
2665 // not what the object does as a result. For example, a toolbar button that prints
2666 // a document has a default action of "Press" rather than "Prints the current document."
2667 wxAccStatus
wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId
), wxString
* WXUNUSED(actionName
))
2669 wxASSERT( GetWindow() != NULL
);
2673 return wxACC_NOT_IMPLEMENTED
;
2676 // Returns the description for this object or a child.
2677 wxAccStatus
wxWindowAccessible::GetDescription(int WXUNUSED(childId
), wxString
* description
)
2679 wxASSERT( GetWindow() != NULL
);
2683 wxString
ht(GetWindow()->GetHelpText());
2689 return wxACC_NOT_IMPLEMENTED
;
2692 // Returns help text for this object or a child, similar to tooltip text.
2693 wxAccStatus
wxWindowAccessible::GetHelpText(int WXUNUSED(childId
), wxString
* helpText
)
2695 wxASSERT( GetWindow() != NULL
);
2699 wxString
ht(GetWindow()->GetHelpText());
2705 return wxACC_NOT_IMPLEMENTED
;
2708 // Returns the keyboard shortcut for this object or child.
2709 // Return e.g. ALT+K
2710 wxAccStatus
wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId
), wxString
* WXUNUSED(shortcut
))
2712 wxASSERT( GetWindow() != NULL
);
2716 return wxACC_NOT_IMPLEMENTED
;
2719 // Returns a role constant.
2720 wxAccStatus
wxWindowAccessible::GetRole(int childId
, wxAccRole
* role
)
2722 wxASSERT( GetWindow() != NULL
);
2726 // If a child, leave wxWindows to call the function on the actual
2729 return wxACC_NOT_IMPLEMENTED
;
2731 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2732 return wxACC_NOT_IMPLEMENTED
;
2734 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2735 return wxACC_NOT_IMPLEMENTED
;
2738 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2739 return wxACC_NOT_IMPLEMENTED
;
2742 //*role = wxROLE_SYSTEM_CLIENT;
2743 *role
= wxROLE_SYSTEM_CLIENT
;
2747 return wxACC_NOT_IMPLEMENTED
;
2751 // Returns a state constant.
2752 wxAccStatus
wxWindowAccessible::GetState(int childId
, long* state
)
2754 wxASSERT( GetWindow() != NULL
);
2758 // If a child, leave wxWindows to call the function on the actual
2761 return wxACC_NOT_IMPLEMENTED
;
2763 if (GetWindow()->IsKindOf(CLASSINFO(wxControl
)))
2764 return wxACC_NOT_IMPLEMENTED
;
2767 if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar
)))
2768 return wxACC_NOT_IMPLEMENTED
;
2771 if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar
)))
2772 return wxACC_NOT_IMPLEMENTED
;
2779 return wxACC_NOT_IMPLEMENTED
;
2783 // Returns a localized string representing the value for the object
2785 wxAccStatus
wxWindowAccessible::GetValue(int WXUNUSED(childId
), wxString
* WXUNUSED(strValue
))
2787 wxASSERT( GetWindow() != NULL
);
2791 return wxACC_NOT_IMPLEMENTED
;
2794 // Selects the object or child.
2795 wxAccStatus
wxWindowAccessible::Select(int WXUNUSED(childId
), wxAccSelectionFlags
WXUNUSED(selectFlags
))
2797 wxASSERT( GetWindow() != NULL
);
2801 return wxACC_NOT_IMPLEMENTED
;
2804 // Gets the window with the keyboard focus.
2805 // If childId is 0 and child is NULL, no object in
2806 // this subhierarchy has the focus.
2807 // If this object has the focus, child should be 'this'.
2808 wxAccStatus
wxWindowAccessible::GetFocus(int* WXUNUSED(childId
), wxAccessible
** WXUNUSED(child
))
2810 wxASSERT( GetWindow() != NULL
);
2814 return wxACC_NOT_IMPLEMENTED
;
2817 // Gets a variant representing the selected children
2819 // Acceptable values:
2820 // - a null variant (IsNull() returns TRUE)
2821 // - a list variant (GetType() == wxT("list")
2822 // - an integer representing the selected child element,
2823 // or 0 if this object is selected (GetType() == wxT("long")
2824 // - a "void*" pointer to a wxAccessible child object
2825 wxAccStatus
wxWindowAccessible::GetSelections(wxVariant
* WXUNUSED(selections
))
2827 wxASSERT( GetWindow() != NULL
);
2831 return wxACC_NOT_IMPLEMENTED
;
2834 #endif // wxUSE_ACCESSIBILITY