src/generic/scrlwing.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        generic/scrolwin.cpp
   3 // Purpose:     wxGenericScrolledWindow implementation
   4 // Author:      Julian Smart
   5 // Modified by: Vadim Zeitlin on 31.08.00: wxScrollHelper allows to implement
   6 // Created:     01/02/97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) wxWindows team
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "genscrolwin.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 #if !defined(__WXGTK__) || defined(__WXUNIVERSAL__)
  36
  37 #include "wx/utils.h"
  38 #include "wx/dcclient.h"
  39
  40 #include "wx/scrolwin.h"
  41 #include "wx/panel.h"
  42 #include "wx/timer.h"
  43
  44 #ifdef __WXMSW__
  45     #include <windows.h> // for DLGC_WANTARROWS
  46 #endif
  47
  48 #ifdef __WXMOTIF__
  49 // For wxRETAINED implementation
  50 #ifdef __VMS__ //VMS's Xm.h is not (yet) compatible with C++
  51                //This code switches off the compiler warnings
  52 # pragma message disable nosimpint
  53 #endif
  54 #include <Xm/Xm.h>
  55 #ifdef __VMS__
  56 # pragma message enable nosimpint
  57 #endif
  58 #endif
  59
  60 IMPLEMENT_CLASS(wxScrolledWindow, wxGenericScrolledWindow)
  61
  62 // ----------------------------------------------------------------------------
  63 // wxScrollHelperEvtHandler: intercept the events from the window and forward
  64 // them to wxScrollHelper
  65 // ----------------------------------------------------------------------------
  66
  67 class WXDLLEXPORT wxScrollHelperEvtHandler : public wxEvtHandler
  68 {
  69 public:
  70     wxScrollHelperEvtHandler(wxScrollHelper *scrollHelper)
  71     {
  72         m_scrollHelper = scrollHelper;
  73     }
  74
  75     virtual bool ProcessEvent(wxEvent& event);
  76
  77     void ResetDrawnFlag() { m_hasDrawnWindow = FALSE; }
  78
  79 private:
  80     wxScrollHelper *m_scrollHelper;
  81
  82     bool m_hasDrawnWindow;
  83 };
  84
  85 // ----------------------------------------------------------------------------
  86 // wxAutoScrollTimer: the timer used to generate a stream of scroll events when
  87 // a captured mouse is held outside the window
  88 // ----------------------------------------------------------------------------
  89
  90 class wxAutoScrollTimer : public wxTimer
  91 {
  92 public:
  93     wxAutoScrollTimer(wxWindow *winToScroll, wxScrollHelper *scroll,
  94                       wxEventType eventTypeToSend,
  95                       int pos, int orient);
  96
  97     virtual void Notify();
  98
  99 private:
 100     wxWindow *m_win;
 101     wxScrollHelper *m_scrollHelper;
 102     wxEventType m_eventType;
 103     int m_pos,
 104         m_orient;
 105 };
 106
 107 // ============================================================================
 108 // implementation
 109 // ============================================================================
 110
 111 // ----------------------------------------------------------------------------
 112 // wxAutoScrollTimer
 113 // ----------------------------------------------------------------------------
 114
 115 wxAutoScrollTimer::wxAutoScrollTimer(wxWindow *winToScroll,
 116                                      wxScrollHelper *scroll,
 117                                      wxEventType eventTypeToSend,
 118                                      int pos, int orient)
 119 {
 120     m_win = winToScroll;
 121     m_scrollHelper = scroll;
 122     m_eventType = eventTypeToSend;
 123     m_pos = pos;
 124     m_orient = orient;
 125 }
 126
 127 void wxAutoScrollTimer::Notify()
 128 {
 129     // only do all this as long as the window is capturing the mouse
 130     if ( wxWindow::GetCapture() != m_win )
 131     {
 132         Stop();
 133     }
 134     else // we still capture the mouse, continue generating events
 135     {
 136         // first scroll the window if we are allowed to do it
 137         wxScrollWinEvent event1(m_eventType, m_pos, m_orient);
 138         event1.SetEventObject(m_win);
 139         if ( m_scrollHelper->SendAutoScrollEvents(event1) &&
 140                 m_win->GetEventHandler()->ProcessEvent(event1) )
 141         {
 142             // and then send a pseudo mouse-move event to refresh the selection
 143             wxMouseEvent event2(wxEVT_MOTION);
 144             wxGetMousePosition(&event2.m_x, &event2.m_y);
 145
 146             // the mouse event coordinates should be client, not screen as
 147             // returned by wxGetMousePosition
 148             wxWindow *parentTop = m_win;
 149             while ( parentTop->GetParent() )
 150                 parentTop = parentTop->GetParent();
 151             wxPoint ptOrig = parentTop->GetPosition();
 152             event2.m_x -= ptOrig.x;
 153             event2.m_y -= ptOrig.y;
 154
 155             event2.SetEventObject(m_win);
 156
 157             // FIXME: we don't fill in the other members - ok?
 158
 159             m_win->GetEventHandler()->ProcessEvent(event2);
 160         }
 161         else // can't scroll further, stop
 162         {
 163             Stop();
 164         }
 165     }
 166 }
 167
 168 // ----------------------------------------------------------------------------
 169 // wxScrollHelperEvtHandler
 170 // ----------------------------------------------------------------------------
 171
 172 bool wxScrollHelperEvtHandler::ProcessEvent(wxEvent& event)
 173 {
 174     wxEventType evType = event.GetEventType();
 175
 176     // always process the size events ourselves, even if the user code handles
 177     // them as well, as we need to AdjustScrollbars()
 178     if ( evType == wxEVT_SIZE )
 179     {
 180         m_scrollHelper->HandleOnSize((wxSizeEvent &)event);
 181     }
 182
 183     // the explanation of wxEVT_PAINT processing hack: for historic reasons
 184     // there are 2 ways to process this event in classes deriving from
 185     // wxScrolledWindow. The user code may
 186     //
 187     //  1. override wxScrolledWindow::OnDraw(dc)
 188     //  2. define its own OnPaint() handler
 189     //
 190     // In addition, in wxUniversal wxWindow defines OnPaint() itself and
 191     // always processes the draw event, so we can't just try the window
 192     // OnPaint() first and call our HandleOnPaint() if it doesn't process it
 193     // (the latter would never be called in wxUniversal).
 194     //
 195     // So the solution is to have a flag telling us whether the user code drew
 196     // anything in the window. We set it to true here but reset it to false in
 197     // wxScrolledWindow::OnPaint() handler (which wouldn't be called if the
 198     // user code defined OnPaint() in the derived class)
 199     m_hasDrawnWindow = TRUE;
 200
 201     if ( wxEvtHandler::ProcessEvent(event) )
 202     {
 203         // normally, nothing more to do here - except if it was a paint event
 204         // which wasn't really processed, then we'll try to call our
 205         // OnDraw() below (from HandleOnPaint)
 206         if ( !m_hasDrawnWindow )
 207         {
 208             return TRUE;
 209         }
 210     }
 211
 212     // reset the skipped flag to FALSE as it might have been set to TRUE in
 213     // ProcessEvent() above
 214     event.Skip(FALSE);
 215
 216     if ( evType == wxEVT_PAINT )
 217     {
 218         m_scrollHelper->HandleOnPaint((wxPaintEvent &)event);
 219         return TRUE;
 220     }
 221
 222     if ( evType == wxEVT_SCROLLWIN_TOP ||
 223          evType == wxEVT_SCROLLWIN_BOTTOM ||
 224          evType == wxEVT_SCROLLWIN_LINEUP ||
 225          evType == wxEVT_SCROLLWIN_LINEDOWN ||
 226          evType == wxEVT_SCROLLWIN_PAGEUP ||
 227          evType == wxEVT_SCROLLWIN_PAGEDOWN ||
 228          evType == wxEVT_SCROLLWIN_THUMBTRACK ||
 229          evType == wxEVT_SCROLLWIN_THUMBRELEASE )
 230     {
 231             m_scrollHelper->HandleOnScroll((wxScrollWinEvent &)event);
 232             return !event.GetSkipped();
 233     }
 234
 235     if ( evType == wxEVT_ENTER_WINDOW )
 236     {
 237         m_scrollHelper->HandleOnMouseEnter((wxMouseEvent &)event);
 238     }
 239     else if ( evType == wxEVT_LEAVE_WINDOW )
 240     {
 241         m_scrollHelper->HandleOnMouseLeave((wxMouseEvent &)event);
 242     }
 243 #if wxUSE_MOUSEWHEEL
 244     else if ( evType == wxEVT_MOUSEWHEEL )
 245     {
 246         m_scrollHelper->HandleOnMouseWheel((wxMouseEvent &)event);
 247     }
 248 #endif // wxUSE_MOUSEWHEEL
 249     else if ( evType == wxEVT_CHAR )
 250     {
 251         m_scrollHelper->HandleOnChar((wxKeyEvent &)event);
 252         return !event.GetSkipped();
 253     }
 254
 255     return FALSE;
 256 }
 257
 258 // ----------------------------------------------------------------------------
 259 // wxScrollHelper construction
 260 // ----------------------------------------------------------------------------
 261
 262 wxScrollHelper::wxScrollHelper(wxWindow *win)
 263 {
 264     m_xScrollPixelsPerLine =
 265     m_yScrollPixelsPerLine =
 266     m_xScrollPosition =
 267     m_yScrollPosition =
 268     m_xScrollLines =
 269     m_yScrollLines =
 270     m_xScrollLinesPerPage =
 271     m_yScrollLinesPerPage = 0;
 272
 273     m_xScrollingEnabled =
 274     m_yScrollingEnabled = TRUE;
 275
 276     m_scaleX =
 277     m_scaleY = 1.0;
 278 #if wxUSE_MOUSEWHEEL
 279     m_wheelRotation = 0;
 280 #endif
 281
 282     m_win =
 283     m_targetWindow = (wxWindow *)NULL;
 284
 285     m_timerAutoScroll = (wxTimer *)NULL;
 286
 287     m_handler = NULL;
 288
 289     if ( win )
 290         SetWindow(win);
 291 }
 292
 293 wxScrollHelper::~wxScrollHelper()
 294 {
 295     StopAutoScrolling();
 296
 297     DeleteEvtHandler();
 298 }
 299
 300 // ----------------------------------------------------------------------------
 301 // setting scrolling parameters
 302 // ----------------------------------------------------------------------------
 303
 304 void wxScrollHelper::SetScrollbars(int pixelsPerUnitX,
 305                                    int pixelsPerUnitY,
 306                                    int noUnitsX,
 307                                    int noUnitsY,
 308                                    int xPos,
 309                                    int yPos,
 310                                    bool noRefresh)
 311 {
 312     int xpos, ypos;
 313
 314     CalcUnscrolledPosition(xPos, yPos, &xpos, &ypos);
 315     bool do_refresh =
 316     (
 317       (noUnitsX != 0 && m_xScrollLines == 0) ||
 318       (noUnitsX < m_xScrollLines && xpos > pixelsPerUnitX*noUnitsX) ||
 319
 320       (noUnitsY != 0 && m_yScrollLines == 0) ||
 321       (noUnitsY < m_yScrollLines && ypos > pixelsPerUnitY*noUnitsY) ||
 322       (xPos != m_xScrollPosition) ||
 323       (yPos != m_yScrollPosition)
 324     );
 325
 326     m_xScrollPixelsPerLine = pixelsPerUnitX;
 327     m_yScrollPixelsPerLine = pixelsPerUnitY;
 328     m_xScrollPosition = xPos;
 329     m_yScrollPosition = yPos;
 330     m_xScrollLines = noUnitsX;
 331     m_yScrollLines = noUnitsY;
 332
 333 #ifdef __WXMOTIF__
 334     // Sorry, some Motif-specific code to implement a backing pixmap
 335     // for the wxRETAINED style. Implementing a backing store can't
 336     // be entirely generic because it relies on the wxWindowDC implementation
 337     // to duplicate X drawing calls for the backing pixmap.
 338
 339     if ( m_targetWindow->GetWindowStyle() & wxRETAINED )
 340     {
 341         Display* dpy = XtDisplay((Widget)m_targetWindow->GetMainWidget());
 342
 343         int totalPixelWidth = m_xScrollLines * m_xScrollPixelsPerLine;
 344         int totalPixelHeight = m_yScrollLines * m_yScrollPixelsPerLine;
 345         if (m_targetWindow->GetBackingPixmap() &&
 346            !((m_targetWindow->GetPixmapWidth() == totalPixelWidth) &&
 347              (m_targetWindow->GetPixmapHeight() == totalPixelHeight)))
 348         {
 349             XFreePixmap (dpy, (Pixmap) m_targetWindow->GetBackingPixmap());
 350             m_targetWindow->SetBackingPixmap((WXPixmap) 0);
 351         }
 352
 353         if (!m_targetWindow->GetBackingPixmap() &&
 354            (noUnitsX != 0) && (noUnitsY != 0))
 355         {
 356             int depth = wxDisplayDepth();
 357             m_targetWindow->SetPixmapWidth(totalPixelWidth);
 358             m_targetWindow->SetPixmapHeight(totalPixelHeight);
 359             m_targetWindow->SetBackingPixmap((WXPixmap) XCreatePixmap (dpy, RootWindow (dpy, DefaultScreen (dpy)),
 360               m_targetWindow->GetPixmapWidth(), m_targetWindow->GetPixmapHeight(), depth));
 361         }
 362
 363     }
 364 #endif // Motif
 365
 366     AdjustScrollbars();
 367
 368     if (do_refresh && !noRefresh)
 369         m_targetWindow->Refresh(TRUE, GetRect());
 370
 371 #ifdef __WXMAC__
 372     m_targetWindow->MacUpdateImmediately() ;
 373 #endif
 374 }
 375
 376 // ----------------------------------------------------------------------------
 377 // target window handling
 378 // ----------------------------------------------------------------------------
 379
 380 void wxScrollHelper::DeleteEvtHandler()
 381 {
 382     // FIXME: we should search for m_handler in the handler list
 383     if ( m_targetWindow )
 384     {
 385         m_targetWindow->PopEventHandler(TRUE /* Delete old event handler*/);
 386     }
 387 }
 388
 389 void wxScrollHelper::SetWindow(wxWindow *win)
 390 {
 391     wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
 392
 393     m_win = win;
 394
 395     DoSetTargetWindow(win);
 396 }
 397
 398 void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
 399 {
 400     m_targetWindow = target;
 401
 402     // install the event handler which will intercept the events we're
 403     // interested in
 404     m_handler = new wxScrollHelperEvtHandler(this);
 405     m_targetWindow->PushEventHandler(m_handler);
 406 }
 407
 408 void wxScrollHelper::SetTargetWindow( wxWindow *target )
 409 {
 410     wxCHECK_RET( target, wxT("target window must not be NULL") );
 411
 412     if ( target == m_targetWindow )
 413         return;
 414
 415     DeleteEvtHandler();
 416
 417     DoSetTargetWindow(target);
 418 }
 419
 420 wxWindow *wxScrollHelper::GetTargetWindow() const
 421 {
 422     return m_targetWindow;
 423 }
 424
 425 // ----------------------------------------------------------------------------
 426 // scrolling implementation itself
 427 // ----------------------------------------------------------------------------
 428
 429 void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
 430 {
 431     int nScrollInc = CalcScrollInc(event);
 432     if ( nScrollInc == 0 )
 433     {
 434         // can't scroll further
 435         event.Skip();
 436
 437         return;
 438     }
 439
 440     int orient = event.GetOrientation();
 441     if (orient == wxHORIZONTAL)
 442     {
 443         m_xScrollPosition += nScrollInc;
 444         m_targetWindow->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
 445     }
 446     else
 447     {
 448         m_yScrollPosition += nScrollInc;
 449         m_targetWindow->SetScrollPos(wxVERTICAL, m_yScrollPosition);
 450     }
 451
 452     bool needsRefresh = FALSE;
 453     int dx = 0,
 454         dy = 0;
 455     if (orient == wxHORIZONTAL)
 456     {
 457        if ( m_xScrollingEnabled )
 458        {
 459            dx = -m_xScrollPixelsPerLine * nScrollInc;
 460        }
 461        else
 462        {
 463            needsRefresh = TRUE;
 464        }
 465     }
 466     else
 467     {
 468         if ( m_yScrollingEnabled )
 469         {
 470             dy = -m_yScrollPixelsPerLine * nScrollInc;
 471         }
 472         else
 473         {
 474             needsRefresh = TRUE;
 475         }
 476     }
 477
 478     if ( needsRefresh )
 479     {
 480         m_targetWindow->Refresh(TRUE, GetRect());
 481     }
 482     else
 483     {
 484         m_targetWindow->ScrollWindow(dx, dy, GetRect());
 485     }
 486
 487 #ifdef __WXMAC__
 488     m_targetWindow->MacUpdateImmediately() ;
 489 #endif
 490 }
 491
 492 int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
 493 {
 494     int pos = event.GetPosition();
 495     int orient = event.GetOrientation();
 496
 497     int nScrollInc = 0;
 498     if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)
 499     {
 500             if (orient == wxHORIZONTAL)
 501                 nScrollInc = - m_xScrollPosition;
 502             else
 503                 nScrollInc = - m_yScrollPosition;
 504     } else
 505     if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
 506     {
 507             if (orient == wxHORIZONTAL)
 508                 nScrollInc = m_xScrollLines - m_xScrollPosition;
 509             else
 510                 nScrollInc = m_yScrollLines - m_yScrollPosition;
 511     } else
 512     if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
 513     {
 514             nScrollInc = -1;
 515     } else
 516     if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
 517     {
 518             nScrollInc = 1;
 519     } else
 520     if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
 521     {
 522             if (orient == wxHORIZONTAL)
 523                 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
 524             else
 525                 nScrollInc = -GetScrollPageSize(wxVERTICAL);
 526     } else
 527     if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
 528     {
 529             if (orient == wxHORIZONTAL)
 530                 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
 531             else
 532                 nScrollInc = GetScrollPageSize(wxVERTICAL);
 533     } else
 534     if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
 535         (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
 536     {
 537             if (orient == wxHORIZONTAL)
 538                 nScrollInc = pos - m_xScrollPosition;
 539             else
 540                 nScrollInc = pos - m_yScrollPosition;
 541     }
 542
 543     if (orient == wxHORIZONTAL)
 544     {
 545         if (m_xScrollPixelsPerLine > 0)
 546         {
 547             int w, h;
 548             GetTargetSize(&w, &h);
 549
 550             int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 551             int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
 552             if (noPositions < 0)
 553                 noPositions = 0;
 554
 555             if ( (m_xScrollPosition + nScrollInc) < 0 )
 556                 nScrollInc = -m_xScrollPosition; // As -ve as we can go
 557             else if ( (m_xScrollPosition + nScrollInc) > noPositions )
 558                 nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
 559         }
 560         else
 561             m_targetWindow->Refresh(TRUE, GetRect());
 562     }
 563     else
 564     {
 565         if (m_yScrollPixelsPerLine > 0)
 566         {
 567             int w, h;
 568             GetTargetSize(&w, &h);
 569
 570             int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 571             int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
 572             if (noPositions < 0)
 573                 noPositions = 0;
 574
 575             if ( (m_yScrollPosition + nScrollInc) < 0 )
 576                 nScrollInc = -m_yScrollPosition; // As -ve as we can go
 577             else if ( (m_yScrollPosition + nScrollInc) > noPositions )
 578                 nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
 579         }
 580         else
 581             m_targetWindow->Refresh(TRUE, GetRect());
 582     }
 583
 584     return nScrollInc;
 585 }
 586
 587 // Adjust the scrollbars - new version.
 588 void wxScrollHelper::AdjustScrollbars()
 589 {
 590 #ifdef __WXMAC__
 591     m_targetWindow->MacUpdateImmediately();
 592 #endif
 593
 594     int w, h;
 595     GetTargetSize(&w, &h);
 596
 597     int oldXScroll = m_xScrollPosition;
 598     int oldYScroll = m_yScrollPosition;
 599
 600     if (m_xScrollLines > 0)
 601     {
 602         // Calculate page size i.e. number of scroll units you get on the
 603         // current client window
 604         int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
 605         if (noPagePositions < 1) noPagePositions = 1;
 606         if ( noPagePositions > m_xScrollLines )
 607             noPagePositions = m_xScrollLines;
 608
 609         // Correct position if greater than extent of canvas minus
 610         // the visible portion of it or if below zero
 611         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
 612         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 613
 614         m_targetWindow->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
 615         // The amount by which we scroll when paging
 616         SetScrollPageSize(wxHORIZONTAL, noPagePositions);
 617     }
 618     else
 619     {
 620         m_xScrollPosition = 0;
 621         m_targetWindow->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
 622     }
 623
 624     if (m_yScrollLines > 0)
 625     {
 626         // Calculate page size i.e. number of scroll units you get on the
 627         // current client window
 628         int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
 629         if (noPagePositions < 1) noPagePositions = 1;
 630         if ( noPagePositions > m_yScrollLines )
 631             noPagePositions = m_yScrollLines;
 632
 633         // Correct position if greater than extent of canvas minus
 634         // the visible portion of it or if below zero
 635         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 636         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 637
 638         m_targetWindow->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
 639         // The amount by which we scroll when paging
 640         SetScrollPageSize(wxVERTICAL, noPagePositions);
 641     }
 642     else
 643     {
 644         m_yScrollPosition = 0;
 645         m_targetWindow->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
 646     }
 647
 648     if (oldXScroll != m_xScrollPosition)
 649     {
 650        if (m_xScrollingEnabled)
 651             m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0,
 652                                           GetRect() );
 653        else
 654             m_targetWindow->Refresh(TRUE, GetRect());
 655     }
 656
 657     if (oldYScroll != m_yScrollPosition)
 658     {
 659         if (m_yScrollingEnabled)
 660             m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
 661                                           GetRect() );
 662         else
 663             m_targetWindow->Refresh(TRUE, GetRect());
 664     }
 665
 666 #ifdef __WXMAC__
 667     m_targetWindow->MacUpdateImmediately();
 668 #endif
 669 }
 670
 671 void wxScrollHelper::DoPrepareDC(wxDC& dc)
 672 {
 673     wxPoint pt = dc.GetDeviceOrigin();
 674     dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
 675                         pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
 676     dc.SetUserScale( m_scaleX, m_scaleY );
 677 }
 678
 679 void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 680 {
 681     if ( x_unit )
 682         *x_unit = m_xScrollPixelsPerLine;
 683     if ( y_unit )
 684         *y_unit = m_yScrollPixelsPerLine;
 685 }
 686
 687 int wxScrollHelper::GetScrollPageSize(int orient) const
 688 {
 689     if ( orient == wxHORIZONTAL )
 690         return m_xScrollLinesPerPage;
 691     else
 692         return m_yScrollLinesPerPage;
 693 }
 694
 695 void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
 696 {
 697     if ( orient == wxHORIZONTAL )
 698         m_xScrollLinesPerPage = pageSize;
 699     else
 700         m_yScrollLinesPerPage = pageSize;
 701 }
 702
 703 /*
 704  * Scroll to given position (scroll position, not pixel position)
 705  */
 706 void wxScrollHelper::Scroll( int x_pos, int y_pos )
 707 {
 708     if (!m_targetWindow)
 709         return;
 710
 711     if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
 712         ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
 713
 714 #ifdef __WXMAC__
 715     m_targetWindow->MacUpdateImmediately();
 716 #endif
 717
 718     int w, h;
 719     GetTargetSize(&w, &h);
 720
 721     if ((x_pos != -1) && (m_xScrollPixelsPerLine))
 722     {
 723         int old_x = m_xScrollPosition;
 724         m_xScrollPosition = x_pos;
 725
 726         // Calculate page size i.e. number of scroll units you get on the
 727         // current client window
 728         int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
 729         if (noPagePositions < 1) noPagePositions = 1;
 730
 731         // Correct position if greater than extent of canvas minus
 732         // the visible portion of it or if below zero
 733         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
 734         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 735
 736         if (old_x != m_xScrollPosition) {
 737             m_targetWindow->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );
 738             m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
 739                                           GetRect() );
 740         }
 741     }
 742     if ((y_pos != -1) && (m_yScrollPixelsPerLine))
 743     {
 744         int old_y = m_yScrollPosition;
 745         m_yScrollPosition = y_pos;
 746
 747         // Calculate page size i.e. number of scroll units you get on the
 748         // current client window
 749         int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
 750         if (noPagePositions < 1) noPagePositions = 1;
 751
 752         // Correct position if greater than extent of canvas minus
 753         // the visible portion of it or if below zero
 754         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 755         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 756
 757         if (old_y != m_yScrollPosition) {
 758             m_targetWindow->SetScrollPos( wxVERTICAL, m_yScrollPosition );
 759             m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine,
 760                                           GetRect() );
 761         }
 762     }
 763
 764 #ifdef __WXMAC__
 765     m_targetWindow->MacUpdateImmediately();
 766 #endif
 767
 768 }
 769
 770 void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
 771 {
 772     m_xScrollingEnabled = x_scroll;
 773     m_yScrollingEnabled = y_scroll;
 774 }
 775
 776 void wxScrollHelper::GetVirtualSize (int *x, int *y) const
 777 {
 778     if ( x )
 779         *x = m_xScrollPixelsPerLine * m_xScrollLines;
 780     if ( y )
 781         *y = m_yScrollPixelsPerLine * m_yScrollLines;
 782 }
 783
 784 // Where the current view starts from
 785 void wxScrollHelper::GetViewStart (int *x, int *y) const
 786 {
 787     if ( x )
 788         *x = m_xScrollPosition;
 789     if ( y )
 790         *y = m_yScrollPosition;
 791 }
 792
 793 void wxScrollHelper::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
 794 {
 795     if ( xx )
 796         *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
 797     if ( yy )
 798         *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 799 }
 800
 801 void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
 802 {
 803     if ( xx )
 804         *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
 805     if ( yy )
 806         *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
 807 }
 808
 809 // ----------------------------------------------------------------------------
 810 // event handlers
 811 // ----------------------------------------------------------------------------
 812
 813 // Default OnSize resets scrollbars, if any
 814 void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
 815 {
 816 #if wxUSE_CONSTRAINTS
 817     if ( m_targetWindow->GetAutoLayout() )
 818         m_targetWindow->Layout();
 819 #endif
 820
 821     AdjustScrollbars();
 822 }
 823
 824 // This calls OnDraw, having adjusted the origin according to the current
 825 // scroll position
 826 void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
 827 {
 828     wxPaintDC dc(m_targetWindow);
 829     DoPrepareDC(dc);
 830
 831     OnDraw(dc);
 832 }
 833
 834 // kbd handling: notice that we use OnChar() and not OnKeyDown() for
 835 // compatibility here - if we used OnKeyDown(), the programs which process
 836 // arrows themselves in their OnChar() would never get the message and like
 837 // this they always have the priority
 838 void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
 839 {
 840     int stx, sty,       // view origin
 841         szx, szy,       // view size (total)
 842         clix, cliy;     // view size (on screen)
 843
 844     GetViewStart(&stx, &sty);
 845     GetTargetSize(&clix, &cliy);
 846     GetVirtualSize(&szx, &szy);
 847
 848     if( m_xScrollPixelsPerLine )
 849     {
 850         clix /= m_xScrollPixelsPerLine;
 851         szx /= m_xScrollPixelsPerLine;
 852     }
 853     else
 854     {
 855         clix = 0;
 856         szx = -1;
 857     }
 858     if( m_yScrollPixelsPerLine )
 859     {
 860         cliy /= m_yScrollPixelsPerLine;
 861         szy /= m_yScrollPixelsPerLine;
 862     }
 863     else
 864     {
 865         cliy = 0;
 866         szy = -1;
 867     }
 868
 869     int xScrollOld = m_xScrollPosition,
 870         yScrollOld = m_yScrollPosition;
 871
 872     int dsty;
 873     switch ( event.KeyCode() )
 874     {
 875         case WXK_PAGEUP:
 876         case WXK_PRIOR:
 877             dsty = sty - (5 * cliy / 6);
 878             Scroll(-1, (dsty == -1) ? 0 : dsty);
 879             break;
 880
 881         case WXK_PAGEDOWN:
 882         case WXK_NEXT:
 883             Scroll(-1, sty + (5 * cliy / 6));
 884             break;
 885
 886         case WXK_HOME:
 887             Scroll(0, event.ControlDown() ? 0 : -1);
 888             break;
 889
 890         case WXK_END:
 891             Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
 892             break;
 893
 894         case WXK_UP:
 895             Scroll(-1, sty - 1);
 896             break;
 897
 898         case WXK_DOWN:
 899             Scroll(-1, sty + 1);
 900             break;
 901
 902         case WXK_LEFT:
 903             Scroll(stx - 1, -1);
 904             break;
 905
 906         case WXK_RIGHT:
 907             Scroll(stx + 1, -1);
 908             break;
 909
 910         default:
 911             // not for us
 912             event.Skip();
 913     }
 914
 915     if ( m_xScrollPosition != xScrollOld )
 916     {
 917         wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
 918                                wxHORIZONTAL);
 919         event.SetEventObject(m_win);
 920         m_win->GetEventHandler()->ProcessEvent(event);
 921     }
 922
 923     if ( m_yScrollPosition != yScrollOld )
 924     {
 925         wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition,
 926                                wxVERTICAL);
 927         event.SetEventObject(m_win);
 928         m_win->GetEventHandler()->ProcessEvent(event);
 929     }
 930 }
 931
 932 // ----------------------------------------------------------------------------
 933 // autoscroll stuff: these functions deal with sending fake scroll events when
 934 // a captured mouse is being held outside the window
 935 // ----------------------------------------------------------------------------
 936
 937 bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const
 938 {
 939     // only send the event if the window is scrollable in this direction
 940     wxWindow *win = (wxWindow *)event.GetEventObject();
 941     return win->HasScrollbar(event.GetOrientation());
 942 }
 943
 944 void wxScrollHelper::StopAutoScrolling()
 945 {
 946     if ( m_timerAutoScroll )
 947     {
 948         delete m_timerAutoScroll;
 949         m_timerAutoScroll = (wxTimer *)NULL;
 950     }
 951 }
 952
 953 void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event)
 954 {
 955     StopAutoScrolling();
 956
 957     event.Skip();
 958 }
 959
 960 void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
 961 {
 962     // don't prevent the usual processing of the event from taking place
 963     event.Skip();
 964
 965     // when a captured mouse leave a scrolled window we start generate
 966     // scrolling events to allow, for example, extending selection beyond the
 967     // visible area in some controls
 968     if ( wxWindow::GetCapture() == m_targetWindow )
 969     {
 970         // where is the mouse leaving?
 971         int pos, orient;
 972         wxPoint pt = event.GetPosition();
 973         if ( pt.x < 0 )
 974         {
 975             orient = wxHORIZONTAL;
 976             pos = 0;
 977         }
 978         else if ( pt.y < 0 )
 979         {
 980             orient = wxVERTICAL;
 981             pos = 0;
 982         }
 983         else // we're lower or to the right of the window
 984         {
 985             wxSize size = m_targetWindow->GetClientSize();
 986             if ( pt.x > size.x )
 987             {
 988                 orient = wxHORIZONTAL;
 989                 pos = m_xScrollLines;
 990             }
 991             else if ( pt.y > size.y )
 992             {
 993                 orient = wxVERTICAL;
 994                 pos = m_yScrollLines;
 995             }
 996             else // this should be impossible
 997             {
 998                 // but seems to happen sometimes under wxMSW - maybe it's a bug
 999                 // there but for now just ignore it
1000
1001                 //wxFAIL_MSG( _T("can't understand where has mouse gone") );
1002
1003                 return;
1004             }
1005         }
1006
1007         // only start the auto scroll timer if the window can be scrolled in
1008         // this direction
1009         if ( !m_targetWindow->HasScrollbar(orient) )
1010             return;
1011
1012         delete m_timerAutoScroll;
1013         m_timerAutoScroll = new wxAutoScrollTimer
1014                                 (
1015                                     m_targetWindow, this,
1016                                     pos == 0 ? wxEVT_SCROLLWIN_LINEUP
1017                                              : wxEVT_SCROLLWIN_LINEDOWN,
1018                                     pos,
1019                                     orient
1020                                 );
1021         m_timerAutoScroll->Start(50); // FIXME: make configurable
1022     }
1023 }
1024
1025 #if wxUSE_MOUSEWHEEL
1026
1027 void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
1028 {
1029     m_wheelRotation += event.GetWheelRotation();
1030     int lines = m_wheelRotation / event.GetWheelDelta();
1031     m_wheelRotation -= lines * event.GetWheelDelta();
1032
1033     if (lines != 0)
1034     {
1035         lines *= event.GetLinesPerAction();
1036
1037         wxScrollWinEvent newEvent;
1038
1039         newEvent.SetPosition(0);
1040         newEvent.SetOrientation(wxVERTICAL);
1041         newEvent.m_eventObject = m_win;
1042         if (lines > 0)
1043             newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
1044         else
1045             newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
1046
1047         int times = abs(lines);
1048         for (; times > 0; times --)
1049             m_win->GetEventHandler()->ProcessEvent(newEvent);
1050
1051         /* Old Way */
1052         // int vsx, vsy;
1053         // GetViewStart(&vsx, &vsy);
1054         // Scroll(-1, vsy - lines);
1055     }
1056 }
1057
1058 #endif // wxUSE_MOUSEWHEEL
1059
1060 // ----------------------------------------------------------------------------
1061 // wxGenericScrolledWindow implementation
1062 // ----------------------------------------------------------------------------
1063
1064 IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
1065
1066 BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
1067     EVT_PAINT(wxGenericScrolledWindow::OnPaint)
1068 END_EVENT_TABLE()
1069
1070 bool wxGenericScrolledWindow::Create(wxWindow *parent,
1071                               wxWindowID id,
1072                               const wxPoint& pos,
1073                               const wxSize& size,
1074                               long style,
1075                               const wxString& name)
1076 {
1077     m_targetWindow = this;
1078
1079     bool ok = wxPanel::Create(parent, id, pos, size, style, name);
1080
1081 #ifdef __WXMSW__
1082     // we need to process arrows ourselves for scrolling
1083     m_lDlgCode |= DLGC_WANTARROWS;
1084 #endif // __WXMSW__
1085
1086     return ok;
1087 }
1088
1089 wxGenericScrolledWindow::~wxGenericScrolledWindow()
1090 {
1091 }
1092
1093 void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
1094 {
1095     // the user code didn't really draw the window if we got here, so set this
1096     // flag to try to call OnDraw() later
1097     m_handler->ResetDrawnFlag();
1098
1099     event.Skip();
1100 }
1101
1102 #if WXWIN_COMPATIBILITY
1103
1104 void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
1105 {
1106       *x_page = GetScrollPageSize(wxHORIZONTAL);
1107       *y_page = GetScrollPageSize(wxVERTICAL);
1108 }
1109
1110 void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
1111 {
1112     if ( xx )
1113         *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
1114     if ( yy )
1115         *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
1116 }
1117
1118 #endif // WXWIN_COMPATIBILITY
1119
1120 #endif // !wxGTK
1121