X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/df311d21f5a5240ee445ccd408e5716c4f05fac8..24af522c4378db219f13146f8bfe22fe790aad0f:/src/common/wincmn.cpp diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp index 891c017583..c40aa1d746 100644 --- a/src/common/wincmn.cpp +++ b/src/common/wincmn.cpp @@ -29,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" @@ -42,17 +41,11 @@ #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" @@ -74,10 +67,6 @@ #include "wx/caret.h" #endif // wxUSE_CARET -#if wxUSE_DISPLAY - #include "wx/display.h" -#endif - #if wxUSE_SYSTEM_OPTIONS #include "wx/sysopt.h" #endif @@ -90,22 +79,22 @@ #else #include #endif - 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) @@ -207,10 +196,7 @@ wxWindowBase::wxWindowBase() m_virtualSize = wxDefaultSize; - m_minVirtualWidth = - m_maxVirtualWidth = wxDefaultCoord; - m_minVirtualHeight = - m_maxVirtualHeight = wxDefaultCoord; + m_scrollHelper = (wxScrollHelper *) NULL; m_windowVariant = wxWINDOW_VARIANT_NORMAL; #if wxUSE_SYSTEM_OPTIONS @@ -226,8 +212,7 @@ wxWindowBase::wxWindowBase() // VZ: this one shouldn't exist... m_isBeingDeleted = false; - // Reserved for future use - m_windowReserved = NULL; + m_freezeCount = 0; } // common part of window creation process @@ -253,14 +238,26 @@ 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 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 @@ -278,6 +275,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 // ---------------------------------------------------------------------------- @@ -298,18 +317,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; @@ -350,6 +369,22 @@ 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 +} + +void wxWindowBase::SendDestroyEvent() +{ + wxWindowDestroyEvent event; + event.SetEventObject(this); + event.SetId(GetId()); + GetEventHandler()->ProcessEvent(event); } bool wxWindowBase::Destroy() @@ -367,7 +402,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() @@ -400,142 +435,12 @@ 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; - wxTopLevelWindow *winTop = NULL; - - 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 ) - { - winTop = wxDynamicCast(parent, wxTopLevelWindow); - if ( winTop && winTop->IsIconized() ) - { - winTop = NULL; - parent = NULL; - } - } -#endif // __WXMOTIF__ - - // did we find the parent? - if ( !parent ) - { - // no other choice - direction |= wxCENTRE_ON_SCREEN; - } - } - - if ( direction & wxCENTRE_ON_SCREEN ) - { - //RN: If we are using wxDisplay we get - //the dimensions of the monitor the window is on, - //otherwise we get the dimensions of the primary monitor - //FIXME: wxDisplay::GetFromWindow only implemented on MSW -#if wxUSE_DISPLAY && defined(__WXMSW__) - int nDisplay = wxDisplay::GetFromWindow((wxWindow*)this); - if(nDisplay != wxNOT_FOUND) - { - wxDisplay windowDisplay(nDisplay); - wxRect displayRect = windowDisplay.GetGeometry(); - widthParent = displayRect.width; - heightParent = displayRect.height; - } - else -#endif - // centre with respect to the whole screen - wxDisplaySize(&widthParent, &heightParent); - } - else - { - if ( IsTopLevel() ) - { - if(winTop) - winTop->GetRectForTopLevelChildren(&posParent.x, &posParent.y, &widthParent, &heightParent); - else - { - // 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 = wxDefaultCoord, - yNew = wxDefaultCoord; - - if ( direction & wxHORIZONTAL ) - xNew = (widthParent - width)/2; - - if ( direction & wxVERTICAL ) - yNew = (heightParent - height)/2; - - xNew += posParent.x; - yNew += posParent.y; - - // FIXME: This needs to get the client display rect of the display - // the window is (via wxDisplay::GetFromWindow). - - // Base size of the visible dimensions of the display - // to take into account the taskbar. And the Mac menu bar at top. - wxRect clientrect = wxGetClientDisplayRect(); - - // NB: in wxMSW, negative position may not necessarily 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 < clientrect.GetLeft()) - xNew = clientrect.GetLeft(); - else if (xNew + width > clientrect.GetRight()) - xNew = clientrect.GetRight() - width; - } - if (posParent.y + heightParent >= 0) // if parent is (partially) on the main display - { - if (yNew + height > clientrect.GetBottom()) - yNew = clientrect.GetBottom() - height; + wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(), + _T("this method only implements centering child windows") ); - // Make certain that the title bar is initially visible - // always, even if this would push the bottom of the - // dialog off the visible area of the display - if (yNew < clientrect.GetTop()) - yNew = clientrect.GetTop(); - } - - // move the window to this position (keeping the old size but using - // SetSize() and not Move() to allow xNew and/or yNew to be wxDefaultCoord) - SetSize(xNew, yNew, width, height, wxSIZE_ALLOW_MINUS_ONE); + SetSize(GetRect().CentreIn(GetParent()->GetClientSize(), dir)); } // fits the window around the children @@ -543,7 +448,7 @@ void wxWindowBase::Fit() { if ( !GetChildren().empty() ) { - SetClientSize(GetBestSize()); + SetSize(GetBestSize()); } //else: do nothing if we have no children } @@ -580,8 +485,10 @@ void wxWindowBase::InvalidateBestSize() m_bestSizeCache = wxDefaultSize; // parent's best size calculation may depend on its children's - // best sizes, so let's invalidate it as well to be safe: - if (m_parent) + // 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(); } @@ -592,7 +499,7 @@ wxSize wxWindowBase::DoGetBestSize() const if ( m_windowSizer ) { - best = GetWindowSizeForVirtualSize(m_windowSizer->GetMinSize()); + best = m_windowSizer->GetMinSize(); } #if wxUSE_CONSTRAINTS else if ( m_constraints ) @@ -637,7 +544,8 @@ wxSize wxWindowBase::DoGetBestSize() const #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; @@ -646,9 +554,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 ) { @@ -675,11 +584,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 @@ -711,8 +615,78 @@ 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) +{ + 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; +} + +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); + 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; + + 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; +} -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(); @@ -726,14 +700,14 @@ wxSize wxWindowBase::GetBestFittingSize() const } -void wxWindowBase::SetBestFittingSize(const wxSize& size) +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) @@ -747,21 +721,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 ) @@ -809,26 +782,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) ) { - m_minVirtualWidth = minW; - m_maxVirtualWidth = maxW; - m_minVirtualHeight = minH; - m_maxVirtualHeight = maxH; + 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::DoSetVirtualSize( int x, int y ) + +#if WXWIN_COMPATIBILITY_2_8 +void wxWindowBase::SetVirtualSizeHints(int WXUNUSED(minW), int WXUNUSED(minH), + int WXUNUSED(maxW), int WXUNUSED(maxH)) { - 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; +} + +void wxWindowBase::SetVirtualSizeHints(const wxSize& WXUNUSED(minsize), + const wxSize& WXUNUSED(maxsize)) +{ +} +#endif // WXWIN_COMPATIBILITY_2_8 +void wxWindowBase::DoSetVirtualSize( int x, int y ) +{ m_virtualSize = wxSize(x, y); } @@ -847,6 +829,35 @@ wxSize wxWindowBase::DoGetVirtualSize() const return size; } +void wxWindowBase::DoGetScreenPosition(int *x, int *y) const +{ + // screen position is the same as (0, 0) in client coords for non TLWs (and + // TLWs override this method) + if ( x ) + *x = 0; + if ( y ) + *y = 0; + + ClientToScreen(x, y); +} + +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 // ---------------------------------------------------------------------------- @@ -865,19 +876,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 // ---------------------------------------------------------------------------- @@ -887,6 +945,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 // ---------------------------------------------------------------------------- @@ -902,12 +1006,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); } @@ -921,6 +1038,8 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent) return false; } + const bool oldEnabledState = IsEnabled(); + // unlink this window from the existing parent. if ( oldParent ) { @@ -941,6 +1060,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; } @@ -1023,6 +1150,11 @@ bool wxWindowBase::RemoveEventHandler(wxEvtHandler *handler) return false; } +bool wxWindowBase::HandleWindowEvent(wxEvent& event) const +{ + return GetEventHandler()->SafelyProcessEvent(event); +} + // ---------------------------------------------------------------------------- // colours, fonts &c // ---------------------------------------------------------------------------- @@ -1083,7 +1215,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?") ); @@ -1109,11 +1241,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; @@ -1127,7 +1257,7 @@ bool wxWindowBase::SetBackgroundColour( const wxColour &colour ) if ( colour == m_backgroundColour ) return false; - m_hasBgCol = colour.Ok(); + m_hasBgCol = colour.IsOk(); if ( m_backgroundStyle != wxBG_STYLE_CUSTOM ) m_backgroundStyle = m_hasBgCol ? wxBG_STYLE_COLOUR : wxBG_STYLE_SYSTEM; @@ -1142,7 +1272,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() ); @@ -1153,7 +1283,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; @@ -1167,12 +1297,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; @@ -1190,7 +1320,7 @@ bool wxWindowBase::SetFont(const wxFont& font) } m_font = font; - m_hasFont = font.Ok(); + m_hasFont = font.IsOk(); m_inheritFont = m_hasFont; InvalidateBestSize(); @@ -1274,12 +1404,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; } @@ -1289,7 +1419,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__ @@ -1585,6 +1715,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) @@ -1595,9 +1726,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(); @@ -1615,7 +1750,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; @@ -1628,7 +1785,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event) #endif // wxUSE_HELP // ---------------------------------------------------------------------------- -// tooltipsroot.Replace("\\", "/"); +// tooltips // ---------------------------------------------------------------------------- #if wxUSE_TOOLTIPS @@ -1651,10 +1808,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 @@ -1778,12 +1938,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) @@ -1837,7 +2006,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 ); } @@ -2100,7 +2269,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) @@ -2126,62 +2295,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()); - } - } -#endif // wxUSE_CONTROLS - - if ( event.GetSetChecked() ) - { -#if wxUSE_CHECKBOX - wxCheckBox *checkbox = wxDynamicCastThis(wxCheckBox); - if ( checkbox ) - { - checkbox->SetValue(event.GetChecked()); - } -#endif // wxUSE_CHECKBOX - -#if wxUSE_RADIOBTN - wxRadioButton *radiobtn = wxDynamicCastThis(wxRadioButton); - if ( radiobtn ) - { - radiobtn->SetValue(event.GetChecked()); - } -#endif // wxUSE_RADIOBTN - } -} - -#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 @@ -2249,6 +2370,58 @@ 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(); +} + +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__ @@ -2258,7 +2431,7 @@ 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.SetBrush(fill ? wxBrush(*wxRED, wxBRUSHSTYLE_CROSSDIAG_HATCH) : *wxTRANSPARENT_BRUSH); dc.DrawRectangle(rect.Deflate(1, 1)); } @@ -2323,76 +2496,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(); } @@ -2437,14 +2543,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 @@ -2457,6 +2563,10 @@ wxBorder wxWindowBase::GetBorder(long flags) const { border = GetDefaultBorder(); } + else if ( border == wxBORDER_THEME ) + { + border = GetDefaultBorderForControl(); + } return border; } @@ -2495,10 +2605,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 ) @@ -2514,19 +2630,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)"), wx_static_cast(void*, this)); + + 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" ); - 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; @@ -2534,9 +2662,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 @@ -2558,14 +2730,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 // ---------------------------------------------------------------------------- @@ -2613,24 +2777,68 @@ bool wxWindowBase::TryParent(wxEvent& event) return wxEvtHandler::TryParent(event); } +// ---------------------------------------------------------------------------- +// window relationships +// ---------------------------------------------------------------------------- + +wxWindow *wxWindowBase::DoGetSibling(WindowOrder order) const +{ + wxCHECK_MSG( GetParent(), NULL, + _T("GetPrev/NextSibling() don't work for TLWs!") ); + + wxWindowList& siblings = GetParent()->GetChildren(); + wxWindowList::compatibility_iterator i = siblings.Find((wxWindow *)this); + wxCHECK_MSG( i, NULL, _T("window not a child of its parent?") ); + + if ( order == OrderBefore ) + i = i->GetPrevious(); + else // OrderAfter + i = i->GetNext(); + + return i ? i->GetData() : NULL; +} + // ---------------------------------------------------------------------------- // keyboard navigation // ---------------------------------------------------------------------------- -// Navigates in the specified direction. -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 +} + +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, MoveKind move) +void wxWindowBase::DoMoveInTabOrder(wxWindow *win, WindowOrder move) { // check that we're not a top level window wxCHECK_RET( GetParent(), @@ -2650,7 +2858,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(); } @@ -2659,7 +2867,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); } @@ -2675,6 +2883,13 @@ 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(); +} + // ---------------------------------------------------------------------------- // global functions // ---------------------------------------------------------------------------- @@ -2957,7 +3172,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; @@ -2973,7 +3188,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; @@ -3091,6 +3306,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: @@ -3107,5 +3323,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; +} + +