Correct signature of HitTest()

[wxWidgets.git] / src / common / wincmn.cpp

diff --git a/src/common/wincmn.cpp b/src/common/wincmn.cpp
index 1f67899546ffc2df4768835eba2ee53d97db375e..a48533d9689d1448a0e2811879f689ea18e4902a 100644 (file)
--- a/src/common/wincmn.cpp
+++ b/src/common/wincmn.cpp
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        common/window.cpp
+// Name:        src/common/window.cpp

 // Purpose:     common (to all ports) wxWindow functions
 // Author:      Julian Smart, Vadim Zeitlin
 // Modified by:
 // Purpose:     common (to all ports) wxWindow functions
 // Author:      Julian Smart, Vadim Zeitlin
 // Modified by:


@@ -17,10 +17,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "windowbase.h"
-#endif
-

 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 
 // For compilers that support precompilation, includes "wx.h".
 #include "wx/wxprec.h"
 


@@ -33,7 +29,6 @@
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"
     #include "wx/log.h"
     #include "wx/intl.h"
     #include "wx/frame.h"

-    #include "wx/defs.h"

     #include "wx/window.h"
     #include "wx/control.h"
     #include "wx/checkbox.h"
     #include "wx/window.h"
     #include "wx/control.h"
     #include "wx/checkbox.h"


@@ -44,18 +39,12 @@
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/statusbr.h"
     #include "wx/dialog.h"
     #include "wx/msgdlg.h"
     #include "wx/statusbr.h"

+    #include "wx/toolbar.h"

     #include "wx/dcclient.h"
     #include "wx/dcclient.h"

-#endif //WX_PRECOMP
-
-#if defined(__WXMAC__) && wxUSE_SCROLLBAR

     #include "wx/scrolbar.h"
     #include "wx/scrolbar.h"

-#endif
-
-#if wxUSE_CONSTRAINTS

     #include "wx/layout.h"
     #include "wx/layout.h"

-#endif // wxUSE_CONSTRAINTS
-
-#include "wx/sizer.h"
+    #include "wx/sizer.h"
+#endif //WX_PRECOMP

 
 #if wxUSE_DRAG_AND_DROP
     #include "wx/dnd.h"
 
 #if wxUSE_DRAG_AND_DROP
     #include "wx/dnd.h"


@@ -81,6 +70,24 @@
     #include "wx/sysopt.h"
 #endif
 
     #include "wx/sysopt.h"
 #endif
 

+// For reporting compile- and runtime version of GTK+ in the ctrl+alt+mclick dialog.
+// The gtk includes don't pull any other headers in, at least not on my system - MR
+#ifdef __WXGTK__
+    #ifdef __WXGTK20__
+        #include <gtk/gtkversion.h>
+    #else
+        #include <gtk/gtkfeatures.h>
+    #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;
+

 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // static data
 // ----------------------------------------------------------------------------


@@ -193,6 +200,8 @@ wxWindowBase::wxWindowBase()
 
     m_virtualSize = wxDefaultSize;
 
 
     m_virtualSize = wxDefaultSize;
 

+    m_scrollHelper = (wxScrollHelper *) NULL;
+

     m_minVirtualWidth =
     m_maxVirtualWidth = wxDefaultCoord;
     m_minVirtualHeight =
     m_minVirtualWidth =
     m_maxVirtualWidth = wxDefaultCoord;
     m_minVirtualHeight =


@@ -242,8 +251,12 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     // generate a new id if the user doesn't care about it
     m_windowId = id == wxID_ANY ? NewControlId() : id;
 
     // generate a new id if the user doesn't care about it
     m_windowId = id == wxID_ANY ? NewControlId() : id;
 

+    // don't use SetWindowStyleFlag() here, this function should only be called
+    // to change the flag after creation as it tries to reflect the changes in
+    // flags by updating the window dynamically and we don't need this here
+    m_windowStyle = style;
+

     SetName(name);
     SetName(name);

-    SetWindowStyleFlag(style);

     SetParent(parent);
 
 #if wxUSE_VALIDATORS
     SetParent(parent);
 
 #if wxUSE_VALIDATORS


@@ -261,6 +274,28 @@ bool wxWindowBase::CreateBase(wxWindowBase *parent,
     return true;
 }
 
     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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // destruction
 // ----------------------------------------------------------------------------


@@ -283,16 +318,9 @@ wxWindowBase::~wxWindowBase()
 
     wxASSERT_MSG( GetChildren().GetCount() == 0, wxT("children not destroyed") );
 
 
     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 )

