Removed TABs that had gotten in to the source

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

diff --git a/src/generic/scrolwin.cpp b/src/generic/scrolwin.cpp
index f561950be3d145be8780fccf12a704a71b2c597f..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


@@ -54,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;


@@ -89,10 +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;
 }
 
     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,


@@ -111,6 +118,7 @@ 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;
 


@@ -124,7 +132,7 @@ bool wxScrolledWindow::Create(wxWindow *parent,
     return ok;
 }
 
     return ok;
 }
 

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

 {
 }
 
 {
 }
 


@@ -136,7 +144,7 @@ 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 )
 {


@@ -146,7 +154,7 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
     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 && xpos > pixelsPerUnitX*noUnitsX) ||

 
       (noUnitsY != 0 && m_yScrollLines == 0) ||
       (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||
 
       (noUnitsY != 0 && m_yScrollLines == 0) ||
       (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||


@@ -220,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;
 }


@@ -235,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();
 


@@ -281,7 +289,7 @@ 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 pos = event.GetPosition();
     int orient = event.GetOrientation();


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


@@ -446,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 );


@@ -456,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);


@@ -471,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;


@@ -479,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;


@@ -487,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;


@@ -498,7 +506,7 @@ 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 (!m_targetWindow)
         return;


@@ -543,7 +551,7 @@ 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) {
             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 );


@@ -555,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;


@@ -570,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;


@@ -578,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;


@@ -586,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;


@@ -599,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())


@@ -611,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);


@@ -623,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)


@@ -697,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);
+    }
+}
+
+
+
+