X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/4dcfef961d0a83c58951d50471108da4c1262cb3..4b7b750dd1ffd0d26b78728adb613b282a37c058:/src/generic/scrolwin.cpp diff --git a/src/generic/scrolwin.cpp b/src/generic/scrolwin.cpp index e217fe5adb..991029613d 100644 --- a/src/generic/scrolwin.cpp +++ b/src/generic/scrolwin.cpp @@ -1,11 +1,11 @@ ///////////////////////////////////////////////////////////////////////////// // Name: generic/scrolwin.cpp -// Purpose: wxScrolledWindow implementation +// Purpose: wxGenericScrolledWindow implementation // Author: Julian Smart -// Modified by: +// Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement // Created: 01/02/97 // RCS-ID: $Id$ -// Copyright: (c) Julian Smart and Markus Holzem +// Copyright: (c) wxWindows team // Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// @@ -21,6 +21,10 @@ #pragma implementation "scrolwin.h" #endif +#ifdef __VMS +#define XtDisplay XTDISPLAY +#endif + // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" @@ -31,11 +35,12 @@ #include "wx/utils.h" #include "wx/dcclient.h" -#include "wx/generic/scrolwin.h" +#include "wx/scrolwin.h" #include "wx/panel.h" +#include "wx/timer.h" #ifdef __WXMSW__ - #include "windows.h" + #include // for DLGC_WANTARROWS #endif #ifdef __WXMOTIF__ @@ -50,85 +55,234 @@ #endif #endif +#ifndef __WXGTK__ +IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow) +#endif + // ---------------------------------------------------------------------------- -// event tables +// wxScrollHelperEvtHandler: intercept the events from the window and forward +// them to wxScrollHelper // ---------------------------------------------------------------------------- -BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) - EVT_SCROLLWIN(wxScrolledWindow::OnScroll) - EVT_SIZE(wxScrolledWindow::OnSize) - EVT_PAINT(wxScrolledWindow::OnPaint) - EVT_CHAR(wxScrolledWindow::OnChar) -END_EVENT_TABLE() +class wxScrollHelperEvtHandler : public wxEvtHandler +{ +public: + wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper) + { + m_scrollHelper = scrollHelper; + } + + virtual bool ProcessEvent(wxEvent& event); + +private: + wxScrollHelper *m_scrollHelper; +}; + +// ---------------------------------------------------------------------------- +// wxAutoScrollTimer: the timer used to generate a stream of scroll events when +// a captured mouse is held outside the window +// ---------------------------------------------------------------------------- + +class wxAutoScrollTimer : public wxTimer +{ +public: + wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll, + wxEventType eventTypeToSend, + int pos, int orient); + + virtual void Notify(); -IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel) +private: + wxWindow *m_win; + wxScrollHelper *m_scrollHelper; + wxEventType m_eventType; + int m_pos, + m_orient; +}; // ============================================================================ // implementation // ============================================================================ // ---------------------------------------------------------------------------- -// wxScrolledWindow creation +// wxAutoScrollTimer // ---------------------------------------------------------------------------- -wxScrolledWindow::wxScrolledWindow() +wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll, + wxScrollHelper *scroll, + wxEventType eventTypeToSend, + int pos, int orient) { - m_xScrollPixelsPerLine = 0; - m_yScrollPixelsPerLine = 0; - m_xScrollingEnabled = TRUE; - m_yScrollingEnabled = TRUE; - m_xScrollPosition = 0; - m_yScrollPosition = 0; - m_xScrollLines = 0; - m_yScrollLines = 0; - m_xScrollLinesPerPage = 0; - m_yScrollLinesPerPage = 0; - m_scaleX = 1.0; - m_scaleY = 1.0; - m_targetWindow = (wxWindow*) NULL; + m_win = winToScroll; + m_scrollHelper = scroll; + m_eventType = eventTypeToSend; + m_pos = pos; + m_orient = orient; } -bool wxScrolledWindow::Create(wxWindow *parent, - wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) +void wxAutoScrollTimer::Notify() { - m_xScrollPixelsPerLine = 0; - m_yScrollPixelsPerLine = 0; - m_xScrollingEnabled = TRUE; - m_yScrollingEnabled = TRUE; - m_xScrollPosition = 0; - m_yScrollPosition = 0; - m_xScrollLines = 0; - m_yScrollLines = 0; - m_xScrollLinesPerPage = 0; + // only do all this as long as the window is capturing the mouse + if ( wxWindow::GetCapture() != m_win ) + { + Stop(); + } + else // we still capture the mouse, continue generating events + { + // first scroll the window if we are allowed to do it + wxScrollWinEvent event1(m_eventType, m_pos, m_orient); + event1.SetEventObject(m_win); + if ( m_scrollHelper->SendAutoScrollEvents(event1) && + m_win->GetEventHandler()->ProcessEvent(event1) ) + { + // and then send a pseudo mouse-move event to refresh the selection + wxMouseEvent event2(wxEVT_MOTION); + wxGetMousePosition(&event2.m_x, &event2.m_y); + + // the mouse event coordinates should be client, not screen as + // returned by wxGetMousePosition + wxWindow *parentTop = m_win; + while ( parentTop->GetParent() ) + parentTop = parentTop->GetParent(); + wxPoint ptOrig = parentTop->GetPosition(); + event2.m_x -= ptOrig.x; + event2.m_y -= ptOrig.y; + + event2.SetEventObject(m_win); + + // FIXME: we don't fill in the other members - ok? + + m_win->GetEventHandler()->ProcessEvent(event2); + } + else // can't scroll further, stop + { + Stop(); + } + } +} + +// ---------------------------------------------------------------------------- +// wxScrollHelperEvtHandler +// ---------------------------------------------------------------------------- + +bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event) +{ + if ( wxEvtHandler::ProcessEvent(event) ) + return TRUE; + + // reset the skipped flag to FALSE as it might have been set to TRUE in + // ProcessEvent() above + event.Skip(FALSE); + + wxEventType evType = event.GetEventType(); + + if ( evType == wxEVT_PAINT ) + { + m_scrollHelper->HandleOnPaint((wxPaintEvent &)event); + return TRUE; + } + + if ( evType == wxEVT_SCROLLWIN_TOP || + evType == wxEVT_SCROLLWIN_BOTTOM || + evType == wxEVT_SCROLLWIN_LINEUP || + evType == wxEVT_SCROLLWIN_LINEDOWN || + evType == wxEVT_SCROLLWIN_PAGEUP || + evType == wxEVT_SCROLLWIN_PAGEDOWN || + evType == wxEVT_SCROLLWIN_THUMBTRACK || + evType == wxEVT_SCROLLWIN_THUMBRELEASE ) + { + m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event); + return !event.GetSkipped(); + } + + if ( evType == wxEVT_ENTER_WINDOW ) + { + m_scrollHelper->HandleOnMouseEnter((wxMouseEvent &)event); + } + else if ( evType == wxEVT_LEAVE_WINDOW ) + { + m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event); + } +#if wxUSE_MOUSEWHEEL + else if ( evType == wxEVT_MOUSEWHEEL ) + { + m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event); + } +#endif // wxUSE_MOUSEWHEEL + else if ( evType == wxEVT_SIZE ) + { + m_scrollHelper->HandleOnSize((wxSizeEvent &)event); + } + else if ( evType == wxEVT_CHAR ) + { + m_scrollHelper->HandleOnChar((wxKeyEvent &)event); + return !event.GetSkipped(); + } + + return FALSE; +} + +// ---------------------------------------------------------------------------- +// wxScrollHelper construction +// ---------------------------------------------------------------------------- + +wxScrollHelper::wxScrollHelper(wxWindow *win) +{ + m_xScrollPixelsPerLine = + m_yScrollPixelsPerLine = + m_xScrollPosition = + m_yScrollPosition = + m_xScrollLines = + m_yScrollLines = + m_xScrollLinesPerPage = m_yScrollLinesPerPage = 0; - m_scaleX = 1.0; + + m_xScrollingEnabled = + m_yScrollingEnabled = TRUE; + + m_scaleX = m_scaleY = 1.0; + m_wheelRotation = 0; - m_targetWindow = this; + m_win = + m_targetWindow = (wxWindow *)NULL; + + m_timerAutoScroll = (wxTimer *)NULL; + + if ( win ) + SetWindow(win); +} - // we need wxWANTS_CHARS to process arrows ourselves - return wxPanel::Create(parent, id, pos, size, style | wxWANTS_CHARS, name); +void wxScrollHelper::SetWindow(wxWindow *win) +{ + wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") ); + + m_targetWindow = m_win = win; + + // install the event handler which will intercept the events we're + // interested in + m_win->PushEventHandler(new wxScrollHelperEvtHandler(this)); } -wxScrolledWindow::~wxScrolledWindow() +wxScrollHelper::~wxScrollHelper() { + StopAutoScrolling(); + + if ( m_targetWindow ) + m_targetWindow->PopEventHandler(TRUE /* do delete it */); } // ---------------------------------------------------------------------------- // setting scrolling parameters // ---------------------------------------------------------------------------- -/* - * 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, - int noUnitsX, int noUnitsY, - int xPos, int yPos, bool noRefresh ) +void wxScrollHelper::SetScrollbars(int pixelsPerUnitX, + int pixelsPerUnitY, + int noUnitsX, + int noUnitsY, + int xPos, + int yPos, + bool noRefresh) { int xpos, ypos; @@ -136,14 +290,12 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY, 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) || (xPos != m_xScrollPosition) || (yPos != m_yScrollPosition) -// (pixelsPerUnitX != m_xScrollPixelsPerLine) || -// (pixelsPerUnitY != m_yScrollPixelsPerLine) ); m_xScrollPixelsPerLine = pixelsPerUnitX; @@ -159,21 +311,21 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY, // be entirely generic because it relies on the wxWindowDC implementation // to duplicate X drawing calls for the backing pixmap. - if ((m_windowStyle & wxRETAINED) == wxRETAINED) + if ( m_targetWindow->GetWindowStyle() & wxRETAINED ) { - Display* dpy = XtDisplay((Widget) GetMainWidget()); + Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget()); int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine; int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine; - if (m_backingPixmap && - !((m_pixmapWidth == totalPixelWidth) && - (m_pixmapHeight == totalPixelHeight))) + if (m_targetWindow->m_backingPixmap && + !((m_targetWindow->m_pixmapWidth == totalPixelWidth) && + (m_targetWindow->m_pixmapHeight == totalPixelHeight))) { - XFreePixmap (dpy, (Pixmap) m_backingPixmap); - m_backingPixmap = (WXPixmap) 0; + XFreePixmap (dpy, (Pixmap) m_targetWindow->m_backingPixmap); + m_targetWindow->m_backingPixmap = (WXPixmap) 0; } - if (!m_backingPixmap && + if (!m_targetWindow->m_backingPixmap && (noUnitsX != 0) && (noUnitsY != 0)) { int depth = wxDisplayDepth(); @@ -189,18 +341,8 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY, AdjustScrollbars(); if (do_refresh && !noRefresh) - m_targetWindow->Refresh(); + m_targetWindow->Refresh(TRUE, GetRect()); -#ifdef __WXMSW__ - // GRG: if this turns out to be really necessary, we could - // at least move it to the above if { ... } so that it is - // only done if noRefresh = FALSE (the default). OTOH, if - // this doesn't break anything, which seems to be the - // case, we could just leave it out. - - // Necessary? - // UpdateWindow ((HWND) m_targetWindow->GetHWND()); -#endif #ifdef __WXMAC__ m_targetWindow->MacUpdateImmediately() ; #endif @@ -210,13 +352,13 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY, // target window handling // ---------------------------------------------------------------------------- -void wxScrolledWindow::SetTargetWindow( wxWindow *target ) +void wxScrollHelper::SetTargetWindow( wxWindow *target ) { wxASSERT_MSG( target, wxT("target window must not be NULL") ); m_targetWindow = target; } -wxWindow *wxScrolledWindow::GetTargetWindow() +wxWindow *wxScrollHelper::GetTargetWindow() const { return m_targetWindow; } @@ -225,115 +367,118 @@ wxWindow *wxScrolledWindow::GetTargetWindow() // scrolling implementation itself // ---------------------------------------------------------------------------- -void wxScrolledWindow::OnScroll(wxScrollWinEvent& event) +void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event) { - int orient = event.GetOrientation(); - int nScrollInc = CalcScrollInc(event); - if (nScrollInc == 0) return; - - if (orient == wxHORIZONTAL) - { - int newPos = m_xScrollPosition + nScrollInc; - SetScrollPos(wxHORIZONTAL, newPos, TRUE ); - } - else + if ( nScrollInc == 0 ) { - int newPos = m_yScrollPosition + nScrollInc; - SetScrollPos(wxVERTICAL, newPos, TRUE ); + // can't scroll further + event.Skip(); + + return; } + int orient = event.GetOrientation(); if (orient == wxHORIZONTAL) { m_xScrollPosition += nScrollInc; + m_targetWindow->SetScrollPos(wxHORIZONTAL, m_xScrollPosition, FALSE); } else { m_yScrollPosition += nScrollInc; + m_targetWindow->SetScrollPos(wxVERTICAL, m_yScrollPosition, FALSE); } + bool needsRefresh = FALSE; + int dx = 0, + dy = 0; if (orient == wxHORIZONTAL) { - if (m_xScrollingEnabled) - m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL); + if ( m_xScrollingEnabled ) + { + dx = -m_xScrollPixelsPerLine * nScrollInc; + } else - m_targetWindow->Refresh(); + { + needsRefresh = TRUE; + } } else { - if (m_yScrollingEnabled) - m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL); + if ( m_yScrollingEnabled ) + { + dy = -m_yScrollPixelsPerLine * nScrollInc; + } else - m_targetWindow->Refresh(); + { + needsRefresh = TRUE; + } + } + + if ( needsRefresh ) + { + m_targetWindow->Refresh(TRUE, GetRect()); + } + else + { + m_targetWindow->ScrollWindow(dx, dy, GetRect()); } + #ifdef __WXMAC__ m_targetWindow->MacUpdateImmediately() ; #endif } -int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event) +int wxScrollHelper::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: - 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; - break; - } - default: - { - break; - } } if (orient == wxHORIZONTAL) @@ -341,7 +486,7 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event) if (m_xScrollPixelsPerLine > 0) { int w, h; - m_targetWindow->GetClientSize(&w, &h); + GetTargetSize(&w, &h); int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine; int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 ); @@ -354,14 +499,14 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event) nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go } else - m_targetWindow->Refresh(); + m_targetWindow->Refresh(TRUE, GetRect()); } else { if (m_yScrollPixelsPerLine > 0) { int w, h; - m_targetWindow->GetClientSize(&w, &h); + GetTargetSize(&w, &h); int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine; int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 ); @@ -374,17 +519,21 @@ int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event) nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go } else - m_targetWindow->Refresh(); + m_targetWindow->Refresh(TRUE, GetRect()); } return nScrollInc; } // Adjust the scrollbars - new version. -void wxScrolledWindow::AdjustScrollbars() +void wxScrollHelper::AdjustScrollbars() { +#ifdef __WXMAC__ + m_targetWindow->MacUpdateImmediately(); +#endif + int w, h; - m_targetWindow->GetClientSize(&w, &h); + GetTargetSize(&w, &h); int oldXScroll = m_xScrollPosition; int oldYScroll = m_yScrollPosition; @@ -395,20 +544,22 @@ void wxScrolledWindow::AdjustScrollbars() // current client window int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 ); if (noPagePositions < 1) noPagePositions = 1; + if ( noPagePositions > m_xScrollLines ) + noPagePositions = m_xScrollLines; // 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 ); - SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines); + m_targetWindow->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines); // The amount by which we scroll when paging SetScrollPageSize(wxHORIZONTAL, noPagePositions); } else { m_xScrollPosition = 0; - SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); + m_targetWindow->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); } if (m_yScrollLines > 0) @@ -417,65 +568,56 @@ void wxScrolledWindow::AdjustScrollbars() // current client window int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 ); if (noPagePositions < 1) noPagePositions = 1; + if ( noPagePositions > m_yScrollLines ) + noPagePositions = m_yScrollLines; // 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 ); - SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines); + m_targetWindow->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines); // The amount by which we scroll when paging SetScrollPageSize(wxVERTICAL, noPagePositions); } else { m_yScrollPosition = 0; - SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); + m_targetWindow->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); } if (oldXScroll != m_xScrollPosition) { if (m_xScrollingEnabled) - m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, (const wxRect *) NULL ); + m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, + GetRect() ); else - m_targetWindow->Refresh(); + m_targetWindow->Refresh(TRUE, GetRect()); } if (oldYScroll != m_yScrollPosition) { if (m_yScrollingEnabled) - m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), (const wxRect *) NULL ); + m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), + GetRect() ); else - m_targetWindow->Refresh(); + m_targetWindow->Refresh(TRUE, GetRect()); } -} -// Override this function if you don't want to have wxScrolledWindow -// automatically change the origin according to the scroll position. -void wxScrolledWindow::PrepareDC(wxDC& dc) -{ - dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine, - -m_yScrollPosition * m_yScrollPixelsPerLine ); - dc.SetUserScale( m_scaleX, m_scaleY ); -} - -#if WXWIN_COMPATIBILITY -void wxScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const -{ - *x_page = GetScrollPageSize(wxHORIZONTAL); - *y_page = GetScrollPageSize(wxVERTICAL); +#ifdef __WXMAC__ + m_targetWindow->MacUpdateImmediately(); +#endif } -void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const +void wxScrollHelper::DoPrepareDC(wxDC& dc) { - if ( xx ) - *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); - if ( yy ) - *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); + wxPoint pt = dc.GetDeviceOrigin(); + dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine, + pt.y - m_yScrollPosition * m_yScrollPixelsPerLine ); + dc.SetUserScale( m_scaleX, m_scaleY ); } -#endif // WXWIN_COMPATIBILITY -void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const +void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const { if ( x_unit ) *x_unit = m_xScrollPixelsPerLine; @@ -483,7 +625,7 @@ void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const *y_unit = m_yScrollPixelsPerLine; } -int wxScrolledWindow::GetScrollPageSize(int orient) const +int wxScrollHelper::GetScrollPageSize(int orient) const { if ( orient == wxHORIZONTAL ) return m_xScrollLinesPerPage; @@ -491,7 +633,7 @@ int wxScrolledWindow::GetScrollPageSize(int orient) const return m_yScrollLinesPerPage; } -void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize) +void wxScrollHelper::SetScrollPageSize(int orient, int pageSize) { if ( orient == wxHORIZONTAL ) m_xScrollLinesPerPage = pageSize; @@ -502,7 +644,7 @@ void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize) /* * Scroll to given position (scroll position, not pixel position) */ -void wxScrolledWindow::Scroll( int x_pos, int y_pos ) +void wxScrollHelper::Scroll( int x_pos, int y_pos ) { if (!m_targetWindow) return; @@ -510,10 +652,14 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos ) if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; +#ifdef __WXMAC__ + m_targetWindow->MacUpdateImmediately(); +#endif + int w, h; - m_targetWindow->GetClientSize(&w, &h); + GetTargetSize(&w, &h); - if (x_pos != -1) + if ((x_pos != -1) && (m_xScrollPixelsPerLine)) { int old_x = m_xScrollPosition; m_xScrollPosition = x_pos; @@ -528,12 +674,13 @@ void wxScrolledWindow::Scroll( int x_pos, int y_pos ) 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, FALSE ); + m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0, + GetRect() ); + } } - if (y_pos != -1) + if ((y_pos != -1) && (m_yScrollPixelsPerLine)) { int old_y = m_yScrollPosition; m_yScrollPosition = y_pos; @@ -547,25 +694,27 @@ 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 ); - - 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, FALSE ); + m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine, + GetRect() ); + } } #ifdef __WXMAC__ m_targetWindow->MacUpdateImmediately(); #endif + } -void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll) +void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll) { m_xScrollingEnabled = x_scroll; m_yScrollingEnabled = y_scroll; } -void wxScrolledWindow::GetVirtualSize (int *x, int *y) const +void wxScrollHelper::GetVirtualSize (int *x, int *y) const { if ( x ) *x = m_xScrollPixelsPerLine * m_xScrollLines; @@ -574,7 +723,7 @@ void wxScrolledWindow::GetVirtualSize (int *x, int *y) const } // Where the current view starts from -void wxScrolledWindow::GetViewStart (int *x, int *y) const +void wxScrollHelper::GetViewStart (int *x, int *y) const { if ( x ) *x = m_xScrollPosition; @@ -582,7 +731,7 @@ void wxScrolledWindow::GetViewStart (int *x, int *y) const *y = m_yScrollPosition; } -void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const +void wxScrollHelper::CalcScrolledPosition(int x, int y, int *xx, int *yy) const { if ( xx ) *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine; @@ -590,7 +739,7 @@ void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) cons *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine; } -void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const +void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const { if ( xx ) *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine; @@ -603,11 +752,11 @@ void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) co // ---------------------------------------------------------------------------- // Default OnSize resets scrollbars, if any -void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event)) +void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event)) { #if wxUSE_CONSTRAINTS - if (GetAutoLayout()) - Layout(); + if ( m_targetWindow->GetAutoLayout() ) + m_targetWindow->Layout(); #endif AdjustScrollbars(); @@ -615,10 +764,10 @@ void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event)) // This calls OnDraw, having adjusted the origin according to the current // scroll position -void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event)) +void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event)) { - wxPaintDC dc(this); - PrepareDC(dc); + wxPaintDC dc(m_targetWindow); + DoPrepareDC(dc); OnDraw(dc); } @@ -627,25 +776,25 @@ 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 -void wxScrolledWindow::OnChar(wxKeyEvent& event) +void wxScrollHelper::HandleOnChar(wxKeyEvent& event) { int stx, sty, // view origin szx, szy, // view size (total) clix, cliy; // view size (on screen) - ViewStart(&stx, &sty); - GetClientSize(&clix, &cliy); + GetViewStart(&stx, &sty); + GetTargetSize(&clix, &cliy); GetVirtualSize(&szx, &szy); if( m_xScrollPixelsPerLine ) { clix /= m_xScrollPixelsPerLine; - szx /= m_xScrollPixelsPerLine; + szx /= m_xScrollPixelsPerLine; } else { clix = 0; - szx = -1; + szx = -1; } if( m_yScrollPixelsPerLine ) { @@ -655,15 +804,16 @@ void wxScrolledWindow::OnChar(wxKeyEvent& event) else { cliy = 0; - szy = -1; + szy = -1; } + int dsty; switch ( event.KeyCode() ) { case WXK_PAGEUP: case WXK_PRIOR: - int y = sty - (5 * cliy / 6); - Scroll(-1, (y == -1) ? 0 : newy); + dsty = sty - (5 * cliy / 6); + Scroll(-1, (dsty == -1) ? 0 : dsty); break; case WXK_PAGEDOWN: @@ -700,3 +850,162 @@ void wxScrolledWindow::OnChar(wxKeyEvent& event) event.Skip(); } } + +// ---------------------------------------------------------------------------- +// autoscroll stuff: these functions deal with sending fake scroll events when +// a captured mouse is being held outside the window +// ---------------------------------------------------------------------------- + +bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const +{ + // only send the event if the window is scrollable in this direction + wxWindow *win = (wxWindow *)event.GetEventObject(); + return win->HasScrollbar(event.GetOrientation()); +} + +void wxScrollHelper::StopAutoScrolling() +{ + if ( m_timerAutoScroll ) + { + delete m_timerAutoScroll; + m_timerAutoScroll = (wxTimer *)NULL; + } +} + +void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event) +{ + StopAutoScrolling(); + + event.Skip(); +} + +void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event) +{ + // don't prevent the usual processing of the event from taking place + event.Skip(); + + // when a captured mouse leave a scrolled window we start generate + // scrolling events to allow, for example, extending selection beyond the + // visible area in some controls + if ( wxWindow::GetCapture() == m_targetWindow ) + { + // where is the mouse leaving? + int pos, orient; + wxPoint pt = event.GetPosition(); + if ( pt.x < 0 ) + { + orient = wxHORIZONTAL; + pos = 0; + } + else if ( pt.y < 0 ) + { + orient = wxVERTICAL; + pos = 0; + } + else // we're lower or to the right of the window + { + wxSize size = m_targetWindow->GetClientSize(); + if ( pt.x > size.x ) + { + orient = wxHORIZONTAL; + pos = m_xScrollLines; + } + else if ( pt.y > size.y ) + { + orient = wxVERTICAL; + pos = m_yScrollLines; + } + else // this should be impossible + { + // 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") ); + + return; + } + } + + // only start the auto scroll timer if the window can be scrolled in + // this direction + if ( !m_targetWindow->HasScrollbar(orient) ) + return; + + delete m_timerAutoScroll; + m_timerAutoScroll = new wxAutoScrollTimer + ( + m_targetWindow, this, + pos == 0 ? wxEVT_SCROLLWIN_LINEUP + : wxEVT_SCROLLWIN_LINEDOWN, + pos, + orient + ); + m_timerAutoScroll->Start(50); // FIXME: make configurable + } +} + +#if wxUSE_MOUSEWHEEL + +void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event) +{ + m_wheelRotation += event.GetWheelRotation(); + int lines = m_wheelRotation / event.GetWheelDelta(); + m_wheelRotation -= lines * event.GetWheelDelta(); + + if (lines != 0) + { + lines *= event.GetLinesPerAction(); + + int vsx, vsy; + GetViewStart(&vsx, &vsy); + Scroll(-1, vsy - lines); + } +} + +#endif // wxUSE_MOUSEWHEEL + +// ---------------------------------------------------------------------------- +// wxGenericScrolledWindow implementation +// ---------------------------------------------------------------------------- + +IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel) + +bool wxGenericScrolledWindow::Create(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) +{ + m_targetWindow = this; + + 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; +} + +wxGenericScrolledWindow::~wxGenericScrolledWindow() +{ +} + +#if WXWIN_COMPATIBILITY +void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const +{ + *x_page = GetScrollPageSize(wxHORIZONTAL); + *y_page = GetScrollPageSize(wxVERTICAL); +} + +void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const +{ + if ( xx ) + *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); + if ( yy ) + *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); +} +#endif // WXWIN_COMPATIBILITY +