-    {
-        if ( m_parent->GetDefaultItem() == this )
-        {
-            m_parent->SetDefaultItem(NULL);
-        }
-

         m_parent->RemoveChild(this);
         m_parent->RemoveChild(this);

-    }

 
 #if wxUSE_CARET
     delete m_caret;
 
 #if wxUSE_CARET
     delete m_caret;


@@ -335,6 +363,14 @@ wxWindowBase::~wxWindowBase()
 #endif
 }
 
 #endif
 }
 

+void wxWindowBase::SendDestroyEvent()
+{
+    wxWindowDestroyEvent event;
+    event.SetEventObject(this);
+    event.SetId(GetId());
+    GetEventHandler()->ProcessEvent(event);
+}
+

 bool wxWindowBase::Destroy()
 {
     delete this;
 bool wxWindowBase::Destroy()
 {
     delete this;


@@ -383,132 +419,20 @@ bool wxWindowBase::DestroyChildren()
 // ----------------------------------------------------------------------------
 
 // centre the window with respect to its parent in either (or both) directions
 // ----------------------------------------------------------------------------
 
 // 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 )
-    {
-        // 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;
-
-    // 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();
+    wxCHECK_RET( !(dir & wxCENTRE_ON_SCREEN) && GetParent(),
+                 _T("this method only implements centering child windows") );

 
 

-    // NB: in wxMSW, negative position may not neccessary mean "out of screen",
-    //     but it may mean that the window is placed on other than the main
-    //     display. Therefore we only make sure centered window is on the main display
-    //     if the parent is at least partially present here.
-    if (posParent.x + widthParent >= 0)  // if parent is (partially) on the main display
-    {
-        if (xNew < 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;
-
-        // 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
 void wxWindowBase::Fit()
 {
 }
 
 // fits the window around the children
 void wxWindowBase::Fit()
 {

-    if ( GetChildren().GetCount() > 0 )
+    if ( !GetChildren().empty() )

     {
     {

-        SetClientSize(GetBestSize());
+        SetSize(GetBestSize());

     }
     //else: do nothing if we have no children
 }
     }
     //else: do nothing if we have no children
 }


@@ -545,17 +469,21 @@ void wxWindowBase::InvalidateBestSize()
     m_bestSizeCache = wxDefaultSize;
 
     // parent's best size calculation may depend on its children's
     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();
 }
 
 // return the size best suited for the current window
 wxSize wxWindowBase::DoGetBestSize() const
 {
         m_parent->InvalidateBestSize();
 }
 
 // return the size best suited for the current window
 wxSize wxWindowBase::DoGetBestSize() const
 {

+    wxSize best;
+

     if ( m_windowSizer )
     {
     if ( m_windowSizer )
     {

-        return m_windowSizer->GetMinSize();
+        best = m_windowSizer->GetMinSize();

     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )
     }
 #if wxUSE_CONSTRAINTS
     else if ( m_constraints )


@@ -591,7 +519,7 @@ wxSize wxWindowBase::DoGetBestSize() const
             //       will never return a size bigger than the current one :-(
         }
 
             //       will never return a size bigger than the current one :-(
         }
 

-        return wxSize(maxX, maxY);
+        best = wxSize(maxX, maxY);

     }
 #endif // wxUSE_CONSTRAINTS
     else if ( !GetChildren().empty()
     }
 #endif // wxUSE_CONSTRAINTS
     else if ( !GetChildren().empty()


@@ -600,7 +528,8 @@ wxSize wxWindowBase::DoGetBestSize() const
 #endif
               )
     {
 #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;
 
         int maxX = 0,
             maxY = 0;
 


@@ -609,9 +538,10 @@ wxSize wxWindowBase::DoGetBestSize() const
               node = node->GetNext() )
         {
             wxWindow *win = node->GetData();
               node = node->GetNext() )
         {
             wxWindow *win = node->GetData();

-            if ( win->IsTopLevel()  || ( ! win->IsShown() )
+            if ( win->IsTopLevel()
+                    || !win->IsShown()

 #if wxUSE_STATUSBAR
 #if wxUSE_STATUSBAR

-                    || wxDynamicCast(win, wxStatusBar)
+                        || wxDynamicCast(win, wxStatusBar)

 #endif // wxUSE_STATUSBAR
                )
             {
 #endif // wxUSE_STATUSBAR
                )
             {


@@ -638,26 +568,109 @@ wxSize wxWindowBase::DoGetBestSize() const
                 maxY = wy + wh;
         }
 
                 maxY = wy + wh;
         }
 

-        // for compatibility with the old versions and because it really looks
-        // slightly more pretty like this, add a pad
-        maxX += 7;
-        maxY += 14;
-
-        return wxSize(maxX, maxY);
+        best = wxSize(maxX, maxY);

     }
     else // ! has children
     {
     }
     else // ! has children
     {

-        // for a generic window there is no natural best size - just use either the
-        // minimum size if there is one, or the current size
-        if ( GetMinSize().IsFullySpecified() )
-            return GetMinSize();
-        else
-            return GetSize();
+        // for a generic window there is no natural best size so, if the
+        // minimal size is not set, use the current size but take care to
+        // remember it as minimal size for the next time because our best size
+        // should be constant: otherwise we could get into a situation when the
+        // window is initially at some size, then expanded to a larger size and
+        // then, when the containing window is shrunk back (because our initial
+        // best size had been used for computing the parent min size), we can't
+        // be shrunk back any more because our best size is now bigger
+        wxSize size = GetMinSize();
+        if ( !size.IsFullySpecified() )
+        {
+            size.SetDefaults(GetSize());
+            wxConstCast(this, wxWindowBase)->SetMinSize(size);
+        }
+
+        // return as-is, unadjusted by the client size difference.
+        return size;

     }
     }

