Applied colspan corrections, #15274 and #15275 (dghart)

[wxWidgets.git] / src / generic / scrlwing.cpp

diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp
index 7b686a1cf3b316bfe893ed906bab29a034d50788..921c5961cae60beff416ab6d410b276c5a23c80c 100644 (file)
--- a/src/generic/scrlwing.cpp
+++ b/src/generic/scrlwing.cpp
@@ -25,20 +25,15 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-

 #include "wx/scrolwin.h"
 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/panel.h"
     #include "wx/dcclient.h"
 #include "wx/scrolwin.h"
 
 #ifndef WX_PRECOMP
     #include "wx/utils.h"
     #include "wx/panel.h"
     #include "wx/dcclient.h"

-    #if wxUSE_TIMER
-        #include "wx/timer.h"
-    #endif
+    #include "wx/timer.h"

     #include "wx/sizer.h"
     #include "wx/sizer.h"

+    #include "wx/settings.h"

 #endif
 
 #ifdef __WXMAC__
 #endif
 
 #ifdef __WXMAC__


@@ -77,21 +72,17 @@
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:

-    wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
+    wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper)

     {
         m_scrollHelper = scrollHelper;
     }
 
     virtual bool ProcessEvent(wxEvent& event);
 
     {
         m_scrollHelper = scrollHelper;
     }
 
     virtual bool ProcessEvent(wxEvent& event);
 

-    void ResetDrawnFlag() { m_hasDrawnWindow = false; }
-

 private:
 private:

-    wxScrollHelper *m_scrollHelper;
-
-    bool m_hasDrawnWindow;
+    wxScrollHelperBase *m_scrollHelper;

 
 

-    DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
+    wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler);

 };
 
 #if wxUSE_TIMER
 };
 
 #if wxUSE_TIMER


@@ -103,7 +94,8 @@ private:
 class wxAutoScrollTimer : public wxTimer
 {
 public:
 class wxAutoScrollTimer : public wxTimer
 {
 public:

-    wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll,
+    wxAutoScrollTimer(wxWindow *winToScroll,
+                      wxScrollHelperBase *scroll,

                       wxEventType eventTypeToSend,
                       int pos, int orient);
 
                       wxEventType eventTypeToSend,
                       int pos, int orient);
 


@@ -111,12 +103,12 @@ public:
 
 private:
     wxWindow *m_win;
 
 private:
     wxWindow *m_win;

-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;

     wxEventType m_eventType;
     int m_pos,
         m_orient;
 
     wxEventType m_eventType;
     int m_pos,
         m_orient;
 

-    DECLARE_NO_COPY_CLASS(wxAutoScrollTimer)
+    wxDECLARE_NO_COPY_CLASS(wxAutoScrollTimer);

 };
 
 // ============================================================================
 };
 
 // ============================================================================


@@ -128,7 +120,7 @@ private:
 // ----------------------------------------------------------------------------
 
 wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,
 // ----------------------------------------------------------------------------
 
 wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,

-                                     wxScrollHelper *scroll,
+                                     wxScrollHelperBase *scroll,

                                      wxEventType eventTypeToSend,
                                      int pos, int orient)
 {
                                      wxEventType eventTypeToSend,
                                      int pos, int orient)
 {


@@ -151,12 +143,13 @@ void wxAutoScrollTimer::Notify()
         // first scroll the window if we are allowed to do it
         wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
         event1.SetEventObject(m_win);
         // first scroll the window if we are allowed to do it
         wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
         event1.SetEventObject(m_win);

+        event1.SetId(m_win->GetId());

         if ( m_scrollHelper->SendAutoScrollEvents(event1) &&
                 m_win->GetEventHandler()->ProcessEvent(event1) )
         {
             // and then send a pseudo mouse-move event to refresh the selection
             wxMouseEvent event2(wxEVT_MOTION);
         if ( m_scrollHelper->SendAutoScrollEvents(event1) &&
                 m_win->GetEventHandler()->ProcessEvent(event1) )
         {
             // and then send a pseudo mouse-move event to refresh the selection
             wxMouseEvent event2(wxEVT_MOTION);

-            wxGetMousePosition(&event2.m_x, &event2.m_y);
+            event2.SetPosition(wxGetMousePosition());

 
             // the mouse event coordinates should be client, not screen as
             // returned by wxGetMousePosition
 
             // the mouse event coordinates should be client, not screen as
             // returned by wxGetMousePosition


@@ -169,7 +162,16 @@ void wxAutoScrollTimer::Notify()
 
             event2.SetEventObject(m_win);
 
 
             event2.SetEventObject(m_win);
 

-            // FIXME: we don't fill in the other members - ok?
+            wxMouseState mouseState = wxGetMouseState();
+
+            event2.m_leftDown = mouseState.LeftIsDown();
+            event2.m_middleDown = mouseState.MiddleIsDown();
+            event2.m_rightDown = mouseState.RightIsDown();
+
+            event2.m_shiftDown = mouseState.ShiftDown();
+            event2.m_controlDown = mouseState.ControlDown();
+            event2.m_altDown = mouseState.AltDown();
+            event2.m_metaDown = mouseState.MetaDown();

 
             m_win->GetEventHandler()->ProcessEvent(event2);
         }
 
             m_win->GetEventHandler()->ProcessEvent(event2);
         }


@@ -189,26 +191,13 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
 {
     wxEventType evType = event.GetEventType();
 
 {
     wxEventType evType = event.GetEventType();
 

-    // the explanation of wxEVT_PAINT processing hack: for historic reasons
-    // there are 2 ways to process this event in classes deriving from
-    // wxScrolledWindow. The user code may
-    //
-    //  1. override wxScrolledWindow::OnDraw(dc)
-    //  2. define its own OnPaint() handler
-    //
-    // In addition, in wxUniversal wxWindow defines OnPaint() itself and
-    // always processes the draw event, so we can't just try the window
-    // OnPaint() first and call our HandleOnPaint() if it doesn't process it
-    // (the latter would never be called in wxUniversal).
-    //
-    // So the solution is to have a flag telling us whether the user code drew
-    // anything in the window. We set it to true here but reset it to false in
-    // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the
-    // user code defined OnPaint() in the derived class)
-    m_hasDrawnWindow = true;
-
-    // pass it on to the real handler
-    bool processed = wxEvtHandler::ProcessEvent(event);
+    // Pass it on to the real handler: notice that we must not call
+    // ProcessEvent() on this object itself as it wouldn't pass it to the next
+    // handler (i.e. the real window) if we're called from a previous handler
+    // (as indicated by "process here only" flag being set) and we do want to
+    // execute the handler defined in the window we're associated with right
+    // now, without waiting until TryAfter() is called from wxEvtHandler.
+    bool processed = m_nextHandler->ProcessEvent(event);

 
     // always process the size events ourselves, even if the user code handles
     // them as well, as we need to AdjustScrollbars()
 
     // always process the size events ourselves, even if the user code handles
     // them as well, as we need to AdjustScrollbars()


@@ -220,22 +209,25 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     if ( evType == wxEVT_SIZE )
     {
         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
     if ( evType == wxEVT_SIZE )
     {
         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);

-

         return true;
     }
 
         return true;
     }
 

-    if ( processed )
-    {
-        // normally, nothing more to do here - except if it was a paint event
-        // which wasn't really processed, then we'll try to call our
-        // OnDraw() below (from HandleOnPaint)
-        if ( m_hasDrawnWindow || event.IsCommandEvent() )
-        {
-            return true;
-        }
-    }
+    if ( processed && event.IsCommandEvent())
+        return true;

 
 

-    if ( evType == wxEVT_PAINT )
+    // For wxEVT_PAINT the user code can either handle this event as usual or
+    // override virtual OnDraw(), so if the event hasn't been handled we need
+    // to call this virtual function ourselves.
+    if (
+#ifndef __WXUNIVERSAL__
+          // in wxUniversal "processed" will always be true, because
+          // all windows use the paint event to draw themselves.
+          // In this case we can't use this flag to determine if a custom
+          // paint event handler already drew our window and we just
+          // call OnDraw() anyway.
+          !processed &&
+#endif // !__WXUNIVERSAL__
+            evType == wxEVT_PAINT )

     {
         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
         return true;
     {
         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
         return true;


@@ -302,19 +294,33 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
         }
     }
 
         }
     }
 

