X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/400a9e419b229cd511d73922bd5506aaab3b120e..c8058a09e5147657342e02e50cf471d7b751abc1:/src/common/wincmn.cpp diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp index 09cc4d70af..200adf03af 100644 --- a/src/common/wincmn.cpp +++ b/src/common/wincmn.cpp @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// -// 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 +// Copyright: (c) wxWidgets team // Licence: wxWindows licence ///////////////////////////////////////////////////////////////////////////// @@ -17,10 +17,6 @@ // headers // ---------------------------------------------------------------------------- -#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA) - #pragma implementation "windowbase.h" -#endif - // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -33,7 +29,6 @@ #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" @@ -44,14 +39,12 @@ #include "wx/dialog.h" #include "wx/msgdlg.h" #include "wx/statusbr.h" + #include "wx/toolbar.h" #include "wx/dcclient.h" -#endif //WX_PRECOMP - -#if wxUSE_CONSTRAINTS + #include "wx/scrolbar.h" #include "wx/layout.h" -#endif // wxUSE_CONSTRAINTS - -#include "wx/sizer.h" + #include "wx/sizer.h" +#endif //WX_PRECOMP #if wxUSE_DRAG_AND_DROP #include "wx/dnd.h" @@ -73,11 +66,32 @@ #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; + // ---------------------------------------------------------------------------- // static data // ---------------------------------------------------------------------------- -#if defined(__WXPM__) +#if defined(__WXPALMOS__) +int wxWindowBase::ms_lastControlId = 32767; +#elif defined(__WXPM__) int wxWindowBase::ms_lastControlId = 2000; #else int wxWindowBase::ms_lastControlId = -200; @@ -117,9 +131,12 @@ wxWindowBase::wxWindowBase() // 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 are created enabled and visible by default m_isShown = @@ -138,11 +155,16 @@ wxWindowBase::wxWindowBase() m_hasBgCol = m_hasFgCol = m_hasFont = false; + m_inheritBgCol = + m_inheritFgCol = + m_inheritFont = false; // no style bits m_exStyle = m_windowStyle = 0; + m_backgroundStyle = wxBG_STYLE_SYSTEM; + #if wxUSE_CONSTRAINTS // no constraints whatsoever m_constraints = (wxLayoutConstraints *) NULL; @@ -175,12 +197,20 @@ wxWindowBase::wxWindowBase() m_virtualSize = wxDefaultSize; + m_scrollHelper = (wxScrollHelper *) NULL; + m_minVirtualWidth = + m_maxVirtualWidth = wxDefaultCoord; m_minVirtualHeight = - m_maxVirtualWidth = - m_maxVirtualHeight = -1; + m_maxVirtualHeight = wxDefaultCoord; 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; @@ -211,15 +241,19 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, // 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 wxWindows own usage) + // reserved for wxWidgets own usage) wxASSERT_MSG( id == wxID_ANY || (id >= 0 && id < 32767), _T("invalid id value") ); // generate a new id if the user doesn't care about it m_windowId = id == wxID_ANY ? NewControlId() : 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 @@ -237,6 +271,28 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, 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; + } + + SetWindowStyleFlag(style); + + return rc; +} + // ---------------------------------------------------------------------------- // destruction // ---------------------------------------------------------------------------- @@ -259,16 +315,9 @@ wxWindowBase::~wxWindowBase() wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") ); - // reset the dangling pointer our parent window may keep to us + // notify the parent about this window destruction if ( m_parent ) - { - if ( m_parent->GetDefaultItem() == this ) - { - m_parent->SetDefaultItem(NULL); - } - m_parent->RemoveChild(this); - } #if wxUSE_CARET delete m_caret; @@ -311,6 +360,14 @@ wxWindowBase::~wxWindowBase() #endif } +void wxWindowBase::SendDestroyEvent() +{ + wxWindowDestroyEvent event; + event.SetEventObject(this); + event.SetId(GetId()); + GetEventHandler()->ProcessEvent(event); +} + bool wxWindowBase::Destroy() { delete this; @@ -359,126 +416,20 @@ 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; - - wxWindow *parent = NULL; + wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(), + _T("this method only implements centering child windows") ); - if ( !(direction & wxCENTRE_ON_SCREEN) ) - { - // 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; - } - } - - if ( direction & wxCENTRE_ON_SCREEN ) - { - // centre with respect to the whole screen - wxDisplaySize(&widthParent, &heightParent); - } - else - { - 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); - } - } - - 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); - - // 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 - { - 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; - } - - // 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); + SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir)); } // fits the window around the children void wxWindowBase::Fit() { - if ( GetChildren().GetCount() > 0 ) + if ( !GetChildren().empty() ) { - SetClientSize(DoGetBestSize()); + SetSize(GetBestSize()); } //else: do nothing if we have no children } @@ -492,12 +443,44 @@ void wxWindowBase::FitInside() } } +// On Mac, scrollbars are explicitly children. +#ifdef __WXMAC__ +static bool wxHasRealChildren(const wxWindowBase* win) +{ + int realChildCount = 0; + + for ( wxWindowList::compatibility_iterator node = win->GetChildren().GetFirst(); + node; + node = node->GetNext() ) + { + wxWindow *win = node->GetData(); + if ( !win->IsTopLevel() && win->IsShown() && !win->IsKindOf(CLASSINFO(wxScrollBar))) + realChildCount ++; + } + return (realChildCount > 0); +} +#endif + +void wxWindowBase::InvalidateBestSize() +{ + 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 ) @@ -533,12 +516,17 @@ 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().empty() ) + else if ( !GetChildren().empty() +#ifdef __WXMAC__ + && wxHasRealChildren(this) +#endif + ) { - // our minimal acceptable size is such that all our visible child windows fit inside + // our minimal acceptable size is such that all our visible child + // windows fit inside int maxX = 0, maxY = 0; @@ -547,9 +535,10 @@ wxSize wxWindowBase::DoGetBestSize() const node = node->GetNext() ) { wxWindow *win = node->GetData(); - if ( win->IsTopLevel() || ( ! win->IsShown() ) + if ( win->IsTopLevel() + || !win->IsShown() #if wxUSE_STATUSBAR - || wxDynamicCast(win, wxStatusBar) + || wxDynamicCast(win, wxStatusBar) #endif // wxUSE_STATUSBAR ) { @@ -564,9 +553,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); @@ -576,66 +565,141 @@ 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; - - return wxSize(maxX, maxY); + best = wxSize(maxX, maxY); } else // ! has children { - // for a generic window there is no natural best size - just use either the - // minimum size if there is one, or the current size - if ( GetMinSize().IsFullySpecified() ) - return GetMinSize(); - else - return GetSize(); + // 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; +} + +// 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) +{ + int rc = wxSystemSettings::GetMetric(what); + 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; + } + } + + return rc; } -void wxWindowBase::SetBestSize(const wxSize& size) +wxSize wxWindowBase::GetWindowBorderSize() const { - // the size only needs to be changed if the current size is incomplete, - // i.e. one of the components was specified as default -- so if both - // were given, simply don't do anything - if ( size.x == -1 || size.y == -1 ) + wxSize size; + + switch ( GetBorder() ) { - wxSize sizeBest = DoGetBestSize(); - if ( size.x != -1 ) - sizeBest.x = size.x; - if ( size.y != -1 ) - sizeBest.y = size.y; + case wxBORDER_NONE: + // nothing to do, size is already (0, 0) + break; - SetSize(sizeBest); + case wxBORDER_SIMPLE: + case wxBORDER_STATIC: + size.x = wxGetMetricOrDefault(wxSYS_BORDER_X); + size.y = wxGetMetricOrDefault(wxSYS_BORDER_Y); + break; + + case wxBORDER_SUNKEN: + case wxBORDER_RAISED: + size.x = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_X), + wxGetMetricOrDefault(wxSYS_BORDER_X)); + size.y = wxMax(wxGetMetricOrDefault(wxSYS_EDGE_Y), + wxGetMetricOrDefault(wxSYS_BORDER_Y)); + break; - // don't shrink the control below its best size - m_minWidth = sizeBest.x; - m_minHeight = sizeBest.y; + case wxBORDER_DOUBLE: + size.x = wxGetMetricOrDefault(wxSYS_EDGE_X) + + wxGetMetricOrDefault(wxSYS_BORDER_X); + size.y = wxGetMetricOrDefault(wxSYS_EDGE_Y) + + wxGetMetricOrDefault(wxSYS_BORDER_Y); + break; + + default: + wxFAIL_MSG(_T("Unknown border style.")); + break; } + + // we have borders on both sides + return size*2; } -// by default the origin is not shifted -wxPoint wxWindowBase::GetClientAreaOrigin() const +wxSize wxWindowBase::GetEffectiveMinSize() const { - return wxPoint(0, 0); + // merge the best size with the min size, giving priority to the min size + wxSize min = GetMinSize(); + if (min.x == wxDefaultCoord || min.y == wxDefaultCoord) + { + wxSize best = GetBestSize(); + if (min.x == wxDefaultCoord) min.x = best.x; + if (min.y == wxDefaultCoord) min.y = best.y; + } + return min; } -// 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::SetInitialSize(const wxSize& size) { - // setting min width greater than max width leads to infinite loops under - // X11 and generally doesn't make any sense, so don't allow it - wxCHECK_RET( (minW == -1 || maxW == -1 || minW <= maxW) && - (minH == -1 || maxH == -1 || minH <= maxH), - _T("min width/height must be less than max width/height!") ); + // 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); - m_minWidth = minW; - m_maxWidth = maxW; - m_minHeight = minH; - m_maxHeight = maxH; + // 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); } void wxWindowBase::SetWindowVariant( wxWindowVariant variant ) @@ -683,6 +747,21 @@ void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant ) SetFont(font); } +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 ) { @@ -694,13 +773,13 @@ void wxWindowBase::SetVirtualSizeHints( int minW, int minH, void wxWindowBase::DoSetVirtualSize( int x, int y ) { - if ( m_minVirtualWidth != -1 && m_minVirtualWidth > x ) + if ( m_minVirtualWidth != wxDefaultCoord && m_minVirtualWidth > x ) x = m_minVirtualWidth; - if ( m_maxVirtualWidth != -1 && m_maxVirtualWidth < x ) + if ( m_maxVirtualWidth != wxDefaultCoord && m_maxVirtualWidth < x ) x = m_maxVirtualWidth; - if ( m_minVirtualHeight != -1 && m_minVirtualHeight > y ) + if ( m_minVirtualHeight != wxDefaultCoord && m_minVirtualHeight > y ) y = m_minVirtualHeight; - if ( m_maxVirtualHeight != -1 && m_maxVirtualHeight < y ) + if ( m_maxVirtualHeight != wxDefaultCoord && m_maxVirtualHeight < y ) y = m_maxVirtualHeight; m_virtualSize = wxSize(x, y); @@ -708,10 +787,29 @@ void wxWindowBase::DoSetVirtualSize( int x, int 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; - return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ), - wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) ); + ClientToScreen(x, y); } // ---------------------------------------------------------------------------- @@ -732,19 +830,63 @@ bool wxWindowBase::Show(bool show) } } -bool wxWindowBase::Enable(bool enable) +bool wxWindowBase::IsEnabled() const { - if ( enable != m_isEnabled ) - { - m_isEnabled = enable; + return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled()); +} - return true; - } - else +void wxWindowBase::NotifyWindowOnEnableChange(bool enabled) +{ +#ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT + DoEnable(enabled); +#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT) + + OnEnabled(enabled); + + // 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); + } +} + +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 true; } +#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT) + + NotifyWindowOnEnableChange(enable); + + return true; } + +bool wxWindowBase::IsShownOnScreen() const +{ + return IsShown() && + (GetParent() == NULL || GetParent()->IsShownOnScreen()); +} + // ---------------------------------------------------------------------------- // RTTI // ---------------------------------------------------------------------------- @@ -788,6 +930,8 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) return false; } + const bool oldEnabledState = IsEnabled(); + // unlink this window from the existing parent. if ( oldParent ) { @@ -808,6 +952,14 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) 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; } @@ -904,18 +1056,25 @@ void wxWindowBase::InheritAttributes() // 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_hasFont && !m_hasFont ) + if ( parent->m_inheritFont && !m_hasFont ) SetFont(parent->GetFont()); // in addition, there is a possibility to explicitly forbid inheriting // colours at each class level by overriding ShouldInheritColours() if ( ShouldInheritColours() ) { - if ( parent->m_hasFgCol && !m_hasFgCol ) + if ( parent->m_inheritFgCol && !m_hasFgCol ) SetForegroundColour(parent->GetForegroundColour()); - if ( parent->m_hasBgCol && !m_hasBgCol ) + // 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 } } @@ -927,8 +1086,17 @@ wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) wxVisualAttributes attrs; attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT); attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT); - attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE); + // 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. + +#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; } @@ -943,17 +1111,16 @@ wxColour wxWindowBase::GetBackgroundColour() const // we must return some valid colour to avoid redoing this every time // and also to avoid surprizing the applications written for older - // wxWindows versions where GetBackgroundColour() always returned + // 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; - // cache it for the next call - wxConstCast(this, wxWindowBase)->m_backgroundColour = colBg; + return colBg; } - - return m_backgroundColour; + else + return m_backgroundColour; } wxColour wxWindowBase::GetForegroundColour() const @@ -961,40 +1128,41 @@ wxColour wxWindowBase::GetForegroundColour() const // logic is the same as above if ( !m_hasFgCol && !m_foregroundColour.Ok() ) { - wxASSERT_MSG( !m_hasFgCol, _T("we have invalid explicit fg colour?") ); - wxColour colFg = GetDefaultAttributes().colFg; if ( !colFg.Ok() ) colFg = GetClassDefaultAttributes().colFg; - wxConstCast(this, wxWindowBase)->m_foregroundColour = colFg; + return colFg; } - - return m_foregroundColour; + else + return m_foregroundColour; } bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) { - if ( !colour.Ok() || (colour == m_backgroundColour) ) + if ( colour == m_backgroundColour ) return false; - m_backgroundColour = colour; - - m_hasBgCol = true; + m_hasBgCol = colour.Ok(); + 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.Ok() || (colour == m_foregroundColour) ) + if (colour == m_foregroundColour ) return false; + m_hasFgCol = colour.Ok(); + m_inheritFgCol = m_hasFgCol; m_foregroundColour = colour; - - m_hasFgCol = true; - + SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() ); return true; } @@ -1002,7 +1170,7 @@ 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; @@ -1013,7 +1181,7 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor) return true; } -wxFont& wxWindowBase::DoGetFont() const +wxFont wxWindowBase::GetFont() const { // logic is the same as in GetBackgroundColour() if ( !m_font.Ok() ) @@ -1024,18 +1192,14 @@ wxFont& wxWindowBase::DoGetFont() const if ( !font.Ok() ) font = GetClassDefaultAttributes().font; - wxConstCast(this, wxWindowBase)->m_font = font; + return font; } - - // cast is here for non-const GetFont() convenience - return wxConstCast(this, wxWindowBase)->m_font; + else + return m_font; } bool wxWindowBase::SetFont(const wxFont& font) { - if ( !font.Ok() ) - return false; - if ( font == m_font ) { // no change @@ -1043,8 +1207,10 @@ bool wxWindowBase::SetFont(const wxFont& font) } m_font = font; + m_hasFont = font.Ok(); + m_inheritFont = m_hasFont; - m_hasFont = true; + InvalidateBestSize(); return true; } @@ -1125,12 +1291,12 @@ 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; } @@ -1150,7 +1316,7 @@ void wxWindowBase::ClearBackground() // 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; @@ -1166,7 +1332,7 @@ 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; @@ -1298,7 +1464,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); } // ---------------------------------------------------------------------------- @@ -1448,7 +1614,10 @@ void wxWindowBase::SetHelpTextForId(const wxString& text) } // 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(); @@ -1466,7 +1635,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) wxHelpProvider *helpProvider = wxHelpProvider::Get(); if ( helpProvider ) { - if ( helpProvider->ShowHelp(this) ) + if ( helpProvider->ShowHelpAtPoint(this, event.GetPosition(), event.GetOrigin()) ) { // skip the event.Skip() below return; @@ -1479,7 +1648,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) #endif // wxUSE_HELP // ---------------------------------------------------------------------------- -// tooltipsroot.Replace("\\", "/"); +// tooltips // ---------------------------------------------------------------------------- #if wxUSE_TOOLTIPS @@ -1502,10 +1671,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 @@ -1629,12 +1801,21 @@ void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld) if ( sizer == m_windowSizer) return; - if ( deleteOld ) - delete m_windowSizer; + 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) @@ -1688,7 +1869,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 ); } @@ -1855,22 +2036,22 @@ 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); } - if ( y != -1 ) + if ( y != wxDefaultCoord ) { constr->top.SetValue(y); constr->top.SetDone(true); } - if ( w != -1 ) + if ( w != wxDefaultCoord ) { constr->width.SetValue(w); constr->width.SetDone(true); } - if ( h != -1 ) + if ( h != wxDefaultCoord ) { constr->height.SetValue(h); constr->height.SetDone(true); @@ -1883,12 +2064,12 @@ 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); } - if ( y != -1 ) + if ( y != wxDefaultCoord ) { constr->top.SetValue(y); constr->top.SetDone(true); @@ -1951,13 +2132,13 @@ void wxWindowBase::AdjustForParentClientOrigin(int& x, int& y, int sizeFlags) co } // ---------------------------------------------------------------------------- -// do Update UI processing for child controls +// Update UI processing // ---------------------------------------------------------------------------- void wxWindowBase::UpdateWindowUI(long flags) { wxUpdateUIEvent event(GetId()); - event.m_eventObject = this; + event.SetEventObject(this); if ( GetEventHandler()->ProcessEvent(event) ) { @@ -1977,60 +2158,14 @@ void wxWindowBase::UpdateWindowUI(long flags) } // do the window-specific processing after processing the update event -// TODO: take specific knowledge out of this function and -// put in each control's base class. Unfortunately we don't -// yet have base implementation files for wxCheckBox and wxRadioButton. void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event) { if ( event.GetSetEnabled() ) Enable(event.GetEnabled()); -#if wxUSE_CONTROLS - if ( event.GetSetText() ) - { - wxControl *control = wxDynamicCastThis(wxControl); - if ( control ) - { - if ( event.GetText() != control->GetLabel() ) - control->SetLabel(event.GetText()); - } -#if wxUSE_CHECKBOX - wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox); - if ( checkbox ) - { - if ( event.GetSetChecked() ) - checkbox->SetValue(event.GetChecked()); - } -#endif // wxUSE_CHECKBOX - -#if wxUSE_RADIOBTN - wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton); - if ( radiobtn ) - { - if ( event.GetSetChecked() ) - radiobtn->SetValue(event.GetChecked()); - } -#endif // wxUSE_RADIOBTN - } -#endif -} - -#if 0 -// call internal idle recursively -// may be obsolete (wait until OnIdle scheme stabilises) -void wxWindowBase::ProcessInternalIdle() -{ - OnInternalIdle(); - - wxWindowList::compatibility_iterator node = GetChildren().GetFirst(); - while (node) - { - wxWindow *child = node->GetData(); - child->ProcessInternalIdle(); - node = node->GetNext(); - } + if ( event.GetSetShown() ) + Show(event.GetShown()); } -#endif // ---------------------------------------------------------------------------- // dialog units translations @@ -2040,10 +2175,10 @@ wxPoint wxWindowBase::ConvertPixelsToDialog(const wxPoint& pt) { int charWidth = GetCharWidth(); int charHeight = GetCharHeight(); - wxPoint pt2(-1, -1); - if (pt.x != -1) + wxPoint pt2 = wxDefaultPosition; + if (pt.x != wxDefaultCoord) pt2.x = (int) ((pt.x * 4) / charWidth); - if (pt.y != -1) + if (pt.y != wxDefaultCoord) pt2.y = (int) ((pt.y * 8) / charHeight); return pt2; @@ -2053,10 +2188,10 @@ wxPoint wxWindowBase::ConvertDialogToPixels(const wxPoint& pt) { int charWidth = GetCharWidth(); int charHeight = GetCharHeight(); - wxPoint pt2(-1, -1); - if (pt.x != -1) + wxPoint pt2 = wxDefaultPosition; + if (pt.x != wxDefaultCoord) pt2.x = (int) ((pt.x * charWidth) / 4); - if (pt.y != -1) + if (pt.y != wxDefaultCoord) pt2.y = (int) ((pt.y * charHeight) / 8); return pt2; @@ -2077,12 +2212,14 @@ 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, @@ -2096,66 +2233,160 @@ void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) UpdateWindowUI(wxUPDATE_UI_RECURSE); } -// process Ctrl-Alt-mclick -void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) +// ---------------------------------------------------------------------------- +// menu-related functions +// ---------------------------------------------------------------------------- + +#if wxUSE_MENUS + +// 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; + +void wxWindowBase::InternalOnPopupMenu(wxCommandEvent& event) { -#if wxUSE_MSGDLG - if ( event.ControlDown() && event.AltDown() ) + // 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); + +static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill = false) +{ + wxClientDC dc((wxWindow *)win); + dc.SetPen(*wxRED_PEN); + dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_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() ) + { + DrawSizers(item->GetWindow()); + } + } +} + +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 { - // don't translate these strings - wxString port; + const wxWindowList& children = win->GetChildren(); + for ( wxWindowList::const_iterator i = children.begin(), + end = children.end(); + i != end; + ++i ) + { + DrawSizers(*i); + } + } +} -#ifdef __WXUNIVERSAL__ - port = _T("Univ/"); -#endif // __WXUNIVERSAL__ +#endif // __WXDEBUG__ - switch ( wxGetOsVersion() ) +// 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() ) { - 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(this); + return; } +#endif // __WXDEBUG__ - 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_MSGDLG + // don't translate these strings, they're for diagnostics purposes only + wxString msg; + msg.Printf(_T("wxWidgets Library (%s port)\n") + _T("Version %d.%d.%d%s%s, compiled at %s %s\n") + _T("Runtime version of toolkit used is %d.%d.%s\n") + _T("Copyright (c) 1995-2007 wxWidgets team"), + wxPlatformInfo::Get().GetPortIdName().c_str(), + wxMAJOR_VERSION, + wxMINOR_VERSION, + wxRELEASE_NUMBER, #if wxUSE_UNICODE - L" (Unicode)", + L" (Unicode)", +#else + wxEmptyString, +#endif +#ifdef __WXDEBUG__ + _T(" Debug build"), +#else + wxEmptyString, +#endif + __TDATE__, + __TTIME__, + wxPlatformInfo::Get().GetToolkitMajorVersion(), + wxPlatformInfo::Get().GetToolkitMinorVersion(), +#ifdef __WXGTK__ + wxString::Format(_T("\nThe compile-time GTK+ version is %d.%d.%d."), GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION).c_str() #else - "", + wxEmptyString #endif - __TDATE__, - __TTIME__ - ), - _T("wxWindows information"), + ); + + wxMessageBox(msg, _T("wxWidgets information"), wxICON_INFORMATION | wxOK, (wxWindow *)this); +#endif // wxUSE_MSGDLG } else -#endif // wxUSE_MSGDLG { event.Skip(); } @@ -2191,16 +2422,23 @@ wxAccessible* wxWindowBase::CreateAccessible() #endif -#if !wxUSE_STL // ---------------------------------------------------------------------------- // list classes implementation // ---------------------------------------------------------------------------- +#if wxUSE_STL + +#include "wx/listimpl.cpp" +WX_DEFINE_LIST(wxWindowList) + +#else // !wxUSE_STL + void wxWindowListNode::DeleteData() { delete (wxWindow *)GetData(); } -#endif + +#endif // wxUSE_STL/!wxUSE_STL // ---------------------------------------------------------------------------- // borders @@ -2213,6 +2451,10 @@ wxBorder wxWindowBase::GetBorder(long flags) const { border = GetDefaultBorder(); } + else if ( border == wxBORDER_THEME ) + { + border = GetDefaultBorderForControl(); + } return border; } @@ -2251,10 +2493,16 @@ 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)"), wx_static_cast(void*, this)); + + wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") ); + + ms_winCaptureChanging = true; wxWindow *winOld = GetCapture(); if ( winOld ) @@ -2270,19 +2518,28 @@ 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)"), wx_static_cast(void*, 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") ); + 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; @@ -2290,9 +2547,53 @@ void wxWindowBase::ReleaseMouse() } //else: stack is empty, no previous capture + ms_winCaptureChanging = false; + wxLogTrace(_T("mousecapture"), (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"), - GetCapture()); + wx_static_cast(void*, 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 @@ -2314,14 +2615,6 @@ bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId)) #endif // wxUSE_HOTKEY -void wxWindowBase::SendDestroyEvent() -{ - wxWindowDestroyEvent event; - event.SetEventObject(this); - event.SetId(GetId()); - GetEventHandler()->ProcessEvent(event); -} - // ---------------------------------------------------------------------------- // event processing // ---------------------------------------------------------------------------- @@ -2346,7 +2639,7 @@ bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event)) bool wxWindowBase::TryParent(wxEvent& event) { - // carry on up the parent-child hierarchy if the propgation count hasn't + // carry on up the parent-child hierarchy if the propagation count hasn't // reached zero yet if ( event.ShouldPropagate() ) { @@ -2369,6 +2662,69 @@ bool wxWindowBase::TryParent(wxEvent& event) return wxEvtHandler::TryParent(event); } +// ---------------------------------------------------------------------------- +// 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 + return false; +#else // !wxHAS_NATIVE_TAB_TRAVERSAL + wxNavigationKeyEvent eventNav; + eventNav.SetFlags(flags); + eventNav.SetEventObject(FindFocus()); + return GetEventHandler()->ProcessEvent(eventNav); +#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL +} + +void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind 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 == MoveAfter ) + { + i = i->GetNext(); + } + + if ( i ) + { + siblings.Insert(i, self); + } + else // MoveAfter and win was the last sibling + { + siblings.Append(self); + } +} + +// ---------------------------------------------------------------------------- +// focus handling +// ---------------------------------------------------------------------------- + +/*static*/ wxWindow* wxWindowBase::FindFocus() +{ + wxWindowBase *win = DoFindFocus(); + return win ? win->GetMainWindowOfCompositeControl() : NULL; +} + // ---------------------------------------------------------------------------- // global functions // ---------------------------------------------------------------------------- @@ -2531,20 +2887,22 @@ wxAccStatus wxWindowAccessible::GetName(int childId, wxString* name) wxString title; - // If a child, leave wxWindows to call the function on the actual + // 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 wxWindows + // 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.IsEmpty()) + if (!title.empty()) { *name = title; return wxACC_OK; @@ -2649,8 +3007,8 @@ wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* if (!GetWindow()) return wxACC_FAIL; - wxString ht(GetWindow()->GetHelpText()); - if (!ht.IsEmpty()) + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); + if (!ht.empty()) { *description = ht; return wxACC_OK; @@ -2665,8 +3023,8 @@ wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* hel if (!GetWindow()) return wxACC_FAIL; - wxString ht(GetWindow()->GetHelpText()); - if (!ht.IsEmpty()) + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); + if (!ht.empty()) { *helpText = ht; return wxACC_OK; @@ -2692,7 +3050,7 @@ wxAccStatus wxWindowAccessible::GetRole(int childId, wxAccRole* role) if (!GetWindow()) return wxACC_FAIL; - // If a child, leave wxWindows to call the function on the actual + // If a child, leave wxWidgets to call the function on the actual // child object. if (childId > 0) return wxACC_NOT_IMPLEMENTED; @@ -2724,7 +3082,7 @@ wxAccStatus wxWindowAccessible::GetState(int childId, long* state) if (!GetWindow()) return wxACC_FAIL; - // If a child, leave wxWindows to call the function on the actual + // If a child, leave wxWidgets to call the function on the actual // child object. if (childId > 0) return wxACC_NOT_IMPLEMENTED; @@ -2783,10 +3141,11 @@ wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible** 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 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") @@ -2799,5 +3158,24 @@ wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections)) 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; +} +