+
+    // Add any difference between size and client size
+    wxSize diff = GetSize() - GetClientSize();
+    best.x += wxMax(0, diff.x);
+    best.y += wxMax(0, diff.y);
+
+    return best;

 }
 
 }
 

+// helper of GetWindowBorderSize(): as many ports don't implement support for
+// wxSYS_BORDER/EDGE_X/Y metrics in their wxSystemSettings, use hard coded
+// fallbacks in this case
+static int wxGetMetricOrDefault(wxSystemMetric what)
+{
+    int rc = wxSystemSettings::GetMetric(what);
+    if ( rc == -1 )
+    {
+        switch ( what )
+        {
+            case wxSYS_BORDER_X:
+            case wxSYS_BORDER_Y:
+                // 2D border is by default 1 pixel wide
+                rc = 1;
+                break;
+
+            case wxSYS_EDGE_X:
+            case wxSYS_EDGE_Y:
+                // 3D borders are by default 2 pixels
+                rc = 2;
+                break;
+
+            default:
+                wxFAIL_MSG( _T("unexpected wxGetMetricOrDefault() argument") );
+                rc = 0;
+        }
+    }
+
+    return rc;
+}
+
+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();
 {
     // merge the best size with the min size, giving priority to the min size
     wxSize min = GetMinSize();


@@ -671,14 +684,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
 {
     // 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)
 
     // If the current size doesn't match then change it
     if (GetSize() != best)


@@ -689,24 +702,7 @@ void wxWindowBase::SetBestFittingSize(const wxSize& size)
 // by default the origin is not shifted
 wxPoint wxWindowBase::GetClientAreaOrigin() const
 {
 // by default the origin is not shifted
 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))
-{
-    // 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!") );
-
-    m_minWidth = minW;
-    m_maxWidth = maxW;
-    m_minHeight = minH;
-    m_maxHeight = maxH;
+    return wxPoint(0,0);

 }
 
 void wxWindowBase::SetWindowVariant( wxWindowVariant variant )
 }
 
 void wxWindowBase::SetWindowVariant( wxWindowVariant variant )


@@ -754,6 +750,21 @@ void wxWindowBase::DoSetWindowVariant( wxWindowVariant variant )
     SetFont(font);
 }
 
     SetFont(font);
 }
 

