X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/ea5c6ca7f7c3dc448da4be353a1153a792d01db4..6dc3e5dc9cefb8a69e4a64d78f1e08c589c750b1:/src/generic/scrolwin.cpp diff --git a/src/generic/scrolwin.cpp b/src/generic/scrolwin.cpp index 6786900ccd..1c28693778 100644 --- a/src/generic/scrolwin.cpp +++ b/src/generic/scrolwin.cpp @@ -1,49 +1,75 @@ ///////////////////////////////////////////////////////////////////////////// -// Name: scrolwin.cpp +// Name: generic/scrolwin.cpp // Purpose: wxScrolledWindow implementation // Author: Julian Smart // Modified by: // Created: 01/02/97 // RCS-ID: $Id$ // Copyright: (c) Julian Smart and Markus Holzem -// Licence: wxWindows license +// Licence: wxWindows license ///////////////////////////////////////////////////////////////////////////// +// ============================================================================ +// declarations +// ============================================================================ + +// ---------------------------------------------------------------------------- +// headers +// ---------------------------------------------------------------------------- + #ifdef __GNUG__ -#pragma implementation -#pragma implementation "scrolwin.h" + #pragma implementation "scrolwin.h" #endif // For compilers that support precompilation, includes "wx.h". #include "wx/wxprec.h" +#ifdef __BORLANDC__ + #pragma hdrstop +#endif + #include "wx/utils.h" #include "wx/dcclient.h" -#ifdef __BORLANDC__ -#pragma hdrstop +#include "wx/generic/scrolwin.h" +#include "wx/panel.h" + +#ifdef __WXMSW__ + #include "windows.h" #endif -#include "wx/generic/scrolwin.h" +#ifdef __WXMOTIF__ +// For wxRETAINED implementation +#ifdef __VMS__ //VMS's Xm.h is not (yet) compatible with C++ + //This code switches off the compiler warnings +# pragma message disable nosimpint +#endif +#include +#ifdef __VMS__ +# pragma message enable nosimpint +#endif +#endif + +// ---------------------------------------------------------------------------- +// event tables +// ---------------------------------------------------------------------------- -#if !USE_SHARED_LIBRARY -BEGIN_EVENT_TABLE(wxScrolledWindow, wxWindow) +BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel) EVT_SCROLLWIN(wxScrolledWindow::OnScroll) EVT_SIZE(wxScrolledWindow::OnSize) EVT_PAINT(wxScrolledWindow::OnPaint) + EVT_CHAR(wxScrolledWindow::OnChar) END_EVENT_TABLE() -IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxWindow) -#endif +IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel) -#ifdef __WXMSW__ -#include "windows.h" -#endif +// ============================================================================ +// implementation +// ============================================================================ -#ifdef __WXMOTIF__ -// For wxRETAINED implementation -#include -#endif +// ---------------------------------------------------------------------------- +// wxScrolledWindow creation +// ---------------------------------------------------------------------------- wxScrolledWindow::wxScrolledWindow() { @@ -61,11 +87,12 @@ wxScrolledWindow::wxScrolledWindow() m_scaleY = 1.0; } -bool wxScrolledWindow::Create(wxWindow *parent, wxWindowID id, - const wxPoint& pos, - const wxSize& size, - long style, - const wxString& name) +bool wxScrolledWindow::Create(wxWindow *parent, + wxWindowID id, + const wxPoint& pos, + const wxSize& size, + long style, + const wxString& name) { m_xScrollPixelsPerLine = 0; m_yScrollPixelsPerLine = 0; @@ -80,29 +107,44 @@ bool wxScrolledWindow::Create(wxWindow *parent, wxWindowID id, m_scaleX = 1.0; m_scaleY = 1.0; - return wxWindow::Create(parent, id, pos, size, style, name); + m_targetWindow = this; + + // we need wxWANTS_CHARS to process arrows ourselves + return wxPanel::Create(parent, id, pos, size, style | wxWANTS_CHARS, name); +} + +wxScrolledWindow::~wxScrolledWindow() +{ } +// ---------------------------------------------------------------------------- +// 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 ) + 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; m_yScrollPixelsPerLine = pixelsPerUnitY; m_xScrollPosition = xPos; @@ -138,22 +180,50 @@ void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY, m_pixmapHeight = totalPixelHeight; m_backingPixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)), m_pixmapWidth, m_pixmapHeight, depth); - } + } } -#endif - +#endif // Motif + AdjustScrollbars(); - - if (do_refresh && !noRefresh) - Refresh(); - + + if (do_refresh && !noRefresh) + m_targetWindow->Refresh(); + #ifdef __WXMSW__ - // Necessary? - UpdateWindow ((HWND) GetHWND()); + // 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 } +// ---------------------------------------------------------------------------- +// target window handling +// ---------------------------------------------------------------------------- + +void wxScrolledWindow::SetTargetWindow( wxWindow *target ) +{ + wxASSERT_MSG( target, wxT("target window must not be NULL") ); + m_targetWindow = target; +} + +wxWindow *wxScrolledWindow::GetTargetWindow() +{ + return m_targetWindow; +} + +// ---------------------------------------------------------------------------- +// scrolling implementation itself +// ---------------------------------------------------------------------------- + void wxScrolledWindow::OnScroll(wxScrollWinEvent& event) { int orient = event.GetOrientation(); @@ -180,145 +250,154 @@ void wxScrolledWindow::OnScroll(wxScrollWinEvent& event) { m_yScrollPosition += nScrollInc; } - + if (orient == wxHORIZONTAL) { if (m_xScrollingEnabled) - ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL); + m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL); else - Refresh(); + m_targetWindow->Refresh(); } else { if (m_yScrollingEnabled) - ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL); + m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL); else - Refresh(); - } + m_targetWindow->Refresh(); + } +#ifdef __WXMAC__ + m_targetWindow->MacUpdateImmediately() ; +#endif } int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event) { - int pos = event.GetPosition(); - int orient = event.GetOrientation(); + int pos = event.GetPosition(); + int orient = event.GetOrientation(); - int nScrollInc = 0; - switch (event.GetEventType()) - { - case wxEVT_SCROLLWIN_TOP: - { - if (orient == wxHORIZONTAL) - nScrollInc = - m_xScrollPosition; - else - nScrollInc = - m_yScrollPosition; - break; - } - case wxEVT_SCROLLWIN_BOTTOM: - { - if (orient == wxHORIZONTAL) - nScrollInc = m_xScrollLines - m_xScrollPosition; - else - nScrollInc = m_yScrollLines - m_yScrollPosition; - break; - } - case wxEVT_SCROLLWIN_LINEUP: - { - nScrollInc = -1; - break; - } - case wxEVT_SCROLLWIN_LINEDOWN: - { - nScrollInc = 1; - break; - } - case wxEVT_SCROLLWIN_PAGEUP: - { - if (orient == wxHORIZONTAL) - nScrollInc = -GetScrollPageSize(wxHORIZONTAL); - else - nScrollInc = -GetScrollPageSize(wxVERTICAL); - break; - } - case wxEVT_SCROLLWIN_PAGEDOWN: - { - if (orient == wxHORIZONTAL) - nScrollInc = GetScrollPageSize(wxHORIZONTAL); - else - nScrollInc = GetScrollPageSize(wxVERTICAL); - break; - } - case wxEVT_SCROLLWIN_THUMBTRACK: + int nScrollInc = 0; + switch (event.GetEventType()) { - if (orient == wxHORIZONTAL) - nScrollInc = pos - m_xScrollPosition; - else - nScrollInc = pos - m_yScrollPosition; - break; + case wxEVT_SCROLLWIN_TOP: + { + if (orient == wxHORIZONTAL) + nScrollInc = - m_xScrollPosition; + else + nScrollInc = - m_yScrollPosition; + break; + } + case wxEVT_SCROLLWIN_BOTTOM: + { + if (orient == wxHORIZONTAL) + nScrollInc = m_xScrollLines - m_xScrollPosition; + else + nScrollInc = m_yScrollLines - m_yScrollPosition; + break; + } + case wxEVT_SCROLLWIN_LINEUP: + { + nScrollInc = -1; + break; + } + case wxEVT_SCROLLWIN_LINEDOWN: + { + nScrollInc = 1; + break; + } + case wxEVT_SCROLLWIN_PAGEUP: + { + if (orient == wxHORIZONTAL) + nScrollInc = -GetScrollPageSize(wxHORIZONTAL); + else + nScrollInc = -GetScrollPageSize(wxVERTICAL); + break; + } + case wxEVT_SCROLLWIN_PAGEDOWN: + { + if (orient == wxHORIZONTAL) + nScrollInc = GetScrollPageSize(wxHORIZONTAL); + else + nScrollInc = GetScrollPageSize(wxVERTICAL); + break; + } + case wxEVT_SCROLLWIN_THUMBTRACK: + case wxEVT_SCROLLWIN_THUMBRELEASE: + { + if (orient == wxHORIZONTAL) + nScrollInc = pos - m_xScrollPosition; + else + nScrollInc = pos - m_yScrollPosition; + break; + } + default: + { + break; + } } - default: + + if (orient == wxHORIZONTAL) { - break; - } - } - - if (orient == wxHORIZONTAL) - { - if (m_xScrollPixelsPerLine > 0) { - int w, h; - GetClientSize(&w, &h); - - int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine; - int noPositions = (int) ( ((nMaxWidth - w)/(float)m_xScrollPixelsPerLine) + 0.5 ); - if (noPositions < 0) - noPositions = 0; - - if ( (m_xScrollPosition + nScrollInc) < 0 ) - nScrollInc = -m_xScrollPosition; // As -ve as we can go - else if ( (m_xScrollPosition + nScrollInc) > noPositions ) - nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go + if (m_xScrollPixelsPerLine > 0) + { + int w, h; + m_targetWindow->GetClientSize(&w, &h); + + int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine; + int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 ); + if (noPositions < 0) + noPositions = 0; + + if ( (m_xScrollPosition + nScrollInc) < 0 ) + nScrollInc = -m_xScrollPosition; // As -ve as we can go + else if ( (m_xScrollPosition + nScrollInc) > noPositions ) + nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go + } + else + m_targetWindow->Refresh(); } else - Refresh(); - } - else - { - if (m_yScrollPixelsPerLine > 0) { - int w, h; - GetClientSize(&w, &h); - - int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine; - int noPositions = (int) ( ((nMaxHeight - h)/(float)m_yScrollPixelsPerLine) + 0.5 ); - if (noPositions < 0) - noPositions = 0; - - if ( (m_yScrollPosition + nScrollInc) < 0 ) - nScrollInc = -m_yScrollPosition; // As -ve as we can go - else if ( (m_yScrollPosition + nScrollInc) > noPositions ) - nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go + { + if (m_yScrollPixelsPerLine > 0) + { + int w, h; + m_targetWindow->GetClientSize(&w, &h); + + int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine; + int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 ); + if (noPositions < 0) + noPositions = 0; + + if ( (m_yScrollPosition + nScrollInc) < 0 ) + nScrollInc = -m_yScrollPosition; // As -ve as we can go + else if ( (m_yScrollPosition + nScrollInc) > noPositions ) + nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go + } + else + m_targetWindow->Refresh(); } - else - Refresh(); - } - return nScrollInc; + return nScrollInc; } // Adjust the scrollbars - new version. -void wxScrolledWindow::AdjustScrollbars(void) +void wxScrolledWindow::AdjustScrollbars() { int w, h; - GetClientSize(&w, &h); + m_targetWindow->GetClientSize(&w, &h); + + int oldXScroll = m_xScrollPosition; + int oldYScroll = m_yScrollPosition; if (m_xScrollLines > 0) { - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 ); + // 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); @@ -326,20 +405,20 @@ void wxScrolledWindow::AdjustScrollbars(void) SetScrollPageSize(wxHORIZONTAL, noPagePositions); } else - { + { m_xScrollPosition = 0; - SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); + SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE); } - + if (m_yScrollLines > 0) { - // Calculate page size i.e. number of scroll units you get on the - // current client window - int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 ); + // 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 ); @@ -350,35 +429,31 @@ void wxScrolledWindow::AdjustScrollbars(void) else { m_yScrollPosition = 0; - SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); + SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE); } -} - -// Default OnSize resets scrollbars, if any -void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event)) -{ -#if wxUSE_CONSTRAINTS - if (GetAutoLayout()) Layout(); -#endif - AdjustScrollbars(); -} - -// This calls OnDraw, having adjusted the origin according to the current -// scroll position -void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event)) -{ - wxPaintDC dc(this); - PrepareDC(dc); + if (oldXScroll != m_xScrollPosition) + { + if (m_xScrollingEnabled) + m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, (const wxRect *) NULL ); + else + m_targetWindow->Refresh(); + } - OnDraw(dc); + if (oldYScroll != m_yScrollPosition) + { + if (m_yScrollingEnabled) + m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), (const wxRect *) NULL ); + else + m_targetWindow->Refresh(); + } } // 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, + dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine, -m_yScrollPosition * m_yScrollPixelsPerLine ); dc.SetUserScale( m_scaleX, m_scaleY ); } @@ -389,12 +464,22 @@ void wxScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const *x_page = GetScrollPageSize(wxHORIZONTAL); *y_page = GetScrollPageSize(wxVERTICAL); } -#endif + +void wxScrolledWindow::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 void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const { - *x_unit = m_xScrollPixelsPerLine; - *y_unit = m_yScrollPixelsPerLine; + if ( x_unit ) + *x_unit = m_xScrollPixelsPerLine; + if ( y_unit ) + *y_unit = m_yScrollPixelsPerLine; } int wxScrolledWindow::GetScrollPageSize(int orient) const @@ -418,51 +503,55 @@ void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize) */ void wxScrolledWindow::Scroll( int x_pos, int y_pos ) { - if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && + if (((x_pos == -1) || (x_pos == m_xScrollPosition)) && ((y_pos == -1) || (y_pos == m_yScrollPosition))) return; - + int w, h; - GetClientSize(&w, &h); + m_targetWindow->GetClientSize(&w, &h); if (x_pos != -1) { + 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/(float)m_xScrollPixelsPerLine) + 0.5 ); + + // 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 ); - - SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE ); + + if (old_x == m_xScrollPosition) return; + + m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE ); + m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 ); } if (y_pos != -1) { + 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/(float)m_yScrollPixelsPerLine) + 0.5 ); + + // 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 ); - - SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE ); + + if (old_y == m_yScrollPosition) return; + + m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE ); + m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine ); } - - // BAD, BAD, can cause event loops if called from OnPaint(). KB. - // Refresh(); - -#ifdef __WXMSW__ - // Necessary? - ::UpdateWindow ((HWND) GetHWND()); + +#ifdef __WXMAC__ + m_targetWindow->MacUpdateImmediately(); #endif } @@ -474,27 +563,135 @@ void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll) void wxScrolledWindow::GetVirtualSize (int *x, int *y) const { - *x = m_xScrollPixelsPerLine * m_xScrollLines; - *y = m_yScrollPixelsPerLine * m_yScrollLines; + if ( x ) + *x = m_xScrollPixelsPerLine * m_xScrollLines; + if ( y ) + *y = m_yScrollPixelsPerLine * m_yScrollLines; } // Where the current view starts from -void wxScrolledWindow::ViewStart (int *x, int *y) const +void wxScrolledWindow::GetViewStart (int *x, int *y) const { - *x = m_xScrollPosition; - *y = m_yScrollPosition; + if ( x ) + *x = m_xScrollPosition; + if ( y ) + *y = m_yScrollPosition; } void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const { - *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine; - *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine; + if ( xx ) + *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine; + if ( yy ) + *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine; } -void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const +void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const +{ + if ( xx ) + *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine; + if ( yy ) + *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine; +} + +// ---------------------------------------------------------------------------- +// event handlers +// ---------------------------------------------------------------------------- + +// Default OnSize resets scrollbars, if any +void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event)) +{ +#if wxUSE_CONSTRAINTS + if (GetAutoLayout()) + Layout(); +#endif + + AdjustScrollbars(); +} + +// This calls OnDraw, having adjusted the origin according to the current +// scroll position +void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event)) { - *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine); - *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine); + wxPaintDC dc(this); + PrepareDC(dc); + + OnDraw(dc); } +// 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 wxScrolledWindow::OnChar(wxKeyEvent& event) +{ + int stx, sty, // view origin + szx, szy, // view size (total) + clix, cliy; // view size (on screen) + ViewStart(&stx, &sty); + GetClientSize(&clix, &cliy); + 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 + { + cliy = 0; + szy = -1; + } + + switch ( event.KeyCode() ) + { + case WXK_PAGEUP: + case WXK_PRIOR: + Scroll(-1, sty - (5 * cliy / 6)); + break; + + case WXK_PAGEDOWN: + case WXK_NEXT: + Scroll(-1, sty + (5 * cliy / 6)); + break; + + case WXK_HOME: + Scroll(0, event.ControlDown() ? 0 : -1); + break; + + case WXK_END: + Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1); + break; + + case WXK_UP: + Scroll(-1, sty - 1); + break; + + case WXK_DOWN: + Scroll(-1, sty + 1); + break; + + case WXK_LEFT: + Scroll(stx - 1, -1); + break; + + case WXK_RIGHT: + Scroll(stx + 1, -1); + break; + + default: + // not for us + event.Skip(); + } +}