corrected use of Print Manager Session APIs for Carbon targets

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

diff --git a/src/generic/scrolwin.cpp b/src/generic/scrolwin.cpp
index 74b4d6bbd26ef07283ae0f4f3a2ed39348e45c08..7cd7722062a273c044c7f7da2df08bd1801b7eb2 100644 (file)
--- a/src/generic/scrolwin.cpp
+++ b/src/generic/scrolwin.cpp
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
 // Name:        generic/scrolwin.cpp
 /////////////////////////////////////////////////////////////////////////////
 // Name:        generic/scrolwin.cpp

-// Purpose:     wxScrolledWindow implementation
+// Purpose:     wxGenericScrolledWindow implementation

 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97
 // Author:      Julian Smart
 // Modified by:
 // Created:     01/02/97


@@ -21,6 +21,10 @@
     #pragma implementation "scrolwin.h"
 #endif
 
     #pragma implementation "scrolwin.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"
 


@@ -50,28 +54,34 @@
 #endif
 #endif
 
 #endif
 #endif
 

+#ifndef __WXGTK__
+#include "wx/scrolwin.h"
+IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
+#endif
+

 // ----------------------------------------------------------------------------
 // event tables
 // ----------------------------------------------------------------------------
 
 // ----------------------------------------------------------------------------
 // event tables
 // ----------------------------------------------------------------------------
 

-BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
-    EVT_SCROLLWIN(wxScrolledWindow::OnScroll)
-    EVT_SIZE(wxScrolledWindow::OnSize)
-    EVT_PAINT(wxScrolledWindow::OnPaint)
-    EVT_CHAR(wxScrolledWindow::OnChar)
+BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
+    EVT_SCROLLWIN(wxGenericScrolledWindow::OnScroll)
+    EVT_SIZE(wxGenericScrolledWindow::OnSize)
+    EVT_PAINT(wxGenericScrolledWindow::OnPaint)
+    EVT_CHAR(wxGenericScrolledWindow::OnChar)
+    EVT_MOUSEWHEEL(wxGenericScrolledWindow::OnMouseWheel)

 END_EVENT_TABLE()
 
 END_EVENT_TABLE()
 

-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
+IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)

 
 // ============================================================================
 // implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------
 
 // ============================================================================
 // implementation
 // ============================================================================
 
 // ----------------------------------------------------------------------------

-// wxScrolledWindow creation
+// wxGenericScrolledWindow creation

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

-wxScrolledWindow::wxScrolledWindow()
+wxGenericScrolledWindow::wxGenericScrolledWindow()

 {
     m_xScrollPixelsPerLine = 0;
     m_yScrollPixelsPerLine = 0;
 {
     m_xScrollPixelsPerLine = 0;
     m_yScrollPixelsPerLine = 0;


@@ -85,9 +95,11 @@ wxScrolledWindow::wxScrolledWindow()
     m_yScrollLinesPerPage = 0;
     m_scaleX = 1.0;
     m_scaleY = 1.0;
     m_yScrollLinesPerPage = 0;
     m_scaleX = 1.0;
     m_scaleY = 1.0;

+    m_wheelRotation = 0;
+    m_targetWindow = (wxWindow*) NULL;

 }
 
 }
 

-bool wxScrolledWindow::Create(wxWindow *parent,
+bool wxGenericScrolledWindow::Create(wxWindow *parent,

                               wxWindowID id,
                               const wxPoint& pos,
                               const wxSize& size,
                               wxWindowID id,
                               const wxPoint& pos,
                               const wxSize& size,


@@ -106,14 +118,21 @@ bool wxScrolledWindow::Create(wxWindow *parent,
     m_yScrollLinesPerPage = 0;
     m_scaleX = 1.0;
     m_scaleY = 1.0;
     m_yScrollLinesPerPage = 0;
     m_scaleX = 1.0;
     m_scaleY = 1.0;

+    m_wheelRotation = 0;

 
     m_targetWindow = this;
 
 
     m_targetWindow = this;
 

-    // we need wxWANTS_CHARS to process arrows ourselves
-    return wxPanel::Create(parent, id, pos, size, style | wxWANTS_CHARS, name);
+    bool ok = wxPanel::Create(parent, id, pos, size, style, name);
+
+#ifdef __WXMSW__
+    // we need to process arrows ourselves for scrolling
+    m_lDlgCode |= DLGC_WANTARROWS;
+#endif // __WXMSW__
+
+    return ok;

 }
 
 }
 

-wxScrolledWindow::~wxScrolledWindow()
+wxGenericScrolledWindow::~wxGenericScrolledWindow()

 {
 }
 
 {
 }
 


@@ -125,20 +144,24 @@ wxScrolledWindow::~wxScrolledWindow()
  * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
  * noUnitsX/noUnitsY:        : no. units per scrollbar
  */
  * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
  * noUnitsX/noUnitsY:        : no. units per scrollbar
  */

-void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
+void wxGenericScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,

                int noUnitsX, int noUnitsY,
                int xPos, int yPos, bool noRefresh )
 {
                int noUnitsX, int noUnitsY,
                int xPos, int yPos, bool noRefresh )
 {

+    int xpos, ypos;
+
+    CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);

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

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

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

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

       (xPos != m_xScrollPosition) ||
       (xPos != m_xScrollPosition) ||