+void wxWindowBase::DoSetSizeHints( int minW, int minH,
+                                   int maxW, int maxH,
+                                   int WXUNUSED(incW), int WXUNUSED(incH) )
+{
+    wxCHECK_RET( (minW == wxDefaultCoord || maxW == wxDefaultCoord || minW <= maxW) &&
+                    (minH == wxDefaultCoord || maxH == wxDefaultCoord || minH <= maxH),
+                 _T("min width/height must be less than max width/height!") );
+
+    m_minWidth = minW;
+    m_maxWidth = maxW;
+    m_minHeight = minH;
+    m_maxHeight = maxH;
+}
+
+

 void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
                                         int maxW, int maxH )
 {
 void wxWindowBase::SetVirtualSizeHints( int minW, int minH,
                                         int maxW, int maxH )
 {


@@ -779,10 +790,29 @@ void wxWindowBase::DoSetVirtualSize( int x, int y )
 
 wxSize wxWindowBase::DoGetVirtualSize() const
 {
 
 wxSize wxWindowBase::DoGetVirtualSize() const
 {

-    wxSize  s( GetClientSize() );
+    // we should use the entire client area so if it is greater than our
+    // virtual size, expand it to fit (otherwise if the window is big enough we
+    // wouldn't be using parts of it)
+    wxSize size = GetClientSize();
+    if ( m_virtualSize.x > size.x )
+        size.x = m_virtualSize.x;
+
+    if ( m_virtualSize.y >= size.y )
+        size.y = m_virtualSize.y;
+
+    return size;
+}
+
+void wxWindowBase::DoGetScreenPosition(int *x, int *y) const
+{
+    // screen position is the same as (0, 0) in client coords for non TLWs (and
+    // TLWs override this method)
+    if ( x )
+        *x = 0;
+    if ( y )
+        *y = 0;

 
 

-    return wxSize( wxMax( m_virtualSize.GetWidth(), s.GetWidth() ),
-                   wxMax( m_virtualSize.GetHeight(), s.GetHeight() ) );
+    ClientToScreen(x, y);

 }
 
 // ----------------------------------------------------------------------------
 }
 
 // ----------------------------------------------------------------------------


@@ -803,19 +833,63 @@ bool wxWindowBase::Show(bool show)
     }
 }
 
     }
 }
 

-bool wxWindowBase::Enable(bool enable)
+bool wxWindowBase::IsEnabled() const

 {
 {

-    if ( enable != m_isEnabled )
-    {
-        m_isEnabled = enable;
+    return IsThisEnabled() && (IsTopLevel() || !GetParent() || GetParent()->IsEnabled());
+}

 
 

-        return true;
-    }
-    else
+void wxWindowBase::NotifyWindowOnEnableChange(bool enabled)
+{
+#ifndef wxHAS_NATIVE_ENABLED_MANAGEMENT
+    DoEnable(enabled);
+#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+
+    OnEnabled(enabled);
+
+    // If we are top-level then the logic doesn't apply - otherwise
+    // showing a modal dialog would result in total greying out (and ungreying
+    // out later) of everything which would be really ugly
+    if ( IsTopLevel() )
+        return;
+
+    for ( wxWindowList::compatibility_iterator node = GetChildren().GetFirst();
+          node;
+          node = node->GetNext() )

     {
     {

+        wxWindowBase * const child = node->GetData();
+        if ( !child->IsTopLevel() && child->IsThisEnabled() )
+            child->NotifyWindowOnEnableChange(enabled);
+    }
+}
+
+bool wxWindowBase::Enable(bool enable)
+{
+    if ( enable == IsThisEnabled() )

         return false;
         return false;

+
+    m_isEnabled = enable;
+
+#ifdef wxHAS_NATIVE_ENABLED_MANAGEMENT
+    DoEnable(enable);
+#else // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+    wxWindowBase * const parent = GetParent();
+    if( !IsTopLevel() && parent && !parent->IsEnabled() )
+    {
+        return true;

     }
     }

+#endif // !defined(wxHAS_NATIVE_ENABLED_MANAGEMENT)
+
+    NotifyWindowOnEnableChange(enable);
+
+    return true;

 }
 }

+
+bool wxWindowBase::IsShownOnScreen() const
+{
+    return IsShown() &&
+           (GetParent() == NULL || GetParent()->IsShownOnScreen());
+}
+

 // ----------------------------------------------------------------------------
 // RTTI
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // RTTI
 // ----------------------------------------------------------------------------


@@ -859,6 +933,8 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent)
         return false;
     }
 
         return false;
     }
 

+    const bool oldEnabledState = IsEnabled();
+

     // unlink this window from the existing parent.
     if ( oldParent )
     {
     // unlink this window from the existing parent.
     if ( oldParent )
     {


@@ -879,6 +955,14 @@ bool wxWindowBase::Reparent(wxWindowBase *newParent)
         wxTopLevelWindows.Append((wxWindow *)this);
     }
 
         wxTopLevelWindows.Append((wxWindow *)this);
     }
 

+    // We need to notify window (and its subwindows) if by changing the parent
+    // we also change our enabled/disabled status.
+    const bool newEnabledState = IsEnabled();
+    if ( newEnabledState != oldEnabledState )
+    {
+        NotifyWindowOnEnableChange(newEnabledState);
+    }
+

     return true;
 }
 
     return true;
 }
 


