/////////////////////////////////////////////////////////////////////////////
// Name: generic/scrolwin.cpp
-// Purpose: wxScrolledWindow implementation
+// Purpose: wxGenericScrolledWindow implementation
// Author: Julian Smart
// Modified by:
// Created: 01/02/97
#pragma implementation "scrolwin.h"
#endif
+#ifdef __VMS
+#define XtDisplay XTDISPLAY
+#endif
+
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#endif
#endif
+#ifndef __WXGTK__
+#include "wx/scrolwin.h"
+IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
+#endif
+
// ----------------------------------------------------------------------------
// event tables
// ----------------------------------------------------------------------------
-BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
- EVT_SCROLLWIN(wxScrolledWindow::OnScroll)
- EVT_SIZE(wxScrolledWindow::OnSize)
- EVT_PAINT(wxScrolledWindow::OnPaint)
- EVT_KEY_DOWN(wxScrolledWindow::OnKeyDown)
+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()
-IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
+IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
-// wxScrolledWindow creation
+// wxGenericScrolledWindow creation
// ----------------------------------------------------------------------------
-wxScrolledWindow::wxScrolledWindow()
+wxGenericScrolledWindow::wxGenericScrolledWindow()
{
m_xScrollPixelsPerLine = 0;
m_yScrollPixelsPerLine = 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,
m_yScrollLinesPerPage = 0;
m_scaleX = 1.0;
m_scaleY = 1.0;
+ m_wheelRotation = 0;
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()
{
}
* 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 xpos, ypos;
+
+ CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);
bool do_refresh =
(
(noUnitsX != 0 && m_xScrollLines == 0) ||
- (noUnitsX < m_xScrollLines) ||
+ (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX*noUnitsX) ||
+
(noUnitsY != 0 && m_yScrollLines == 0) ||
- (noUnitsY < m_yScrollLines) ||
+ (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||
(xPos != m_xScrollPosition) ||
- (yPos != m_yScrollPosition) ||
- (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
- (pixelsPerUnitY != m_yScrollPixelsPerLine)
+ (yPos != m_yScrollPosition)
+// (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
+// (pixelsPerUnitY != m_yScrollPixelsPerLine)
);
m_xScrollPixelsPerLine = pixelsPerUnitX;
// 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;
}
-wxWindow *wxScrolledWindow::GetTargetWindow()
+wxWindow *wxGenericScrolledWindow::GetTargetWindow()
{
return m_targetWindow;
}
// scrolling implementation itself
// ----------------------------------------------------------------------------
-void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
+void wxGenericScrolledWindow::OnScroll(wxScrollWinEvent& event)
{
int orient = event.GetOrientation();
m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
else
m_targetWindow->Refresh();
- }
+ }
#ifdef __WXMAC__
m_targetWindow->MacUpdateImmediately() ;
#endif
}
-int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
+int wxGenericScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
{
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;
- 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;
- break;
- }
- case wxEVT_SCROLLWIN_LINEUP:
- {
+ } else
+ if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
+ {
nScrollInc = -1;
- break;
- }
- case wxEVT_SCROLLWIN_LINEDOWN:
- {
+ } else
+ if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
+ {
nScrollInc = 1;
- break;
- }
- case wxEVT_SCROLLWIN_PAGEUP:
- {
+ } else
+ if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
+ {
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);
- break;
- }
- case wxEVT_SCROLLWIN_THUMBTRACK:
- {
+ } else
+ if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
+ (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
+ {
if (orient == wxHORIZONTAL)
nScrollInc = pos - m_xScrollPosition;
else
nScrollInc = pos - m_yScrollPosition;
- break;
- }
- default:
- {
- break;
- }
}
if (orient == wxHORIZONTAL)
}
// Adjust the scrollbars - new version.
-void wxScrolledWindow::AdjustScrollbars()
+void wxGenericScrolledWindow::AdjustScrollbars()
{
int w, h;
m_targetWindow->GetClientSize(&w, &h);
if (m_xScrollLines > 0)
{
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
+ // 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);
+ // the visible portion of it or if below zero
+ m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
m_xScrollPosition = wxMax( 0, m_xScrollPosition );
SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
if (m_yScrollLines > 0)
{
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
+ // 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
+ // the visible portion of it or if below zero
m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
m_yScrollPosition = wxMax( 0, m_yScrollPosition );
}
}
-// 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.
-void wxScrolledWindow::PrepareDC(wxDC& dc)
+void wxGenericScrolledWindow::PrepareDC(wxDC& dc)
{
dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
-m_yScrollPosition * m_yScrollPixelsPerLine );
}
#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);
}
-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);
}
#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;
*y_unit = m_yScrollPixelsPerLine;
}
-int wxScrolledWindow::GetScrollPageSize(int orient) const
+int wxGenericScrolledWindow::GetScrollPageSize(int orient) const
{
if ( orient == wxHORIZONTAL )
return m_xScrollLinesPerPage;
return m_yScrollLinesPerPage;
}
-void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
+void wxGenericScrolledWindow::SetScrollPageSize(int orient, int pageSize)
{
if ( orient == wxHORIZONTAL )
m_xScrollLinesPerPage = pageSize;
/*
* 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)
+ 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
+ // 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
+ // the visible portion of it or if below zero
m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
m_xScrollPosition = wxMax( 0, m_xScrollPosition );
- m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
-
+ 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;
- // Calculate page size i.e. number of scroll units you get on the
- // current client window
+ // 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
+ // the visible portion of it or if below zero
m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
m_yScrollPosition = wxMax( 0, 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 );
+ }
}
-
#ifdef __WXMAC__
- m_targetWindow->MacUpdateImmediately() ;
+ m_targetWindow->MacUpdateImmediately();
#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;
}
-void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
+void wxGenericScrolledWindow::GetVirtualSize (int *x, int *y) const
{
if ( x )
*x = m_xScrollPixelsPerLine * m_xScrollLines;
}
// 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;
*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;
*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;
// ----------------------------------------------------------------------------
// Default OnSize resets scrollbars, if any
-void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
+void wxGenericScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
{
#if wxUSE_CONSTRAINTS
if (GetAutoLayout())
// 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);
OnDraw(dc);
}
-// kbd handling
-void wxScrolledWindow::OnKeyDown(wxKeyEvent& event)
+// kbd handling: notice that we use OnChar() and not OnKeyDown() for
+// 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 wxGenericScrolledWindow::OnChar(wxKeyEvent& event)
{
int stx, sty, // view origin
szx, szy, // view size (total)
ViewStart(&stx, &sty);
GetClientSize(&clix, &cliy);
- clix /= m_xScrollPixelsPerLine;
- cliy /= m_yScrollPixelsPerLine;
GetVirtualSize(&szx, &szy);
- szx /= m_xScrollPixelsPerLine;
- szy /= m_yScrollPixelsPerLine;
+ if( m_xScrollPixelsPerLine )
+ {
+ clix /= m_xScrollPixelsPerLine;
+ szx /= m_xScrollPixelsPerLine;
+ }
+ else
+ {
+ clix = 0;
+ szx = -1;
+ }
+ if( m_yScrollPixelsPerLine )
+ {
+ cliy /= m_yScrollPixelsPerLine;
+ szy /= m_yScrollPixelsPerLine;
+ }
+ else
+ {
+ cliy = 0;
+ szy = -1;
+ }
+
+ int dsty;
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:
Scroll(-1, sty + (5 * cliy / 6));
break;
- // notice that handling of Ctrl-Home/End is asymmetrical: Home goes to
- // the beginning of the current line, Ctrl-Home returns to the origin
- // while End goes to the bottom without changing horizontal position
- // and only Ctrl-End does go to the most rightmost position as well
case WXK_HOME:
Scroll(0, event.ControlDown() ? 0 : -1);
break;
case WXK_END:
- Scroll(event.ControlDown() ? szx - clix : -1, szy - cliy);
+ Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
break;
case WXK_UP:
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);
+ }
+}
+
+
+
+
projects / wxWidgets.git / blobdiff