]> git.saurik.com Git - wxWidgets.git/blobdiff - src/generic/scrlwing.cpp
adding special case for Carbon DataBrowser Checkbox
[wxWidgets.git] / src / generic / scrlwing.cpp
index 13f1e7e5e0e8d12927694dc74414987961b69084..300f0a1463d5e7ac1a54cf7a40c9aa6d065a5f64 100644 (file)
@@ -72,7 +72,7 @@
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:
-    wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
+    wxScrollHelperEvtHandler(wxScrollHelperBase *scrollHelper)
     {
         m_scrollHelper = scrollHelper;
     }
@@ -82,11 +82,11 @@ public:
     void ResetDrawnFlag() { m_hasDrawnWindow = false; }
 
 private:
-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;
 
     bool m_hasDrawnWindow;
 
-    DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
+    wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler);
 };
 
 #if wxUSE_TIMER
@@ -98,7 +98,8 @@ private:
 class wxAutoScrollTimer : public wxTimer
 {
 public:
-    wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll,
+    wxAutoScrollTimer(wxWindow *winToScroll,
+                      wxScrollHelperBase *scroll,
                       wxEventType eventTypeToSend,
                       int pos, int orient);
 
@@ -106,12 +107,12 @@ public:
 
 private:
     wxWindow *m_win;
-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;
     wxEventType m_eventType;
     int m_pos,
         m_orient;
 
-    DECLARE_NO_COPY_CLASS(wxAutoScrollTimer)
+    wxDECLARE_NO_COPY_CLASS(wxAutoScrollTimer);
 };
 
 // ============================================================================
@@ -123,7 +124,7 @@ private:
 // ----------------------------------------------------------------------------
 
 wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,