-      (yPos != m_yScrollPosition) ||
-      (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
-      (pixelsPerUnitY != m_yScrollPixelsPerLine)
+      (yPos != m_yScrollPosition)
+//       (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
+//       (pixelsPerUnitY != m_yScrollPixelsPerLine)

     );
 
     m_xScrollPixelsPerLine = pixelsPerUnitX;
     );
 
     m_xScrollPixelsPerLine = pixelsPerUnitX;


@@ -205,13 +228,13 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
 // target window handling
 // ----------------------------------------------------------------------------
 
 // target window handling
 // ----------------------------------------------------------------------------
 

-void wxScrolledWindow::SetTargetWindow( wxWindow *target )
+void wxGenericScrolledWindow::SetTargetWindow( wxWindow *target )

 {
     wxASSERT_MSG( target, wxT("target window must not be NULL") );
     m_targetWindow = target;
 }
 
 {
     wxASSERT_MSG( target, wxT("target window must not be NULL") );
     m_targetWindow = target;
 }
 

-wxWindow *wxScrolledWindow::GetTargetWindow()
+wxWindow *wxGenericScrolledWindow::GetTargetWindow()

 {
     return m_targetWindow;
 }
 {
     return m_targetWindow;
 }


@@ -220,7 +243,7 @@ wxWindow *wxScrolledWindow::GetTargetWindow()
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 
 // scrolling implementation itself
 // ----------------------------------------------------------------------------
 

-void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
+void wxGenericScrolledWindow::OnScroll(wxScrollWinEvent& event)

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


@@ -266,69 +289,55 @@ void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
 #endif
 }
 
 #endif
 }
 

-int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
+int wxGenericScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)

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

-    switch (event.GetEventType())
+    if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)

     {
     {

-        case wxEVT_SCROLLWIN_TOP:
-        {

             if (orient == wxHORIZONTAL)
                 nScrollInc = - m_xScrollPosition;
             else
                 nScrollInc = - m_yScrollPosition;
             if (orient == wxHORIZONTAL)
                 nScrollInc = - m_xScrollPosition;
             else
                 nScrollInc = - m_yScrollPosition;

-            break;
-        }
-        case wxEVT_SCROLLWIN_BOTTOM:
-        {
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
+    {

             if (orient == wxHORIZONTAL)
                 nScrollInc = m_xScrollLines - m_xScrollPosition;
             else
                 nScrollInc = m_yScrollLines - m_yScrollPosition;
             if (orient == wxHORIZONTAL)
                 nScrollInc = m_xScrollLines - m_xScrollPosition;
             else
                 nScrollInc = m_yScrollLines - m_yScrollPosition;

-            break;
-        }
-        case wxEVT_SCROLLWIN_LINEUP:
-        {
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
+    {

             nScrollInc = -1;
             nScrollInc = -1;

-            break;
-        }
-        case wxEVT_SCROLLWIN_LINEDOWN:
-        {
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
+    {

             nScrollInc = 1;
             nScrollInc = 1;

-            break;
-        }
-        case wxEVT_SCROLLWIN_PAGEUP:
-        {
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
+    {

             if (orient == wxHORIZONTAL)
                 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
             else
                 nScrollInc = -GetScrollPageSize(wxVERTICAL);
             if (orient == wxHORIZONTAL)
                 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
             else
                 nScrollInc = -GetScrollPageSize(wxVERTICAL);

-            break;
-        }
-        case wxEVT_SCROLLWIN_PAGEDOWN:
-        {
+    } else
+    if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
+    {

             if (orient == wxHORIZONTAL)
                 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
             else
                 nScrollInc = GetScrollPageSize(wxVERTICAL);
             if (orient == wxHORIZONTAL)
                 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
             else
                 nScrollInc = GetScrollPageSize(wxVERTICAL);

-            break;
-        }
-        case wxEVT_SCROLLWIN_THUMBTRACK:
-        case wxEVT_SCROLLWIN_THUMBRELEASE:
-        {
+    } else
+    if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
+        (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
+    {

             if (orient == wxHORIZONTAL)
                 nScrollInc = pos - m_xScrollPosition;
             else
                 nScrollInc = pos - m_yScrollPosition;
             if (orient == wxHORIZONTAL)
                 nScrollInc = pos - m_xScrollPosition;
             else
                 nScrollInc = pos - m_yScrollPosition;

-            break;
-        }
-        default:
-        {
-            break;
-        }

     }
 
     if (orient == wxHORIZONTAL)
     }
 
     if (orient == wxHORIZONTAL)


@@ -376,7 +385,7 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
 }
 
 // Adjust the scrollbars - new version.
 }
 
 // Adjust the scrollbars - new version.

-void wxScrolledWindow::AdjustScrollbars()
+void wxGenericScrolledWindow::AdjustScrollbars()

 {
     int w, h;
     m_targetWindow->GetClientSize(&w, &h);
 {
     int w, h;
     m_targetWindow->GetClientSize(&w, &h);


@@ -445,9 +454,9 @@ void wxScrolledWindow::AdjustScrollbars()
     }
 }
 
     }
 }
 

-// Override this function if you don't want to have wxScrolledWindow
+// Override this function if you don't want to have wxGenericScrolledWindow

 // automatically change the origin according to the scroll position.
 // automatically change the origin according to the scroll position.

-void wxScrolledWindow::PrepareDC(wxDC& dc)
+void wxGenericScrolledWindow::PrepareDC(wxDC& dc)

 {
     dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
                         -m_yScrollPosition * m_yScrollPixelsPerLine );
 {
     dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
                         -m_yScrollPosition * m_yScrollPixelsPerLine );


@@ -455,13 +464,13 @@ void wxScrolledWindow::PrepareDC(wxDC& dc)
 }
 
 #if WXWIN_COMPATIBILITY
 }
 
 #if WXWIN_COMPATIBILITY