@@ -1005,8 +1089,17 @@ wxWindowBase::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
     wxVisualAttributes attrs;
     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
     wxVisualAttributes attrs;
     attrs.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
     attrs.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);

-    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);

 
 

+    // On Smartphone/PocketPC, wxSYS_COLOUR_WINDOW is a better reflection of
+    // the usual background colour than wxSYS_COLOUR_BTNFACE.
+    // It's a pity that wxSYS_COLOUR_WINDOW isn't always a suitable background
+    // colour on other platforms.
+
+#if defined(__WXWINCE__) && (defined(__SMARTPHONE__) || defined(__POCKETPC__))
+    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOW);
+#else
+    attrs.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
+#endif

     return attrs;
 }
 
     return attrs;
 }
 


@@ -1082,7 +1175,7 @@ bool wxWindowBase::SetCursor(const wxCursor& cursor)
 {
     // setting an invalid cursor is ok, it means that we don't have any special
     // 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;
     {
         // no change
         return false;


@@ -1203,12 +1296,12 @@ wxRect wxWindowBase::GetUpdateClientRect() const
     return rectUpdate;
 }
 
     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;
 }
 
 {
     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;
 }
 {
     return m_updateRegion.Contains(x, y, w, h) != wxOutRegion;
 }


@@ -1526,7 +1619,10 @@ void wxWindowBase::SetHelpTextForId(const wxString& text)
 }
 
 // get the help string associated with this window (may be empty)
 }
 
 // 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();
 {
     wxString text;
     wxHelpProvider *helpProvider = wxHelpProvider::Get();


@@ -1544,7 +1640,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event)
     wxHelpProvider *helpProvider = wxHelpProvider::Get();
     if ( helpProvider )
     {
     wxHelpProvider *helpProvider = wxHelpProvider::Get();
     if ( helpProvider )
     {

-        if ( helpProvider->ShowHelp(this) )
+        if ( helpProvider->ShowHelpAtPoint(this, event.GetPosition(), event.GetOrigin()) )

         {
             // skip the event.Skip() below
             return;
         {
             // skip the event.Skip() below
             return;


@@ -1557,7 +1653,7 @@ void wxWindowBase::OnHelp(wxHelpEvent& event)
 #endif // wxUSE_HELP
 
 // ----------------------------------------------------------------------------
 #endif // wxUSE_HELP
 
 // ----------------------------------------------------------------------------

-// tooltipsroot.Replace("\\", "/");
+// tooltips

 // ----------------------------------------------------------------------------
 
 #if wxUSE_TOOLTIPS
 // ----------------------------------------------------------------------------
 
 #if wxUSE_TOOLTIPS


@@ -1580,10 +1676,13 @@ void wxWindowBase::SetToolTip( const wxString &tip )
 
 void wxWindowBase::DoSetToolTip(wxToolTip *tooltip)
 {
 
 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
 }
 
 #endif // wxUSE_TOOLTIPS


@@ -1707,12 +1806,21 @@ void wxWindowBase::SetSizer(wxSizer *sizer, bool deleteOld)
     if ( sizer == m_windowSizer)
         return;
 
     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;
 
     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)
 }
 
 void wxWindowBase::SetSizerAndFit(wxSizer *sizer, bool deleteOld)


@@ -1766,7 +1874,7 @@ bool wxWindowBase::Layout()
     // If there is a sizer, use it instead of the constraints
     if ( GetSizer() )
     {
     // 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 );
     }
         GetVirtualSize(&w, &h);
         GetSizer()->SetDimension( 0, 0, w, h );
     }


@@ -2029,7 +2137,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)
 // ----------------------------------------------------------------------------
 
 void wxWindowBase::UpdateWindowUI(long flags)


@@ -2055,63 +2163,15 @@ void wxWindowBase::UpdateWindowUI(long flags)
 }
 
 // do the window-specific processing after processing the update event
 }
 
 // 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());
 
 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 ( event.GetSetShown() )
+        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
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // dialog units translations
 // ----------------------------------------------------------------------------


@@ -2178,71 +2238,119 @@ void wxWindowBase::OnInitDialog( wxInitDialogEvent &WXUNUSED(event) )
     UpdateWindowUI(wxUPDATE_UI_RECURSE);
 }
 
     UpdateWindowUI(wxUPDATE_UI_RECURSE);
 }
 