-    if ( processed )
-        event.Skip(wasSkipped);
+    event.Skip(wasSkipped);
+
+    // We called ProcessEvent() on the next handler, meaning that we explicitly
+    // worked around the request to process the event in this handler only. As
+    // explained above, this is unfortunately really necessary but the trouble
+    // is that the event will continue to be post-processed by the previous
+    // handler resulting in duplicate calls to event handlers. Call the special
+    // function below to prevent this from happening, base class DoTryChain()
+    // will check for it and behave accordingly.
+    //
+    // And if we're not called from DoTryChain(), this won't do anything anyhow.
+    event.DidntHonourProcessOnlyIn();

 
     return processed;
 }
 
 
     return processed;
 }
 

+// ============================================================================
+// wxScrollHelperBase implementation
+// ============================================================================
+

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// wxScrollHelper construction
+// wxScrollHelperBase construction

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-wxScrollHelper::wxScrollHelper(wxWindow *win)
+wxScrollHelperBase::wxScrollHelperBase(wxWindow *win)

 {
 {

-    wxASSERT_MSG( win, _T("associated window can't be NULL in wxScrollHelper") );
+    wxASSERT_MSG( win, wxT("associated window can't be NULL in wxScrollHelper") );

 
     m_xScrollPixelsPerLine =
     m_yScrollPixelsPerLine =
 
     m_xScrollPixelsPerLine =
     m_yScrollPixelsPerLine =


@@ -328,6 +334,8 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
     m_xScrollingEnabled =
     m_yScrollingEnabled = true;
 
     m_xScrollingEnabled =
     m_yScrollingEnabled = true;
 

+    m_kbdScrollingEnabled = true;
+

     m_scaleX =
     m_scaleY = 1.0;
 #if wxUSE_MOUSEWHEEL
     m_scaleX =
     m_scaleY = 1.0;
 #if wxUSE_MOUSEWHEEL


@@ -335,21 +343,21 @@ wxScrollHelper::wxScrollHelper(wxWindow *win)
 #endif
 
     m_win =
 #endif
 
     m_win =

-    m_targetWindow = (wxWindow *)NULL;
+    m_targetWindow = NULL;

 
 

-    m_timerAutoScroll = (wxTimer *)NULL;
+    m_timerAutoScroll = NULL;

 
     m_handler = NULL;
 
     m_win = win;
 
     m_handler = NULL;
 
     m_win = win;

-    
-    m_win->SetScrollHelper( this );
+
+    m_win->SetScrollHelper(static_cast<wxScrollHelper *>(this));

 
     // by default, the associated window is also the target window
     DoSetTargetWindow(win);
 }
 
 
     // by default, the associated window is also the target window
     DoSetTargetWindow(win);
 }
 

-wxScrollHelper::~wxScrollHelper()
+wxScrollHelperBase::~wxScrollHelperBase()

 {
     StopAutoScrolling();
 
 {
     StopAutoScrolling();
 


@@ -360,24 +368,25 @@ wxScrollHelper::~wxScrollHelper()
 // setting scrolling parameters
 // ----------------------------------------------------------------------------
 
 // setting scrolling parameters
 // ----------------------------------------------------------------------------
 

-void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
-                                   int pixelsPerUnitY,
-                                   int noUnitsX,
-                                   int noUnitsY,
-                                   int xPos,
-                                   int yPos,
-                                   bool noRefresh)
+void wxScrollHelperBase::SetScrollbars(int pixelsPerUnitX,
+                                       int pixelsPerUnitY,
+                                       int noUnitsX,
+                                       int noUnitsY,
+                                       int xPos,
+                                       int yPos,
+                                       bool noRefresh)

 {
 {

-    int xpos, ypos;
+    // Convert positions expressed in scroll units to positions in pixels.
+    int xPosInPixels = (xPos + m_xScrollPosition)*m_xScrollPixelsPerLine,
+        yPosInPixels = (yPos + m_yScrollPosition)*m_yScrollPixelsPerLine;

 
 

-    CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);

     bool do_refresh =
     (
       (noUnitsX != 0 && m_xScrollLines == 0) ||
     bool do_refresh =
     (
       (noUnitsX != 0 && m_xScrollLines == 0) ||

-      (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX * noUnitsX) ||
+      (noUnitsX < m_xScrollLines && xPosInPixels > pixelsPerUnitX * noUnitsX) ||

 
       (noUnitsY != 0 && m_yScrollLines == 0) ||
 
       (noUnitsY != 0 && m_yScrollLines == 0) ||

-      (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY * noUnitsY) ||
+      (noUnitsY < m_yScrollLines && yPosInPixels > pixelsPerUnitY * noUnitsY) ||

       (xPos != m_xScrollPosition) ||
       (yPos != m_yScrollPosition)
     );
       (xPos != m_xScrollPosition) ||
       (yPos != m_yScrollPosition)
     );


@@ -427,7 +436,7 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 // [target] window handling
 // ----------------------------------------------------------------------------
 
 // [target] window handling
 // ----------------------------------------------------------------------------
 

-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()

 {
     // search for m_handler in the handler list
     if ( m_win && m_handler )
 {
     // search for m_handler in the handler list
     if ( m_win && m_handler )


@@ -443,7 +452,7 @@ void wxScrollHelper::DeleteEvtHandler()
     }
 }
 
     }
 }
 

-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)

 {
     m_targetWindow = target;
 #ifdef __WXMAC__
 {
     m_targetWindow = target;
 #ifdef __WXMAC__


@@ -463,7 +472,7 @@ void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
     }
 }
 
     }
 }
 

-void wxScrollHelper::SetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::SetTargetWindow(wxWindow *target)

 {
     wxCHECK_RET( target, wxT("target window must not be NULL") );
 
 {
     wxCHECK_RET( target, wxT("target window must not be NULL") );
 


@@ -473,7 +482,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target)
     DoSetTargetWindow(target);
 }
 
     DoSetTargetWindow(target);
 }
 

-wxWindow *wxScrollHelper::GetTargetWindow() const
+wxWindow *wxScrollHelperBase::GetTargetWindow() const

 {
     return m_targetWindow;
 }
 {
     return m_targetWindow;
 }


@@ -482,7 +491,7 @@ wxWindow *wxScrollHelper::GetTargetWindow() const
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 