-void wxScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
+void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const

 {
       *x_page = GetScrollPageSize(wxHORIZONTAL);
       *y_page = GetScrollPageSize(wxVERTICAL);
 }
 
 {
       *x_page = GetScrollPageSize(wxHORIZONTAL);
       *y_page = GetScrollPageSize(wxVERTICAL);
 }
 

-void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
+void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const

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


@@ -470,7 +479,7 @@ void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy
 }
 #endif // WXWIN_COMPATIBILITY
 
 }
 #endif // WXWIN_COMPATIBILITY
 

-void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
+void wxGenericScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const

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


@@ -478,7 +487,7 @@ void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
         *y_unit = m_yScrollPixelsPerLine;
 }
 
         *y_unit = m_yScrollPixelsPerLine;
 }
 

-int wxScrolledWindow::GetScrollPageSize(int orient) const
+int wxGenericScrolledWindow::GetScrollPageSize(int orient) const

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


@@ -486,7 +495,7 @@ int wxScrolledWindow::GetScrollPageSize(int orient) const
         return m_yScrollLinesPerPage;
 }
 
         return m_yScrollLinesPerPage;
 }
 

-void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
+void wxGenericScrolledWindow::SetScrollPageSize(int orient, int pageSize)

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


@@ -497,15 +506,18 @@ void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
 /*
  * Scroll to given position (scroll position, not pixel position)
  */
 /*
  * Scroll to given position (scroll position, not pixel position)
  */

-void wxScrolledWindow::Scroll( int x_pos, int y_pos )
+void wxGenericScrolledWindow::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;
     m_targetWindow->GetClientSize(&w, &h);
 
     if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
         ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
 
     int w, h;
     m_targetWindow->GetClientSize(&w, &h);
 

-    if (x_pos != -1)
+    if ((x_pos != -1) && (m_xScrollPixelsPerLine))

     {
         int old_x = m_xScrollPosition;
         m_xScrollPosition = x_pos;
     {
         int old_x = m_xScrollPosition;
         m_xScrollPosition = x_pos;


@@ -520,12 +532,12 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 
         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 

-        if (old_x == m_xScrollPosition) return;
-
-        m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
-        m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
+        if (old_x != m_xScrollPosition) {
+            m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
+            m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
+        }

     }
     }

-    if (y_pos != -1)
+    if ((y_pos != -1) && (m_yScrollPixelsPerLine))

     {
         int old_y = m_yScrollPosition;
         m_yScrollPosition = y_pos;
     {
         int old_y = m_yScrollPosition;
         m_yScrollPosition = y_pos;


@@ -539,11 +551,11 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
         // the visible portion of it or if below zero
         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
         // 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) return;

 
 

-        m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
-        m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
+        if (old_y != m_yScrollPosition) {
+            m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
+            m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
+        }

     }
 
 #ifdef __WXMAC__
     }
 
 #ifdef __WXMAC__