-// process Ctrl-Alt-mclick
-void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
+// 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)

 {
 {

-#if wxUSE_MSGDLG
-    if ( event.ControlDown() && event.AltDown() )
+    wxClientDC dc((wxWindow *)win);
+    dc.SetPen(*wxRED_PEN);
+    dc.SetBrush(fill ? wxBrush(*wxRED, wxCROSSDIAG_HATCH): *wxTRANSPARENT_BRUSH);
+    dc.DrawRectangle(rect.Deflate(1, 1));
+}
+
+static void DrawSizer(wxWindowBase *win, wxSizer *sizer)
+{
+    const wxSizerItemList& items = sizer->GetChildren();
+    for ( wxSizerItemList::const_iterator i = items.begin(),
+                                        end = items.end();
+          i != end;
+          ++i )
+    {
+        wxSizerItem *item = *i;
+        if ( item->IsSizer() )
+        {
+            DrawBorder(win, item->GetRect().Deflate(2));
+            DrawSizer(win, item->GetSizer());
+        }
+        else if ( item->IsSpacer() )
+        {
+            DrawBorder(win, item->GetRect().Deflate(2), true);
+        }
+        else if ( item->IsWindow() )
+        {
+            DrawSizers(item->GetWindow());
+        }
+    }
+}
+
+static void DrawSizers(wxWindowBase *win)
+{
+    wxSizer *sizer = win->GetSizer();
+    if ( sizer )
+    {
+        DrawBorder(win, win->GetClientSize());
+        DrawSizer(win, sizer);
+    }
+    else // no sizer, still recurse into the children

     {
     {

-        // don't translate these strings
-        wxString port;
+        const wxWindowList& children = win->GetChildren();
+        for ( wxWindowList::const_iterator i = children.begin(),
+                                         end = children.end();
+              i != end;
+              ++i )
+        {
+            DrawSizers(*i);
+        }
+    }
+}

 
 

-#ifdef __WXUNIVERSAL__
-        port = _T("Univ/");
-#endif // __WXUNIVERSAL__
+#endif // __WXDEBUG__

 
 

-        switch ( wxGetOsVersion() )
+// process special middle clicks
+void wxWindowBase::OnMiddleClick( wxMouseEvent& event )
+{
+    if ( event.ControlDown() && event.AltDown() )
+    {
+#ifdef __WXDEBUG__
+        // Ctrl-Alt-Shift-mclick makes the sizers visible in debug builds
+        if ( event.ShiftDown() )

         {
         {

-            case wxMOTIF_X:     port += _T("Motif"); break;
-            case wxMAC:
-            case wxMAC_DARWIN:  port += _T("Mac"); break;
-            case wxBEOS:        port += _T("BeOS"); break;
-            case wxGTK:
-            case wxGTK_WIN32:
-            case wxGTK_OS2:
-            case wxGTK_BEOS:    port += _T("GTK"); break;
-            case wxWINDOWS:
-            case wxPENWINDOWS:
-            case wxWINDOWS_NT:
-            case wxWIN32S:
-            case wxWIN95:
-            case wxWIN386:      port += _T("MS Windows"); break;
-            case wxMGL_UNIX:
-            case wxMGL_X:
-            case wxMGL_WIN32:
-            case wxMGL_OS2:     port += _T("MGL"); break;
-            case wxWINDOWS_OS2:
-            case wxOS2_PM:      port += _T("OS/2"); break;
-            default:            port += _T("unknown"); break;
+            DrawSizers(this);
+            return;

         }
         }

+#endif // __WXDEBUG__

 
 

-        wxMessageBox(wxString::Format(
-                                      _T(
-                                        "       wxWidgets Library (%s port)\nVersion %u.%u.%u%s%s, compiled at %s %s\n   Copyright (c) 1995-2004 wxWidgets team"
-                                        ),
-                                      port.c_str(),
-                                      wxMAJOR_VERSION,
-                                      wxMINOR_VERSION,
-                                      wxRELEASE_NUMBER,
+#if wxUSE_MSGDLG
+        // don't translate these strings, they're for diagnostics purposes only
+        wxString msg;
+        msg.Printf(_T("wxWidgets Library (%s port)\n")
+                   _T("Version %d.%d.%d%s%s, compiled at %s %s\n")
+                   _T("Runtime version of toolkit used is %d.%d.%s\n")
+                   _T("Copyright (c) 1995-2007 wxWidgets team"),
+                   wxPlatformInfo::Get().GetPortIdName().c_str(),
+                   wxMAJOR_VERSION,
+                   wxMINOR_VERSION,
+                   wxRELEASE_NUMBER,

 #if wxUSE_UNICODE
 #if wxUSE_UNICODE

-                                      L" (Unicode)",
+                   L" (Unicode)",

 #else
 #else

-                                      "",
+                   wxEmptyString,

 #endif
 #ifdef __WXDEBUG__
 #endif
 #ifdef __WXDEBUG__

-                                      _T(" Debug build"),
+                   _T(" Debug build"),

 #else
 #else

-                                      wxEmptyString,
+                   wxEmptyString,

 #endif
 #endif

-                                      __TDATE__,
-                                      __TTIME__
-                                     ),
-                     _T("wxWidgets information"),
+                   __TDATE__,
+                   __TTIME__,
+                   wxPlatformInfo::Get().GetToolkitMajorVersion(),
+                   wxPlatformInfo::Get().GetToolkitMinorVersion(),
+#ifdef __WXGTK__
+                   wxString::Format(_T("\nThe compile-time GTK+ version is %d.%d.%d."), GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION).c_str()
+#else
+                   wxEmptyString
+#endif
+                   );
+
+        wxMessageBox(msg, _T("wxWidgets information"),

                      wxICON_INFORMATION | wxOK,
                      (wxWindow *)this);
                      wxICON_INFORMATION | wxOK,
                      (wxWindow *)this);

+#endif // wxUSE_MSGDLG

     }
     else
     }
     else

-#endif // wxUSE_MSGDLG

     {
         event.Skip();
     }
     {
         event.Skip();
     }


@@ -2278,16 +2386,23 @@ wxAccessible* wxWindowBase::CreateAccessible()
 
 #endif
 
 
 #endif
 

-#if !wxUSE_STL

 // ----------------------------------------------------------------------------
 // list classes implementation
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // list classes implementation
 // ----------------------------------------------------------------------------
 

+#if wxUSE_STL
+
+#include "wx/listimpl.cpp"
+WX_DEFINE_LIST(wxWindowList)
+
+#else // !wxUSE_STL
+

 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }
 void wxWindowListNode::DeleteData()
 {
     delete (wxWindow *)GetData();
 }

-#endif
+
+#endif // wxUSE_STL/!wxUSE_STL

 
 // ----------------------------------------------------------------------------
 // borders
 
 // ----------------------------------------------------------------------------
 // borders


@@ -2338,10 +2453,16 @@ struct WXDLLEXPORT wxWindowNext
     wxWindow *win;
     wxWindowNext *next;
 } *wxWindowBase::ms_winCaptureNext = NULL;
     wxWindow *win;
     wxWindowNext *next;
 } *wxWindowBase::ms_winCaptureNext = NULL;