-                                     wxScrollHelper *scroll,
+                                     wxScrollHelperBase *scroll,
                                      wxEventType eventTypeToSend,
                                      int pos, int orient)
 {
@@ -151,7 +152,7 @@ void wxAutoScrollTimer::Notify()
         {
             // 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
@@ -303,11 +304,15 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     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") );
 
@@ -330,21 +335,21 @@ wxScrollHelper::wxScrollHelper(wxWindow *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_win->SetScrollHelper( this );
+
+    m_win->SetScrollHelper(static_cast<wxScrollHelper *>(this));
 
     // by default, the associated window is also the target window
     DoSetTargetWindow(win);
 }
 
-wxScrollHelper::~wxScrollHelper()
+wxScrollHelperBase::~wxScrollHelperBase()
 {
     StopAutoScrolling();
 
@@ -355,13 +360,13 @@ wxScrollHelper::~wxScrollHelper()
 // 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;
 
@@ -422,7 +427,7 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 // [target] window handling
 // ----------------------------------------------------------------------------
 
-void wxScrollHelper::DeleteEvtHandler()
+void wxScrollHelperBase::DeleteEvtHandler()
 {
     // search for m_handler in the handler list
     if ( m_win && m_handler )
@@ -438,13 +443,13 @@ void wxScrollHelper::DeleteEvtHandler()
     }
 }
 
-void wxScrollHelper::ResetDrawnFlag()
+void wxScrollHelperBase::ResetDrawnFlag()
 {
     wxCHECK_RET( m_handler, "invalid use of ResetDrawnFlag - no handler?" );
     m_handler->ResetDrawnFlag();
 }
 
-void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
+void wxScrollHelperBase::DoSetTargetWindow(wxWindow *target)
 {
     m_targetWindow = target;
 #ifdef __WXMAC__
@@ -464,7 +469,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") );
 
@@ -474,7 +479,7 @@ void wxScrollHelper::SetTargetWindow(wxWindow *target)
     DoSetTargetWindow(target);
 }
 
-wxWindow *wxScrollHelper::GetTargetWindow() const
+wxWindow *wxScrollHelperBase::GetTargetWindow() const
 {
     return m_targetWindow;
 }
@@ -483,7 +488,7 @@ wxWindow *wxScrollHelper::GetTargetWindow() const
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 
-void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
+void wxScrollHelperBase::HandleOnScroll(wxScrollWinEvent& event)
 {
     int nScrollInc = CalcScrollInc(event);
     if ( nScrollInc == 0 )
@@ -555,7 +560,7 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
     }
 }
 
-int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
+int wxScrollHelperBase::CalcScrollInc(wxScrollWinEvent& event)
 {
     int pos = event.GetPosition();
     int orient = event.GetOrientation();
@@ -644,212 +649,12 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
     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
-    // 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,
@@ -861,7 +666,7 @@ void wxScrollHelper::DoPrepareDC(wxDC& dc)
     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;
@@ -879,7 +684,7 @@ void wxScrollHelper::SetScrollRate( int xstep, int ystep )
     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;
@@ -888,7 +693,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;
@@ -896,7 +701,7 @@ int wxScrollHelper::GetScrollLines( int orient ) const
         return m_yScrollLines;
 }
 
-int wxScrollHelper::GetScrollPageSize(int orient) const
+int wxScrollHelperBase::GetScrollPageSize(int orient) const
 {
     if ( orient == wxHORIZONTAL )
         return m_xScrollLinesPerPage;
@@ -904,7 +709,7 @@ int wxScrollHelper::GetScrollPageSize(int orient) const
         return m_yScrollLinesPerPage;
 }
 
-void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
+void wxScrollHelperBase::SetScrollPageSize(int orient, int pageSize)
 {
     if ( orient == wxHORIZONTAL )
         m_xScrollLinesPerPage = pageSize;
@@ -912,89 +717,14 @@ void wxScrollHelper::SetScrollPageSize(int orient, int 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
-void wxScrollHelper::GetViewStart (int *x, int *y) const
+void wxScrollHelperBase::DoGetViewStart (int *x, int *y) const
 {
     if ( x )
         *x = m_xScrollPosition;
@@ -1002,7 +732,8 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const
         *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;
@@ -1010,7 +741,8 @@ void wxScrollHelper::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) cons
         *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;
@@ -1022,7 +754,7 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co
 // geometry
 // ----------------------------------------------------------------------------
 
-bool wxScrollHelper::ScrollLayout()
+bool wxScrollHelperBase::ScrollLayout()
 {
     if ( m_win->GetSizer() && m_targetWindow == m_win )
     {
@@ -1040,7 +772,7 @@ bool wxScrollHelper::ScrollLayout()
     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();
@@ -1051,7 +783,7 @@ void wxScrollHelper::ScrollDoSetVirtualSize(int x, int y)
 
 // 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() )
@@ -1065,7 +797,7 @@ wxSize wxScrollHelper::ScrollGetBestVirtualSize() const
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any
-void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
+void wxScrollHelperBase::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 {
     if ( m_targetWindow->GetAutoLayout() )
     {
@@ -1082,7 +814,7 @@ void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 
 // 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);
@@ -1095,7 +827,7 @@ 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
-void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
+void wxScrollHelperBase::HandleOnChar(wxKeyEvent& event)
 {
     int stx = 0, sty = 0,       // view origin
         szx = 0, szy = 0,       // view size (total)
@@ -1192,32 +924,32 @@ void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
 // 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());
 }
 
-void wxScrollHelper::StopAutoScrolling()
+void wxScrollHelperBase::StopAutoScrolling()
 {
 #if wxUSE_TIMER
     if ( m_timerAutoScroll )
     {
         delete m_timerAutoScroll;
-        m_timerAutoScroll = (wxTimer *)NULL;
+        m_timerAutoScroll = NULL;
     }
 #endif
 }
 
-void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseEnter(wxMouseEvent& event)
 {
     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();
@@ -1288,7 +1020,7 @@ void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
 
 #if wxUSE_MOUSEWHEEL
 
-void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
+void wxScrollHelperBase::HandleOnMouseWheel(wxMouseEvent& event)
 {
     m_wheelRotation += event.GetWheelRotation();
     int lines = m_wheelRotation / event.GetWheelDelta();
@@ -1329,7 +1061,7 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
 #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
@@ -1341,22 +1073,89 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     if ( win == m_targetWindow )
         return; // nothing to do
 
-    while ( win->GetParent() != m_targetWindow )
+#ifdef __WXMAC__
+    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 to 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) )
+    {
+        // 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() )
     {
-        win = win->GetParent();
-        if ( !win )
-            return; // event is not from a child of the target window
+        // 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);
 
-    // 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);
 
@@ -1365,13 +1164,13 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     {
         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;
@@ -1385,13 +1184,13 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     {
         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;
@@ -1403,12 +1202,316 @@ void wxScrollHelper::HandleOnChildFocus(wxChildFocusEvent& event)
     Scroll(startx, starty);
 }
 
+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrollHelper implementation
+// ----------------------------------------------------------------------------
+
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+    : wxScrollHelperBase(winToScroll)
+{
+    m_xVisibility =
+    m_yVisibility = wxSHOW_SB_DEFAULT;
+}
+
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+                                      wxScrollbarVisibility vert)
+{
+    if ( horz != m_xVisibility || vert != m_yVisibility )
+    {
+        m_xVisibility = horz;
+        m_yVisibility = vert;
+
+        AdjustScrollbars();
+    }
+}
+
+void
+wxScrollHelper::DoAdjustScrollbar(int orient,
+                                  int clientSize,
+                                  int virtSize,
+                                  int pixelsPerUnit,
+                                  int& scrollUnits,
+                                  int& scrollPosition,
+                                  int& scrollLinesPerPage,
+                                  wxScrollbarVisibility visibility)
+{
+    // 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;
+
+        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;
+
+    }
+
+    m_win->SetScrollbar(orient, scrollPosition, scrollLinesPerPage, range);
+}
+
+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 wxScrollHelper::DoScroll( 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() );
+    }
+}
+
+#endif // wxHAS_GENERIC_SCROLLWIN
+
 // ----------------------------------------------------------------------------
 // wxScrolled<T> and wxScrolledWindow implementation
 // ----------------------------------------------------------------------------
 
 wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
-                                          const wxScrollHelperNative *helper,
+                                          const wxScrollHelper *helper,
                                           const wxSize& origBest)
 {
     // NB: We don't do this in WX_FORWARD_TO_SCROLL_HELPER, because not