-void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
+void wxScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event)

 {
     int nScrollInc = CalcScrollInc(event);
     if ( nScrollInc == 0 )
 {
     int nScrollInc = CalcScrollInc(event);
     if ( nScrollInc == 0 )


@@ -554,7 +563,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
     }
 }
 
     }
 }
 

-int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
+int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event)

 {
     int pos = event.GetPosition();
     int orient = event.GetOrientation();
 {
     int pos = event.GetPosition();
     int orient = event.GetOrientation();


@@ -643,212 +652,12 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
     return nScrollInc;
 }
 
     return nScrollInc;
 }
 

-// Adjust the scrollbars - new version.
-void wxScrollHelper::AdjustScrollbars()
-{
-    static wxRecursionGuardFlag s_flagReentrancy;
-    wxRecursionGuard guard(s_flagReentrancy);
-    if ( guard.IsInside() )
-    {
-        // don't reenter AdjustScrollbars() while another call to
-        // AdjustScrollbars() is in progress because this may lead to calling
-        // ScrollWindow() twice and this can really happen under MSW if
-        // SetScrollbar() call below adds or removes the scrollbar which
-        // changes the window size and hence results in another
-        // AdjustScrollbars() call
-        return;
-    }
-
-    int w = 0, h = 0;
-    int oldw, oldh;
-
-    int oldXScroll = m_xScrollPosition;
-    int oldYScroll = m_yScrollPosition;
-
-    // VZ: at least under Windows this loop is useless because when scrollbars
-    //     [dis]appear we get a WM_SIZE resulting in another call to
-    //     AdjustScrollbars() anyhow. As it doesn't seem to do any harm I leave
-    //     it here for now but it would be better to ensure that all ports
-    //     generate EVT_SIZE when scrollbars [dis]appear, emulating it if
-    //     necessary, and remove it later
-    // JACS: Stop potential infinite loop by limiting number of iterations
-    int iterationCount = 0;
-    const int iterationMax = 5;
-    do
-    {
-        iterationCount ++;
-
-        GetTargetSize(&w, 0);
-
-        // scroll lines per page: if 0, no scrolling is needed
-        int linesPerPage;
-
-        if ( m_xScrollPixelsPerLine == 0 )
-        {
-            // scrolling is disabled
-            m_xScrollLines = 0;
-            m_xScrollPosition = 0;
-            linesPerPage = 0;
-        }
-        else // might need scrolling
-        {
-            // Round up integer division to catch any "leftover" client space.
-            const int wVirt = m_targetWindow->GetVirtualSize().GetWidth();
-            m_xScrollLines = (wVirt + m_xScrollPixelsPerLine - 1) / m_xScrollPixelsPerLine;
-
-            // Calculate page size i.e. number of scroll units you get on the
-            // current client window.
-            linesPerPage = w / m_xScrollPixelsPerLine;
-
-            // Special case. When client and virtual size are very close but
-            // the client is big enough, kill scrollbar.
-            if ((linesPerPage < m_xScrollLines) && (w >= wVirt)) ++linesPerPage;
-
-            if (linesPerPage >= m_xScrollLines)
-            {
-                // we're big enough to not need scrolling
-                linesPerPage =
-                m_xScrollLines =
-                m_xScrollPosition = 0;
-            }
-            else // we do need a scrollbar
-            {
-                if ( linesPerPage < 1 )
-                    linesPerPage = 1;
-
-                // Correct position if greater than extent of canvas minus
-                // the visible portion of it or if below zero
-                const int posMax = m_xScrollLines - linesPerPage;
-                if ( m_xScrollPosition > posMax )
-                    m_xScrollPosition = posMax;
-                else if ( m_xScrollPosition < 0 )
-                    m_xScrollPosition = 0;
-            }
-        }
-
-        m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition,
-                            linesPerPage, m_xScrollLines);
-
-        // The amount by which we scroll when paging
-        SetScrollPageSize(wxHORIZONTAL, linesPerPage);
-
-        GetTargetSize(0, &h);
-
-        if ( m_yScrollPixelsPerLine == 0 )
-        {
-            // scrolling is disabled
-            m_yScrollLines = 0;
-            m_yScrollPosition = 0;
-            linesPerPage = 0;
-        }
-        else // might need scrolling
-        {
-            // Round up integer division to catch any "leftover" client space.
-            const int hVirt = m_targetWindow->GetVirtualSize().GetHeight();
-            m_yScrollLines = ( hVirt + m_yScrollPixelsPerLine - 1 ) / m_yScrollPixelsPerLine;
-
-            // Calculate page size i.e. number of scroll units you get on the
-            // current client window.
-            linesPerPage = h / m_yScrollPixelsPerLine;
-
-            // Special case. When client and virtual size are very close but
-            // the client is big enough, kill scrollbar.
-            if ((linesPerPage < m_yScrollLines) && (h >= hVirt)) ++linesPerPage;
-
-            if (linesPerPage >= m_yScrollLines)
-            {
-                // we're big enough to not need scrolling
-                linesPerPage =
-                m_yScrollLines =
-                m_yScrollPosition = 0;
-            }
-            else // we do need a scrollbar
-            {
-                if ( linesPerPage < 1 )
-                    linesPerPage = 1;
-
-                // Correct position if greater than extent of canvas minus
-                // the visible portion of it or if below zero
-                const int posMax = m_yScrollLines - linesPerPage;
-                if ( m_yScrollPosition > posMax )
-                    m_yScrollPosition = posMax;
-                else if ( m_yScrollPosition < 0 )
-                    m_yScrollPosition = 0;
-            }
-        }
-
-        m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition,
-                            linesPerPage, m_yScrollLines);
-
-        // The amount by which we scroll when paging
-        SetScrollPageSize(wxVERTICAL, linesPerPage);
-
-
-        // If a scrollbar (dis)appeared as a result of this, adjust them again.
-        oldw = w;
-        oldh = h;
-
-        GetTargetSize( &w, &h );
-    } while ( (w != oldw || h != oldh) && (iterationCount < iterationMax) );
-
-#ifdef __WXMOTIF__
-    // Sorry, some Motif-specific code to implement a backing pixmap
-    // for the wxRETAINED style. Implementing a backing store can't
-    // be entirely generic because it relies on the wxWindowDC implementation
-    // to duplicate X drawing calls for the backing pixmap.
-
-    if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
-    {
-        Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
-
-        int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
-        int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
-        if (m_targetWindow->GetBackingPixmap() &&
-           !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
-             (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
-        {
-            XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
-            m_targetWindow->SetBackingPixmap((WXPixmap) 0);
-        }
-
-        if (!m_targetWindow->GetBackingPixmap() &&
-           (m_xScrollLines != 0) && (m_yScrollLines != 0))
-        {
-            int depth = wxDisplayDepth();
-            m_targetWindow->SetPixmapWidth(totalPixelWidth);
-            m_targetWindow->SetPixmapHeight(totalPixelHeight);
-            m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
-              m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
-        }
-
-    }
-#endif // Motif
-
-    if (oldXScroll != m_xScrollPosition)
-    {
-       if (m_xScrollingEnabled)
-            m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
-                                          GetScrollRect() );
-       else
-            m_targetWindow->Refresh(true, GetScrollRect());
-    }
-
-    if (oldYScroll != m_yScrollPosition)
-    {
-        if (m_yScrollingEnabled)
-            m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
-                                          GetScrollRect() );
-        else
-            m_targetWindow->Refresh(true, GetScrollRect());
-    }
-}
-
-void wxScrollHelper::DoPrepareDC(wxDC& dc)
+void wxScrollHelperBase::DoPrepareDC(wxDC& dc)

 {
     wxPoint pt = dc.GetDeviceOrigin();
 #ifdef __WXGTK__
     // It may actually be correct to always query
 {
     wxPoint pt = dc.GetDeviceOrigin();
 #ifdef __WXGTK__
     // It may actually be correct to always query

-    // the m_sign from the DC here, but I leve the
+    // the m_sign from the DC here, but I leave the

     // #ifdef GTK for now.
     if (m_win->GetLayoutDirection() == wxLayout_RightToLeft)
         dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine,
     // #ifdef GTK for now.
     if (m_win->GetLayoutDirection() == wxLayout_RightToLeft)
         dc.SetDeviceOrigin( pt.x + m_xScrollPosition * m_xScrollPixelsPerLine,


@@ -860,7 +669,7 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc)
     dc.SetUserScale( m_scaleX, m_scaleY );
 }
 
     dc.SetUserScale( m_scaleX, m_scaleY );
 }
 