+wxWindow *wxWindowBase::ms_winCaptureCurrent = NULL;
+bool wxWindowBase::ms_winCaptureChanging = false;

 
 void wxWindowBase::CaptureMouse()
 {
 
 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 )
 
     wxWindow *winOld = GetCapture();
     if ( winOld )


@@ -2357,19 +2478,28 @@ void wxWindowBase::CaptureMouse()
     //else: no mouse capture to save
 
     DoCaptureMouse();
     //else: no mouse capture to save
 
     DoCaptureMouse();

+    ms_winCaptureCurrent = (wxWindow*)this;
+
+    ms_winCaptureChanging = false;

 }
 
 void wxWindowBase::ReleaseMouse()
 {
 }
 
 void wxWindowBase::ReleaseMouse()
 {

-    wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), this);
+    wxLogTrace(_T("mousecapture"), _T("ReleaseMouse(%p)"), wx_static_cast(void*, this));
+
+    wxASSERT_MSG( !ms_winCaptureChanging, _T("recursive ReleaseMouse call?") );

 
     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
 
 
     wxASSERT_MSG( GetCapture() == this, wxT("attempt to release mouse, but this window hasn't captured it") );
 

+    ms_winCaptureChanging = true;
+

     DoReleaseMouse();
     DoReleaseMouse();

+    ms_winCaptureCurrent = NULL;

 
     if ( ms_winCaptureNext )
     {
         ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();
 
     if ( ms_winCaptureNext )
     {
         ((wxWindowBase*)ms_winCaptureNext->win)->DoCaptureMouse();

+        ms_winCaptureCurrent = ms_winCaptureNext->win;

 
         wxWindowNext *item = ms_winCaptureNext;
         ms_winCaptureNext = item->next;
 
         wxWindowNext *item = ms_winCaptureNext;
         ms_winCaptureNext = item->next;


@@ -2377,9 +2507,53 @@ void wxWindowBase::ReleaseMouse()
     }
     //else: stack is empty, no previous capture
 
     }
     //else: stack is empty, no previous capture
 

