X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/3a074ba8f6df3a80e0d6a89d138b1a9caa7c8366..025644120d48ad13f1bb1fd82d9cc8f61c505364:/src/common/wincmn.cpp diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp index dd19223457..6eac63e1a9 100644 --- a/src/common/wincmn.cpp +++ b/src/common/wincmn.cpp @@ -1,12 +1,12 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: common/window.cpp +// Name: src/common/window.cpp // Purpose: common (to all ports) wxWindow functions // Author: Julian Smart, Vadim Zeitlin // Modified by: // Created: 13/07/98 // RCS-ID: $Id$ -// Copyright: (c) wxWindows team -// Licence: wxWindows license +// Copyright: (c) wxWidgets team +// Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// // ============================================================================ @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#ifdef __GNUG__ - #pragma implementation "windowbase.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,28 +29,32 @@ #include "wx/log.h" #include "wx/intl.h" #include "wx/frame.h" - #include "wx/defs.h" #include "wx/window.h" #include "wx/control.h" #include "wx/checkbox.h" #include "wx/radiobut.h" + #include "wx/statbox.h" #include "wx/textctrl.h" #include "wx/settings.h" #include "wx/dialog.h" #include "wx/msgdlg.h" #include "wx/statusbr.h" -#endif //WX_PRECOMP - -#if wxUSE_CONSTRAINTS + #include "wx/toolbar.h" + #include "wx/dcclient.h" + #include "wx/scrolbar.h" #include "wx/layout.h" -#endif // wxUSE_CONSTRAINTS - -#include "wx/sizer.h" + #include "wx/sizer.h" + #include "wx/menu.h" +#endif //WX_PRECOMP #if wxUSE_DRAG_AND_DROP #include "wx/dnd.h" #endif // wxUSE_DRAG_AND_DROP +#if wxUSE_ACCESSIBILITY + #include "wx/access.h" +#endif + #if wxUSE_HELP #include "wx/cshelp.h" #endif // wxUSE_HELP @@ -67,11 +67,34 @@ #include "wx/caret.h" #endif // wxUSE_CARET +#if wxUSE_SYSTEM_OPTIONS + #include "wx/sysopt.h" +#endif + +// For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog. +// The gtk includes don't pull any other headers in, at least not on my system - MR +#ifdef __WXGTK__ + #ifdef __WXGTK20__ + #include + #else + #include + #endif +#endif + +#include "wx/platinfo.h" + +// Windows List +WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows; + +// globals +#if wxUSE_MENUS +wxMenu *wxCurrentPopupMenu = NULL; +#endif // wxUSE_MENUS + // ---------------------------------------------------------------------------- // static data // ---------------------------------------------------------------------------- -int wxWindowBase::ms_lastControlId = -200; IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler) @@ -85,7 +108,7 @@ BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler) EVT_MIDDLE_DOWN(wxWindowBase::OnMiddleClick) #if wxUSE_HELP - EVT_HELP(-1, wxWindowBase::OnHelp) + EVT_HELP(wxID_ANY, wxWindowBase::OnHelp) #endif // wxUSE_HELP END_EVENT_TABLE() @@ -99,22 +122,24 @@ END_EVENT_TABLE() // ---------------------------------------------------------------------------- // the default initialization -void wxWindowBase::InitBase() +wxWindowBase::wxWindowBase() { // no window yet, no parent nor children m_parent = (wxWindow *)NULL; - m_windowId = -1; - m_children.DeleteContents( FALSE ); // don't auto delete node data + m_windowId = wxID_ANY; // no constraints on the minimal window size m_minWidth = + m_maxWidth = wxDefaultCoord; m_minHeight = - m_maxWidth = - m_maxHeight = -1; + m_maxHeight = wxDefaultCoord; + + // invalidiated cache value + m_bestSizeCache = wxDefaultSize; - // window is created enabled but it's not visible yet - m_isShown = FALSE; - m_isEnabled = TRUE; + // window are created enabled and visible by default + m_isShown = + m_isEnabled = true; // the default event handler is just this window m_eventHandler = this; @@ -124,29 +149,20 @@ void wxWindowBase::InitBase() m_windowValidator = (wxValidator *) NULL; #endif // wxUSE_VALIDATORS - // use the system default colours - m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE); - m_foregroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); - - // don't set the font here for wxMSW as we don't call WM_SETFONT here and - // so the font is *not* really set - but calls to SetFont() later won't do - // anything because m_font appears to be already set! -#ifndef __WXMSW__ - m_font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); -#endif // __WXMSW__ - - // the colours/fonts are default for now + // the colours/fonts are default for now, so leave m_font, + // m_backgroundColour and m_foregroundColour uninitialized and set those m_hasBgCol = m_hasFgCol = - m_hasFont = FALSE; + m_hasFont = false; + m_inheritBgCol = + m_inheritFgCol = + m_inheritFont = false; // no style bits m_exStyle = m_windowStyle = 0; - // an optimization for the event processing: checking this flag is much - // faster than using IsKindOf(CLASSINFO(wxWindow)) - m_isWindow = TRUE; + m_backgroundStyle = wxBG_STYLE_SYSTEM; #if wxUSE_CONSTRAINTS // no constraints whatsoever @@ -156,7 +172,7 @@ void wxWindowBase::InitBase() m_windowSizer = (wxSizer *) NULL; m_containingSizer = (wxSizer *) NULL; - m_autoLayout = FALSE; + m_autoLayout = false; #if wxUSE_DRAG_AND_DROP m_dropTarget = (wxDropTarget *)NULL; @@ -171,18 +187,32 @@ void wxWindowBase::InitBase() #endif // wxUSE_CARET #if wxUSE_PALETTE - m_hasCustomPalette = FALSE; + m_hasCustomPalette = false; #endif // wxUSE_PALETTE +#if wxUSE_ACCESSIBILITY + m_accessible = NULL; +#endif + m_virtualSize = wxDefaultSize; - m_minVirtualWidth = - m_minVirtualHeight = - m_maxVirtualWidth = - m_maxVirtualHeight = -1; + m_scrollHelper = (wxScrollHelper *) NULL; + + m_windowVariant = wxWINDOW_VARIANT_NORMAL; +#if wxUSE_SYSTEM_OPTIONS + if ( wxSystemOptions::HasOption(wxWINDOW_DEFAULT_VARIANT) ) + { + m_windowVariant = (wxWindowVariant) wxSystemOptions::GetOptionInt( wxWINDOW_DEFAULT_VARIANT ) ; + } +#endif // Whether we're using the current theme for this window (wxGTK only for now) - m_themeEnabled = FALSE; + m_themeEnabled = false; + + // VZ: this one shouldn't exist... + m_isBeingDeleted = false; + + m_freezeCount = 0; } // common part of window creation process @@ -191,19 +221,43 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, const wxPoint& WXUNUSED(pos), const wxSize& WXUNUSED(size), long style, - const wxValidator& validator, + const wxValidator& wxVALIDATOR_PARAM(validator), const wxString& name) { - // m_isWindow is set to TRUE in wxWindowBase::Init() as well as many other - // member variables - check that it has been called (will catch the case - // when a new ctor is added which doesn't call InitWindow) - wxASSERT_MSG( m_isWindow, wxT("Init() must have been called before!") ); +#if wxUSE_STATBOX + // wxGTK doesn't allow to create controls with static box as the parent so + // this will result in a crash when the program is ported to wxGTK so warn + // the user about it + + // if you get this assert, the correct solution is to create the controls + // as siblings of the static box + wxASSERT_MSG( !parent || !wxDynamicCast(parent, wxStaticBox), + _T("wxStaticBox can't be used as a window parent!") ); +#endif // wxUSE_STATBOX + + // ids are limited to 16 bits under MSW so if you care about portability, + // it's not a good idea to use ids out of this range (and negative ids are + // reserved for wxWidgets own usage) + wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767) || + (id >= wxID_AUTO_LOWEST && id <= wxID_AUTO_HIGHEST), + _T("invalid id value") ); // generate a new id if the user doesn't care about it - m_windowId = id == -1 ? NewControlId() : id; + if ( id == wxID_ANY ) + { + m_windowId = NewControlId(); + } + else // valid id specified + { + m_windowId = id; + } + + // don't use SetWindowStyleFlag() here, this function should only be called + // to change the flag after creation as it tries to reflect the changes in + // flags by updating the window dynamically and we don't need this here + m_windowStyle = style; SetName(name); - SetWindowStyleFlag(style); SetParent(parent); #if wxUSE_VALIDATORS @@ -215,10 +269,32 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, // dialog/frame and all children will inherit it by defult if ( parent && (parent->GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) ) { - SetExtraStyle(wxWS_EX_VALIDATE_RECURSIVELY); + SetExtraStyle(GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY); + } + + return true; +} + +bool wxWindowBase::ToggleWindowStyle(int flag) +{ + wxASSERT_MSG( flag, _T("flags with 0 value can't be toggled") ); + + bool rc; + long style = GetWindowStyleFlag(); + if ( style & flag ) + { + style &= ~flag; + rc = false; + } + else // currently off + { + style |= flag; + rc = true; } - return TRUE; + SetWindowStyleFlag(style); + + return rc; } // ---------------------------------------------------------------------------- @@ -239,18 +315,27 @@ wxWindowBase::~wxWindowBase() // Just in case we've loaded a top-level window via LoadNativeDialog but // we weren't a dialog class - wxTopLevelWindows.DeleteObject(this); + wxTopLevelWindows.DeleteObject((wxWindow*)this); + +#if wxUSE_MENUS + // The associated popup menu can still be alive, disassociate from it in + // this case + if ( wxCurrentPopupMenu && wxCurrentPopupMenu->GetInvokingWindow() == this ) + wxCurrentPopupMenu->SetInvokingWindow(NULL); +#endif // wxUSE_MENUS wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") ); + // notify the parent about this window destruction + if ( m_parent ) + m_parent->RemoveChild(this); + #if wxUSE_CARET - if ( m_caret ) - delete m_caret; + delete m_caret; #endif // wxUSE_CARET #if wxUSE_VALIDATORS - if ( m_windowValidator ) - delete m_windowValidator; + delete m_windowValidator; #endif // wxUSE_VALIDATORS #if wxUSE_CONSTRAINTS @@ -266,56 +351,69 @@ wxWindowBase::~wxWindowBase() delete m_constraints; m_constraints = NULL; } - #endif // wxUSE_CONSTRAINTS if ( m_containingSizer ) - m_containingSizer->Remove((wxWindow*)this); + m_containingSizer->Detach( (wxWindow*)this ); - if ( m_windowSizer ) - delete m_windowSizer; + delete m_windowSizer; #if wxUSE_DRAG_AND_DROP - if ( m_dropTarget ) - delete m_dropTarget; + delete m_dropTarget; #endif // wxUSE_DRAG_AND_DROP #if wxUSE_TOOLTIPS - if ( m_tooltip ) - delete m_tooltip; + delete m_tooltip; #endif // wxUSE_TOOLTIPS - // reset the dangling pointer our parent window may keep to us - if ( m_parent && m_parent->GetDefaultItem() == this ) - { - m_parent->SetDefaultItem(NULL); - } +#if wxUSE_ACCESSIBILITY + delete m_accessible; +#endif + +#if wxUSE_HELP + // NB: this has to be called unconditionally, because we don't know + // whether this window has associated help text or not + wxHelpProvider *helpProvider = wxHelpProvider::Get(); + if ( helpProvider ) + helpProvider->RemoveHelp(this); +#endif +} + +bool wxWindowBase::IsBeingDeleted() const +{ + return m_isBeingDeleted || + (!IsTopLevel() && m_parent && m_parent->IsBeingDeleted()); +} + +void wxWindowBase::SendDestroyEvent() +{ + wxWindowDestroyEvent event; + event.SetEventObject(this); + event.SetId(GetId()); + GetEventHandler()->ProcessEvent(event); } bool wxWindowBase::Destroy() { delete this; - return TRUE; + return true; } bool wxWindowBase::Close(bool force) { wxCloseEvent event(wxEVT_CLOSE_WINDOW, m_windowId); event.SetEventObject(this); -#if WXWIN_COMPATIBILITY - event.SetForce(force); -#endif // WXWIN_COMPATIBILITY event.SetCanVeto(!force); - // return FALSE if window wasn't closed because the application vetoed the + // return false if window wasn't closed because the application vetoed the // close event - return GetEventHandler()->ProcessEvent(event) && !event.GetVeto(); + return HandleWindowEvent(event) && !event.GetVeto(); } bool wxWindowBase::DestroyChildren() { - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( ;; ) { // we iterate until the list becomes empty @@ -325,16 +423,17 @@ bool wxWindowBase::DestroyChildren() wxWindow *child = node->GetData(); - wxASSERT_MSG( child, wxT("children list contains empty nodes") ); - - child->Show(FALSE); + // note that we really want to call delete and not ->Destroy() here + // because we want to delete the child immediately, before we are + // deleted, and delayed deletion would result in problems as our (top + // level) child could outlive its parent delete child; wxASSERT_MSG( !GetChildren().Find(child), wxT("child didn't remove itself using RemoveChild()") ); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- @@ -342,136 +441,71 @@ bool wxWindowBase::DestroyChildren() // ---------------------------------------------------------------------------- // centre the window with respect to its parent in either (or both) directions -void wxWindowBase::Centre(int direction) +void wxWindowBase::DoCentre(int dir) { - // the position/size of the parent window or of the entire screen - wxPoint posParent; - int widthParent, heightParent; + wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(), + _T("this method only implements centering child windows") ); - wxWindow *parent = NULL; + SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir)); +} - if ( !(direction & wxCENTRE_ON_SCREEN) ) +// fits the window around the children +void wxWindowBase::Fit() +{ + if ( !GetChildren().empty() ) { - // find the parent to centre this window on: it should be the - // immediate parent for the controls but the top level parent for the - // top level windows (like dialogs) - parent = GetParent(); - if ( IsTopLevel() ) - { - while ( parent && !parent->IsTopLevel() ) - { - parent = parent->GetParent(); - } - } - - // there is no wxTopLevelWindow under wxMotif yet -#ifndef __WXMOTIF__ - // we shouldn't center the dialog on the iconized window: under - // Windows, for example, this places it completely off the screen - if ( parent ) - { - wxTopLevelWindow *winTop = wxDynamicCast(parent, wxTopLevelWindow); - if ( winTop && winTop->IsIconized() ) - { - parent = NULL; - } - } -#endif // __WXMOTIF__ - - // did we find the parent? - if ( !parent ) - { - // no other choice - direction |= wxCENTRE_ON_SCREEN; - } + SetSize(GetBestSize()); } + //else: do nothing if we have no children +} - if ( direction & wxCENTRE_ON_SCREEN ) - { - // centre with respect to the whole screen - wxDisplaySize(&widthParent, &heightParent); - } - else +// fits virtual size (ie. scrolled area etc.) around children +void wxWindowBase::FitInside() +{ + if ( GetChildren().GetCount() > 0 ) { - if ( IsTopLevel() ) - { - // centre on the parent - parent->GetSize(&widthParent, &heightParent); - - // adjust to the parents position - posParent = parent->GetPosition(); - } - else - { - // centre inside the parents client rectangle - parent->GetClientSize(&widthParent, &heightParent); - } + SetVirtualSize( GetBestVirtualSize() ); } +} - int width, height; - GetSize(&width, &height); - - int xNew = -1, - yNew = -1; - - if ( direction & wxHORIZONTAL ) - xNew = (widthParent - width)/2; - - if ( direction & wxVERTICAL ) - yNew = (heightParent - height)/2; - - xNew += posParent.x; - yNew += posParent.y; - - // Base size of the visible dimensions of the display - // to take into account the taskbar - wxRect rect = wxGetClientDisplayRect(); - wxSize size (rect.width,rect.height); +// On Mac, scrollbars are explicitly children. +#ifdef __WXMAC__ +static bool wxHasRealChildren(const wxWindowBase* win) +{ + int realChildCount = 0; - // NB: in wxMSW, negative position may not neccessary mean "out of screen", - // but it may mean that the window is placed on other than the main - // display. Therefore we only make sure centered window is on the main display - // if the parent is at least partially present here. - if (posParent.x + widthParent >= 0) // if parent is (partially) on the main display - { - if (xNew < 0) - xNew = 0; - else if (xNew+width > size.x) - xNew = size.x-width-1; - } - if (posParent.y + heightParent >= 0) // if parent is (partially) on the main display + for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); + node; + node = node->GetNext() ) { - if (yNew+height > size.y) - yNew = size.y-height-1; - - // Make certain that the title bar is initially visible - // always, even if this would push the bottom of the - // dialog of the visible area of the display - if (yNew < 0) - yNew = 0; + wxWindow *win = node->GetData(); + if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar))) + realChildCount ++; } - - // move the window to this position (keeping the old size but using - // SetSize() and not Move() to allow xNew and/or yNew to be -1) - SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE); + return (realChildCount > 0); } +#endif -// fits the window around the children -void wxWindowBase::Fit() +void wxWindowBase::InvalidateBestSize() { - if ( GetChildren().GetCount() > 0 ) - { - SetClientSize(DoGetBestSize()); - } - //else: do nothing if we have no children + m_bestSizeCache = wxDefaultSize; + + // parent's best size calculation may depend on its children's + // as long as child window we are in is not top level window itself + // (because the TLW size is never resized automatically) + // so let's invalidate it as well to be safe: + if (m_parent && !IsTopLevel()) + m_parent->InvalidateBestSize(); } // return the size best suited for the current window wxSize wxWindowBase::DoGetBestSize() const { + wxSize best; + if ( m_windowSizer ) { - return m_windowSizer->GetMinSize(); + best = m_windowSizer->GetMinSize(); } #if wxUSE_CONSTRAINTS else if ( m_constraints ) @@ -482,7 +516,7 @@ wxSize wxWindowBase::DoGetBestSize() const int maxX = 0, maxY = 0; - for ( wxWindowList::Node *node = GetChildren().GetFirst(); + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() ) { @@ -507,23 +541,29 @@ wxSize wxWindowBase::DoGetBestSize() const // will never return a size bigger than the current one :-( } - return wxSize(maxX, maxY); + best = wxSize(maxX, maxY); } #endif // wxUSE_CONSTRAINTS - else if ( GetChildren().GetCount() > 0 ) + else if ( !GetChildren().empty() +#ifdef __WXMAC__ + && wxHasRealChildren(this) +#endif + ) { - // our minimal acceptable size is such that all our windows fit inside + // our minimal acceptable size is such that all our visible child + // windows fit inside int maxX = 0, maxY = 0; - for ( wxWindowList::Node *node = GetChildren().GetFirst(); + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() ) { wxWindow *win = node->GetData(); if ( win->IsTopLevel() + || !win->IsShown() #if wxUSE_STATUSBAR - || wxDynamicCast(win, wxStatusBar) + || wxDynamicCast(win, wxStatusBar) #endif // wxUSE_STATUSBAR ) { @@ -538,9 +578,9 @@ wxSize wxWindowBase::DoGetBestSize() const // if the window hadn't been positioned yet, assume that it is in // the origin - if ( wx == -1 ) + if ( wx == wxDefaultCoord ) wx = 0; - if ( wy == -1 ) + if ( wy == wxDefaultCoord ) wy = 0; win->GetSize(&ww, &wh); @@ -550,73 +590,279 @@ wxSize wxWindowBase::DoGetBestSize() const maxY = wy + wh; } - // for compatibility with the old versions and because it really looks - // slightly more pretty like this, add a pad - maxX += 7; - maxY += 14; + best = wxSize(maxX, maxY); + } + else // ! has children + { + // for a generic window there is no natural best size so, if the + // minimal size is not set, use the current size but take care to + // remember it as minimal size for the next time because our best size + // should be constant: otherwise we could get into a situation when the + // window is initially at some size, then expanded to a larger size and + // then, when the containing window is shrunk back (because our initial + // best size had been used for computing the parent min size), we can't + // be shrunk back any more because our best size is now bigger + wxSize size = GetMinSize(); + if ( !size.IsFullySpecified() ) + { + size.SetDefaults(GetSize()); + wxConstCast(this, wxWindowBase)->SetMinSize(size); + } + + // return as-is, unadjusted by the client size difference. + return size; + } + + // Add any difference between size and client size + wxSize diff = GetSize() - GetClientSize(); + best.x += wxMax(0, diff.x); + best.y += wxMax(0, diff.y); + + return best; +} - return wxSize(maxX, maxY); +// helper of GetWindowBorderSize(): as many ports don't implement support for +// wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded +// fallbacks in this case +static int wxGetMetricOrDefault(wxSystemMetric what, const wxWindowBase* win) +{ + int rc = wxSystemSettings::GetMetric( + what, static_cast(const_cast(win))); + if ( rc == -1 ) + { + switch ( what ) + { + case wxSYS_BORDER_X: + case wxSYS_BORDER_Y: + // 2D border is by default 1 pixel wide + rc = 1; + break; + + case wxSYS_EDGE_X: + case wxSYS_EDGE_Y: + // 3D borders are by default 2 pixels + rc = 2; + break; + + default: + wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") ); + rc = 0; + } } - else + + return rc; +} + +wxSize wxWindowBase::GetWindowBorderSize() const +{ + wxSize size; + + switch ( GetBorder() ) + { + case wxBORDER_NONE: + // nothing to do, size is already (0, 0) + break; + + case wxBORDER_SIMPLE: + case wxBORDER_STATIC: + size.x = wxGetMetricOrDefault(wxSYS_BORDER_X, this); + size.y = wxGetMetricOrDefault(wxSYS_BORDER_Y, this); + break; + + case wxBORDER_SUNKEN: + case wxBORDER_RAISED: + size.x = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X, this), + wxGetMetricOrDefault(wxSYS_BORDER_X, this)); + size.y = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y, this), + wxGetMetricOrDefault(wxSYS_BORDER_Y, this)); + break; + + case wxBORDER_DOUBLE: + size.x = wxGetMetricOrDefault(wxSYS_EDGE_X, this) + + wxGetMetricOrDefault(wxSYS_BORDER_X, this); + size.y = wxGetMetricOrDefault(wxSYS_EDGE_Y, this) + + wxGetMetricOrDefault(wxSYS_BORDER_Y, this); + break; + + default: + wxFAIL_MSG(_T("Unknown border style.")); + break; + } + + // we have borders on both sides + return size*2; +} + +wxSize wxWindowBase::GetEffectiveMinSize() const +{ + // merge the best size with the min size, giving priority to the min size + wxSize min = GetMinSize(); + if (min.x == wxDefaultCoord || min.y == wxDefaultCoord) { - // for a generic window there is no natural best size - just use the - // current one - return GetSize(); + wxSize best = GetBestSize(); + if (min.x == wxDefaultCoord) min.x = best.x; + if (min.y == wxDefaultCoord) min.y = best.y; } + return min; +} + + +void wxWindowBase::SetInitialSize(const wxSize& size) +{ + // Set the min size to the size passed in. This will usually either be + // wxDefaultSize or the size passed to this window's ctor/Create function. + SetMinSize(size); + + // Merge the size with the best size if needed + wxSize best = GetEffectiveMinSize(); + + // If the current size doesn't match then change it + if (GetSize() != best) + SetSize(best); } + // by default the origin is not shifted wxPoint wxWindowBase::GetClientAreaOrigin() const { - return wxPoint(0, 0); + return wxPoint(0,0); +} + +wxSize wxWindowBase::ClientToWindowSize(const wxSize& size) const +{ + const wxSize diff(GetSize() - GetClientSize()); + + return wxSize(size.x == -1 ? -1 : size.x + diff.x, + size.y == -1 ? -1 : size.y + diff.y); +} + +wxSize wxWindowBase::WindowToClientSize(const wxSize& size) const +{ + const wxSize diff(GetSize() - GetClientSize()); + + return wxSize(size.x == -1 ? -1 : size.x - diff.x, + size.y == -1 ? -1 : size.y - diff.y); +} + +void wxWindowBase::SetWindowVariant( wxWindowVariant variant ) +{ + if ( m_windowVariant != variant ) + { + m_windowVariant = variant; + + DoSetWindowVariant(variant); + } +} + +void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant ) +{ + // adjust the font height to correspond to our new variant (notice that + // we're only called if something really changed) + wxFont font = GetFont(); + int size = font.GetPointSize(); + switch ( variant ) + { + case wxWINDOW_VARIANT_NORMAL: + break; + + case wxWINDOW_VARIANT_SMALL: + size *= 3; + size /= 4; + break; + + case wxWINDOW_VARIANT_MINI: + size *= 2; + size /= 3; + break; + + case wxWINDOW_VARIANT_LARGE: + size *= 5; + size /= 4; + break; + + default: + wxFAIL_MSG(_T("unexpected window variant")); + break; + } + + font.SetPointSize(size); + SetFont(font); } -// set the min/max size of the window -void wxWindowBase::SetSizeHints(int minW, int minH, - int maxW, int maxH, - int WXUNUSED(incW), int WXUNUSED(incH)) +void wxWindowBase::DoSetSizeHints( int minW, int minH, + int maxW, int maxH, + int WXUNUSED(incW), int WXUNUSED(incH) ) { + wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) && + (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH), + _T("min width/height must be less than max width/height!") ); + m_minWidth = minW; m_maxWidth = maxW; m_minHeight = minH; m_maxHeight = maxH; } -void wxWindowBase::SetVirtualSizeHints( int minW, int minH, - int maxW, int maxH ) + +#if WXWIN_COMPATIBILITY_2_8 +void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW), int WXUNUSED(minH), + int WXUNUSED(maxW), int WXUNUSED(maxH)) { - m_minVirtualWidth = minW; - m_maxVirtualWidth = maxW; - m_minVirtualHeight = minH; - m_maxVirtualHeight = maxH; +} - SetVirtualSize( GetClientSize() ); +void wxWindowBase::SetVirtualSizeHints(const wxSize& WXUNUSED(minsize), + const wxSize& WXUNUSED(maxsize)) +{ } +#endif // WXWIN_COMPATIBILITY_2_8 void wxWindowBase::DoSetVirtualSize( int x, int y ) { - if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x ) - x = m_minVirtualWidth; - if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x ) - x = m_maxVirtualWidth; - if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y ) - y = m_minVirtualHeight; - if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y ) - y = m_maxVirtualHeight; - m_virtualSize = wxSize(x, y); } wxSize wxWindowBase::DoGetVirtualSize() const { - wxSize s( GetClientSize() ); + // we should use the entire client area so if it is greater than our + // virtual size, expand it to fit (otherwise if the window is big enough we + // wouldn't be using parts of it) + wxSize size = GetClientSize(); + if ( m_virtualSize.x > size.x ) + size.x = m_virtualSize.x; + + if ( m_virtualSize.y >= size.y ) + size.y = m_virtualSize.y; + + return size; +} + +void wxWindowBase::DoGetScreenPosition(int *x, int *y) const +{ + // screen position is the same as (0, 0) in client coords for non TLWs (and + // TLWs override this method) + if ( x ) + *x = 0; + if ( y ) + *y = 0; + + ClientToScreen(x, y); +} - if( m_virtualSize.GetWidth() != -1 ) - s.SetWidth( m_virtualSize.GetWidth() ); - if( m_virtualSize.GetHeight() != -1 ) - s.SetHeight( m_virtualSize.GetHeight() ); +void wxWindowBase::SendSizeEvent(int flags) +{ + wxSizeEvent event(GetSize(), GetId()); + event.SetEventObject(this); + if ( flags & wxSEND_EVENT_POST ) + wxPostEvent(this, event); + else + HandleWindowEvent(event); +} - return s; +void wxWindowBase::SendSizeEventToParent(int flags) +{ + wxWindow * const parent = GetParent(); + if ( parent && !parent->IsBeingDeleted() ) + parent->SendSizeEvent(flags); } // ---------------------------------------------------------------------------- @@ -629,70 +875,178 @@ bool wxWindowBase::Show(bool show) { m_isShown = show; - return TRUE; + return true; } else { - return FALSE; + return false; } } -bool wxWindowBase::Enable(bool enable) +bool wxWindowBase::IsEnabled() const { - if ( enable != m_isEnabled ) - { - m_isEnabled = enable; + return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled()); +} + +void wxWindowBase::NotifyWindowOnEnableChange(bool enabled) +{ +#ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT + DoEnable(enabled); +#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT) + + OnEnabled(enabled); - return TRUE; + // If we are top-level then the logic doesn't apply - otherwise + // showing a modal dialog would result in total greying out (and ungreying + // out later) of everything which would be really ugly + if ( IsTopLevel() ) + return; + + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + node; + node = node->GetNext() ) + { + wxWindowBase * const child = node->GetData(); + if ( !child->IsTopLevel() && child->IsThisEnabled() ) + child->NotifyWindowOnEnableChange(enabled); } - else +} + +bool wxWindowBase::Enable(bool enable) +{ + if ( enable == IsThisEnabled() ) + return false; + + m_isEnabled = enable; + +#ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT + DoEnable(enable); +#else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT) + wxWindowBase * const parent = GetParent(); + if( !IsTopLevel() && parent && !parent->IsEnabled() ) { - return FALSE; + return true; } +#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT) + + NotifyWindowOnEnableChange(enable); + + return true; +} + +bool wxWindowBase::IsShownOnScreen() const +{ + // A window is shown on screen if it itself is shown and so are all its + // parents. But if a window is toplevel one, then its always visible on + // screen if IsShown() returns true, even if it has a hidden parent. + return IsShown() && + (IsTopLevel() || GetParent() == NULL || GetParent()->IsShownOnScreen()); } + // ---------------------------------------------------------------------------- // RTTI // ---------------------------------------------------------------------------- bool wxWindowBase::IsTopLevel() const { - return FALSE; + return false; } // ---------------------------------------------------------------------------- -// reparenting the window +// Freeze/Thaw // ---------------------------------------------------------------------------- -void wxWindowBase::AddChild(wxWindowBase *child) +void wxWindowBase::Freeze() { - wxCHECK_RET( child, wxT("can't add a NULL child") ); + if ( !m_freezeCount++ ) + { + // physically freeze this window: + DoFreeze(); - // this should never happen and it will lead to a crash later if it does - // because RemoveChild() will remove only one node from the children list - // and the other(s) one(s) will be left with dangling pointers in them - wxASSERT_MSG( !GetChildren().Find(child), _T("AddChild() called twice") ); + // and recursively freeze all children: + for ( wxWindowList::iterator i = GetChildren().begin(); + i != GetChildren().end(); ++i ) + { + wxWindow *child = *i; + if ( child->IsTopLevel() ) + continue; - GetChildren().Append(child); - child->SetParent(this); + child->Freeze(); + } + } } -void wxWindowBase::RemoveChild(wxWindowBase *child) +void wxWindowBase::Thaw() { - wxCHECK_RET( child, wxT("can't remove a NULL child") ); - - GetChildren().DeleteObject(child); - child->SetParent((wxWindow *)NULL); -} + wxASSERT_MSG( m_freezeCount, "Thaw() without matching Freeze()" ); -bool wxWindowBase::Reparent(wxWindowBase *newParent) + if ( !--m_freezeCount ) + { + // recursively thaw all children: + for ( wxWindowList::iterator i = GetChildren().begin(); + i != GetChildren().end(); ++i ) + { + wxWindow *child = *i; + if ( child->IsTopLevel() ) + continue; + + child->Thaw(); + } + + // physically thaw this window: + DoThaw(); + } +} + +// ---------------------------------------------------------------------------- +// reparenting the window +// ---------------------------------------------------------------------------- + +void wxWindowBase::AddChild(wxWindowBase *child) +{ + wxCHECK_RET( child, wxT("can't add a NULL child") ); + + // this should never happen and it will lead to a crash later if it does + // because RemoveChild() will remove only one node from the children list + // and the other(s) one(s) will be left with dangling pointers in them + wxASSERT_MSG( !GetChildren().Find((wxWindow*)child), _T("AddChild() called twice") ); + + GetChildren().Append((wxWindow*)child); + child->SetParent(this); + + // adding a child while frozen will assert when thawed, so freeze it as if + // it had been already present when we were frozen + if ( IsFrozen() && !child->IsTopLevel() ) + child->Freeze(); +} + +void wxWindowBase::RemoveChild(wxWindowBase *child) +{ + wxCHECK_RET( child, wxT("can't remove a NULL child") ); + + // removing a child while frozen may result in permanently frozen window + // if used e.g. from Reparent(), so thaw it + // + // NB: IsTopLevel() doesn't return true any more when a TLW child is being + // removed from its ~wxWindowBase, so check for IsBeingDeleted() too + if ( IsFrozen() && !child->IsBeingDeleted() && !child->IsTopLevel() ) + child->Thaw(); + + GetChildren().DeleteObject((wxWindow *)child); + child->SetParent(NULL); +} + +bool wxWindowBase::Reparent(wxWindowBase *newParent) { wxWindow *oldParent = GetParent(); if ( newParent == oldParent ) { // nothing done - return FALSE; + return false; } + const bool oldEnabledState = IsEnabled(); + // unlink this window from the existing parent. if ( oldParent ) { @@ -700,7 +1054,7 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) } else { - wxTopLevelWindows.DeleteObject(this); + wxTopLevelWindows.DeleteObject((wxWindow *)this); } // add it to the new one @@ -710,10 +1064,18 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) } else { - wxTopLevelWindows.Append(this); + wxTopLevelWindows.Append((wxWindow *)this); + } + + // We need to notify window (and its subwindows) if by changing the parent + // we also change our enabled/disabled status. + const bool newEnabledState = IsEnabled(); + if ( newEnabledState != oldEnabledState ) + { + NotifyWindowOnEnableChange(newEnabledState); } - return TRUE; + return true; } // ---------------------------------------------------------------------------- @@ -756,7 +1118,7 @@ wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler) bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) { - wxCHECK_MSG( handler, FALSE, _T("RemoveEventHandler(NULL) called") ); + wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") ); wxEvtHandler *handlerPrev = NULL, *handlerCur = GetEventHandler(); @@ -779,9 +1141,11 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) { handlerNext->SetPreviousHandler ( handlerPrev ); } + handler->SetNextHandler(NULL); + handler->SetPreviousHandler(NULL); - return TRUE; + return true; } handlerPrev = handlerCur; @@ -790,75 +1154,192 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) wxFAIL_MSG( _T("where has the event handler gone?") ); - return FALSE; + return false; +} + +bool wxWindowBase::HandleWindowEvent(wxEvent& event) const +{ + return GetEventHandler()->SafelyProcessEvent(event); } // ---------------------------------------------------------------------------- -// cursors, fonts &c +// colours, fonts &c // ---------------------------------------------------------------------------- -bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) +void wxWindowBase::InheritAttributes() { - if ( !colour.Ok() || (colour == m_backgroundColour) ) - return FALSE; + const wxWindowBase * const parent = GetParent(); + if ( !parent ) + return; - m_backgroundColour = colour; + // we only inherit attributes which had been explicitly set for the parent + // which ensures that this only happens if the user really wants it and + // not by default which wouldn't make any sense in modern GUIs where the + // controls don't all use the same fonts (nor colours) + if ( parent->m_inheritFont && !m_hasFont ) + SetFont(parent->GetFont()); - m_hasBgCol = TRUE; + // in addition, there is a possibility to explicitly forbid inheriting + // colours at each class level by overriding ShouldInheritColours() + if ( ShouldInheritColours() ) + { + if ( parent->m_inheritFgCol && !m_hasFgCol ) + SetForegroundColour(parent->GetForegroundColour()); - return TRUE; + // inheriting (solid) background colour is wrong as it totally breaks + // any kind of themed backgrounds + // + // instead, the controls should use the same background as their parent + // (ideally by not drawing it at all) +#if 0 + if ( parent->m_inheritBgCol && !m_hasBgCol ) + SetBackgroundColour(parent->GetBackgroundColour()); +#endif // 0 + } } -bool wxWindowBase::SetForegroundColour( const wxColour &colour ) +/* static */ wxVisualAttributes +wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) { - if ( !colour.Ok() || (colour == m_foregroundColour) ) - return FALSE; + // it is important to return valid values for all attributes from here, + // GetXXX() below rely on this + wxVisualAttributes attrs; + attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); + attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); - m_foregroundColour = colour; + // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of + // the usual background colour than wxSYS_COLOUR_BTNFACE. + // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background + // colour on other platforms. - m_hasFgCol = TRUE; +#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__)) + attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW); +#else + attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE); +#endif + return attrs; +} + +wxColour wxWindowBase::GetBackgroundColour() const +{ + if ( !m_backgroundColour.IsOk() ) + { + wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") ); + + // get our default background colour + wxColour colBg = GetDefaultAttributes().colBg; + + // we must return some valid colour to avoid redoing this every time + // and also to avoid surprizing the applications written for older + // wxWidgets versions where GetBackgroundColour() always returned + // something -- so give them something even if it doesn't make sense + // for this window (e.g. it has a themed background) + if ( !colBg.Ok() ) + colBg = GetClassDefaultAttributes().colBg; - return TRUE; + return colBg; + } + else + return m_backgroundColour; +} + +wxColour wxWindowBase::GetForegroundColour() const +{ + // logic is the same as above + if ( !m_hasFgCol && !m_foregroundColour.Ok() ) + { + wxColour colFg = GetDefaultAttributes().colFg; + + if ( !colFg.IsOk() ) + colFg = GetClassDefaultAttributes().colFg; + + return colFg; + } + else + return m_foregroundColour; +} + +bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) +{ + if ( colour == m_backgroundColour ) + return false; + + m_hasBgCol = colour.IsOk(); + if ( m_backgroundStyle != wxBG_STYLE_CUSTOM ) + m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM; + + m_inheritBgCol = m_hasBgCol; + m_backgroundColour = colour; + SetThemeEnabled( !m_hasBgCol && !m_foregroundColour.Ok() ); + return true; +} + +bool wxWindowBase::SetForegroundColour( const wxColour &colour ) +{ + if (colour == m_foregroundColour ) + return false; + + m_hasFgCol = colour.IsOk(); + m_inheritFgCol = m_hasFgCol; + m_foregroundColour = colour; + SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() ); + return true; } bool wxWindowBase::SetCursor(const wxCursor& cursor) { // setting an invalid cursor is ok, it means that we don't have any special // cursor - if ( m_cursor == cursor ) + if ( m_cursor.IsSameAs(cursor) ) { // no change - return FALSE; + return false; } m_cursor = cursor; - return TRUE; + return true; } -bool wxWindowBase::SetFont(const wxFont& font) +wxFont wxWindowBase::GetFont() const { - // don't try to set invalid font, always fall back to the default - const wxFont& fontOk = font.Ok() ? font : *wxSWISS_FONT; + // logic is the same as in GetBackgroundColour() + if ( !m_font.IsOk() ) + { + wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") ); + + wxFont font = GetDefaultAttributes().font; + if ( !font.IsOk() ) + font = GetClassDefaultAttributes().font; + + return font; + } + else + return m_font; +} - if ( fontOk == m_font ) +bool wxWindowBase::SetFont(const wxFont& font) +{ + if ( font == m_font ) { // no change - return FALSE; + return false; } - m_font = fontOk; + m_font = font; + m_hasFont = font.IsOk(); + m_inheritFont = m_hasFont; - m_hasFont = TRUE; + InvalidateBestSize(); - return TRUE; + return true; } #if wxUSE_PALETTE void wxWindowBase::SetPalette(const wxPalette& pal) { - m_hasCustomPalette = TRUE; + m_hasCustomPalette = true; m_palette = pal; // VZ: can anyone explain me what do we do here? @@ -910,7 +1391,7 @@ void wxWindowBase::SetValidator(const wxValidator& validator) m_windowValidator = (wxValidator *)validator.Clone(); if ( m_windowValidator ) - m_windowValidator->SetWindow(this) ; + m_windowValidator->SetWindow(this); } #endif // wxUSE_VALIDATORS @@ -930,27 +1411,38 @@ wxRect wxWindowBase::GetUpdateClientRect() const return rectUpdate; } -bool wxWindowBase::IsExposed(int x, int y) const +bool wxWindowBase::DoIsExposed(int x, int y) const { return m_updateRegion.Contains(x, y) != wxOutRegion; } -bool wxWindowBase::IsExposed(int x, int y, int w, int h) const +bool wxWindowBase::DoIsExposed(int x, int y, int w, int h) const { return m_updateRegion.Contains(x, y, w, h) != wxOutRegion; } +void wxWindowBase::ClearBackground() +{ + // wxGTK uses its own version, no need to add never used code +#ifndef __WXGTK__ + wxClientDC dc((wxWindow *)this); + wxBrush brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID); + dc.SetBackground(brush); + dc.Clear(); +#endif // __WXGTK__ +} + // ---------------------------------------------------------------------------- // find child window by id or name // ---------------------------------------------------------------------------- -wxWindow *wxWindowBase::FindWindow( long id ) +wxWindow *wxWindowBase::FindWindow(long id) const { if ( id == m_windowId ) return (wxWindow *)this; wxWindowBase *res = (wxWindow *)NULL; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { wxWindowBase *child = node->GetData(); @@ -960,13 +1452,13 @@ wxWindow *wxWindowBase::FindWindow( long id ) return (wxWindow *)res; } -wxWindow *wxWindowBase::FindWindow( const wxString& name ) +wxWindow *wxWindowBase::FindWindow(const wxString& name) const { if ( name == m_windowName ) return (wxWindow *)this; wxWindowBase *res = (wxWindow *)NULL; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { wxWindow *child = node->GetData(); @@ -1022,7 +1514,7 @@ wxWindow *wxFindWindowRecursively(const wxWindow *parent, return (wxWindow *)parent; // It wasn't, so check all its children - for ( wxWindowList::Node * node = parent->GetChildren().GetFirst(); + for ( wxWindowList::compatibility_iterator node = parent->GetChildren().GetFirst(); node; node = node->GetNext() ) { @@ -1052,7 +1544,7 @@ wxWindow *wxFindWindowHelper(const wxWindow *parent, } // start at very top of wx's windows - for ( wxWindowList::Node * node = wxTopLevelWindows.GetFirst(); + for ( wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst(); node; node = node->GetNext() ) { @@ -1092,7 +1584,7 @@ wxWindowBase::FindWindowByName(const wxString& title, const wxWindow *parent) wxWindow * wxWindowBase::FindWindowById( long id, const wxWindow* parent ) { - return wxFindWindowHelper(parent, _T(""), id, wxFindWindowCmpIds); + return wxFindWindowHelper(parent, wxEmptyString, id, wxFindWindowCmpIds); } // ---------------------------------------------------------------------------- @@ -1104,7 +1596,7 @@ void wxWindowBase::MakeModal(bool modal) // Disable all other windows if ( IsTopLevel() ) { - wxWindowList::Node *node = wxTopLevelWindows.GetFirst(); + wxWindowList::compatibility_iterator node = wxTopLevelWindows.GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1121,24 +1613,24 @@ bool wxWindowBase::Validate() #if wxUSE_VALIDATORS bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node; node = node->GetNext() ) { wxWindowBase *child = node->GetData(); wxValidator *validator = child->GetValidator(); if ( validator && !validator->Validate((wxWindow *)this) ) { - return FALSE; + return false; } if ( recurse && !child->Validate() ) { - return FALSE; + return false; } } #endif // wxUSE_VALIDATORS - return TRUE; + return true; } bool wxWindowBase::TransferDataToWindow() @@ -1146,7 +1638,7 @@ bool wxWindowBase::TransferDataToWindow() #if wxUSE_VALIDATORS bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node; node = node->GetNext() ) { wxWindowBase *child = node->GetData(); @@ -1154,9 +1646,11 @@ bool wxWindowBase::TransferDataToWindow() if ( validator && !validator->TransferToWindow() ) { wxLogWarning(_("Could not transfer data to window")); +#if wxUSE_LOG wxLog::FlushActive(); +#endif // wxUSE_LOG - return FALSE; + return false; } if ( recurse ) @@ -1164,13 +1658,13 @@ bool wxWindowBase::TransferDataToWindow() if ( !child->TransferDataToWindow() ) { // warning already given - return FALSE; + return false; } } } #endif // wxUSE_VALIDATORS - return TRUE; + return true; } bool wxWindowBase::TransferDataFromWindow() @@ -1178,7 +1672,7 @@ bool wxWindowBase::TransferDataFromWindow() #if wxUSE_VALIDATORS bool recurse = (GetExtraStyle() & wxWS_EX_VALIDATE_RECURSIVELY) != 0; - wxWindowList::Node *node; + wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node; node = node->GetNext() ) { wxWindow *child = node->GetData(); @@ -1188,7 +1682,7 @@ bool wxWindowBase::TransferDataFromWindow() // nop warning here because the application is supposed to give // one itself - we don't know here what might have gone wrongly - return FALSE; + return false; } if ( recurse ) @@ -1196,13 +1690,13 @@ bool wxWindowBase::TransferDataFromWindow() if ( !child->TransferDataFromWindow() ) { // warning already given - return FALSE; + return false; } } } #endif // wxUSE_VALIDATORS - return TRUE; + return true; } void wxWindowBase::InitDialog() @@ -1228,6 +1722,7 @@ void wxWindowBase::SetHelpText(const wxString& text) } } +#if WXWIN_COMPATIBILITY_2_8 // associate this help text with all windows with the same id as this // one void wxWindowBase::SetHelpTextForId(const wxString& text) @@ -1238,9 +1733,13 @@ void wxWindowBase::SetHelpTextForId(const wxString& text) helpProvider->AddHelp(GetId(), text); } } +#endif // WXWIN_COMPATIBILITY_2_8 // get the help string associated with this window (may be empty) -wxString wxWindowBase::GetHelpText() const +// default implementation forwards calls to the help provider +wxString +wxWindowBase::GetHelpTextAtPoint(const wxPoint & WXUNUSED(pt), + wxHelpEvent::Origin WXUNUSED(origin)) const { wxString text; wxHelpProvider *helpProvider = wxHelpProvider::Get(); @@ -1258,7 +1757,29 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) wxHelpProvider *helpProvider = wxHelpProvider::Get(); if ( helpProvider ) { - if ( helpProvider->ShowHelp(this) ) + wxPoint pos = event.GetPosition(); + const wxHelpEvent::Origin origin = event.GetOrigin(); + if ( origin == wxHelpEvent::Origin_Keyboard ) + { + // if the help event was generated from keyboard it shouldn't + // appear at the mouse position (which is still the only position + // associated with help event) if the mouse is far away, although + // we still do use the mouse position if it's over the window + // because we suppose the user looks approximately at the mouse + // already and so it would be more convenient than showing tooltip + // at some arbitrary position which can be quite far from it + const wxRect rectClient = GetClientRect(); + if ( !rectClient.Contains(ScreenToClient(pos)) ) + { + // position help slightly under and to the right of this window + pos = ClientToScreen(wxPoint( + 2*GetCharWidth(), + rectClient.height + GetCharHeight() + )); + } + } + + if ( helpProvider->ShowHelpAtPoint(this, pos, origin) ) { // skip the event.Skip() below return; @@ -1271,7 +1792,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) #endif // wxUSE_HELP // ---------------------------------------------------------------------------- -// tooltipsroot.Replace("\\", "/"); +// tooltips // ---------------------------------------------------------------------------- #if wxUSE_TOOLTIPS @@ -1294,10 +1815,13 @@ void wxWindowBase::SetToolTip( const wxString &tip ) void wxWindowBase::DoSetToolTip(wxToolTip *tooltip) { - if ( m_tooltip ) - delete m_tooltip; + if ( m_tooltip != tooltip ) + { + if ( m_tooltip ) + delete m_tooltip; - m_tooltip = tooltip; + m_tooltip = tooltip; + } } #endif // wxUSE_TOOLTIPS @@ -1369,15 +1893,15 @@ void wxWindowBase::AddConstraintReference(wxWindowBase *otherWin) { if ( !m_constraintsInvolvedIn ) m_constraintsInvolvedIn = new wxWindowList; - if ( !m_constraintsInvolvedIn->Find(otherWin) ) - m_constraintsInvolvedIn->Append(otherWin); + if ( !m_constraintsInvolvedIn->Find((wxWindow *)otherWin) ) + m_constraintsInvolvedIn->Append((wxWindow *)otherWin); } // REMOVE back-pointer to other windows we're involved with. void wxWindowBase::RemoveConstraintReference(wxWindowBase *otherWin) { if ( m_constraintsInvolvedIn ) - m_constraintsInvolvedIn->DeleteObject(otherWin); + m_constraintsInvolvedIn->DeleteObject((wxWindow *)otherWin); } // Reset any constraints that mention this window @@ -1385,7 +1909,7 @@ void wxWindowBase::DeleteRelatedConstraints() { if ( m_constraintsInvolvedIn ) { - wxWindowList::Node *node = m_constraintsInvolvedIn->GetFirst(); + wxWindowList::compatibility_iterator node = m_constraintsInvolvedIn->GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1404,8 +1928,8 @@ void wxWindowBase::DeleteRelatedConstraints() constr->centreY.ResetIfWin(this); } - wxWindowList::Node *next = node->GetNext(); - delete node; + wxWindowList::compatibility_iterator next = node->GetNext(); + m_constraintsInvolvedIn->Erase(node); node = next; } @@ -1418,12 +1942,24 @@ void wxWindowBase::DeleteRelatedConstraints() void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld) { - if ( deleteOld ) - delete m_windowSizer; + if ( sizer == m_windowSizer) + return; + + if ( m_windowSizer ) + { + m_windowSizer->SetContainingWindow(NULL); + + if ( deleteOld ) + delete m_windowSizer; + } m_windowSizer = sizer; + if ( m_windowSizer ) + { + m_windowSizer->SetContainingWindow((wxWindow *)this); + } - SetAutoLayout( sizer != NULL ); + SetAutoLayout(m_windowSizer != NULL); } void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld) @@ -1432,6 +1968,19 @@ void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld) sizer->SetSizeHints( (wxWindow*) this ); } + +void wxWindowBase::SetContainingSizer(wxSizer* sizer) +{ + // adding a window to a sizer twice is going to result in fatal and + // hard to debug problems later because when deleting the second + // associated wxSizerItem we're going to dereference a dangling + // pointer; so try to detect this as early as possible + wxASSERT_MSG( !sizer || m_containingSizer != sizer, + _T("Adding a window to the same sizer twice?") ); + + m_containingSizer = sizer; +} + #if wxUSE_CONSTRAINTS void wxWindowBase::SatisfyConstraints() @@ -1464,7 +2013,7 @@ bool wxWindowBase::Layout() // If there is a sizer, use it instead of the constraints if ( GetSizer() ) { - int w, h; + int w = 0, h = 0; GetVirtualSize(&w, &h); GetSizer()->SetDimension( 0, 0, w, h ); } @@ -1476,7 +2025,7 @@ bool wxWindowBase::Layout() } #endif - return TRUE; + return true; } #if wxUSE_CONSTRAINTS @@ -1500,7 +2049,7 @@ bool wxWindowBase::LayoutPhase2(int *noChanges) // Layout grand children DoPhase(2); - return TRUE; + return true; } // Do a phase of evaluating child constraints @@ -1519,7 +2068,7 @@ bool wxWindowBase::DoPhase(int phase) int noChanges = 0; // loop over all children setting their constraints - for ( wxWindowList::Node *node = GetChildren().GetFirst(); + for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); node; node = node->GetNext() ) { @@ -1554,7 +2103,7 @@ bool wxWindowBase::DoPhase(int phase) } } - return TRUE; + return true; } void wxWindowBase::ResetConstraints() @@ -1562,17 +2111,17 @@ void wxWindowBase::ResetConstraints() wxLayoutConstraints *constr = GetConstraints(); if ( constr ) { - constr->left.SetDone(FALSE); - constr->top.SetDone(FALSE); - constr->right.SetDone(FALSE); - constr->bottom.SetDone(FALSE); - constr->width.SetDone(FALSE); - constr->height.SetDone(FALSE); - constr->centreX.SetDone(FALSE); - constr->centreY.SetDone(FALSE); + constr->left.SetDone(false); + constr->top.SetDone(false); + constr->right.SetDone(false); + constr->bottom.SetDone(false); + constr->width.SetDone(false); + constr->height.SetDone(false); + constr->centreX.SetDone(false); + constr->centreY.SetDone(false); } - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1614,7 +2163,7 @@ void wxWindowBase::SetConstraintSizes(bool recurse) if ( recurse ) { - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while (node) { wxWindow *win = node->GetData(); @@ -1631,25 +2180,25 @@ void wxWindowBase::SetSizeConstraint(int x, int y, int w, int h) wxLayoutConstraints *constr = GetConstraints(); if ( constr ) { - if ( x != -1 ) + if ( x != wxDefaultCoord ) { constr->left.SetValue(x); - constr->left.SetDone(TRUE); + constr->left.SetDone(true); } - if ( y != -1 ) + if ( y != wxDefaultCoord ) { constr->top.SetValue(y); - constr->top.SetDone(TRUE); + constr->top.SetDone(true); } - if ( w != -1 ) + if ( w != wxDefaultCoord ) { constr->width.SetValue(w); - constr->width.SetDone(TRUE); + constr->width.SetDone(true); } - if ( h != -1 ) + if ( h != wxDefaultCoord ) { constr->height.SetValue(h); - constr->height.SetDone(TRUE); + constr->height.SetDone(true); } } } @@ -1659,15 +2208,15 @@ void wxWindowBase::MoveConstraint(int x, int y) wxLayoutConstraints *constr = GetConstraints(); if ( constr ) { - if ( x != -1 ) + if ( x != wxDefaultCoord ) { constr->left.SetValue(x); - constr->left.SetDone(TRUE); + constr->left.SetDone(true); } - if ( y != -1 ) + if ( y != wxDefaultCoord ) { constr->top.SetValue(y); - constr->top.SetDone(TRUE); + constr->top.SetDone(true); } } } @@ -1727,58 +2276,39 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) co } // ---------------------------------------------------------------------------- -// do Update UI processing for child controls +// Update UI processing // ---------------------------------------------------------------------------- -// TODO: should this be implemented for the child window rather -// than the parent? Then you can override it e.g. for wxCheckBox -// to do the Right Thing rather than having to assume a fixed number -// of control classes. -void wxWindowBase::UpdateWindowUI() +void wxWindowBase::UpdateWindowUI(long flags) { -#if wxUSE_CONTROLS wxUpdateUIEvent event(GetId()); - event.m_eventObject = this; + event.SetEventObject(this); if ( GetEventHandler()->ProcessEvent(event) ) { - if ( event.GetSetEnabled() ) - Enable(event.GetEnabled()); + DoUpdateWindowUI(event); + } - if ( event.GetSetText() ) + if (flags & wxUPDATE_UI_RECURSE) + { + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); + while (node) { - wxControl *control = wxDynamicCastThis(wxControl); - if ( control ) - { -#if wxUSE_TEXTCTRL - wxTextCtrl *text = wxDynamicCast(control, wxTextCtrl); - if ( text ) - text->SetValue(event.GetText()); - else -#endif // wxUSE_TEXTCTRL - control->SetLabel(event.GetText()); - } + wxWindow* child = (wxWindow*) node->GetData(); + child->UpdateWindowUI(flags); + node = node->GetNext(); } + } +} -#if wxUSE_CHECKBOX - wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox); - if ( checkbox ) - { - if ( event.GetSetChecked() ) - checkbox->SetValue(event.GetChecked()); - } -#endif // wxUSE_CHECKBOX +// do the window-specific processing after processing the update event +void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event) +{ + if ( event.GetSetEnabled() ) + Enable(event.GetEnabled()); -#if wxUSE_RADIOBTN - wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton); - if ( radiobtn ) - { - if ( event.GetSetChecked() ) - radiobtn->SetValue(event.GetChecked()); - } -#endif // wxUSE_RADIOBTN - } -#endif // wxUSE_CONTROLS + if ( event.GetSetShown() ) + Show(event.GetShown()); } // ---------------------------------------------------------------------------- @@ -1789,11 +2319,11 @@ wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt) { int charWidth = GetCharWidth(); int charHeight = GetCharHeight(); - wxPoint pt2(-1, -1); - if (pt.x != -1) - pt2.x = (int) ((pt.x * 4) / charWidth) ; - if (pt.y != -1) - pt2.y = (int) ((pt.y * 8) / charHeight) ; + wxPoint pt2 = wxDefaultPosition; + if (pt.x != wxDefaultCoord) + pt2.x = (int) ((pt.x * 4) / charWidth); + if (pt.y != wxDefaultCoord) + pt2.y = (int) ((pt.y * 8) / charHeight); return pt2; } @@ -1802,11 +2332,11 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) { int charWidth = GetCharWidth(); int charHeight = GetCharHeight(); - wxPoint pt2(-1, -1); - if (pt.x != -1) - pt2.x = (int) ((pt.x * charWidth) / 4) ; - if (pt.y != -1) - pt2.y = (int) ((pt.y * charHeight) / 8) ; + wxPoint pt2 = wxDefaultPosition; + if (pt.x != wxDefaultCoord) + pt2.x = (int) ((pt.x * charWidth) / 4); + if (pt.y != wxDefaultCoord) + pt2.y = (int) ((pt.y * charHeight) / 8); return pt2; } @@ -1818,7 +2348,7 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) // propagate the colour change event to the subwindows void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event) { - wxWindowList::Node *node = GetChildren().GetFirst(); + wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); while ( node ) { // Only propagate to non-top-level windows @@ -1826,105 +2356,224 @@ void wxWindowBase::OnSysColourChanged(wxSysColourChangedEvent& event) if ( !win->IsTopLevel() ) { wxSysColourChangedEvent event2; - event.m_eventObject = win; + event.SetEventObject(win); win->GetEventHandler()->ProcessEvent(event2); } node = node->GetNext(); } + + Refresh(); } -// the default action is to populate dialog with data when it's created +// the default action is to populate dialog with data when it's created, +// and nudge the UI into displaying itself correctly in case +// we've turned the wxUpdateUIEvents frequency down low. void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) { TransferDataToWindow(); + + // Update the UI at this point + UpdateWindowUI(wxUPDATE_UI_RECURSE); } -// process Ctrl-Alt-mclick -void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) +// ---------------------------------------------------------------------------- +// menu-related functions +// ---------------------------------------------------------------------------- + +#if wxUSE_MENUS + +bool wxWindowBase::PopupMenu(wxMenu *menu, int x, int y) { -#if wxUSE_MSGDLG - if ( event.ControlDown() && event.AltDown() ) - { - // don't translate these strings - wxString port; + wxCHECK_MSG( menu, false, "can't popup NULL menu" ); + + wxCurrentPopupMenu = menu; + const bool rc = DoPopupMenu(menu, x, y); + wxCurrentPopupMenu = NULL; + + return rc; +} + +// this is used to pass the id of the selected item from the menu event handler +// to the main function itself +// +// it's ok to use a global here as there can be at most one popup menu shown at +// any time +static int gs_popupMenuSelection = wxID_NONE; -#ifdef __WXUNIVERSAL__ - port = _T("Univ/"); -#endif // __WXUNIVERSAL__ +void wxWindowBase::InternalOnPopupMenu(wxCommandEvent& event) +{ + // store the id in a global variable where we'll retrieve it from later + gs_popupMenuSelection = event.GetId(); +} + +int +wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y) +{ + gs_popupMenuSelection = wxID_NONE; + + Connect(wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu), + NULL, + this); + + PopupMenu(&menu, x, y); + + Disconnect(wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu), + NULL, + this); + + return gs_popupMenuSelection; +} + +#endif // wxUSE_MENUS + +// methods for drawing the sizers in a visible way +#ifdef __WXDEBUG__ + +static void DrawSizers(wxWindowBase *win); - switch ( wxGetOsVersion() ) +static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false) +{ + wxClientDC dc((wxWindow *)win); + dc.SetPen(*wxRED_PEN); + dc.SetBrush(fill ? wxBrush(*wxRED, wxBRUSHSTYLE_CROSSDIAG_HATCH) : *wxTRANSPARENT_BRUSH); + dc.DrawRectangle(rect.Deflate(1, 1)); +} + +static void DrawSizer(wxWindowBase *win, wxSizer *sizer) +{ + const wxSizerItemList& items = sizer->GetChildren(); + for ( wxSizerItemList::const_iterator i = items.begin(), + end = items.end(); + i != end; + ++i ) + { + wxSizerItem *item = *i; + if ( item->IsSizer() ) + { + DrawBorder(win, item->GetRect().Deflate(2)); + DrawSizer(win, item->GetSizer()); + } + else if ( item->IsSpacer() ) + { + DrawBorder(win, item->GetRect().Deflate(2), true); + } + else if ( item->IsWindow() ) { - case wxMOTIF_X: port = _T("Motif"); break; - case wxMAC: - case wxMAC_DARWIN: port = _T("Mac"); break; - case wxBEOS: port = _T("BeOS"); break; - case wxGTK: - case wxGTK_WIN32: - case wxGTK_OS2: - case wxGTK_BEOS: port = _T("GTK"); break; - case wxWINDOWS: - case wxPENWINDOWS: - case wxWINDOWS_NT: - case wxWIN32S: - case wxWIN95: - case wxWIN386: port = _T("MS Windows"); break; - case wxMGL_UNIX: - case wxMGL_X: - case wxMGL_WIN32: - case wxMGL_OS2: port = _T("MGL"); break; - case wxWINDOWS_OS2: - case wxOS2_PM: port = _T("OS/2"); break; - default: port = _T("unknown"); break; + DrawSizers(item->GetWindow()); } + } +} - wxMessageBox(wxString::Format( - _T( - " wxWindows Library (%s port)\nVersion %u.%u.%u%s, compiled at %s %s\n Copyright (c) 1995-2002 wxWindows team" - ), - port.c_str(), - wxMAJOR_VERSION, - wxMINOR_VERSION, - wxRELEASE_NUMBER, -#if wxUSE_UNICODE - L" (Unicode)", -#else - "", -#endif - __TDATE__, - __TTIME__ - ), - _T("wxWindows information"), - wxICON_INFORMATION | wxOK, - (wxWindow *)this); +static void DrawSizers(wxWindowBase *win) +{ + wxSizer *sizer = win->GetSizer(); + if ( sizer ) + { + DrawBorder(win, win->GetClientSize()); + DrawSizer(win, sizer); + } + else // no sizer, still recurse into the children + { + const wxWindowList& children = win->GetChildren(); + for ( wxWindowList::const_iterator i = children.begin(), + end = children.end(); + i != end; + ++i ) + { + DrawSizers(*i); + } + } +} + +#endif // __WXDEBUG__ + +// process special middle clicks +void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) +{ + if ( event.ControlDown() && event.AltDown() ) + { +#ifdef __WXDEBUG__ + // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds + if ( event.ShiftDown() ) + { + DrawSizers(this); + return; + } +#endif // __WXDEBUG__ + ::wxInfoMessageBox((wxWindow*)this); } else -#endif // wxUSE_MSGDLG { event.Skip(); } } +// ---------------------------------------------------------------------------- +// accessibility +// ---------------------------------------------------------------------------- + +#if wxUSE_ACCESSIBILITY +void wxWindowBase::SetAccessible(wxAccessible* accessible) +{ + if (m_accessible && (accessible != m_accessible)) + delete m_accessible; + m_accessible = accessible; + if (m_accessible) + m_accessible->SetWindow((wxWindow*) this); +} + +// Returns the accessible object, creating if necessary. +wxAccessible* wxWindowBase::GetOrCreateAccessible() +{ + if (!m_accessible) + m_accessible = CreateAccessible(); + return m_accessible; +} + +// Override to create a specific accessible object. +wxAccessible* wxWindowBase::CreateAccessible() +{ + return new wxWindowAccessible((wxWindow*) this); +} + +#endif + // ---------------------------------------------------------------------------- // list classes implementation // ---------------------------------------------------------------------------- +#if wxUSE_STL + +#include "wx/listimpl.cpp" +WX_DEFINE_LIST(wxWindowList) + +#else // !wxUSE_STL + void wxWindowListNode::DeleteData() { delete (wxWindow *)GetData(); } +#endif // wxUSE_STL/!wxUSE_STL + // ---------------------------------------------------------------------------- // borders // ---------------------------------------------------------------------------- -wxBorder wxWindowBase::GetBorder() const +wxBorder wxWindowBase::GetBorder(long flags) const { - wxBorder border = (wxBorder)(m_windowStyle & wxBORDER_MASK); + wxBorder border = (wxBorder)(flags & wxBORDER_MASK); if ( border == wxBORDER_DEFAULT ) { border = GetDefaultBorder(); } + else if ( border == wxBORDER_THEME ) + { + border = GetDefaultBorderForControl(); + } return border; } @@ -1963,16 +2612,22 @@ struct WXDLLEXPORT wxWindowNext wxWindow *win; wxWindowNext *next; } *wxWindowBase::ms_winCaptureNext = NULL; +wxWindow *wxWindowBase::ms_winCaptureCurrent = NULL; +bool wxWindowBase::ms_winCaptureChanging = false; void wxWindowBase::CaptureMouse() { - wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), this); + wxLogTrace(_T("mousecapture"), _T("CaptureMouse(%p)"), static_cast(this)); + + wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") ); + + ms_winCaptureChanging = true; wxWindow *winOld = GetCapture(); if ( winOld ) { ((wxWindowBase*) winOld)->DoReleaseMouse(); - + // save it on stack wxWindowNext *item = new wxWindowNext; item->win = winOld; @@ -1982,31 +2637,321 @@ void wxWindowBase::CaptureMouse() //else: no mouse capture to save DoCaptureMouse(); + ms_winCaptureCurrent = (wxWindow*)this; + + ms_winCaptureChanging = false; } void wxWindowBase::ReleaseMouse() { - wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this); + wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), static_cast(this)); + + wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") ); - wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") ); + wxASSERT_MSG( GetCapture() == this, + "attempt to release mouse, but this window hasn't captured it" ); + wxASSERT_MSG( ms_winCaptureCurrent == this, + "attempt to release mouse, but this window hasn't captured it" ); + + ms_winCaptureChanging = true; DoReleaseMouse(); + ms_winCaptureCurrent = NULL; if ( ms_winCaptureNext ) { ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse(); - + ms_winCaptureCurrent = ms_winCaptureNext->win; + wxWindowNext *item = ms_winCaptureNext; ms_winCaptureNext = item->next; delete item; } //else: stack is empty, no previous capture + ms_winCaptureChanging = false; + wxLogTrace(_T("mousecapture"), - _T("After ReleaseMouse() mouse is captured by %p"), - GetCapture()); + (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"), + static_cast(GetCapture())); +} + +static void DoNotifyWindowAboutCaptureLost(wxWindow *win) +{ + wxMouseCaptureLostEvent event(win->GetId()); + event.SetEventObject(win); + if ( !win->GetEventHandler()->ProcessEvent(event) ) + { + // windows must handle this event, otherwise the app wouldn't behave + // correctly if it loses capture unexpectedly; see the discussion here: + // http://sourceforge.net/tracker/index.php?func=detail&aid=1153662&group_id=9863&atid=109863 + // http://article.gmane.org/gmane.comp.lib.wxwidgets.devel/82376 + wxFAIL_MSG( _T("window that captured the mouse didn't process wxEVT_MOUSE_CAPTURE_LOST") ); + } +} + +/* static */ +void wxWindowBase::NotifyCaptureLost() +{ + // don't do anything if capture lost was expected, i.e. resulted from + // a wx call to ReleaseMouse or CaptureMouse: + if ( ms_winCaptureChanging ) + return; + + // if the capture was lost unexpectedly, notify every window that has + // capture (on stack or current) about it and clear the stack: + + if ( ms_winCaptureCurrent ) + { + DoNotifyWindowAboutCaptureLost(ms_winCaptureCurrent); + ms_winCaptureCurrent = NULL; + } + + while ( ms_winCaptureNext ) + { + wxWindowNext *item = ms_winCaptureNext; + ms_winCaptureNext = item->next; + + DoNotifyWindowAboutCaptureLost(item->win); + + delete item; + } +} + +#if wxUSE_HOTKEY + +bool +wxWindowBase::RegisterHotKey(int WXUNUSED(hotkeyId), + int WXUNUSED(modifiers), + int WXUNUSED(keycode)) +{ + // not implemented + return false; +} + +bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId)) +{ + // not implemented + return false; +} + +#endif // wxUSE_HOTKEY + +// ---------------------------------------------------------------------------- +// event processing +// ---------------------------------------------------------------------------- + +bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event)) +{ +#if wxUSE_VALIDATORS + // Can only use the validator of the window which + // is receiving the event + if ( event.GetEventObject() == this ) + { + wxValidator * const validator = GetValidator(); + if ( validator && validator->ProcessEventHere(event) ) + { + return true; + } + } +#endif // wxUSE_VALIDATORS + + return false; +} + +bool wxWindowBase::TryParent(wxEvent& event) +{ + // carry on up the parent-child hierarchy if the propagation count hasn't + // reached zero yet + if ( event.ShouldPropagate() ) + { + // honour the requests to stop propagation at this window: this is + // used by the dialogs, for example, to prevent processing the events + // from the dialog controls in the parent frame which rarely, if ever, + // makes sense + if ( !(GetExtraStyle() & wxWS_EX_BLOCK_EVENTS) ) + { + wxWindow *parent = GetParent(); + if ( parent && !parent->IsBeingDeleted() ) + { + wxPropagateOnce propagateOnce(event); + + return parent->GetEventHandler()->ProcessEvent(event); + } + } + } + + return wxEvtHandler::TryParent(event); +} + +// ---------------------------------------------------------------------------- +// window relationships +// ---------------------------------------------------------------------------- + +wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const +{ + wxCHECK_MSG( GetParent(), NULL, + _T("GetPrev/NextSibling() don't work for TLWs!") ); + + wxWindowList& siblings = GetParent()->GetChildren(); + wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this); + wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") ); + + if ( order == OrderBefore ) + i = i->GetPrevious(); + else // OrderAfter + i = i->GetNext(); + + return i ? i->GetData() : NULL; } +// ---------------------------------------------------------------------------- +// keyboard navigation +// ---------------------------------------------------------------------------- + +// Navigates in the specified direction inside this window +bool wxWindowBase::DoNavigateIn(int flags) +{ +#ifdef wxHAS_NATIVE_TAB_TRAVERSAL + // native code doesn't process our wxNavigationKeyEvents anyhow + wxUnusedVar(flags); + return false; +#else // !wxHAS_NATIVE_TAB_TRAVERSAL + wxNavigationKeyEvent eventNav; + wxWindow *focused = FindFocus(); + eventNav.SetCurrentFocus(focused); + eventNav.SetEventObject(focused); + eventNav.SetFlags(flags); + return GetEventHandler()->ProcessEvent(eventNav); +#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL +} + +bool wxWindowBase::HandleAsNavigationKey(const wxKeyEvent& event) +{ + if ( event.GetKeyCode() != WXK_TAB ) + return false; + + int flags = wxNavigationKeyEvent::FromTab; + + if ( event.ShiftDown() ) + flags |= wxNavigationKeyEvent::IsBackward; + else + flags |= wxNavigationKeyEvent::IsForward; + + if ( event.ControlDown() ) + flags |= wxNavigationKeyEvent::WinChange; + + Navigate(flags); + return true; +} + +void wxWindowBase::DoMoveInTabOrder(wxWindow *win, WindowOrder move) +{ + // check that we're not a top level window + wxCHECK_RET( GetParent(), + _T("MoveBefore/AfterInTabOrder() don't work for TLWs!") ); + + // detect the special case when we have nothing to do anyhow and when the + // code below wouldn't work + if ( win == this ) + return; + + // find the target window in the siblings list + wxWindowList& siblings = GetParent()->GetChildren(); + wxWindowList::compatibility_iterator i = siblings.Find(win); + wxCHECK_RET( i, _T("MoveBefore/AfterInTabOrder(): win is not a sibling") ); + + // unfortunately, when wxUSE_STL == 1 DetachNode() is not implemented so we + // can't just move the node around + wxWindow *self = (wxWindow *)this; + siblings.DeleteObject(self); + if ( move == OrderAfter ) + { + i = i->GetNext(); + } + + if ( i ) + { + siblings.Insert(i, self); + } + else // OrderAfter and win was the last sibling + { + siblings.Append(self); + } +} + +// ---------------------------------------------------------------------------- +// focus handling +// ---------------------------------------------------------------------------- + +/*static*/ wxWindow* wxWindowBase::FindFocus() +{ + wxWindowBase *win = DoFindFocus(); + return win ? win->GetMainWindowOfCompositeControl() : NULL; +} + +bool wxWindowBase::HasFocus() const +{ + wxWindowBase *win = DoFindFocus(); + return win == this || + win == wxConstCast(this, wxWindowBase)->GetMainWindowOfCompositeControl(); +} + +// ---------------------------------------------------------------------------- +// drag and drop +// ---------------------------------------------------------------------------- + +#if wxUSE_DRAG_AND_DROP && !defined(__WXMSW__) + +namespace +{ + +class DragAcceptFilesTarget : public wxFileDropTarget +{ +public: + DragAcceptFilesTarget(wxWindowBase *win) : m_win(win) {} + + virtual bool OnDropFiles(wxCoord x, wxCoord y, + const wxArrayString& filenames) + { + wxDropFilesEvent event(wxEVT_DROP_FILES, + filenames.size(), + wxCArrayString(filenames).Release()); + event.SetEventObject(m_win); + event.m_pos.x = x; + event.m_pos.y = y; + + return m_win->HandleWindowEvent(event); + } + +private: + wxWindowBase * const m_win; + + DECLARE_NO_COPY_CLASS(DragAcceptFilesTarget) +}; + + +} // anonymous namespace + +// Generic version of DragAcceptFiles(). It works by installing a simple +// wxFileDropTarget-to-EVT_DROP_FILES adaptor and therefore cannot be used +// together with explicit SetDropTarget() calls. +void wxWindowBase::DragAcceptFiles(bool accept) +{ + if ( accept ) + { + wxASSERT_MSG( !GetDropTarget(), + "cannot use DragAcceptFiles() and SetDropTarget() together" ); + SetDropTarget(new DragAcceptFilesTarget(this)); + } + else + { + SetDropTarget(NULL); + } +} + +#endif // wxUSE_DRAG_AND_DROP && !defined(__WXMSW__) + // ---------------------------------------------------------------------------- // global functions // ---------------------------------------------------------------------------- @@ -2019,4 +2964,446 @@ wxWindow* wxGetTopLevelParent(wxWindow *win) return win; } -// vi:sts=4:sw=4:et +#if wxUSE_ACCESSIBILITY +// ---------------------------------------------------------------------------- +// accessible object for windows +// ---------------------------------------------------------------------------- + +// Can return either a child object, or an integer +// representing the child element, starting from 1. +wxAccStatus wxWindowAccessible::HitTest(const wxPoint& WXUNUSED(pt), int* WXUNUSED(childId), wxAccessible** WXUNUSED(childObject)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the rectangle for this object (id = 0) or a child element (id > 0). +wxAccStatus wxWindowAccessible::GetLocation(wxRect& rect, int elementId) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxWindow* win = NULL; + if (elementId == 0) + { + win = GetWindow(); + } + else + { + if (elementId <= (int) GetWindow()->GetChildren().GetCount()) + { + win = GetWindow()->GetChildren().Item(elementId-1)->GetData(); + } + else + return wxACC_FAIL; + } + if (win) + { + rect = win->GetRect(); + if (win->GetParent() && !win->IsKindOf(CLASSINFO(wxTopLevelWindow))) + rect.SetPosition(win->GetParent()->ClientToScreen(rect.GetPosition())); + return wxACC_OK; + } + + return wxACC_NOT_IMPLEMENTED; +} + +// Navigates from fromId to toId/toObject. +wxAccStatus wxWindowAccessible::Navigate(wxNavDir navDir, int fromId, + int* WXUNUSED(toId), wxAccessible** toObject) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + switch (navDir) + { + case wxNAVDIR_FIRSTCHILD: + { + if (GetWindow()->GetChildren().GetCount() == 0) + return wxACC_FALSE; + wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetFirst()->GetData(); + *toObject = childWindow->GetOrCreateAccessible(); + + return wxACC_OK; + } + case wxNAVDIR_LASTCHILD: + { + if (GetWindow()->GetChildren().GetCount() == 0) + return wxACC_FALSE; + wxWindow* childWindow = (wxWindow*) GetWindow()->GetChildren().GetLast()->GetData(); + *toObject = childWindow->GetOrCreateAccessible(); + + return wxACC_OK; + } + case wxNAVDIR_RIGHT: + case wxNAVDIR_DOWN: + case wxNAVDIR_NEXT: + { + wxWindowList::compatibility_iterator node = + wxWindowList::compatibility_iterator(); + if (fromId == 0) + { + // Can't navigate to sibling of this window + // if we're a top-level window. + if (!GetWindow()->GetParent()) + return wxACC_NOT_IMPLEMENTED; + + node = GetWindow()->GetParent()->GetChildren().Find(GetWindow()); + } + else + { + if (fromId <= (int) GetWindow()->GetChildren().GetCount()) + node = GetWindow()->GetChildren().Item(fromId-1); + } + + if (node && node->GetNext()) + { + wxWindow* nextWindow = node->GetNext()->GetData(); + *toObject = nextWindow->GetOrCreateAccessible(); + return wxACC_OK; + } + else + return wxACC_FALSE; + } + case wxNAVDIR_LEFT: + case wxNAVDIR_UP: + case wxNAVDIR_PREVIOUS: + { + wxWindowList::compatibility_iterator node = + wxWindowList::compatibility_iterator(); + if (fromId == 0) + { + // Can't navigate to sibling of this window + // if we're a top-level window. + if (!GetWindow()->GetParent()) + return wxACC_NOT_IMPLEMENTED; + + node = GetWindow()->GetParent()->GetChildren().Find(GetWindow()); + } + else + { + if (fromId <= (int) GetWindow()->GetChildren().GetCount()) + node = GetWindow()->GetChildren().Item(fromId-1); + } + + if (node && node->GetPrevious()) + { + wxWindow* previousWindow = node->GetPrevious()->GetData(); + *toObject = previousWindow->GetOrCreateAccessible(); + return wxACC_OK; + } + else + return wxACC_FALSE; + } + } + + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the name of the specified object. +wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString title; + + // If a child, leave wxWidgets to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + // This will eventually be replaced by specialised + // accessible classes, one for each kind of wxWidgets + // control or window. +#if wxUSE_BUTTON + if (GetWindow()->IsKindOf(CLASSINFO(wxButton))) + title = ((wxButton*) GetWindow())->GetLabel(); + else +#endif + title = GetWindow()->GetName(); + + if (!title.empty()) + { + *name = title; + return wxACC_OK; + } + else + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the number of children. +wxAccStatus wxWindowAccessible::GetChildCount(int* childId) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + *childId = (int) GetWindow()->GetChildren().GetCount(); + return wxACC_OK; +} + +// Gets the specified child (starting from 1). +// If *child is NULL and return value is wxACC_OK, +// this means that the child is a simple element and +// not an accessible object. +wxAccStatus wxWindowAccessible::GetChild(int childId, wxAccessible** child) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + if (childId == 0) + { + *child = this; + return wxACC_OK; + } + + if (childId > (int) GetWindow()->GetChildren().GetCount()) + return wxACC_FAIL; + + wxWindow* childWindow = GetWindow()->GetChildren().Item(childId-1)->GetData(); + *child = childWindow->GetOrCreateAccessible(); + if (*child) + return wxACC_OK; + else + return wxACC_FAIL; +} + +// Gets the parent, or NULL. +wxAccStatus wxWindowAccessible::GetParent(wxAccessible** parent) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxWindow* parentWindow = GetWindow()->GetParent(); + if (!parentWindow) + { + *parent = NULL; + return wxACC_OK; + } + else + { + *parent = parentWindow->GetOrCreateAccessible(); + if (*parent) + return wxACC_OK; + else + return wxACC_FAIL; + } +} + +// Performs the default action. childId is 0 (the action for this object) +// or > 0 (the action for a child). +// Return wxACC_NOT_SUPPORTED if there is no default action for this +// window (e.g. an edit control). +wxAccStatus wxWindowAccessible::DoDefaultAction(int WXUNUSED(childId)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the default action for this object (0) or > 0 (the action for a child). +// Return wxACC_OK even if there is no action. actionName is the action, or the empty +// string if there is no action. +// The retrieved string describes the action that is performed on an object, +// not what the object does as a result. For example, a toolbar button that prints +// a document has a default action of "Press" rather than "Prints the current document." +wxAccStatus wxWindowAccessible::GetDefaultAction(int WXUNUSED(childId), wxString* WXUNUSED(actionName)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the description for this object or a child. +wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* description) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); + if (!ht.empty()) + { + *description = ht; + return wxACC_OK; + } + return wxACC_NOT_IMPLEMENTED; +} + +// Returns help text for this object or a child, similar to tooltip text. +wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* helpText) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); + if (!ht.empty()) + { + *helpText = ht; + return wxACC_OK; + } + return wxACC_NOT_IMPLEMENTED; +} + +// Returns the keyboard shortcut for this object or child. +// Return e.g. ALT+K +wxAccStatus wxWindowAccessible::GetKeyboardShortcut(int WXUNUSED(childId), wxString* WXUNUSED(shortcut)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Returns a role constant. +wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + // If a child, leave wxWidgets to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + if (GetWindow()->IsKindOf(CLASSINFO(wxControl))) + return wxACC_NOT_IMPLEMENTED; +#if wxUSE_STATUSBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar))) + return wxACC_NOT_IMPLEMENTED; +#endif +#if wxUSE_TOOLBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar))) + return wxACC_NOT_IMPLEMENTED; +#endif + + //*role = wxROLE_SYSTEM_CLIENT; + *role = wxROLE_SYSTEM_CLIENT; + return wxACC_OK; + + #if 0 + return wxACC_NOT_IMPLEMENTED; + #endif +} + +// Returns a state constant. +wxAccStatus wxWindowAccessible::GetState(int childId, long* state) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + // If a child, leave wxWidgets to call the function on the actual + // child object. + if (childId > 0) + return wxACC_NOT_IMPLEMENTED; + + if (GetWindow()->IsKindOf(CLASSINFO(wxControl))) + return wxACC_NOT_IMPLEMENTED; + +#if wxUSE_STATUSBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxStatusBar))) + return wxACC_NOT_IMPLEMENTED; +#endif +#if wxUSE_TOOLBAR + if (GetWindow()->IsKindOf(CLASSINFO(wxToolBar))) + return wxACC_NOT_IMPLEMENTED; +#endif + + *state = 0; + return wxACC_OK; + + #if 0 + return wxACC_NOT_IMPLEMENTED; + #endif +} + +// Returns a localized string representing the value for the object +// or child. +wxAccStatus wxWindowAccessible::GetValue(int WXUNUSED(childId), wxString* WXUNUSED(strValue)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Selects the object or child. +wxAccStatus wxWindowAccessible::Select(int WXUNUSED(childId), wxAccSelectionFlags WXUNUSED(selectFlags)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +// Gets the window with the keyboard focus. +// If childId is 0 and child is NULL, no object in +// this subhierarchy has the focus. +// If this object has the focus, child should be 'this'. +wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** WXUNUSED(child)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} + +#if wxUSE_VARIANT +// Gets a variant representing the selected children +// of this object. +// Acceptable values: +// - a null variant (IsNull() returns true) +// - a list variant (GetType() == wxT("list") +// - an integer representing the selected child element, +// or 0 if this object is selected (GetType() == wxT("long") +// - a "void*" pointer to a wxAccessible child object +wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections)) +{ + wxASSERT( GetWindow() != NULL ); + if (!GetWindow()) + return wxACC_FAIL; + + return wxACC_NOT_IMPLEMENTED; +} +#endif // wxUSE_VARIANT + +#endif // wxUSE_ACCESSIBILITY + +// ---------------------------------------------------------------------------- +// RTL support +// ---------------------------------------------------------------------------- + +wxCoord +wxWindowBase::AdjustForLayoutDirection(wxCoord x, + wxCoord width, + wxCoord widthTotal) const +{ + if ( GetLayoutDirection() == wxLayout_RightToLeft ) + { + x = widthTotal - x - width; + } + + return x; +} + +