-void wxScrollHelper::SetScrollRate( int xstep, int ystep )
+void wxScrollHelperBase::SetScrollRate( int xstep, int ystep )

 {
     int old_x = m_xScrollPixelsPerLine * m_xScrollPosition;
     int old_y = m_yScrollPixelsPerLine * m_yScrollPosition;
 {
     int old_x = m_xScrollPixelsPerLine * m_xScrollPosition;
     int old_y = m_yScrollPixelsPerLine * m_yScrollPosition;


@@ -878,7 +687,7 @@ void wxScrollHelper::SetScrollRate( int xstep, int ystep )
     AdjustScrollbars();
 }
 
     AdjustScrollbars();
 }
 

-void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
+void wxScrollHelperBase::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const

 {
     if ( x_unit )
         *x_unit = m_xScrollPixelsPerLine;
 {
     if ( x_unit )
         *x_unit = m_xScrollPixelsPerLine;


@@ -887,7 +696,7 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 }
 
 
 }
 
 

-int wxScrollHelper::GetScrollLines( int orient ) const
+int wxScrollHelperBase::GetScrollLines( int orient ) const

 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLines;
 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLines;


@@ -895,7 +704,7 @@ int wxScrollHelper::GetScrollLines( int orient ) const
         return m_yScrollLines;
 }
 
         return m_yScrollLines;
 }
 

-int wxScrollHelper::GetScrollPageSize(int orient) const
+int wxScrollHelperBase::GetScrollPageSize(int orient) const

 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLinesPerPage;
 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLinesPerPage;


@@ -903,7 +712,7 @@ int wxScrollHelper::GetScrollPageSize(int orient) const
         return m_yScrollLinesPerPage;
 }
 
         return m_yScrollLinesPerPage;
 }
 

-void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
+void wxScrollHelperBase::SetScrollPageSize(int orient, int pageSize)

 {
     if ( orient == wxHORIZONTAL )
         m_xScrollLinesPerPage = pageSize;
 {
     if ( orient == wxHORIZONTAL )
         m_xScrollLinesPerPage = pageSize;


@@ -911,89 +720,14 @@ void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
         m_yScrollLinesPerPage = pageSize;
 }
 
         m_yScrollLinesPerPage = pageSize;
 }
 

-/*
- * Scroll to given position (scroll position, not pixel position)
- */
-void wxScrollHelper::Scroll( int x_pos, int y_pos )
-{
-    if (!m_targetWindow)
-        return;
-
-    if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
-        ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
-
-    int w = 0, h = 0;
-    GetTargetSize(&w, &h);
-
-    // compute new position:
-    int new_x = m_xScrollPosition;
-    int new_y = m_yScrollPosition;
-
-    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
-    {
-        new_x = x_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = w/m_xScrollPixelsPerLine;
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        new_x = wxMin( m_xScrollLines-noPagePositions, new_x );
-        new_x = wxMax( 0, new_x );
-    }
-    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
-    {
-        new_y = y_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = h/m_yScrollPixelsPerLine;
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        new_y = wxMin( m_yScrollLines-noPagePositions, new_y );
-        new_y = wxMax( 0, new_y );
-    }
-
-    if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
-        return; // nothing to do, the position didn't change
-
-    // flush all pending repaints before we change m_{x,y}ScrollPosition, as
-    // otherwise invalidated area could be updated incorrectly later when
-    // ScrollWindow() makes sure they're repainted before scrolling them
-    m_targetWindow->Update();
-
-    // update the position and scroll the window now:
-    if (m_xScrollPosition != new_x)
-    {
-        int old_x = m_xScrollPosition;
-        m_xScrollPosition = new_x;
-        m_win->SetScrollPos( wxHORIZONTAL, new_x );
-        m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
-                                      GetScrollRect() );
-    }
-
-    if (m_yScrollPosition != new_y)
-    {
-        int old_y = m_yScrollPosition;
-        m_yScrollPosition = new_y;
-        m_win->SetScrollPos( wxVERTICAL, new_y );
-        m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
-                                      GetScrollRect() );
-    }
-}
-
-void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
+void wxScrollHelperBase::EnableScrolling (bool x_scroll, bool y_scroll)

 {
     m_xScrollingEnabled = x_scroll;
     m_yScrollingEnabled = y_scroll;
 }
 
 // Where the current view starts from
 {
     m_xScrollingEnabled = x_scroll;
     m_yScrollingEnabled = y_scroll;
 }
 
 // Where the current view starts from

-void wxScrollHelper::GetViewStart (int *x, int *y) const
+void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const

 {
     if ( x )
         *x = m_xScrollPosition;
 {
     if ( x )
         *x = m_xScrollPosition;


@@ -1001,7 +735,8 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const
         *y = m_yScrollPosition;
 }
 
         *y = m_yScrollPosition;
 }
 