+    ms_winCaptureChanging = false;
+

     wxLogTrace(_T("mousecapture"),
         (const wxChar *) _T("After ReleaseMouse() mouse is captured by %p"),
     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
 }
 
 #if wxUSE_HOTKEY


@@ -2401,14 +2575,6 @@ bool wxWindowBase::UnregisterHotKey(int WXUNUSED(hotkeyId))
 
 #endif // wxUSE_HOTKEY
 
 
 #endif // wxUSE_HOTKEY
 

-void wxWindowBase::SendDestroyEvent()
-{
-    wxWindowDestroyEvent event;
-    event.SetEventObject(this);
-    event.SetId(GetId());
-    GetEventHandler()->ProcessEvent(event);
-}
-

 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------
 // event processing
 // ----------------------------------------------------------------------------


@@ -2433,7 +2599,7 @@ bool wxWindowBase::TryValidator(wxEvent& wxVALIDATOR_PARAM(event))
 
 bool wxWindowBase::TryParent(wxEvent& event)
 {
 
 bool wxWindowBase::TryParent(wxEvent& event)
 {

-    // carry on up the parent-child hierarchy if the propgation count hasn't
+    // carry on up the parent-child hierarchy if the propagation count hasn't

     // reached zero yet
     if ( event.ShouldPropagate() )
     {
     // reached zero yet
     if ( event.ShouldPropagate() )
     {


@@ -2460,17 +2626,18 @@ bool wxWindowBase::TryParent(wxEvent& event)
 // keyboard navigation
 // ----------------------------------------------------------------------------
 
 // 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
+    return false;
+#else // !wxHAS_NATIVE_TAB_TRAVERSAL

     wxNavigationKeyEvent eventNav;
     eventNav.SetFlags(flags);
     wxNavigationKeyEvent eventNav;
     eventNav.SetFlags(flags);

-    eventNav.SetEventObject(this);
-    if ( GetParent()->GetEventHandler()->ProcessEvent(eventNav) )
-    {
-        return true;
-    }
-    return false;
+    eventNav.SetEventObject(FindFocus());
+    return GetEventHandler()->ProcessEvent(eventNav);
+#endif // wxHAS_NATIVE_TAB_TRAVERSAL/!wxHAS_NATIVE_TAB_TRAVERSAL

 }
 
 void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)
 }
 
 void wxWindowBase::DoMoveInTabOrder(wxWindow *win, MoveKind move)


@@ -2800,7 +2967,7 @@ wxAccStatus wxWindowAccessible::GetDescription(int WXUNUSED(childId), wxString*
     if (!GetWindow())
         return wxACC_FAIL;
 
     if (!GetWindow())
         return wxACC_FAIL;
 

-    wxString ht(GetWindow()->GetHelpText());
+    wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));

     if (!ht.empty())
     {
         *description = ht;
     if (!ht.empty())
     {
         *description = ht;


@@ -2816,7 +2983,7 @@ wxAccStatus wxWindowAccessible::GetHelpText(int WXUNUSED(childId), wxString* hel
     if (!GetWindow())
         return wxACC_FAIL;
 
     if (!GetWindow())
         return wxACC_FAIL;
 

-    wxString ht(GetWindow()->GetHelpText());
+    wxString ht(GetWindow()->GetHelpTextAtPoint(wxDefaultPosition, wxHelpEvent::Origin_Keyboard));

     if (!ht.empty())
     {
         *helpText = ht;
     if (!ht.empty())
     {
         *helpText = ht;


@@ -2934,6 +3101,7 @@ wxAccStatus wxWindowAccessible::GetFocus(int* WXUNUSED(childId), wxAccessible**
     return wxACC_NOT_IMPLEMENTED;
 }
 
     return wxACC_NOT_IMPLEMENTED;
 }
 

+#if wxUSE_VARIANT

 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:
 // Gets a variant representing the selected children
 // of this object.
 // Acceptable values:


@@ -2950,5 +3118,24 @@ wxAccStatus wxWindowAccessible::GetSelections(wxVariant* WXUNUSED(selections))
 
     return wxACC_NOT_IMPLEMENTED;
 }
 
     return wxACC_NOT_IMPLEMENTED;
 }

+#endif // wxUSE_VARIANT

 
 #endif // wxUSE_ACCESSIBILITY
 
 #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;
+}
+