Document wxDateTime::GregorianAdoption enum and TimeZone class.

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

diff --git a/src/generic/scrlwing.cpp b/src/generic/scrlwing.cpp
index 606207d2600b35fd2ba22e0a15bfef7d0642792c..81dedd9875bf5ff84381ffb0d5956fce104eab55 100644 (file)
--- a/src/generic/scrlwing.cpp
+++ b/src/generic/scrlwing.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 /////////////////////////////////////////////////////////////////////////////

-// Name:        generic/scrolwin.cpp
-// Purpose:     wxGenericScrolledWindow implementation
+// Name:        src/generic/scrlwing.cpp
+// Purpose:     wxScrolledWindow implementation

 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement.
 //              Ron Lee on 10.4.02:  virtual size / auto scrollbars et al.
 // Author:      Julian Smart
 // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement.
 //              Ron Lee on 10.4.02:  virtual size / auto scrollbars et al.


@@ -18,14 +18,6 @@
 // headers
 // ----------------------------------------------------------------------------
 
 // headers
 // ----------------------------------------------------------------------------
 

-#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
-    #pragma implementation "genscrolwin.h"
-#endif
-
-#ifdef __VMS
-#define XtDisplay XTDISPLAY
-#endif
-

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


@@ -33,21 +25,26 @@
     #pragma hdrstop
 #endif
 
     #pragma hdrstop
 #endif
 

-#if !defined(__WXGTK__) || defined(__WXUNIVERSAL__)
+#include "wx/scrolwin.h"

 
 

-#include "wx/utils.h"
-#include "wx/dcclient.h"
+#ifndef WX_PRECOMP
+    #include "wx/utils.h"
+    #include "wx/panel.h"
+    #include "wx/dcclient.h"
+    #include "wx/timer.h"
+    #include "wx/sizer.h"
+    #include "wx/settings.h"
+#endif

 
 

-#include "wx/scrolwin.h"
-#include "wx/panel.h"
-#if wxUSE_TIMER
-#include "wx/timer.h"
+#ifdef __WXMAC__
+#include "wx/scrolbar.h"

 #endif
 #endif

-#include "wx/sizer.h"
+

 #include "wx/recguard.h"
 
 #ifdef __WXMSW__
     #include <windows.h> // for DLGC_WANTARROWS
 #include "wx/recguard.h"
 
 #ifdef __WXMSW__
     #include <windows.h> // for DLGC_WANTARROWS

+    #include "wx/msw/winundef.h"

 #endif
 
 #ifdef __WXMOTIF__
 #endif
 
 #ifdef __WXMOTIF__


@@ -62,8 +59,6 @@
 #endif
 #endif
 
 #endif
 #endif
 

-IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
-

 /*
     TODO PROPERTIES
         style wxHSCROLL | wxVSCROLL
 /*
     TODO PROPERTIES
         style wxHSCROLL | wxVSCROLL


@@ -77,7 +72,7 @@ IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:
 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
 {
 public:

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

     {
         m_scrollHelper = scrollHelper;
     }
     {
         m_scrollHelper = scrollHelper;
     }


@@ -87,11 +82,11 @@ public:
     void ResetDrawnFlag() { m_hasDrawnWindow = false; }
 
 private:
     void ResetDrawnFlag() { m_hasDrawnWindow = false; }
 
 private:

-    wxScrollHelper *m_scrollHelper;
+    wxScrollHelperBase *m_scrollHelper;

 
     bool m_hasDrawnWindow;
 
 
     bool m_hasDrawnWindow;
 

-    DECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler)
+    wxDECLARE_NO_COPY_CLASS(wxScrollHelperEvtHandler);

 };
 
 #if wxUSE_TIMER
 };
 
 #if wxUSE_TIMER


@@ -103,7 +98,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 +107,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 +124,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)
 {


@@ -156,7 +152,7 @@ void wxAutoScrollTimer::Notify()
         {
             // and then send a pseudo mouse-move event to refresh the selection
             wxMouseEvent event2(wxEVT_MOTION);
         {
             // 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


@@ -207,8 +203,13 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
     // user code defined OnPaint() in the derived class)
     m_hasDrawnWindow = true;
 
     // 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()


@@ -229,22 +230,30 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
         // 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)
         // 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 )
+        if ( m_hasDrawnWindow || event.IsCommandEvent() )

         {
             return true;
         }
     }
 
         {
             return true;
         }
     }
 

-    // reset the skipped flag to false as it might have been set to true in
-    // ProcessEvent() above
-    event.Skip(false);
-

     if ( evType == wxEVT_PAINT )
     {
         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
         return true;
     }
 
     if ( evType == wxEVT_PAINT )
     {
         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
         return true;
     }
 

+    if ( evType == wxEVT_CHILD_FOCUS )
+    {
+        m_scrollHelper->HandleOnChildFocus((wxChildFocusEvent &)event);
+        return true;
+    }
+
+    // reset the skipped flag (which might have been set to true in
+    // ProcessEvent() above) to be able to test it below
+    bool wasSkipped = event.GetSkipped();
+    if ( wasSkipped )
+        event.Skip(false);
+

     if ( evType == wxEVT_SCROLLWIN_TOP ||
          evType == wxEVT_SCROLLWIN_BOTTOM ||
          evType == wxEVT_SCROLLWIN_LINEUP ||
     if ( evType == wxEVT_SCROLLWIN_TOP ||
          evType == wxEVT_SCROLLWIN_BOTTOM ||
          evType == wxEVT_SCROLLWIN_LINEUP ||


@@ -254,8 +263,16 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
          evType == wxEVT_SCROLLWIN_THUMBTRACK ||
          evType == wxEVT_SCROLLWIN_THUMBRELEASE )
     {
          evType == wxEVT_SCROLLWIN_THUMBTRACK ||
          evType == wxEVT_SCROLLWIN_THUMBRELEASE )
     {

-            m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
-            return !event.GetSkipped();
+        m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
+        if ( !event.GetSkipped() )
+        {
+            // it makes sense to indicate that we processed the message as we
+            // did scroll the window (and also notice that wxAutoScrollTimer
+            // relies on our return value to stop scrolling when we are at top
+            // or bottom already)
+            processed = true;
+            wasSkipped = false;
+        }

     }
 
     if ( evType == wxEVT_ENTER_WINDOW )
     }
 
     if ( evType == wxEVT_ENTER_WINDOW )


@@ -267,26 +284,53 @@ bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
         m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event);
     }
 #if wxUSE_MOUSEWHEEL
         m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event);
     }
 #if wxUSE_MOUSEWHEEL

+    // Use GTK's own scroll wheel handling in GtkScrolledWindow
+#ifndef __WXGTK20__

     else if ( evType == wxEVT_MOUSEWHEEL )
     {
         m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);
     else if ( evType == wxEVT_MOUSEWHEEL )
     {
         m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);

+        return true;

     }
     }

+#endif

 #endif // wxUSE_MOUSEWHEEL
     else if ( evType == wxEVT_CHAR )
     {
         m_scrollHelper->HandleOnChar((wxKeyEvent &)event);
 #endif // wxUSE_MOUSEWHEEL
     else if ( evType == wxEVT_CHAR )
     {
         m_scrollHelper->HandleOnChar((wxKeyEvent &)event);

-        return !event.GetSkipped();
+        if ( !event.GetSkipped() )
+        {
+            processed = true;
+            wasSkipped = false;
+        }

     }
 
     }
 

-    return false;
+    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;

 }
 
 }
 

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

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

-// wxScrollHelper construction
+// wxScrollHelperBase construction

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

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

 {
 {

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

     m_xScrollPixelsPerLine =
     m_yScrollPixelsPerLine =
     m_xScrollPosition =
     m_xScrollPixelsPerLine =
     m_yScrollPixelsPerLine =
     m_xScrollPosition =


@@ -299,6 +343,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


@@ -306,17 +352,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_handler = NULL;
 

-    if ( win )
-        SetWindow(win);
+    m_win = win;
+
+    m_win->SetScrollHelper(static_cast<wxScrollHelper *>(this));
+
+    // by default, the associated window is also the target window
+    DoSetTargetWindow(win);

 }
 
 }
 

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

 {
     StopAutoScrolling();
 
 {
     StopAutoScrolling();
 


@@ -327,24 +377,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)
     );


@@ -364,7 +415,11 @@ void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 
     // The above should arguably be deprecated, this however we still need.
 
 
     // The above should arguably be deprecated, this however we still need.
 

-    m_targetWindow->SetVirtualSize( w, h );
+    // take care not to set 0 virtual size, 0 means that we don't have any
+    // scrollbars and hence we should use the real size instead of the virtual
+    // one which is indicated by using wxDefaultCoord
+    m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord,
+                                    h ? h : wxDefaultCoord);

 
     if (do_refresh && !noRefresh)
         m_targetWindow->Refresh(true, GetScrollRect());
 
     if (do_refresh && !noRefresh)
         m_targetWindow->Refresh(true, GetScrollRect());


@@ -390,7 +445,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 )


@@ -406,19 +461,18 @@ void wxScrollHelper::DeleteEvtHandler()
     }
 }
 
     }
 }
 

-void wxScrollHelper::SetWindow(wxWindow *win)
+void wxScrollHelperBase::ResetDrawnFlag()

 {
 {

-    wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
-
-    m_win = win;
-
-    // by default, the associated window is also the target window
-    DoSetTargetWindow(win);
+    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;
 {
     m_targetWindow = target;

+#ifdef __WXMAC__
+    target->MacSetClipChildren( true ) ;
+#endif

 
     // install the event handler which will intercept the events we're
     // interested in (but only do it for our real window, not the target window
 
     // install the event handler which will intercept the events we're
     // interested in (but only do it for our real window, not the target window


@@ -433,7 +487,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") );
 


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

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

 {
     return m_targetWindow;
 }
 {
     return m_targetWindow;
 }


@@ -452,7 +506,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 )


@@ -463,21 +517,10 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
         return;
     }
 
         return;
     }
 

-    int orient = event.GetOrientation();
-    if (orient == wxHORIZONTAL)
-    {
-        m_xScrollPosition += nScrollInc;
-        m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
-    }
-    else
-    {
-        m_yScrollPosition += nScrollInc;
-        m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
-    }
-

     bool needsRefresh = false;
     int dx = 0,
         dy = 0;
     bool needsRefresh = false;
     int dx = 0,
         dy = 0;

+    int orient = event.GetOrientation();

     if (orient == wxHORIZONTAL)
     {
        if ( m_xScrollingEnabled )
     if (orient == wxHORIZONTAL)
     {
        if ( m_xScrollingEnabled )


@@ -501,6 +544,30 @@ void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
         }
     }
 
         }
     }
 

+    if ( !needsRefresh )
+    {
+        // 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
+#ifdef __WXMAC__
+        // wxWindowMac is taking care of making sure the update area is correctly
+        // set up, while not forcing an immediate redraw
+#else
+        m_targetWindow->Update();
+#endif
+    }
+
+    if (orient == wxHORIZONTAL)
+    {
+        m_xScrollPosition += nScrollInc;
+        m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
+    }
+    else
+    {
+        m_yScrollPosition += nScrollInc;
+        m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
+    }
+

     if ( needsRefresh )
     {
         m_targetWindow->Refresh(true, GetScrollRect());
     if ( needsRefresh )
     {
         m_targetWindow->Refresh(true, GetScrollRect());


@@ -511,7 +578,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();


@@ -564,259 +631,60 @@ int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
 
     if (orient == wxHORIZONTAL)
     {
 
     if (orient == wxHORIZONTAL)
     {

-        if (m_xScrollPixelsPerLine > 0)
+        if ( m_xScrollPosition + nScrollInc < 0 )

         {
         {

-            if ( m_xScrollPosition + nScrollInc < 0 )
-            {
-                // As -ve as we can go
-                nScrollInc = -m_xScrollPosition;
-            }
-            else // check for the other bound
-            {
-                const int posMax = m_xScrollLines - m_xScrollLinesPerPage;
-                if ( m_xScrollPosition + nScrollInc > posMax )
-                {
-                    // As +ve as we can go
-                    nScrollInc = posMax - m_xScrollPosition;
-                }
-            }
+            // As -ve as we can go
+            nScrollInc = -m_xScrollPosition;

         }
         }

-        else
-            m_targetWindow->Refresh(true, GetScrollRect());
-    }
-    else
-    {
-        if ( m_yScrollPixelsPerLine > 0 )
+        else // check for the other bound

         {
         {

-            if ( m_yScrollPosition + nScrollInc < 0 )
+            const int posMax = m_xScrollLines - m_xScrollLinesPerPage;
+            if ( m_xScrollPosition + nScrollInc > posMax )

             {
             {

-                // As -ve as we can go
-                nScrollInc = -m_yScrollPosition;
+                // As +ve as we can go
+                nScrollInc = posMax - m_xScrollPosition;

             }
             }

-            else // check for the other bound
-            {
-                const int posMax = m_yScrollLines - m_yScrollLinesPerPage;
-                if ( m_yScrollPosition + nScrollInc > posMax )
-                {
-                    // As +ve as we can go
-                    nScrollInc = posMax - m_yScrollPosition;
-                }
-            }
-        }
-        else
-        {
-            // VZ: why do we do this? (FIXME)
-            m_targetWindow->Refresh(true, GetScrollRect());

         }
     }
         }
     }

-
-    return nScrollInc;
-}
-
-// Adjust the scrollbars - new version.
-void wxScrollHelper::AdjustScrollbars()
-{
-    static wxRecursionGuardFlag s_flagReentrancy;
-    wxRecursionGuard guard(s_flagReentrancy);
-    if ( guard.IsInside() )
+    else // wxVERTICAL

     {
     {

-        // 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
-    do
-    {
-        GetTargetSize(&w, 0);
-
-        // scroll lines per page: if 0, no scrolling is needed
-        int linesPerPage;
-
-        if ( m_xScrollPixelsPerLine == 0 )
+        if ( m_yScrollPosition + nScrollInc < 0 )

         {
         {

-            // scrolling is disabled
-            m_xScrollLines = 0;
-            m_xScrollPosition = 0;
-            linesPerPage = 0;
+            // As -ve as we can go
+            nScrollInc = -m_yScrollPosition;

         }
         }

-        else // might need scrolling
+        else // check for the other bound

         {
         {

-            // 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
+            const int posMax = m_yScrollLines - m_yScrollLinesPerPage;
+            if ( m_yScrollPosition + nScrollInc > posMax )

             {
             {

-                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;
+                // As +ve as we can go
+                nScrollInc = posMax - m_yScrollPosition;

             }
         }
             }
         }

-
-        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 );
-
-#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());
-    }
+    return nScrollInc;

 }
 
 }
 

-void wxScrollHelper::DoPrepareDC(wxDC& dc)
+void wxScrollHelperBase::DoPrepareDC(wxDC& dc)

 {
     wxPoint pt = dc.GetDeviceOrigin();
 {
     wxPoint pt = dc.GetDeviceOrigin();

-    dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
-                        pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
+#ifdef __WXGTK__
+    // It may actually be correct to always query
+    // 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,
+                            pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
+    else
+#endif
+        dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
+                            pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );

     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;


@@ -834,7 +702,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;


@@ -842,7 +710,16 @@ void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
         *y_unit = m_yScrollPixelsPerLine;
 }
 
         *y_unit = m_yScrollPixelsPerLine;
 }
 

-int wxScrollHelper::GetScrollPageSize(int orient) const
+
+int wxScrollHelperBase::GetScrollLines( int orient ) const
+{
+    if ( orient == wxHORIZONTAL )
+        return m_xScrollLines;
+    else
+        return m_yScrollLines;
+}
+
+int wxScrollHelperBase::GetScrollPageSize(int orient) const

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


@@ -850,7 +727,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;


@@ -858,72 +735,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, h;
-    GetTargetSize(&w, &h);
-
-    if ((x_pos != -1) && (m_xScrollPixelsPerLine))
-    {
-        int old_x = m_xScrollPosition;
-        m_xScrollPosition = x_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
-        m_xScrollPosition = wxMax( 0, m_xScrollPosition );
-
-        if (old_x != m_xScrollPosition) {
-            m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );
-            m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
-                                          GetScrollRect() );
-        }
-    }
-    if ((y_pos != -1) && (m_yScrollPixelsPerLine))
-    {
-        int old_y = m_yScrollPosition;
-        m_yScrollPosition = y_pos;
-
-        // Calculate page size i.e. number of scroll units you get on the
-        // current client window
-        int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
-        if (noPagePositions < 1) noPagePositions = 1;
-
-        // Correct position if greater than extent of canvas minus
-        // the visible portion of it or if below zero
-        m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
-        m_yScrollPosition = wxMax( 0, m_yScrollPosition );
-
-        if (old_y != m_yScrollPosition) {
-            m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition );
-            m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*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;


@@ -931,16 +750,8 @@ void wxScrollHelper::GetViewStart (int *x, int *y) const
         *y = m_yScrollPosition;
 }
 
         *y = m_yScrollPosition;
 }
 

-#if WXWIN_COMPATIBILITY_2_2
-
-void wxScrollHelper::ViewStart(int *x, int *y) const
-{
-    GetViewStart( x, y );
-}
-
-#endif // WXWIN_COMPATIBILITY_2_2
-
-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;


@@ -948,7 +759,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;


@@ -956,17 +768,59 @@ void wxScrollHelper::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) co
         *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 
         *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 

+// ----------------------------------------------------------------------------
+// geometry
+// ----------------------------------------------------------------------------
+
+bool wxScrollHelperBase::ScrollLayout()
+{
+    if ( m_win->GetSizer() && m_targetWindow == m_win )
+    {
+        // If we're the scroll target, take into account the
+        // virtual size and scrolled position of the window.
+
+        int x = 0, y = 0, w = 0, h = 0;
+        CalcScrolledPosition(0,0, &x,&y);
+        m_win->GetVirtualSize(&w, &h);
+        m_win->GetSizer()->SetDimension(x, y, w, h);
+        return true;
+    }
+
+    // fall back to default for LayoutConstraints
+    return m_win->wxWindow::Layout();
+}
+
+void wxScrollHelperBase::ScrollDoSetVirtualSize(int x, int y)
+{
+    m_win->wxWindow::DoSetVirtualSize( x, y );
+    AdjustScrollbars();
+
+    if (m_win->GetAutoLayout())
+        m_win->Layout();
+}
+
+// wxWindow's GetBestVirtualSize returns the actual window size,
+// whereas we want to return the virtual size
+wxSize wxScrollHelperBase::ScrollGetBestVirtualSize() const
+{
+    wxSize clientSize(m_win->GetClientSize());
+    if ( m_win->GetSizer() )
+        clientSize.IncTo(m_win->GetSizer()->CalcMin());
+
+    return clientSize;
+}
+

 // ----------------------------------------------------------------------------
 // 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() )
     {
         wxSize size = m_targetWindow->GetBestVirtualSize();
 {
     if ( m_targetWindow->GetAutoLayout() )
     {
         wxSize size = m_targetWindow->GetBestVirtualSize();

-        
+

         // This will call ::Layout() and ::AdjustScrollbars()
         m_win->SetVirtualSize( size );
     }
         // This will call ::Layout() and ::AdjustScrollbars()
         m_win->SetVirtualSize( size );
     }


@@ -978,7 +832,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);


@@ -991,97 +845,78 @@ 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, sty,       // view origin
-        szx, szy,       // view size (total)
-        clix, cliy;     // 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);
+
+    // 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:

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

             break;
 
         case WXK_PAGEDOWN:
             break;
 
         case WXK_PAGEDOWN:

-        case WXK_NEXT:
-            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 event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
-                               wxHORIZONTAL);
-        event.SetEventObject(m_win);
-        m_win->GetEventHandler()->ProcessEvent(event);
-    }
+    m_win->ProcessWindowEvent(newEvent);

 
 

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

     {
     {

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

     }
 }
 
     }
 }
 


@@ -1090,32 +925,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();


@@ -1156,7 +987,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;
             }


@@ -1186,7 +1017,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();


@@ -1198,7 +1029,7 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
         wxScrollWinEvent newEvent;
 
         newEvent.SetPosition(0);
         wxScrollWinEvent newEvent;
 
         newEvent.SetPosition(0);

-        newEvent.SetOrientation(wxVERTICAL);
+        newEvent.SetOrientation( event.GetWheelAxis() == 0 ? wxVERTICAL : wxHORIZONTAL);

         newEvent.SetEventObject(m_win);
 
         if (event.IsPageScroll())
         newEvent.SetEventObject(m_win);
 
         if (event.IsPageScroll())


@@ -1227,78 +1058,500 @@ void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
 
 #endif // wxUSE_MOUSEWHEEL
 
 
 #endif // wxUSE_MOUSEWHEEL
 

-// ----------------------------------------------------------------------------
-// wxGenericScrolledWindow implementation
-// ----------------------------------------------------------------------------
+void wxScrollHelperBase::HandleOnChildFocus(wxChildFocusEvent& event)
+{
+    // this event should be processed by all windows in parenthood chain,
+    // e.g. so that nested wxScrolledWindows work correctly
+    event.Skip();
+
+    // find the immediate child under which the window receiving focus is:
+    wxWindow *win = event.GetWindow();

 
 

-IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
+    if ( win == m_targetWindow )
+        return; // nothing to do

 
 

-BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
-    EVT_PAINT(wxGenericScrolledWindow::OnPaint)
-END_EVENT_TABLE()
+#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;
+    }

 
 

-bool wxGenericScrolledWindow::Create(wxWindow *parent,
-                              wxWindowID id,
-                              const wxPoint& pos,
-                              const wxSize& size,
-                              long style,
-                              const wxString& name)
+    // 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() )
+    {
+        // we can't make it fit so avoid scrolling it at all, this is only
+        // going to be confusing and not helpful
+        return;
+    }
+
+
+    // do make the window fit inside the view area by scrolling to it
+    int stepx, stepy;
+    GetScrollPixelsPerUnit(&stepx, &stepy);
+
+    int startx, starty;
+    GetViewStart(&startx, &starty);
+
+    // first in vertical direction:
+    if ( stepy > 0 )
+    {
+        int diff = 0;
+
+        if ( winRect.GetTop() < 0 )
+        {
+            diff = winRect.GetTop();
+        }
+        else if ( winRect.GetBottom() > viewRect.GetHeight() )
+        {
+            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;
+        }
+
+        starty = (starty * stepy + diff) / stepy;
+    }
+
+    // then horizontal:
+    if ( stepx > 0 )
+    {
+        int diff = 0;
+
+        if ( winRect.GetLeft() < 0 )
+        {
+            diff = winRect.GetLeft();
+        }
+        else if ( winRect.GetRight() > viewRect.GetWidth() )
+        {
+            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;
+        }
+
+        startx = (startx * stepx + diff) / stepx;
+    }
+
+    Scroll(startx, starty);
+}
+
+
+#ifdef wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrollHelper implementation
+// ----------------------------------------------------------------------------
+
+wxScrollHelper::wxScrollHelper(wxWindow *winToScroll)
+    : wxScrollHelperBase(winToScroll)

 {
 {

-    m_targetWindow = this;
+    m_xVisibility =
+    m_yVisibility = wxSHOW_SB_DEFAULT;
+}

 
 

-    bool ok = wxPanel::Create(parent, id, pos, size, style|wxHSCROLL|wxVSCROLL, name);
+void wxScrollHelper::DoShowScrollbars(wxScrollbarVisibility horz,
+                                      wxScrollbarVisibility vert)
+{
+    if ( horz != m_xVisibility || vert != m_yVisibility )
+    {
+        m_xVisibility = horz;
+        m_yVisibility = vert;

 
 

-    return ok;
+        AdjustScrollbars();
+    }

 }
 
 }
 

-wxGenericScrolledWindow::~wxGenericScrolledWindow()
+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);

 }
 
 }
 

-bool wxGenericScrolledWindow::Layout()
+void wxScrollHelper::AdjustScrollbars()

 {
 {

-    if (GetSizer() && m_targetWindow == this)
+    static wxRecursionGuardFlag s_flagReentrancy;
+    wxRecursionGuard guard(s_flagReentrancy);
+    if ( guard.IsInside() )

     {
     {

-        // If we're the scroll target, take into account the
-        // virtual size and scrolled position of the window.
+        // 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 x, y, w, h;
-        CalcScrolledPosition(0,0, &x,&y);
-        GetVirtualSize(&w, &h);
-        GetSizer()->SetDimension(x, y, w, h);
-        return true;
+    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;

     }
 
     }
 

-    // fall back to default for LayoutConstraints
-    return wxPanel::Layout();
+#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 wxGenericScrolledWindow::DoSetVirtualSize(int x, int y)
+void wxScrollHelper::DoScroll( int x_pos, int y_pos )

 {
 {

-    wxPanel::DoSetVirtualSize( x, y );
-    AdjustScrollbars();
+    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;

 
 

-    if (GetAutoLayout())
-        Layout();
+        // 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 wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
+#endif // wxHAS_GENERIC_SCROLLWIN
+
+// ----------------------------------------------------------------------------
+// wxScrolled<T> and wxScrolledWindow implementation
+// ----------------------------------------------------------------------------
+
+wxSize wxScrolledT_Helper::FilterBestSize(const wxWindow *win,
+                                          const wxScrollHelper *helper,
+                                          const wxSize& origBest)

 {
 {

-    // 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();
+    // 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).

 
 

-    event.Skip();
+    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__
 }
 
 #ifdef __WXMSW__

-WXLRESULT
-wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
-                                       WXWPARAM wParam,
-                                       WXLPARAM lParam)
+WXLRESULT wxScrolledT_Helper::FilterMSWWindowProc(WXUINT nMsg, WXLRESULT rc)

 {
 {

-    WXLRESULT rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
-

 #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 )


@@ -1306,12 +1559,10 @@ wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
         rc |= DLGC_WANTARROWS;
     }
 #endif
         rc |= DLGC_WANTARROWS;
     }
 #endif

-

     return rc;
 }
     return rc;
 }

-

 #endif // __WXMSW__
 
 #endif // __WXMSW__
 

-#endif // !wxGTK
-
-// vi:sts=4:sw=4:et
+// 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)