-void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const
+void wxScrollHelperBase::DoCalcScrolledPosition(int x, int y,
+                                                int *xx, int *yy) const

 {
     if ( xx )
         *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
 {
     if ( xx )
         *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;


@@ -1009,7 +744,8 @@ void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) cons
         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 
         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 

-void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
+void wxScrollHelperBase::DoCalcUnscrolledPosition(int x, int y,
+                                                  int *xx, int *yy) const

 {
     if ( xx )
         *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
 {
     if ( xx )
         *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;


@@ -1021,7 +757,7 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co
 // geometry
 // ----------------------------------------------------------------------------
 
 // geometry
 // ----------------------------------------------------------------------------
 

-bool wxScrollHelper::ScrollLayout()
+bool wxScrollHelperBase::ScrollLayout()

 {
     if ( m_win->GetSizer() && m_targetWindow == m_win )
     {
 {
     if ( m_win->GetSizer() && m_targetWindow == m_win )
     {


@@ -1039,7 +775,7 @@ bool wxScrollHelper::ScrollLayout()
     return m_win->wxWindow::Layout();
 }
 
     return m_win->wxWindow::Layout();
 }
 

-void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
+void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y)

 {
     m_win->wxWindow::DoSetVirtualSize( x, y );
     AdjustScrollbars();
 {
     m_win->wxWindow::DoSetVirtualSize( x, y );
     AdjustScrollbars();


@@ -1050,7 +786,7 @@ void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
 
 // wxWindow's GetBestVirtualSize returns the actual window size,
 // whereas we want to return the virtual size
 
 // wxWindow's GetBestVirtualSize returns the actual window size,
 // whereas we want to return the virtual size

-wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
+wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const

 {
     wxSize clientSize(m_win->GetClientSize());
     if ( m_win->GetSizer() )
 {
     wxSize clientSize(m_win->GetClientSize());
     if ( m_win->GetSizer() )


@@ -1059,35 +795,12 @@ wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
     return clientSize;
 }
 
     return clientSize;
 }
 

-// return the window best size from the given best virtual size
-wxSize
-wxScrollHelper::ScrollGetWindowSizeForVirtualSize(const wxSize& size) const
-{
-    // Only use the content to set the window size in the direction
-    // where there's no scrolling; otherwise we're going to get a huge
-    // window in the direction in which scrolling is enabled
-    int ppuX, ppuY;
-    GetScrollPixelsPerUnit(&ppuX, &ppuY);
-
-    wxSize minSize = m_win->GetMinSize();
-    if ( !minSize.IsFullySpecified() )
-        minSize = m_win->GetSize();
-
-    wxSize best(size);
-    if (ppuX > 0)
-        best.x = minSize.x;
-    if (ppuY > 0)
-        best.y = minSize.y;
-
-    return best;
-}
-

 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any
 // ----------------------------------------------------------------------------
 // event handlers
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any

-void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event))

 {
     if ( m_targetWindow->GetAutoLayout() )
     {
 {
     if ( m_targetWindow->GetAutoLayout() )
     {


@@ -1104,7 +817,7 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 
 // This calls OnDraw, having adjusted the origin according to the current
 // scroll position
 
 // This calls OnDraw, having adjusted the origin according to the current
 // scroll position

-void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnPaint(wxPaintEvent& WXUNUSED(event))

 {
     // don't use m_targetWindow here, this is always called for ourselves
     wxPaintDC dc(m_win);
 {
     // don't use m_targetWindow here, this is always called for ourselves
     wxPaintDC dc(m_win);


@@ -1117,95 +830,79 @@ void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 // compatibility here - if we used OnKeyDown(), the programs which process
 // arrows themselves in their OnChar() would never get the message and like
 // this they always have the priority
 // compatibility here - if we used OnKeyDown(), the programs which process
 // arrows themselves in their OnChar() would never get the message and like
 // this they always have the priority

-void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
+void wxScrollHelperBase::HandleOnChar(wxKeyEvent& event)

 {
 {

-    int stx = 0, sty = 0,       // view origin
-        szx = 0, szy = 0,       // view size (total)
-        clix = 0, cliy = 0;     // view size (on screen)
-
-    GetViewStart(&stx, &sty);
-    GetTargetSize(&clix, &cliy);
-    m_targetWindow->GetVirtualSize(&szx, &szy);
-
-    if( m_xScrollPixelsPerLine )
-    {
-        clix /= m_xScrollPixelsPerLine;
-        szx /= m_xScrollPixelsPerLine;
-    }
-    else
-    {
-        clix = 0;
-        szx = -1;
-    }
-    if( m_yScrollPixelsPerLine )
-    {
-        cliy /= m_yScrollPixelsPerLine;
-        szy /= m_yScrollPixelsPerLine;
-    }
-    else
+    if ( !m_kbdScrollingEnabled )

     {
     {

-        cliy = 0;
-        szy = -1;
+        event.Skip();
+        return;

     }
 
     }
 

-    int xScrollOld = m_xScrollPosition,
-        yScrollOld = m_yScrollPosition;
+    // prepare the event this key press maps to
+    wxScrollWinEvent newEvent;
+
+    newEvent.SetPosition(0);
+    newEvent.SetEventObject(m_win);
+    newEvent.SetId(m_win->GetId());
+
+    // this is the default, it's changed to wxHORIZONTAL below if needed
+    newEvent.SetOrientation(wxVERTICAL);
+
+    // some key events result in scrolling in both horizontal and vertical
+    // direction, e.g. Ctrl-{Home,End}, if this flag is true we should generate
+    // a second event in horizontal direction in addition to the primary one
+    bool sendHorizontalToo = false;

 
 

-    int dsty;

     switch ( event.GetKeyCode() )
     {
         case WXK_PAGEUP:
     switch ( event.GetKeyCode() )
     {
         case WXK_PAGEUP:

-            dsty = sty - (5 * cliy / 6);
-            Scroll(-1, (dsty == -1) ? 0 : dsty);
+            newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEUP);

             break;
 
         case WXK_PAGEDOWN:
             break;
 
         case WXK_PAGEDOWN:

-            Scroll(-1, sty + (5 * cliy / 6));
+            newEvent.SetEventType(wxEVT_SCROLLWIN_PAGEDOWN);

             break;
 
         case WXK_HOME:
             break;
 
         case WXK_HOME:

-            Scroll(0, event.ControlDown() ? 0 : -1);
-            break;
+            newEvent.SetEventType(wxEVT_SCROLLWIN_TOP);

 
 

-        case WXK_END:
-            Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
+            sendHorizontalToo = event.ControlDown();

             break;
 
             break;
 

-        case WXK_UP:
-            Scroll(-1, sty - 1);
-            break;
+        case WXK_END:
+            newEvent.SetEventType(wxEVT_SCROLLWIN_BOTTOM);

 
 

-        case WXK_DOWN:
-            Scroll(-1, sty + 1);
+            sendHorizontalToo = event.ControlDown();

             break;
 
         case WXK_LEFT:
             break;
 
         case WXK_LEFT:

-            Scroll(stx - 1, -1);
+            newEvent.SetOrientation(wxHORIZONTAL);
+            // fall through
+
+        case WXK_UP:
+            newEvent.SetEventType(wxEVT_SCROLLWIN_LINEUP);

             break;
 
         case WXK_RIGHT:
             break;
 
         case WXK_RIGHT:

-            Scroll(stx + 1, -1);
+            newEvent.SetOrientation(wxHORIZONTAL);
+            // fall through
+
+        case WXK_DOWN:
+            newEvent.SetEventType(wxEVT_SCROLLWIN_LINEDOWN);

             break;
 
         default:
             break;
 
         default:

-            // not for us
+            // not a scrolling key

             event.Skip();
             event.Skip();

+            return;

     }
 
     }
 

-    if ( m_xScrollPosition != xScrollOld )
-    {
-        wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
-                               wxHORIZONTAL);
-        evt.SetEventObject(m_win);
-        m_win->GetEventHandler()->ProcessEvent(evt);
-    }
+    m_win->ProcessWindowEvent(newEvent);

 
 

-    if ( m_yScrollPosition != yScrollOld )
+    if ( sendHorizontalToo )

     {
     {

-        wxScrollWinEvent evt(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition,
-                               wxVERTICAL);
-        evt.SetEventObject(m_win);
-        m_win->GetEventHandler()->ProcessEvent(evt);
+        newEvent.SetOrientation(wxHORIZONTAL);
+        m_win->ProcessWindowEvent(newEvent);

     }
 }
 
     }
 }
 


@@ -1214,32 +911,28 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
 // a captured mouse is being held outside the window
 // ----------------------------------------------------------------------------
 
 // a captured mouse is being held outside the window
 // ----------------------------------------------------------------------------
 

-bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const
+bool wxScrollHelperBase::SendAutoScrollEvents(wxScrollWinEvent& event) const

 {
     // only send the event if the window is scrollable in this direction
     wxWindow *win = (wxWindow *)event.GetEventObject();
     return win->HasScrollbar(event.GetOrientation());
 }
 
 {
     // only send the event if the window is scrollable in this direction
     wxWindow *win = (wxWindow *)event.GetEventObject();
     return win->HasScrollbar(event.GetOrientation());
 }
 

-void wxScrollHelper::StopAutoScrolling()
+void wxScrollHelperBase::StopAutoScrolling()

 {
 #if wxUSE_TIMER
 {
 #if wxUSE_TIMER

-    if ( m_timerAutoScroll )
-    {
-        delete m_timerAutoScroll;
-        m_timerAutoScroll = (wxTimer *)NULL;
-    }
+    wxDELETE(m_timerAutoScroll);

 #endif
 }
 
 #endif
 }
 

-void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseEnter(wxMouseEvent& event)

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

-void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseLeave(wxMouseEvent& event)

 {
     // don't prevent the usual processing of the event from taking place
     event.Skip();
 {
     // don't prevent the usual processing of the event from taking place
     event.Skip();


@@ -1280,7 +973,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
                 // but seems to happen sometimes under wxMSW - maybe it's a bug
                 // there but for now just ignore it
 
                 // but seems to happen sometimes under wxMSW - maybe it's a bug
                 // there but for now just ignore it
 

-                //wxFAIL_MSG( _T("can't understand where has mouse gone") );
+                //wxFAIL_MSG( wxT("can't understand where has mouse gone") );

 
                 return;
             }
 
                 return;
             }


@@ -1310,7 +1003,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
 
 #if wxUSE_MOUSEWHEEL
 
 
 #if wxUSE_MOUSEWHEEL
 

-void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)

 {
     m_wheelRotation += event.GetWheelRotation();
     int lines = m_wheelRotation / event.GetWheelDelta();
 {
     m_wheelRotation += event.GetWheelRotation();
     int lines = m_wheelRotation / event.GetWheelDelta();


@@ -1351,7 +1044,7 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
 #endif // wxUSE_MOUSEWHEEL
 
 
 #endif // wxUSE_MOUSEWHEEL
 

-void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
+void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event)

 {
     // this event should be processed by all windows in parenthood chain,
     // e.g. so that nested wxScrolledWindows work correctly
 {
     // this event should be processed by all windows in parenthood chain,
     // e.g. so that nested wxScrolledWindows work correctly


@@ -1363,21 +1056,89 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     if ( win == m_targetWindow )
         return; // nothing to do
 
     if ( win == m_targetWindow )
         return; // nothing to do
 

-    while ( win->GetParent() != m_targetWindow )
+#if defined( __WXOSX__ ) && wxUSE_SCROLLBAR
+    if (wxDynamicCast(win, wxScrollBar))
+        return;
+#endif
+
+    // Fixing ticket: http://trac.wxwidgets.org/ticket/9563
+    // When a child inside a wxControlContainer receives a focus, the
+    // wxControlContainer generates an artificial wxChildFocusEvent for
+    // itself, telling its parent that 'it' received the focus. The effect is
+    // that this->HandleOnChildFocus is called twice, first with the
+    // artificial wxChildFocusEvent and then with the original event.  We need
+    // to ignore the artificial event here or otherwise HandleOnChildFocus
+    // would first scroll the target window to make the entire
+    // wxControlContainer visible and immediately afterwards scroll the target
+    // window again to make the child widget visible. This leads to ugly
+    // flickering when using nested wxPanels/wxScrolledWindows.
+    //
+    // Ignore this event if 'win' is derived from wxControlContainer AND its
+    // parent is the m_targetWindow AND 'win' is not actually reciving the
+    // focus (win != FindFocus).  TODO: This affects all wxControlContainer
+    // objects, but wxControlContainer is not part of the wxWidgets RTTI and
+    // so wxDynamicCast(win, wxControlContainer) does not compile.  Find a way
+    // to determine if 'win' derives from wxControlContainer. Until then,
+    // testing if 'win' derives from wxPanel will probably get >90% of all
+    // cases.
+
+    wxWindow *actual_focus=wxWindow::FindFocus();
+    if (win != actual_focus &&
+        wxDynamicCast(win, wxPanel) != 0 &&
+        win->GetParent() == m_targetWindow)
+        // if win is a wxPanel and receives the focus, it should not be
+        // scrolled into view
+        return;
+
+    const wxRect viewRect(m_targetWindow->GetClientRect());
+
+    // For composite controls such as wxComboCtrl we should try to fit the
+    // entire control inside the visible area of the target window, not just
+    // the focused child of the control. Otherwise we'd make only the textctrl
+    // part of a wxComboCtrl visible and the button would still be outside the
+    // scrolled area.  But do so only if the parent fits *entirely* inside the
+    // scrolled window. In other situations, such as nested wxPanel or
+    // wxScrolledWindows, the parent might be way too big to fit inside the
+    // scrolled window. If that is the case, then make only the focused window
+    // visible
+    if ( win->GetParent() != m_targetWindow)
+    {
+        wxWindow *parent=win->GetParent();
+        wxSize parent_size=parent->GetSize();
+        if (parent_size.GetWidth() <= viewRect.GetWidth() &&
+            parent_size.GetHeight() <= viewRect.GetHeight())
+            // make the immediate parent visible instead of the focused control
+            win=parent;
+    }
+
+    // make win position relative to the m_targetWindow viewing area instead of
+    // its parent
+    const wxRect
+        winRect(m_targetWindow->ScreenToClient(win->GetScreenPosition()),
+                win->GetSize());
+
+    // check if it's fully visible
+    if ( viewRect.Contains(winRect) )

     {
     {

-        win = win->GetParent();
-        wxCHECK_RET( win, "incorrectly sent wxChildFocusEvent - not our child" );
+        // it is, nothing to do
+        return;
+    }
+
+    // check if we can make it fully visible: this is only possible if it's not
+    // larger than our view area
+    if ( winRect.GetWidth() > viewRect.GetWidth() ||
+            winRect.GetHeight() > viewRect.GetHeight() )
+    {
+        // we can't make it fit so avoid scrolling it at all, this is only
+        // going to be confusing and not helpful
+        return;

     }
 
     }
 

-    // if the child is not fully visible, try to scroll it into view:
+
+    // do make the window fit inside the view area by scrolling to it

     int stepx, stepy;
     GetScrollPixelsPerUnit(&stepx, &stepy);
 
     int stepx, stepy;
     GetScrollPixelsPerUnit(&stepx, &stepy);
 

-    // NB: we don't call CalcScrolledPosition() on win->GetPosition() here,
-    //     because children' positions are already scrolled
-    wxRect winrect(win->GetPosition(), win->GetSize());
-    wxSize view(m_targetWindow->GetClientSize());
-

     int startx, starty;
     GetViewStart(&startx, &starty);
 
     int startx, starty;
     GetViewStart(&startx, &starty);
 


@@ -1386,13 +1147,13 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     {
         int diff = 0;
 
     {
         int diff = 0;
 

-        if ( winrect.GetTop() < 0 )
+        if ( winRect.GetTop() < 0 )

         {
         {

-            diff = winrect.GetTop();
+            diff = winRect.GetTop();

         }
         }

-        else if ( winrect.GetBottom() > view.y )
+        else if ( winRect.GetBottom() > viewRect.GetHeight() )

         {
         {

-            diff = winrect.GetBottom() - view.y + 1;
+            diff = winRect.GetBottom() - viewRect.GetHeight() + 1;

             // round up to next scroll step if we can't get exact position,
             // so that the window is fully visible:
             diff += stepy - 1;
             // round up to next scroll step if we can't get exact position,
             // so that the window is fully visible:
             diff += stepy - 1;


@@ -1406,13 +1167,13 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     {
         int diff = 0;
 
     {
         int diff = 0;
 

-        if ( winrect.GetLeft() < 0 )
+        if ( winRect.GetLeft() < 0 )

         {
         {

-            diff = winrect.GetLeft();
+            diff = winRect.GetLeft();

         }
         }

-        else if ( winrect.GetRight() > view.x )
+        else if ( winRect.GetRight() > viewRect.GetWidth() )

         {
         {

-            diff = winrect.GetRight() - view.x + 1;
+            diff = winRect.GetRight() - viewRect.GetWidth() + 1;

             // round up to next scroll step if we can't get exact position,
             // so that the window is fully visible:
             diff += stepx - 1;
             // round up to next scroll step if we can't get exact position,
             // so that the window is fully visible:
             diff += stepx - 1;


@@ -1424,59 +1185,359 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     Scroll(startx, starty);
 }
 
     Scroll(startx, starty);
 }
 

+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+

 // ----------------------------------------------------------------------------
 // ----------------------------------------------------------------------------

-// wxScrolledWindow implementation
+// wxScrollHelper implementation

 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 

-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+    : wxScrollHelperBase(winToScroll)
+{
+    m_xVisibility =
+    m_yVisibility = wxSHOW_SB_DEFAULT;
+}

 
 

-BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
-    EVT_PAINT(wxScrolledWindow::OnPaint)
-END_EVENT_TABLE()
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+                                      wxScrollbarVisibility vert)
+{
+    if ( horz != m_xVisibility || vert != m_yVisibility )
+    {
+        m_xVisibility = horz;
+        m_yVisibility = vert;

 
 

-bool wxScrolledWindow::Create(wxWindow *parent,
-                              wxWindowID id,
-                              const wxPoint& pos,
-                              const wxSize& size,
-                              long style,
-                              const wxString& name)
+        AdjustScrollbars();
+    }
+}
+
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+                                  int clientSize,
+                                  int virtSize,
+                                  int pixelsPerUnit,
+                                  int& scrollUnits,
+                                  int& scrollPosition,
+                                  int& scrollLinesPerPage,
+                                  wxScrollbarVisibility visibility)

 {
 {

-    m_targetWindow = this;
-#ifdef __WXMAC__
-    MacSetClipChildren( true ) ;
-#endif
+    // scroll lines per page: if 0, no scrolling is needed
+    // check if we need scrollbar in this direction at all
+    if ( pixelsPerUnit == 0 || clientSize >= virtSize )
+    {
+        // scrolling is disabled or unnecessary
+        scrollUnits =
+        scrollPosition = 0;
+        scrollLinesPerPage = 0;
+    }
+    else // might need scrolling
+    {
+        // Round up integer division to catch any "leftover" client space.
+        scrollUnits = (virtSize + pixelsPerUnit - 1) / pixelsPerUnit;
+
+        // Calculate the number of fully scroll units
+        scrollLinesPerPage = clientSize / pixelsPerUnit;
+
+        if ( scrollLinesPerPage >= scrollUnits )
+        {
+            // we're big enough to not need scrolling
+            scrollUnits =
+            scrollPosition = 0;
+            scrollLinesPerPage = 0;
+        }
+        else // we do need a scrollbar
+        {
+            if ( scrollLinesPerPage < 1 )
+                scrollLinesPerPage = 1;
+
+            // Correct position if greater than extent of canvas minus
+            // the visible portion of it or if below zero
+            const int posMax = scrollUnits - scrollLinesPerPage;
+            if ( scrollPosition > posMax )
+                scrollPosition = posMax;
+            else if ( scrollPosition < 0 )
+                scrollPosition = 0;
+        }
+    }
+
+    // in wxSHOW_SB_NEVER case don't show the scrollbar even if it's needed, in
+    // wxSHOW_SB_ALWAYS case show the scrollbar even if it's not needed by
+    // passing a special range value to SetScrollbar()
+    int range;
+    switch ( visibility )
+    {
+        case wxSHOW_SB_NEVER:
+            range = 0;
+            break;

 
 

-    // by default, we're scrollable in both directions (but if one of the
-    // styles is specified explicitly, we shouldn't add the other one
-    // automatically)
-    if ( !(style & (wxHSCROLL | wxVSCROLL)) )
-        style |= wxHSCROLL | wxVSCROLL;
+        case wxSHOW_SB_ALWAYS:
+            range = scrollUnits ? scrollUnits : -1;
+            break;
+
+        default:
+            wxFAIL_MSG( wxS("unknown scrollbar visibility") );
+            // fall through
+
+        case wxSHOW_SB_DEFAULT:
+            range = scrollUnits;
+            break;

 
 

-    bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+    }

 
 

-    return ok;
+    m_win->SetScrollbar(orient, scrollPosition, scrollLinesPerPage, range);

 }
 
 }
 

-wxScrolledWindow::~wxScrolledWindow()
+void wxScrollHelper::AdjustScrollbars()

 {
 {

+    static wxRecursionGuardFlag s_flagReentrancy;
+    wxRecursionGuard guard(s_flagReentrancy);
+    if ( guard.IsInside() )
+    {
+        // don't reenter AdjustScrollbars() while another call to
+        // AdjustScrollbars() is in progress because this may lead to calling
+        // ScrollWindow() twice and this can really happen under MSW if
+        // SetScrollbar() call below adds or removes the scrollbar which
+        // changes the window size and hence results in another
+        // AdjustScrollbars() call
+        return;
+    }
+
+    int oldXScroll = m_xScrollPosition;
+    int oldYScroll = m_yScrollPosition;
+
+    // we may need to readjust the scrollbars several times as enabling one of
+    // them reduces the area available for the window contents and so can make
+    // the other scrollbar necessary now although it wasn't necessary before
+    //
+    // VZ: normally this loop should be over in at most 2 iterations, I don't
+    //     know why do we need 5 of them
+    for ( int iterationCount = 0; iterationCount < 5; iterationCount++ )
+    {
+        wxSize clientSize = GetTargetSize();
+        const wxSize virtSize = m_targetWindow->GetVirtualSize();
+
+        // this block of code tries to work around the following problem: the
+        // window could have been just resized to have enough space to show its
+        // full contents without the scrollbars, but its client size could be
+        // not big enough because it does have the scrollbars right now and so
+        // the scrollbars would remain even though we don't need them any more
+        //
+        // to prevent this from happening, check if we have enough space for
+        // everything without the scrollbars and explicitly disable them then
+        const wxSize availSize = GetSizeAvailableForScrollTarget(
+            m_win->GetSize() - m_win->GetWindowBorderSize());
+        if ( availSize != clientSize )
+        {
+            if ( availSize.x >= virtSize.x && availSize.y >= virtSize.y )
+            {
+                // this will be enough to make the scrollbars disappear below
+                // and then the client size will indeed become equal to the
+                // full available size
+                clientSize = availSize;
+            }
+        }
+
+
+        DoAdjustScrollbar(wxHORIZONTAL,
+                          clientSize.x,
+                          virtSize.x,
+                          m_xScrollPixelsPerLine,
+                          m_xScrollLines,
+                          m_xScrollPosition,
+                          m_xScrollLinesPerPage,
+                          m_xVisibility);
+
+        DoAdjustScrollbar(wxVERTICAL,
+                          clientSize.y,
+                          virtSize.y,
+                          m_yScrollPixelsPerLine,
+                          m_yScrollLines,
+                          m_yScrollPosition,
+                          m_yScrollLinesPerPage,
+                          m_yVisibility);
+
+
+        // If a scrollbar (dis)appeared as a result of this, we need to adjust
+        // them again but if the client size didn't change, then we're done
+        if ( GetTargetSize() == clientSize )
+            break;
+    }
+
+#ifdef __WXMOTIF__
+    // Sorry, some Motif-specific code to implement a backing pixmap
+    // for the wxRETAINED style. Implementing a backing store can't
+    // be entirely generic because it relies on the wxWindowDC implementation
+    // to duplicate X drawing calls for the backing pixmap.
+
+    if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
+    {
+        Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
+
+        int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
+        int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
+        if (m_targetWindow->GetBackingPixmap() &&
+           !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
+             (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
+        {
+            XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
+            m_targetWindow->SetBackingPixmap((WXPixmap) 0);
+        }
+
+        if (!m_targetWindow->GetBackingPixmap() &&
+           (m_xScrollLines != 0) && (m_yScrollLines != 0))
+        {
+            int depth = wxDisplayDepth();
+            m_targetWindow->SetPixmapWidth(totalPixelWidth);
+            m_targetWindow->SetPixmapHeight(totalPixelHeight);
+            m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
+              m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
+        }
+
+    }
+#endif // Motif
+
+    if (oldXScroll != m_xScrollPosition)
+    {
+       if (m_xScrollingEnabled)
+            m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll - m_xScrollPosition), 0,
+                                          GetScrollRect() );
+       else
+            m_targetWindow->Refresh(true, GetScrollRect());
+    }
+
+    if (oldYScroll != m_yScrollPosition)
+    {
+        if (m_yScrollingEnabled)
+            m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
+                                          GetScrollRect() );
+        else
+            m_targetWindow->Refresh(true, GetScrollRect());
+    }

 }
 
 }
 

-void wxScrolledWindow::OnPaint(wxPaintEvent& event)
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )

 {
 {

-    // the user code didn't really draw the window if we got here, so set this
-    // flag to try to call OnDraw() later
-    m_handler->ResetDrawnFlag();
+    if (!m_targetWindow)
+        return;

 
 

-    event.Skip();
+    if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
+        ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
+
+    int w = 0, h = 0;
+    GetTargetSize(&w, &h);
+
+    // compute new position:
+    int new_x = m_xScrollPosition;
+    int new_y = m_yScrollPosition;
+
+    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
+    {
+        new_x = x_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = w/m_xScrollPixelsPerLine;
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        new_x = wxMin( m_xScrollLines-noPagePositions, new_x );
+        new_x = wxMax( 0, new_x );
+    }
+    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
+    {
+        new_y = y_pos;
+
+        // Calculate page size i.e. number of scroll units you get on the
+        // current client window
+        int noPagePositions = h/m_yScrollPixelsPerLine;
+        if (noPagePositions < 1) noPagePositions = 1;
+
+        // Correct position if greater than extent of canvas minus
+        // the visible portion of it or if below zero
+        new_y = wxMin( m_yScrollLines-noPagePositions, new_y );
+        new_y = wxMax( 0, new_y );
+    }
+
+    if ( new_x == m_xScrollPosition && new_y == m_yScrollPosition )
+        return; // nothing to do, the position didn't change
+
+    // flush all pending repaints before we change m_{x,y}ScrollPosition, as
+    // otherwise invalidated area could be updated incorrectly later when
+    // ScrollWindow() makes sure they're repainted before scrolling them
+    m_targetWindow->Update();
+
+    // update the position and scroll the window now:
+    if (m_xScrollPosition != new_x)
+    {
+        int old_x = m_xScrollPosition;
+        m_xScrollPosition = new_x;
+        m_win->SetScrollPos( wxHORIZONTAL, new_x );
+        m_targetWindow->ScrollWindow( (old_x-new_x)*m_xScrollPixelsPerLine, 0,
+                                      GetScrollRect() );
+    }
+
+    if (m_yScrollPosition != new_y)
+    {
+        int old_y = m_yScrollPosition;
+        m_yScrollPosition = new_y;
+        m_win->SetScrollPos( wxVERTICAL, new_y );
+        m_targetWindow->ScrollWindow( 0, (old_y-new_y)*m_yScrollPixelsPerLine,
+                                      GetScrollRect() );
+    }

 }
 
 }
 

-#ifdef __WXMSW__
-WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg,
-                                       WXWPARAM wParam,
-                                       WXLPARAM lParam)
+#endif // wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrolled<T> and wxScrolledWindow implementation
+// ----------------------------------------------------------------------------
+
+wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
+                                          const wxScrollHelper *helper,
+                                          const wxSize& origBest)

 {
 {

-    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
+    // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not
+    //     all scrollable windows should behave like this, only those that
+    //     contain children controls within scrollable area
+    //     (i.e., wxScrolledWindow) and other some scrollable windows may
+    //     have different DoGetBestSize() implementation (e.g. wxTreeCtrl).
+
+    wxSize best = origBest;
+
+    if ( win->GetAutoLayout() )
+    {
+        // Only use the content to set the window size in the direction
+        // where there's no scrolling; otherwise we're going to get a huge
+        // window in the direction in which scrolling is enabled
+        int ppuX, ppuY;
+        helper->GetScrollPixelsPerUnit(&ppuX, &ppuY);
+
+        // NB: This code used to use *current* size if min size wasn't
+        //     specified, presumably to get some reasonable (i.e., larger than
+        //     minimal) size.  But that's a wrong thing to do in GetBestSize(),
+        //     so we use minimal size as specified. If the app needs some
+        //     minimal size for its scrolled window, it should set it and put
+        //     the window into sizer as expandable so that it can use all space
+        //     available to it.
+        //
+        //     See also http://svn.wxwidgets.org/viewvc/wx?view=rev&revision=45864
+
+        wxSize minSize = win->GetMinSize();
+
+        if ( ppuX > 0 )
+            best.x = minSize.x + wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
+
+        if ( ppuY > 0 )
+            best.y = minSize.y + wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
+    }
+
+    return best;
+}

 
 

+#ifdef __WXMSW__
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)
+{

 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
     if ( nMsg == WM_GETDLGCODE )
 #ifndef __WXWINCE__
     // we need to process arrows ourselves for scrolling
     if ( nMsg == WM_GETDLGCODE )


@@ -1484,8 +1545,10 @@ WXLRESULT wxScrolledWindow::MSWWindowProc(WXUINT nMsg,
         rc |= DLGC_WANTARROWS;
     }
 #endif
         rc |= DLGC_WANTARROWS;
     }
 #endif

-

     return rc;
 }
     return rc;
 }

-

 #endif // __WXMSW__
 #endif // __WXMSW__

+
+// NB: skipping wxScrolled<T> in wxRTTI information because being a templte,
+//     it doesn't and can't implement wxRTTI support
+IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)