@@ -551,13 +563,13 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos )
 #endif
 }
 
 #endif
 }
 

-void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
+void wxGenericScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)

 {
     m_xScrollingEnabled = x_scroll;
     m_yScrollingEnabled = y_scroll;
 }
 
 {
     m_xScrollingEnabled = x_scroll;
     m_yScrollingEnabled = y_scroll;
 }
 

-void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
+void wxGenericScrolledWindow::GetVirtualSize (int *x, int *y) const

 {
     if ( x )
         *x = m_xScrollPixelsPerLine * m_xScrollLines;
 {
     if ( x )
         *x = m_xScrollPixelsPerLine * m_xScrollLines;


@@ -566,7 +578,7 @@ void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
 }
 
 // Where the current view starts from
 }
 
 // Where the current view starts from

-void wxScrolledWindow::GetViewStart (int *x, int *y) const
+void wxGenericScrolledWindow::GetViewStart (int *x, int *y) const

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


@@ -574,7 +586,7 @@ void wxScrolledWindow::GetViewStart (int *x, int *y) const
         *y = m_yScrollPosition;
 }
 
         *y = m_yScrollPosition;
 }
 

-void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
+void wxGenericScrolledWindow::CalcScrolledPosition(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;


@@ -582,7 +594,7 @@ void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) cons
         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 
         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 }
 

-void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
+void wxGenericScrolledWindow::CalcUnscrolledPosition(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;


@@ -595,7 +607,7 @@ void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) co
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any
 // ----------------------------------------------------------------------------
 
 // Default OnSize resets scrollbars, if any

-void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
+void wxGenericScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))

 {
 #if wxUSE_CONSTRAINTS
     if (GetAutoLayout())
 {
 #if wxUSE_CONSTRAINTS
     if (GetAutoLayout())


@@ -607,7 +619,7 @@ void wxScrolledWindow::OnSize(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 wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
+void wxGenericScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))

 {
     wxPaintDC dc(this);
     PrepareDC(dc);
 {
     wxPaintDC dc(this);
     PrepareDC(dc);


@@ -619,7 +631,7 @@ void wxScrolledWindow::OnPaint(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 wxScrolledWindow::OnChar(wxKeyEvent& event)
+void wxGenericScrolledWindow::OnChar(wxKeyEvent& event)

 {
     int stx, sty,       // view origin
         szx, szy,       // view size (total)
 {
     int stx, sty,       // view origin
         szx, szy,       // view size (total)


@@ -632,12 +644,12 @@ void wxScrolledWindow::OnChar(wxKeyEvent& event)
     if( m_xScrollPixelsPerLine )
     {
         clix /= m_xScrollPixelsPerLine;
     if( m_xScrollPixelsPerLine )
     {
         clix /= m_xScrollPixelsPerLine;

-       szx /= m_xScrollPixelsPerLine;
+        szx /= m_xScrollPixelsPerLine;

     }
     else
     {
         clix = 0;
     }
     else
     {
         clix = 0;

-       szx = -1;
+        szx = -1;

     }
     if( m_yScrollPixelsPerLine )
     {
     }
     if( m_yScrollPixelsPerLine )
     {


@@ -647,14 +659,16 @@ void wxScrolledWindow::OnChar(wxKeyEvent& event)
     else
     {
         cliy = 0;
     else
     {
         cliy = 0;

-       szy = -1;
+        szy = -1;

     }
 
     }
 

+    int dsty;

     switch ( event.KeyCode() )
     {
         case WXK_PAGEUP:
         case WXK_PRIOR:
     switch ( event.KeyCode() )
     {
         case WXK_PAGEUP:
         case WXK_PRIOR:

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

             break;
 
         case WXK_PAGEDOWN:
             break;
 
         case WXK_PAGEDOWN:


@@ -691,3 +705,24 @@ void wxScrolledWindow::OnChar(wxKeyEvent& event)
             event.Skip();
     }
 }
             event.Skip();
     }
 }

+
+
+void wxGenericScrolledWindow::OnMouseWheel(wxMouseEvent& event)
+{
+    int lines;
+    int vsx, vsy;
+
+    m_wheelRotation += event.GetWheelRotation();
+    lines = m_wheelRotation / event.GetWheelDelta();
+    m_wheelRotation -= lines * event.GetWheelDelta();
+
+    if (lines != 0) {
+        lines *= event.GetLinesPerAction();
+        GetViewStart(&vsx, &vsy);
+        Scroll(-1, vsy - lines);
+    }
+}
+
+
+
+