src/generic/scrolwin.cpp

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