X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/e7445ff8ee26e39fab1e35455e1bef954bdf636f..be5be16a2326d8bfaa109d522212adffca4dcf5d:/src/common/wincmn.cpp diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp index 9e8bc62c7c..6243c4d73d 100644 --- a/src/common/wincmn.cpp +++ b/src/common/wincmn.cpp @@ -38,20 +38,15 @@ #include "wx/settings.h" #include "wx/dialog.h" #include "wx/msgdlg.h" + #include "wx/msgout.h" #include "wx/statusbr.h" #include "wx/toolbar.h" #include "wx/dcclient.h" -#endif //WX_PRECOMP - -#if defined(__WXMAC__) && wxUSE_SCROLLBAR #include "wx/scrolbar.h" -#endif - -#if wxUSE_CONSTRAINTS #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" @@ -77,29 +72,20 @@ #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__ - #include - extern const unsigned int gtk_major_version; - extern const unsigned int gtk_minor_version; - extern const unsigned int gtk_micro_version; -#endif +#include "wx/platinfo.h" // Windows List WXDLLIMPEXP_DATA_CORE(wxWindowList) wxTopLevelWindows; +// globals +#if wxUSE_MENUS +wxMenu *wxCurrentPopupMenu = NULL; +#endif // wxUSE_MENUS + // ---------------------------------------------------------------------------- // static data // ---------------------------------------------------------------------------- -#if defined(__WXPALMOS__) -int wxWindowBase::ms_lastControlId = 32767; -#elif defined(__WXPM__) -int wxWindowBase::ms_lastControlId = 2000; -#else -int wxWindowBase::ms_lastControlId = -200; -#endif IMPLEMENT_ABSTRACT_CLASS(wxWindowBase, wxEvtHandler) @@ -116,6 +102,7 @@ BEGIN_EVENT_TABLE(wxWindowBase, wxEvtHandler) EVT_HELP(wxID_ANY, wxWindowBase::OnHelp) #endif // wxUSE_HELP + EVT_SIZE(wxWindowBase::InternalOnSize) END_EVENT_TABLE() // ============================================================================ @@ -130,7 +117,7 @@ END_EVENT_TABLE() wxWindowBase::wxWindowBase() { // no window yet, no parent nor children - m_parent = (wxWindow *)NULL; + m_parent = NULL; m_windowId = wxID_ANY; // no constraints on the minimal window size @@ -151,7 +138,7 @@ wxWindowBase::wxWindowBase() #if wxUSE_VALIDATORS // no validator - m_windowValidator = (wxValidator *) NULL; + m_windowValidator = NULL; #endif // wxUSE_VALIDATORS // the colours/fonts are default for now, so leave m_font, @@ -167,28 +154,28 @@ wxWindowBase::wxWindowBase() m_exStyle = m_windowStyle = 0; - m_backgroundStyle = wxBG_STYLE_SYSTEM; + m_backgroundStyle = wxBG_STYLE_ERASE; #if wxUSE_CONSTRAINTS // no constraints whatsoever - m_constraints = (wxLayoutConstraints *) NULL; - m_constraintsInvolvedIn = (wxWindowList *) NULL; + m_constraints = NULL; + m_constraintsInvolvedIn = NULL; #endif // wxUSE_CONSTRAINTS - m_windowSizer = (wxSizer *) NULL; - m_containingSizer = (wxSizer *) NULL; + m_windowSizer = NULL; + m_containingSizer = NULL; m_autoLayout = false; #if wxUSE_DRAG_AND_DROP - m_dropTarget = (wxDropTarget *)NULL; + m_dropTarget = NULL; #endif // wxUSE_DRAG_AND_DROP #if wxUSE_TOOLTIPS - m_tooltip = (wxToolTip *)NULL; + m_tooltip = NULL; #endif // wxUSE_TOOLTIPS #if wxUSE_CARET - m_caret = (wxCaret *)NULL; + m_caret = NULL; #endif // wxUSE_CARET #if wxUSE_PALETTE @@ -201,10 +188,7 @@ wxWindowBase::wxWindowBase() m_virtualSize = wxDefaultSize; - m_minVirtualWidth = - m_maxVirtualWidth = wxDefaultCoord; - m_minVirtualHeight = - m_maxVirtualHeight = wxDefaultCoord; + m_scrollHelper = NULL; m_windowVariant = wxWINDOW_VARIANT_NORMAL; #if wxUSE_SYSTEM_OPTIONS @@ -217,8 +201,12 @@ wxWindowBase::wxWindowBase() // Whether we're using the current theme for this window (wxGTK only for now) m_themeEnabled = false; - // VZ: this one shouldn't exist... + // This is set to true by SendDestroyEvent() which should be called by the + // most derived class to ensure that the destruction event is sent as soon + // as possible to allow its handlers to still see the undestroyed window m_isBeingDeleted = false; + + m_freezeCount = 0; } // common part of window creation process @@ -230,28 +218,29 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent, const wxValidator& wxVALIDATOR_PARAM(validator), const wxString& name) { -#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), + 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 == wxID_ANY ? 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 @@ -269,6 +258,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 // ---------------------------------------------------------------------------- @@ -289,18 +300,18 @@ wxWindowBase::~wxWindowBase() // we weren't a dialog class 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") ); - // 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; @@ -341,10 +352,44 @@ wxWindowBase::~wxWindowBase() #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() +{ + if ( m_isBeingDeleted ) + { + // we could have been already called from a more derived class dtor, + // e.g. ~wxTLW calls us and so does ~wxWindow and the latter call + // should be simply ignored + return; + } + + m_isBeingDeleted = true; + + wxWindowDestroyEvent event; + event.SetEventObject(this); + event.SetId(GetId()); + GetEventHandler()->ProcessEvent(event); } bool wxWindowBase::Destroy() { + SendDestroyEvent(); + delete this; return true; @@ -358,7 +403,7 @@ bool wxWindowBase::Close(bool force) // 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() @@ -373,11 +418,11 @@ bool wxWindowBase::DestroyChildren() wxWindow *child = node->GetData(); - // 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; + // note that we really want to delete it immediately so don't call the + // possible overridden Destroy() version which might not delete the + // child immediately resulting in problems with our (top level) child + // outliving its parent + child->wxWindowBase::Destroy(); wxASSERT_MSG( !GetChildren().Find(child), wxT("child didn't remove itself using RemoveChild()") ); @@ -404,7 +449,7 @@ void wxWindowBase::Fit() { if ( !GetChildren().empty() ) { - SetClientSize(GetBestSize()); + SetSize(GetBestSize()); } //else: do nothing if we have no children } @@ -419,7 +464,7 @@ void wxWindowBase::FitInside() } // On Mac, scrollbars are explicitly children. -#ifdef __WXMAC__ +#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) static bool wxHasRealChildren(const wxWindowBase* win) { int realChildCount = 0; @@ -455,7 +500,7 @@ wxSize wxWindowBase::DoGetBestSize() const if ( m_windowSizer ) { - best = GetWindowSizeForVirtualSize(m_windowSizer->GetMinSize()); + best = m_windowSizer->GetMinSize(); } #if wxUSE_CONSTRAINTS else if ( m_constraints ) @@ -495,12 +540,13 @@ wxSize wxWindowBase::DoGetBestSize() const } #endif // wxUSE_CONSTRAINTS else if ( !GetChildren().empty() -#ifdef __WXMAC__ +#if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__) && 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; @@ -509,9 +555,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 ) { @@ -538,11 +585,6 @@ 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 @@ -574,29 +616,132 @@ wxSize wxWindowBase::DoGetBestSize() const 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, 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; + } + } + + 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::GetBestFittingSize() const +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) { wxSize best = GetBestSize(); if (min.x == wxDefaultCoord) min.x = best.x; if (min.y == wxDefaultCoord) min.y = best.y; } + return min; } +wxSize wxWindowBase::GetBestSize() const +{ + if ( !m_windowSizer && m_bestSizeCache.IsFullySpecified() ) + return m_bestSizeCache; + + // call DoGetBestClientSize() first, if a derived class overrides it wants + // it to be used + wxSize size = DoGetBestClientSize(); + if ( size != wxDefaultSize ) + { + size += DoGetBorderSize(); + + CacheBestSize(size); + return size; + } + + return DoGetBestSize(); +} + +void wxWindowBase::SetMinSize(const wxSize& minSize) +{ + m_minWidth = minSize.x; + m_minHeight = minSize.y; +} -void wxWindowBase::SetBestFittingSize(const wxSize& size) +void wxWindowBase::SetMaxSize(const wxSize& maxSize) +{ + m_maxWidth = maxSize.x; + m_maxHeight = maxSize.y; +} + +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 = GetBestFittingSize(); + wxSize best = GetEffectiveMinSize(); // If the current size doesn't match then change it if (GetSize() != best) @@ -610,21 +755,20 @@ wxPoint wxWindowBase::GetClientAreaOrigin() const return wxPoint(0,0); } -// set the min/max size of the window -void wxWindowBase::DoSetSizeHints(int minW, int minH, - int maxW, int maxH, - int WXUNUSED(incW), int WXUNUSED(incH)) +wxSize wxWindowBase::ClientToWindowSize(const wxSize& size) const { - // 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 == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) && - (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH), - _T("min width/height must be less than max width/height!") ); + const wxSize diff(GetSize() - GetClientSize()); - m_minWidth = minW; - m_maxWidth = maxW; - m_minHeight = minH; - m_maxHeight = maxH; + 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 ) @@ -672,26 +816,35 @@ void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant ) SetFont(font); } -void wxWindowBase::SetVirtualSizeHints( int minW, int minH, - int maxW, int maxH ) +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; +} + + +#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; } -void wxWindowBase::DoSetVirtualSize( int x, int y ) +void wxWindowBase::SetVirtualSizeHints(const wxSize& WXUNUSED(minsize), + const wxSize& WXUNUSED(maxsize)) { - if ( m_minVirtualWidth != wxDefaultCoord && m_minVirtualWidth > x ) - x = m_minVirtualWidth; - if ( m_maxVirtualWidth != wxDefaultCoord && m_maxVirtualWidth < x ) - x = m_maxVirtualWidth; - if ( m_minVirtualHeight != wxDefaultCoord && m_minVirtualHeight > y ) - y = m_minVirtualHeight; - if ( m_maxVirtualHeight != wxDefaultCoord && m_maxVirtualHeight < y ) - y = m_maxVirtualHeight; +} +#endif // WXWIN_COMPATIBILITY_2_8 +void wxWindowBase::DoSetVirtualSize( int x, int y ) +{ m_virtualSize = wxSize(x, y); } @@ -722,6 +875,23 @@ void wxWindowBase::DoGetScreenPosition(int *x, int *y) const ClientToScreen(x, y); } +void wxWindowBase::SendSizeEvent(int flags) +{ + wxSizeEvent event(GetSize(), GetId()); + event.SetEventObject(this); + if ( flags & wxSEND_EVENT_POST ) + wxPostEvent(this, event); + else + HandleWindowEvent(event); +} + +void wxWindowBase::SendSizeEventToParent(int flags) +{ + wxWindow * const parent = GetParent(); + if ( parent && !parent->IsBeingDeleted() ) + parent->SendSizeEvent(flags); +} + // ---------------------------------------------------------------------------- // show/hide/enable/disable the window // ---------------------------------------------------------------------------- @@ -740,19 +910,66 @@ 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 +{ + // 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 // ---------------------------------------------------------------------------- @@ -762,6 +979,52 @@ bool wxWindowBase::IsTopLevel() const return false; } +// ---------------------------------------------------------------------------- +// Freeze/Thaw +// ---------------------------------------------------------------------------- + +void wxWindowBase::Freeze() +{ + if ( !m_freezeCount++ ) + { + // physically freeze this window: + DoFreeze(); + + // and recursively freeze all children: + for ( wxWindowList::iterator i = GetChildren().begin(); + i != GetChildren().end(); ++i ) + { + wxWindow *child = *i; + if ( child->IsTopLevel() ) + continue; + + child->Freeze(); + } + } +} + +void wxWindowBase::Thaw() +{ + wxASSERT_MSG( m_freezeCount, "Thaw() without matching Freeze()" ); + + 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 // ---------------------------------------------------------------------------- @@ -777,12 +1040,25 @@ void wxWindowBase::AddChild(wxWindowBase *child) 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); } @@ -796,6 +1072,8 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) return false; } + const bool oldEnabledState = IsEnabled(); + // unlink this window from the existing parent. if ( oldParent ) { @@ -816,6 +1094,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; } @@ -823,73 +1109,124 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) // event handler stuff // ---------------------------------------------------------------------------- -void wxWindowBase::PushEventHandler(wxEvtHandler *handler) +void wxWindowBase::SetEventHandler(wxEvtHandler *handler) +{ + wxCHECK_RET(handler != NULL, "SetEventHandler(NULL) called"); + + m_eventHandler = handler; +} + +void wxWindowBase::SetNextHandler(wxEvtHandler *WXUNUSED(handler)) +{ + // disable wxEvtHandler chain mechanism for wxWindows: + // wxWindow uses its own stack mechanism which doesn't mix well with wxEvtHandler's one + + wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain"); +} +void wxWindowBase::SetPreviousHandler(wxEvtHandler *WXUNUSED(handler)) +{ + // we can't simply wxFAIL here as in SetNextHandler: in fact the last + // handler of our stack when is destroyed will be Unlink()ed and thus + // will call this function to update the pointer of this window... + + //wxFAIL_MSG("wxWindow cannot be part of a wxEvtHandler chain"); +} + +void wxWindowBase::PushEventHandler(wxEvtHandler *handlerToPush) { + wxCHECK_RET( handlerToPush != NULL, "PushEventHandler(NULL) called" ); + + // the new handler is going to be part of the wxWindow stack of event handlers: + // it can't be part also of an event handler double-linked chain: + wxASSERT_MSG(handlerToPush->IsUnlinked(), + "The handler being pushed in the wxWindow stack shouldn't be part of " + "a wxEvtHandler chain; call Unlink() on it first"); + wxEvtHandler *handlerOld = GetEventHandler(); + wxCHECK_RET( handlerOld, "an old event handler is NULL?" ); + + // now use wxEvtHandler double-linked list to implement a stack: + handlerToPush->SetNextHandler(handlerOld); - handler->SetNextHandler(handlerOld); + if (handlerOld != this) + handlerOld->SetPreviousHandler(handlerToPush); - if ( handlerOld ) - GetEventHandler()->SetPreviousHandler(handler); + SetEventHandler(handlerToPush); - SetEventHandler(handler); +#if wxDEBUG_LEVEL + // final checks of the operations done above: + wxASSERT_MSG( handlerToPush->GetPreviousHandler() == NULL, + "the first handler of the wxWindow stack should " + "have no previous handlers set" ); + wxASSERT_MSG( handlerToPush->GetNextHandler() != NULL, + "the first handler of the wxWindow stack should " + "have non-NULL next handler" ); + + wxEvtHandler* pLast = handlerToPush; + while ( pLast && pLast != this ) + pLast = pLast->GetNextHandler(); + wxASSERT_MSG( pLast->GetNextHandler() == NULL, + "the last handler of the wxWindow stack should " + "have this window as next handler" ); +#endif // wxDEBUG_LEVEL } wxEvtHandler *wxWindowBase::PopEventHandler(bool deleteHandler) { - wxEvtHandler *handlerA = GetEventHandler(); - if ( handlerA ) - { - wxEvtHandler *handlerB = handlerA->GetNextHandler(); - handlerA->SetNextHandler((wxEvtHandler *)NULL); + // we need to pop the wxWindow stack, i.e. we need to remove the first handler - if ( handlerB ) - handlerB->SetPreviousHandler((wxEvtHandler *)NULL); - SetEventHandler(handlerB); + wxEvtHandler *firstHandler = GetEventHandler(); + wxCHECK_MSG( firstHandler != NULL, NULL, "wxWindow cannot have a NULL event handler" ); + wxCHECK_MSG( firstHandler != this, NULL, "cannot pop the wxWindow itself" ); + wxCHECK_MSG( firstHandler->GetPreviousHandler() == NULL, NULL, + "the first handler of the wxWindow stack should have no previous handlers set" ); - if ( deleteHandler ) - { - delete handlerA; - handlerA = (wxEvtHandler *)NULL; - } + wxEvtHandler *secondHandler = firstHandler->GetNextHandler(); + wxCHECK_MSG( secondHandler != NULL, NULL, + "the first handler of the wxWindow stack should have non-NULL next handler" ); + + firstHandler->SetNextHandler(NULL); + secondHandler->SetPreviousHandler(NULL); + + // now firstHandler is completely unlinked; set secondHandler as the new window event handler + SetEventHandler(secondHandler); + + if ( deleteHandler ) + { + delete firstHandler; + firstHandler = NULL; } - return handlerA; + return firstHandler; } -bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) +bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handlerToRemove) { - wxCHECK_MSG( handler, false, _T("RemoveEventHandler(NULL) called") ); + wxCHECK_MSG( handlerToRemove != NULL, false, "RemoveEventHandler(NULL) called" ); + wxCHECK_MSG( handlerToRemove != this, false, "Cannot remove the window itself" ); + + if (handlerToRemove == GetEventHandler()) + { + // removing the first event handler is equivalent to "popping" the stack + PopEventHandler(false); + return true; + } - wxEvtHandler *handlerPrev = NULL, - *handlerCur = GetEventHandler(); - while ( handlerCur ) + // NOTE: the wxWindow event handler list is always terminated with "this" handler + wxEvtHandler *handlerCur = GetEventHandler()->GetNextHandler(); + while ( handlerCur != this ) { wxEvtHandler *handlerNext = handlerCur->GetNextHandler(); - if ( handlerCur == handler ) + if ( handlerCur == handlerToRemove ) { - if ( handlerPrev ) - { - handlerPrev->SetNextHandler(handlerNext); - } - else - { - SetEventHandler(handlerNext); - } - - if ( handlerNext ) - { - handlerNext->SetPreviousHandler ( handlerPrev ); - } - - handler->SetNextHandler(NULL); - handler->SetPreviousHandler(NULL); + handlerCur->Unlink(); + wxASSERT_MSG( handlerCur != GetEventHandler(), + "the case Remove == Pop should was already handled" ); return true; } - handlerPrev = handlerCur; handlerCur = handlerNext; } @@ -898,6 +1235,12 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) return false; } +bool wxWindowBase::HandleWindowEvent(wxEvent& event) const +{ + // SafelyProcessEvent() will handle exceptions nicely + return GetEventHandler()->SafelyProcessEvent(event); +} + // ---------------------------------------------------------------------------- // colours, fonts &c // ---------------------------------------------------------------------------- @@ -958,7 +1301,7 @@ wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant)) wxColour wxWindowBase::GetBackgroundColour() const { - if ( !m_backgroundColour.Ok() ) + if ( !m_backgroundColour.IsOk() ) { wxASSERT_MSG( !m_hasBgCol, _T("we have invalid explicit bg colour?") ); @@ -984,11 +1327,9 @@ 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() ) + if ( !colFg.IsOk() ) colFg = GetClassDefaultAttributes().colFg; return colFg; @@ -1002,9 +1343,7 @@ bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) if ( colour == m_backgroundColour ) return false; - m_hasBgCol = colour.Ok(); - if ( m_backgroundStyle != wxBG_STYLE_CUSTOM ) - m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM; + m_hasBgCol = colour.IsOk(); m_inheritBgCol = m_hasBgCol; m_backgroundColour = colour; @@ -1017,7 +1356,7 @@ bool wxWindowBase::SetForegroundColour( const wxColour &colour ) if (colour == m_foregroundColour ) return false; - m_hasFgCol = colour.Ok(); + m_hasFgCol = colour.IsOk(); m_inheritFgCol = m_hasFgCol; m_foregroundColour = colour; SetThemeEnabled( !m_hasFgCol && !m_backgroundColour.Ok() ); @@ -1028,7 +1367,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; @@ -1042,12 +1381,12 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor) wxFont wxWindowBase::GetFont() const { // logic is the same as in GetBackgroundColour() - if ( !m_font.Ok() ) + if ( !m_font.IsOk() ) { wxASSERT_MSG( !m_hasFont, _T("we have invalid explicit font?") ); wxFont font = GetDefaultAttributes().font; - if ( !font.Ok() ) + if ( !font.IsOk() ) font = GetClassDefaultAttributes().font; return font; @@ -1065,7 +1404,7 @@ bool wxWindowBase::SetFont(const wxFont& font) } m_font = font; - m_hasFont = font.Ok(); + m_hasFont = font.IsOk(); m_inheritFont = m_hasFont; InvalidateBestSize(); @@ -1149,12 +1488,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; } @@ -1164,7 +1503,7 @@ void wxWindowBase::ClearBackground() // wxGTK uses its own version, no need to add never used code #ifndef __WXGTK__ wxClientDC dc((wxWindow *)this); - wxBrush brush(GetBackgroundColour(), wxSOLID); + wxBrush brush(GetBackgroundColour(), wxBRUSHSTYLE_SOLID); dc.SetBackground(brush); dc.Clear(); #endif // __WXGTK__ @@ -1179,7 +1518,7 @@ wxWindow *wxWindowBase::FindWindow(long id) const if ( id == m_windowId ) return (wxWindow *)this; - wxWindowBase *res = (wxWindow *)NULL; + wxWindowBase *res = NULL; wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { @@ -1195,7 +1534,7 @@ wxWindow *wxWindowBase::FindWindow(const wxString& name) const if ( name == m_windowName ) return (wxWindow *)this; - wxWindowBase *res = (wxWindow *)NULL; + wxWindowBase *res = NULL; wxWindowList::compatibility_iterator node; for ( node = m_children.GetFirst(); node && !res; node = node->GetNext() ) { @@ -1460,6 +1799,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) @@ -1470,9 +1810,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(); @@ -1490,7 +1834,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; @@ -1503,7 +1869,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) #endif // wxUSE_HELP // ---------------------------------------------------------------------------- -// tooltipsroot.Replace("\\", "/"); +// tooltips // ---------------------------------------------------------------------------- #if wxUSE_TOOLTIPS @@ -1521,7 +1887,7 @@ void wxWindowBase::SetToolTip( const wxString &tip ) } // setting empty tooltip text does not remove the tooltip any more - use - // SetToolTip((wxToolTip *)NULL) for this + // SetToolTip(NULL) for this } void wxWindowBase::DoSetToolTip(wxToolTip *tooltip) @@ -1645,7 +2011,7 @@ void wxWindowBase::DeleteRelatedConstraints() } delete m_constraintsInvolvedIn; - m_constraintsInvolvedIn = (wxWindowList *) NULL; + m_constraintsInvolvedIn = NULL; } } @@ -1656,12 +2022,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) @@ -1730,6 +2105,14 @@ bool wxWindowBase::Layout() return true; } +void wxWindowBase::InternalOnSize(wxSizeEvent& event) +{ + if ( GetAutoLayout() ) + Layout(); + + event.Skip(); +} + #if wxUSE_CONSTRAINTS // first phase of the constraints evaluation: set our own constraints @@ -1978,7 +2361,7 @@ 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) @@ -2013,23 +2396,6 @@ void wxWindowBase::DoUpdateWindowUI(wxUpdateUIEvent& event) Show(event.GetShown()); } -#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(); - } -} -#endif - // ---------------------------------------------------------------------------- // dialog units translations // ---------------------------------------------------------------------------- @@ -2096,16 +2462,90 @@ void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) ) UpdateWindowUI(wxUPDATE_UI_RECURSE); } +// ---------------------------------------------------------------------------- +// menu-related functions +// ---------------------------------------------------------------------------- + +#if wxUSE_MENUS + +bool wxWindowBase::PopupMenu(wxMenu *menu, int x, int y) +{ + 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; + +void wxWindowBase::InternalOnPopupMenu(wxCommandEvent& event) +{ + // store the id in a global variable where we'll retrieve it from later + gs_popupMenuSelection = event.GetId(); +} + +void wxWindowBase::InternalOnPopupMenuUpdate(wxUpdateUIEvent& WXUNUSED(event)) +{ + // nothing to do but do not skip it +} + +int +wxWindowBase::DoGetPopupMenuSelectionFromUser(wxMenu& menu, int x, int y) +{ + gs_popupMenuSelection = wxID_NONE; + + Connect(wxEVT_COMMAND_MENU_SELECTED, + wxCommandEventHandler(wxWindowBase::InternalOnPopupMenu), + NULL, + this); + + // it is common to construct the menu passed to this function dynamically + // using some fixed range of ids which could clash with the ids used + // elsewhere in the program, which could result in some menu items being + // unintentionally disabled or otherwise modified by update UI handlers + // elsewhere in the program code and this is difficult to avoid in the + // program itself, so instead we just temporarily suspend UI updating while + // this menu is shown + Connect(wxEVT_UPDATE_UI, + wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate), + NULL, + this); + + PopupMenu(&menu, x, y); + + Disconnect(wxEVT_UPDATE_UI, + wxUpdateUIEventHandler(wxWindowBase::InternalOnPopupMenuUpdate), + NULL, + this); + 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) +static void DrawBorder(wxWindowBase *win, const wxRect& rect, bool fill, const wxPen* pen) { wxClientDC dc((wxWindow *)win); - dc.SetPen(*wxRED_PEN); - dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_HATCH): *wxTRANSPARENT_BRUSH); + dc.SetPen(*pen); + dc.SetBrush(fill ? wxBrush(pen->GetColour(), wxBRUSHSTYLE_CROSSDIAG_HATCH) : + *wxTRANSPARENT_BRUSH); dc.DrawRectangle(rect.Deflate(1, 1)); } @@ -2120,26 +2560,29 @@ static void DrawSizer(wxWindowBase *win, wxSizer *sizer) wxSizerItem *item = *i; if ( item->IsSizer() ) { - DrawBorder(win, item->GetRect().Deflate(2)); + DrawBorder(win, item->GetRect().Deflate(2), false, wxRED_PEN); DrawSizer(win, item->GetSizer()); } else if ( item->IsSpacer() ) { - DrawBorder(win, item->GetRect().Deflate(2), true); + DrawBorder(win, item->GetRect().Deflate(2), true, wxBLUE_PEN); } else if ( item->IsWindow() ) { DrawSizers(item->GetWindow()); } + else + wxFAIL_MSG("inconsistent wxSizerItem status!"); } } static void DrawSizers(wxWindowBase *win) { + DrawBorder(win, win->GetClientSize(), false, wxGREEN_PEN); + wxSizer *sizer = win->GetSizer(); if ( sizer ) { - DrawBorder(win, win->GetClientSize()); DrawSizer(win, sizer); } else // no sizer, still recurse into the children @@ -2152,6 +2595,26 @@ static void DrawSizers(wxWindowBase *win) { DrawSizers(*i); } + + // show all kind of sizes of this window; see the "window sizing" topic + // overview for more info about the various differences: + wxSize fullSz = win->GetSize(); + wxSize clientSz = win->GetClientSize(); + wxSize bestSz = win->GetBestSize(); + wxSize minSz = win->GetMinSize(); + wxSize maxSz = win->GetMaxSize(); + wxSize virtualSz = win->GetVirtualSize(); + + wxMessageOutputDebug dbgout; + dbgout.Printf( + "%-10s => fullsz=%4d;%-4d clientsz=%4d;%-4d bestsz=%4d;%-4d minsz=%4d;%-4d maxsz=%4d;%-4d virtualsz=%4d;%-4d\n", + win->GetName(), + fullSz.x, fullSz.y, + clientSz.x, clientSz.y, + bestSz.x, bestSz.y, + minSz.x, minSz.y, + maxSz.x, maxSz.y, + virtualSz.x, virtualSz.y); } } @@ -2170,76 +2633,9 @@ void wxWindowBase::OnMiddleClick( wxMouseEvent& event ) return; } #endif // __WXDEBUG__ - -#if wxUSE_MSGDLG - // don't translate these strings - wxString port; - -#ifdef __WXUNIVERSAL__ - port = _T("Univ/"); -#endif // __WXUNIVERSAL__ - - switch ( wxGetOsVersion() ) - { - 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; - case wxPALMOS: port += _T("Palm OS"); break; - case wxWINDOWS_CE: port += _T("Windows CE (generic)"); break; - case wxWINDOWS_POCKETPC: port += _T("Windows CE PocketPC"); break; - case wxWINDOWS_SMARTPHONE: port += _T("Windows CE Smartphone"); break; - default: port += _T("unknown"); break; - } - - wxMessageBox(wxString::Format( - _T( - " wxWidgets Library (%s port)\nVersion %d.%d.%d%s%s, compiled at %s %s%s\n Copyright (c) 1995-2006 wxWidgets team" - ), - port.c_str(), - wxMAJOR_VERSION, - wxMINOR_VERSION, - wxRELEASE_NUMBER, -#if wxUSE_UNICODE - L" (Unicode)", -#else - "", -#endif -#ifdef __WXDEBUG__ - _T(" Debug build"), -#else - wxEmptyString, -#endif - __TDATE__, - __TTIME__, -#ifdef __WXGTK__ - wxString::Format(_T("\nagainst GTK+ %d.%d.%d. Runtime GTK+ version: %d.%d.%d"), GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION, gtk_major_version, gtk_minor_version, gtk_micro_version).c_str() -#else - "" -#endif - ), - _T("wxWidgets information"), - wxICON_INFORMATION | wxOK, - (wxWindow *)this); + ::wxInfoMessageBox((wxWindow*)this); } else -#endif // wxUSE_MSGDLG { event.Skip(); } @@ -2284,14 +2680,14 @@ wxAccessible* wxWindowBase::CreateAccessible() #include "wx/listimpl.cpp" WX_DEFINE_LIST(wxWindowList) -#else +#else // !wxUSE_STL void wxWindowListNode::DeleteData() { delete (wxWindow *)GetData(); } -#endif +#endif // wxUSE_STL/!wxUSE_STL // ---------------------------------------------------------------------------- // borders @@ -2304,6 +2700,10 @@ wxBorder wxWindowBase::GetBorder(long flags) const { border = GetDefaultBorder(); } + else if ( border == wxBORDER_THEME ) + { + border = GetDefaultBorderForControl(); + } return border; } @@ -2342,10 +2742,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)"), static_cast(this)); + + wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive CaptureMouse call?") ); + + ms_winCaptureChanging = true; wxWindow *winOld = GetCapture(); if ( winOld ) @@ -2361,19 +2767,31 @@ 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( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") ); + wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") ); + + 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; @@ -2381,9 +2799,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()); + 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 @@ -2405,37 +2867,29 @@ 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 // ---------------------------------------------------------------------------- -bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event)) +bool wxWindowBase::TryBefore(wxEvent& event) { #if wxUSE_VALIDATORS // Can only use the validator of the window which // is receiving the event if ( event.GetEventObject() == this ) { - wxValidator *validator = GetValidator(); - if ( validator && validator->ProcessEvent(event) ) + wxValidator * const validator = GetValidator(); + if ( validator && validator->ProcessEventHere(event) ) { return true; } } #endif // wxUSE_VALIDATORS - return false; + return wxEvtHandler::TryBefore(event); } -bool wxWindowBase::TryParent(wxEvent& event) +bool wxWindowBase::TryAfter(wxEvent& event) { // carry on up the parent-child hierarchy if the propagation count hasn't // reached zero yet @@ -2457,27 +2911,71 @@ bool wxWindowBase::TryParent(wxEvent& event) } } - return wxEvtHandler::TryParent(event); + return wxEvtHandler::TryAfter(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. -bool wxWindowBase::Navigate(int flags) +// 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); - eventNav.SetEventObject(this); - if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) ) - { - return true; - } - return false; + return GetEventHandler()->ProcessEvent(eventNav); +#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL } -void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move) +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(), @@ -2497,7 +2995,7 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move) // can't just move the node around wxWindow *self = (wxWindow *)this; siblings.DeleteObject(self); - if ( move == MoveAfter ) + if ( move == OrderAfter ) { i = i->GetNext(); } @@ -2506,7 +3004,7 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move) { siblings.Insert(i, self); } - else // MoveAfter and win was the last sibling + else // OrderAfter and win was the last sibling { siblings.Append(self); } @@ -2522,6 +3020,68 @@ void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move) 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; + + wxDECLARE_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 // ---------------------------------------------------------------------------- @@ -2804,7 +3364,7 @@ wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString* if (!GetWindow()) return wxACC_FAIL; - wxString ht(GetWindow()->GetHelpText()); + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); if (!ht.empty()) { *description = ht; @@ -2820,7 +3380,7 @@ wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* hel if (!GetWindow()) return wxACC_FAIL; - wxString ht(GetWindow()->GetHelpText()); + wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard)); if (!ht.empty()) { *helpText = ht; @@ -2938,6 +3498,7 @@ 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: @@ -2954,5 +3515,25 @@ 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; +} + +