src/generic/scrolwin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/scrolwin.cpp
   3 // Purpose:     wxScrolledWindow implementation
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "scrolwin.h"
  22 #endif
  23
  24 // For compilers that support precompilation, includes "wx.h".
  25 #include "wx/wxprec.h"
  26
  27 #ifdef __BORLANDC__
  28     #pragma hdrstop
  29 #endif
  30
  31 #include "wx/utils.h"
  32 #include "wx/dcclient.h"
  33
  34 #include "wx/generic/scrolwin.h"
  35 #include "wx/panel.h"
  36
  37 #ifdef __WXMSW__
  38     #include "windows.h"
  39 #endif
  40
  41 #ifdef __WXMOTIF__
  42 // For wxRETAINED implementation
  43 #ifdef __VMS__ //VMS's Xm.h is not (yet) compatible with C++
  44                //This code switches off the compiler warnings
  45 # pragma message disable nosimpint
  46 #endif
  47 #include <Xm/Xm.h>
  48 #ifdef __VMS__
  49 # pragma message enable nosimpint
  50 #endif
  51 #endif
  52
  53 // ----------------------------------------------------------------------------
  54 // event tables
  55 // ----------------------------------------------------------------------------
  56
  57 BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
  58     EVT_SCROLLWIN(wxScrolledWindow::OnScroll)
  59     EVT_SIZE(wxScrolledWindow::OnSize)
  60     EVT_PAINT(wxScrolledWindow::OnPaint)
  61     EVT_CHAR(wxScrolledWindow::OnChar)
  62 END_EVENT_TABLE()
  63
  64 IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
  65
  66 // ============================================================================
  67 // implementation
  68 // ============================================================================
  69
  70 // ----------------------------------------------------------------------------
  71 // wxScrolledWindow creation
  72 // ----------------------------------------------------------------------------
  73
  74 wxScrolledWindow::wxScrolledWindow()
  75 {
  76     m_xScrollPixelsPerLine = 0;
  77     m_yScrollPixelsPerLine = 0;
  78     m_xScrollingEnabled = TRUE;
  79     m_yScrollingEnabled = TRUE;
  80     m_xScrollPosition = 0;
  81     m_yScrollPosition = 0;
  82     m_xScrollLines = 0;
  83     m_yScrollLines = 0;
  84     m_xScrollLinesPerPage = 0;
  85     m_yScrollLinesPerPage = 0;
  86     m_scaleX = 1.0;
  87     m_scaleY = 1.0;
  88 }
  89
  90 bool wxScrolledWindow::Create(wxWindow *parent,
  91                               wxWindowID id,
  92                               const wxPoint& pos,
  93                               const wxSize& size,
  94                               long style,
  95                               const wxString& name)
  96 {
  97     m_xScrollPixelsPerLine = 0;
  98     m_yScrollPixelsPerLine = 0;
  99     m_xScrollingEnabled = TRUE;
 100     m_yScrollingEnabled = TRUE;
 101     m_xScrollPosition = 0;
 102     m_yScrollPosition = 0;
 103     m_xScrollLines = 0;
 104     m_yScrollLines = 0;
 105     m_xScrollLinesPerPage = 0;
 106     m_yScrollLinesPerPage = 0;
 107     m_scaleX = 1.0;
 108     m_scaleY = 1.0;
 109
 110     m_targetWindow = this;
 111
 112     // we need wxWANTS_CHARS to process arrows ourselves
 113     return wxPanel::Create(parent, id, pos, size, style | wxWANTS_CHARS, name);
 114 }
 115
 116 wxScrolledWindow::~wxScrolledWindow()
 117 {
 118 }
 119
 120 // ----------------------------------------------------------------------------
 121 // setting scrolling parameters
 122 // ----------------------------------------------------------------------------
 123
 124 /*
 125  * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
 126  * noUnitsX/noUnitsY:        : no. units per scrollbar
 127  */
 128 void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
 129                int noUnitsX, int noUnitsY,
 130                int xPos, int yPos, bool noRefresh )
 131 {
 132     bool do_refresh =
 133     (
 134       (noUnitsX != 0 && m_xScrollLines == 0) ||
 135       (noUnitsX < m_xScrollLines) ||
 136       (noUnitsY != 0 && m_yScrollLines == 0) ||
 137       (noUnitsY < m_yScrollLines) ||
 138       (xPos != m_xScrollPosition) ||
 139       (yPos != m_yScrollPosition) ||
 140       (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
 141       (pixelsPerUnitY != m_yScrollPixelsPerLine)
 142     );
 143
 144     m_xScrollPixelsPerLine = pixelsPerUnitX;
 145     m_yScrollPixelsPerLine = pixelsPerUnitY;
 146     m_xScrollPosition = xPos;
 147     m_yScrollPosition = yPos;
 148     m_xScrollLines = noUnitsX;
 149     m_yScrollLines = noUnitsY;
 150
 151 #ifdef __WXMOTIF__
 152     // Sorry, some Motif-specific code to implement a backing pixmap
 153     // for the wxRETAINED style. Implementing a backing store can't
 154     // be entirely generic because it relies on the wxWindowDC implementation
 155     // to duplicate X drawing calls for the backing pixmap.
 156
 157     if ((m_windowStyle & wxRETAINED) == wxRETAINED)
 158     {
 159         Display* dpy = XtDisplay((Widget) GetMainWidget());
 160
 161         int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
 162         int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
 163         if (m_backingPixmap &&
 164            !((m_pixmapWidth == totalPixelWidth) &&
 165              (m_pixmapHeight == totalPixelHeight)))
 166         {
 167             XFreePixmap (dpy, (Pixmap) m_backingPixmap);
 168             m_backingPixmap = (WXPixmap) 0;
 169         }
 170
 171         if (!m_backingPixmap &&
 172            (noUnitsX != 0) && (noUnitsY != 0))
 173         {
 174             int depth = wxDisplayDepth();
 175             m_pixmapWidth = totalPixelWidth;
 176             m_pixmapHeight = totalPixelHeight;
 177             m_backingPixmap = (WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 178             m_pixmapWidth, m_pixmapHeight, depth);
 179         }
 180
 181     }
 182 #endif // Motif
 183
 184     AdjustScrollbars();
 185
 186     if (do_refresh && !noRefresh)
 187         m_targetWindow->Refresh();
 188
 189 #ifdef __WXMSW__
 190     // GRG: if this turns out to be really necessary, we could
 191     //   at least move it to the above if { ... } so that it is
 192     //   only done if noRefresh = FALSE (the default). OTOH, if
 193     //   this doesn't break anything, which seems to be the
 194     //   case, we could just leave it out.
 195
 196     // Necessary?
 197     // UpdateWindow ((HWND) m_targetWindow->GetHWND());
 198 #endif
 199 #ifdef __WXMAC__
 200     m_targetWindow->MacUpdateImmediately() ;
 201 #endif
 202 }
 203
 204 // ----------------------------------------------------------------------------
 205 // target window handling
 206 // ----------------------------------------------------------------------------
 207
 208 void wxScrolledWindow::SetTargetWindow( wxWindow *target )
 209 {
 210     wxASSERT_MSG( target, wxT("target window must not be NULL") );
 211     m_targetWindow = target;
 212 }
 213
 214 wxWindow *wxScrolledWindow::GetTargetWindow()
 215 {
 216     return m_targetWindow;
 217 }
 218
 219 // ----------------------------------------------------------------------------
 220 // scrolling implementation itself
 221 // ----------------------------------------------------------------------------
 222
 223 void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
 224 {
 225     int orient = event.GetOrientation();
 226
 227     int nScrollInc = CalcScrollInc(event);
 228     if (nScrollInc == 0) return;
 229
 230     if (orient == wxHORIZONTAL)
 231     {
 232         int newPos = m_xScrollPosition + nScrollInc;
 233         SetScrollPos(wxHORIZONTAL, newPos, TRUE );
 234     }
 235     else
 236     {
 237         int newPos = m_yScrollPosition + nScrollInc;
 238         SetScrollPos(wxVERTICAL, newPos, TRUE );
 239     }
 240
 241     if (orient == wxHORIZONTAL)
 242     {
 243         m_xScrollPosition += nScrollInc;
 244     }
 245     else
 246     {
 247         m_yScrollPosition += nScrollInc;
 248     }
 249
 250     if (orient == wxHORIZONTAL)
 251     {
 252        if (m_xScrollingEnabled)
 253             m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL);
 254        else
 255             m_targetWindow->Refresh();
 256     }
 257     else
 258     {
 259         if (m_yScrollingEnabled)
 260             m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
 261         else
 262             m_targetWindow->Refresh();
 263     }
 264 #ifdef __WXMAC__
 265     m_targetWindow->MacUpdateImmediately() ;
 266 #endif
 267 }
 268
 269 int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
 270 {
 271     int pos = event.GetPosition();
 272     int orient = event.GetOrientation();
 273
 274     int nScrollInc = 0;
 275     switch (event.GetEventType())
 276     {
 277         case wxEVT_SCROLLWIN_TOP:
 278         {
 279             if (orient == wxHORIZONTAL)
 280                 nScrollInc = - m_xScrollPosition;
 281             else
 282                 nScrollInc = - m_yScrollPosition;
 283             break;
 284         }
 285         case wxEVT_SCROLLWIN_BOTTOM:
 286         {
 287             if (orient == wxHORIZONTAL)
 288                 nScrollInc = m_xScrollLines - m_xScrollPosition;
 289             else
 290                 nScrollInc = m_yScrollLines - m_yScrollPosition;
 291             break;
 292         }
 293         case wxEVT_SCROLLWIN_LINEUP:
 294         {
 295             nScrollInc = -1;
 296             break;
 297         }
 298         case wxEVT_SCROLLWIN_LINEDOWN:
 299         {
 300             nScrollInc = 1;
 301             break;
 302         }
 303         case wxEVT_SCROLLWIN_PAGEUP:
 304         {
 305             if (orient == wxHORIZONTAL)
 306                 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
 307             else
 308                 nScrollInc = -GetScrollPageSize(wxVERTICAL);
 309             break;
 310         }
 311         case wxEVT_SCROLLWIN_PAGEDOWN:
 312         {
 313             if (orient == wxHORIZONTAL)
 314                 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
 315             else
 316                 nScrollInc = GetScrollPageSize(wxVERTICAL);
 317             break;
 318         }
 319         case wxEVT_SCROLLWIN_THUMBTRACK:
 320         case wxEVT_SCROLLWIN_THUMBRELEASE:
 321         {
 322             if (orient == wxHORIZONTAL)
 323                 nScrollInc = pos - m_xScrollPosition;
 324             else
 325                 nScrollInc = pos - m_yScrollPosition;
 326             break;
 327         }
 328         default:
 329         {
 330             break;
 331         }
 332     }
 333
 334     if (orient == wxHORIZONTAL)
 335     {
 336         if (m_xScrollPixelsPerLine > 0)
 337         {
 338             int w, h;
 339             m_targetWindow->GetClientSize(&w, &h);
 340
 341             int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 342             int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
 343             if (noPositions < 0)
 344                 noPositions = 0;
 345
 346             if ( (m_xScrollPosition + nScrollInc) < 0 )
 347                 nScrollInc = -m_xScrollPosition; // As -ve as we can go
 348             else if ( (m_xScrollPosition + nScrollInc) > noPositions )
 349                 nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
 350         }
 351         else
 352             m_targetWindow->Refresh();
 353     }
 354     else
 355     {
 356         if (m_yScrollPixelsPerLine > 0)
 357         {
 358             int w, h;
 359             m_targetWindow->GetClientSize(&w, &h);
 360
 361             int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 362             int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
 363             if (noPositions < 0)
 364                 noPositions = 0;
 365
 366             if ( (m_yScrollPosition + nScrollInc) < 0 )
 367                 nScrollInc = -m_yScrollPosition; // As -ve as we can go
 368             else if ( (m_yScrollPosition + nScrollInc) > noPositions )
 369                 nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
 370         }
 371         else
 372             m_targetWindow->Refresh();
 373     }
 374
 375     return nScrollInc;
 376 }
 377
 378 // Adjust the scrollbars - new version.
 379 void wxScrolledWindow::AdjustScrollbars()
 380 {
 381     int w, h;
 382     m_targetWindow->GetClientSize(&w, &h);
 383
 384     int oldXScroll = m_xScrollPosition;
 385     int oldYScroll = m_yScrollPosition;
 386
 387     if (m_xScrollLines > 0)
 388     {
 389         // Calculate page size i.e. number of scroll units you get on the
 390         // current client window
 391         int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
 392         if (noPagePositions < 1) noPagePositions = 1;
 393
 394         // Correct position if greater than extent of canvas minus
 395         // the visible portion of it or if below zero
 396         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
 397         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 398
 399         SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
 400         // The amount by which we scroll when paging
 401         SetScrollPageSize(wxHORIZONTAL, noPagePositions);
 402     }
 403     else
 404     {
 405         m_xScrollPosition = 0;
 406         SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
 407     }
 408
 409     if (m_yScrollLines > 0)
 410     {
 411         // Calculate page size i.e. number of scroll units you get on the
 412         // current client window
 413         int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
 414         if (noPagePositions < 1) noPagePositions = 1;
 415
 416         // Correct position if greater than extent of canvas minus
 417         // the visible portion of it or if below zero
 418         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 419         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 420
 421         SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
 422         // The amount by which we scroll when paging
 423         SetScrollPageSize(wxVERTICAL, noPagePositions);
 424     }
 425     else
 426     {
 427         m_yScrollPosition = 0;
 428         SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
 429     }
 430
 431     if (oldXScroll != m_xScrollPosition)
 432     {
 433        if (m_xScrollingEnabled)
 434             m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0, (const wxRect *) NULL );
 435        else
 436             m_targetWindow->Refresh();
 437     }
 438
 439     if (oldYScroll != m_yScrollPosition)
 440     {
 441         if (m_yScrollingEnabled)
 442             m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition), (const wxRect *) NULL );
 443         else
 444             m_targetWindow->Refresh();
 445     }
 446 }
 447
 448 // Override this function if you don't want to have wxScrolledWindow
 449 // automatically change the origin according to the scroll position.
 450 void wxScrolledWindow::PrepareDC(wxDC& dc)
 451 {
 452     dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
 453                         -m_yScrollPosition * m_yScrollPixelsPerLine );
 454     dc.SetUserScale( m_scaleX, m_scaleY );
 455 }
 456
 457 #if WXWIN_COMPATIBILITY
 458 void wxScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
 459 {
 460       *x_page = GetScrollPageSize(wxHORIZONTAL);
 461       *y_page = GetScrollPageSize(wxVERTICAL);
 462 }
 463
 464 void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
 465 {
 466     if ( xx )
 467         *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
 468     if ( yy )
 469         *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
 470 }
 471 #endif // WXWIN_COMPATIBILITY
 472
 473 void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 474 {
 475     if ( x_unit )
 476         *x_unit = m_xScrollPixelsPerLine;
 477     if ( y_unit )
 478         *y_unit = m_yScrollPixelsPerLine;
 479 }
 480
 481 int wxScrolledWindow::GetScrollPageSize(int orient) const
 482 {
 483     if ( orient == wxHORIZONTAL )
 484         return m_xScrollLinesPerPage;
 485     else
 486         return m_yScrollLinesPerPage;
 487 }
 488
 489 void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
 490 {
 491     if ( orient == wxHORIZONTAL )
 492         m_xScrollLinesPerPage = pageSize;
 493     else
 494         m_yScrollLinesPerPage = pageSize;
 495 }
 496
 497 /*
 498  * Scroll to given position (scroll position, not pixel position)
 499  */
 500 void wxScrolledWindow::Scroll( int x_pos, int y_pos )
 501 {
 502     if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
 503         ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
 504
 505     int w, h;
 506     m_targetWindow->GetClientSize(&w, &h);
 507
 508     if (x_pos != -1)
 509     {
 510         int old_x = m_xScrollPosition;
 511         m_xScrollPosition = x_pos;
 512
 513         // Calculate page size i.e. number of scroll units you get on the
 514         // current client window
 515         int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
 516         if (noPagePositions < 1) noPagePositions = 1;
 517
 518         // Correct position if greater than extent of canvas minus
 519         // the visible portion of it or if below zero
 520         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
 521         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 522
 523         if (old_x == m_xScrollPosition) return;
 524
 525         m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
 526         m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
 527     }
 528     if (y_pos != -1)
 529     {
 530         int old_y = m_yScrollPosition;
 531         m_yScrollPosition = y_pos;
 532
 533         // Calculate page size i.e. number of scroll units you get on the
 534         // current client window
 535         int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
 536         if (noPagePositions < 1) noPagePositions = 1;
 537
 538         // Correct position if greater than extent of canvas minus
 539         // the visible portion of it or if below zero
 540         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 541         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 542
 543         if (old_y == m_yScrollPosition) return;
 544
 545         m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
 546         m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
 547     }
 548
 549 #ifdef __WXMAC__
 550     m_targetWindow->MacUpdateImmediately();
 551 #endif
 552 }
 553
 554 void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
 555 {
 556     m_xScrollingEnabled = x_scroll;
 557     m_yScrollingEnabled = y_scroll;
 558 }
 559
 560 void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
 561 {
 562     if ( x )
 563         *x = m_xScrollPixelsPerLine * m_xScrollLines;
 564     if ( y )
 565         *y = m_yScrollPixelsPerLine * m_yScrollLines;
 566 }
 567
 568 // Where the current view starts from
 569 void wxScrolledWindow::GetViewStart (int *x, int *y) const
 570 {
 571     if ( x )
 572         *x = m_xScrollPosition;
 573     if ( y )
 574         *y = m_yScrollPosition;
 575 }
 576
 577 void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
 578 {
 579     if ( xx )
 580         *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
 581     if ( yy )
 582         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 583 }
 584
 585 void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
 586 {
 587     if ( xx )
 588         *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
 589     if ( yy )
 590         *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
 591 }
 592
 593 // ----------------------------------------------------------------------------
 594 // event handlers
 595 // ----------------------------------------------------------------------------
 596
 597 // Default OnSize resets scrollbars, if any
 598 void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
 599 {
 600 #if wxUSE_CONSTRAINTS
 601     if (GetAutoLayout())
 602         Layout();
 603 #endif
 604
 605     AdjustScrollbars();
 606 }
 607
 608 // This calls OnDraw, having adjusted the origin according to the current
 609 // scroll position
 610 void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
 611 {
 612     wxPaintDC dc(this);
 613     PrepareDC(dc);
 614
 615     OnDraw(dc);
 616 }
 617
 618 // kbd handling: notice that we use OnChar() and not OnKeyDown() for
 619 // compatibility here - if we used OnKeyDown(), the programs which process
 620 // arrows themselves in their OnChar() would never get the message and like
 621 // this they always have the priority
 622 void wxScrolledWindow::OnChar(wxKeyEvent& event)
 623 {
 624     int stx, sty,       // view origin
 625         szx, szy,       // view size (total)
 626         clix, cliy;     // view size (on screen)
 627
 628     ViewStart(&stx, &sty);
 629     GetClientSize(&clix, &cliy);
 630     GetVirtualSize(&szx, &szy);
 631
 632     if( m_xScrollPixelsPerLine )
 633     {
 634         clix /= m_xScrollPixelsPerLine;
 635         szx /= m_xScrollPixelsPerLine;
 636     }
 637     else
 638     {
 639         clix = 0;
 640         szx = -1;
 641     }
 642     if( m_yScrollPixelsPerLine )
 643     {
 644         cliy /= m_yScrollPixelsPerLine;
 645         szy /= m_yScrollPixelsPerLine;
 646     }
 647     else
 648     {
 649         cliy = 0;
 650         szy = -1;
 651     }
 652
 653     switch ( event.KeyCode() )
 654     {
 655         case WXK_PAGEUP:
 656         case WXK_PRIOR:
 657             Scroll(-1, sty - (5 * cliy / 6));
 658             break;
 659
 660         case WXK_PAGEDOWN:
 661         case WXK_NEXT:
 662             Scroll(-1, sty + (5 * cliy / 6));
 663             break;
 664
 665         case WXK_HOME:
 666             Scroll(0, event.ControlDown() ? 0 : -1);
 667             break;
 668
 669         case WXK_END:
 670             Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
 671             break;
 672
 673         case WXK_UP:
 674             Scroll(-1, sty - 1);
 675             break;
 676
 677         case WXK_DOWN:
 678             Scroll(-1, sty + 1);
 679             break;
 680
 681         case WXK_LEFT:
 682             Scroll(stx - 1, -1);
 683             break;
 684
 685         case WXK_RIGHT:
 686             Scroll(stx + 1, -1);
 687             break;
 688
 689         default:
 690             // not for us
 691             event.Skip();
 692     }
 693 }