src/generic/scrolwin.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        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 #ifdef __GNUG__
  13 #pragma implementation
  14 #pragma implementation "scrolwin.h"
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #include "wx/utils.h"
  21 #include "wx/dcclient.h"
  22
  23 #ifdef __WXMSW__
  24 #include "windows.h"
  25 #endif
  26
  27 #ifdef __BORLANDC__
  28 #pragma hdrstop
  29 #endif
  30
  31 #include "wx/generic/scrolwin.h"
  32
  33 #if !USE_SHARED_LIBRARY
  34 BEGIN_EVENT_TABLE(wxScrolledWindow, wxWindow)
  35     EVT_SCROLL(wxScrolledWindow::OnScroll)
  36     EVT_SIZE(wxScrolledWindow::OnSize)
  37     EVT_PAINT(wxScrolledWindow::OnPaint)
  38 END_EVENT_TABLE()
  39
  40 IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxWindow)
  41 #endif
  42
  43 wxScrolledWindow::wxScrolledWindow(void)
  44 {
  45     m_xScrollPixelsPerLine = 0;
  46     m_yScrollPixelsPerLine = 0;
  47     m_xScrollingEnabled = TRUE;
  48     m_yScrollingEnabled = TRUE;
  49     m_xScrollPosition = 0;
  50     m_yScrollPosition = 0;
  51     m_xScrollLines = 0;
  52     m_yScrollLines = 0;
  53     m_xScrollLinesPerPage = 0;
  54     m_yScrollLinesPerPage = 0;
  55     m_scaleX = 1.0;
  56     m_scaleY = 1.0;
  57 }
  58
  59 bool wxScrolledWindow::Create(wxWindow *parent, wxWindowID id,
  60            const wxPoint& pos,
  61            const wxSize& size,
  62            long style,
  63            const wxString& name)
  64 {
  65     m_xScrollPixelsPerLine = 0;
  66     m_yScrollPixelsPerLine = 0;
  67     m_xScrollingEnabled = TRUE;
  68     m_yScrollingEnabled = TRUE;
  69     m_xScrollPosition = 0;
  70     m_yScrollPosition = 0;
  71     m_xScrollLines = 0;
  72     m_yScrollLines = 0;
  73     m_xScrollLinesPerPage = 0;
  74     m_yScrollLinesPerPage = 0;
  75     m_scaleX = 1.0;
  76     m_scaleY = 1.0;
  77
  78     return wxWindow::Create(parent, id, pos, size, style, name);
  79 }
  80
  81 /*
  82  * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
  83  * noUnitsX/noUnitsY:        : no. units per scrollbar
  84  */
  85 void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
  86                int noUnitsX, int noUnitsY,
  87                int xPos, int yPos, bool noRefresh )
  88 {
  89     bool do_refresh =
  90     (
  91       (noUnitsX != 0 && m_xScrollLines == 0) ||
  92       (noUnitsX < m_xScrollPosition) ||
  93       (noUnitsY != 0 && m_yScrollLines == 0) ||
  94       (noUnitsY < m_yScrollPosition) ||
  95       (xPos != m_xScrollPosition) ||
  96       (yPos != m_yScrollPosition) ||
  97       (pixelsPerUnitX != m_xScrollPixelsPerLine) ||
  98       (pixelsPerUnitY != m_yScrollPixelsPerLine)
  99     );
 100
 101     m_xScrollPixelsPerLine = pixelsPerUnitX;
 102     m_yScrollPixelsPerLine = pixelsPerUnitY;
 103     m_xScrollPosition = xPos;
 104     m_yScrollPosition = yPos;
 105     m_xScrollLines = noUnitsX;
 106     m_yScrollLines = noUnitsY;
 107
 108     AdjustScrollbars();
 109
 110    if (do_refresh && !noRefresh) Refresh();
 111
 112 #ifdef __WXMSW__
 113     UpdateWindow ((HWND) GetHWND());
 114 #endif
 115 }
 116
 117 void wxScrolledWindow::OnScroll(wxScrollEvent& event)
 118 {
 119     int orient = event.GetOrientation();
 120
 121     int nScrollInc = CalcScrollInc(event);
 122     if (nScrollInc == 0) return;
 123
 124     // TODO: should we store the scroll position here as well as in wxWindow?
 125     if (orient == wxHORIZONTAL)
 126     {
 127         int newPos = m_xScrollPosition + nScrollInc;
 128         SetScrollPos(wxHORIZONTAL, newPos, TRUE );
 129     }
 130     else
 131     {
 132         int newPos = m_yScrollPosition + nScrollInc;
 133         SetScrollPos(wxVERTICAL, newPos, TRUE );
 134     }
 135
 136 /*
 137   // TODO We need to multiply the ScrollWindow amount by the scaling
 138   // factor, but how do we know what this is in wxWin 2.0???
 139   float scaleX = 1.0;
 140   float scaleY = 1.0;
 141
 142   if ( this->IsKindOf(CLASSINFO(wxCanvas)) )
 143   {
 144     wxDC* dc = ((wxCanvas *)this)->GetDC();
 145     dc->GetUserScale(&scaleX, &scaleY);
 146   }
 147 */
 148
 149     if (orient == wxHORIZONTAL)
 150     {
 151         m_xScrollPosition += nScrollInc;
 152     }
 153     else
 154     {
 155         m_yScrollPosition += nScrollInc;
 156     }
 157
 158     if (orient == wxHORIZONTAL)
 159     {
 160        if (m_xScrollingEnabled)
 161             ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL);
 162        else
 163             Refresh();
 164     }
 165     else
 166     {
 167         if (m_yScrollingEnabled)
 168             ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
 169         else
 170             Refresh();
 171   }
 172 }
 173
 174 int wxScrolledWindow::CalcScrollInc(wxScrollEvent& event)
 175 {
 176   int pos = event.GetPosition();
 177   int orient = event.GetOrientation();
 178
 179   int nScrollInc = 0;
 180   switch (event.GetEventType())
 181   {
 182     case wxEVT_SCROLL_TOP:
 183     {
 184       if (orient == wxHORIZONTAL)
 185         nScrollInc = - m_xScrollPosition;
 186       else
 187         nScrollInc = - m_yScrollPosition;
 188       break;
 189     }
 190     case wxEVT_SCROLL_BOTTOM:
 191     {
 192       if (orient == wxHORIZONTAL)
 193         nScrollInc = m_xScrollLines - m_xScrollPosition;
 194       else
 195         nScrollInc = m_yScrollLines - m_yScrollPosition;
 196       break;
 197     }
 198     case wxEVT_SCROLL_LINEUP:
 199     {
 200       nScrollInc = -1;
 201       break;
 202     }
 203     case wxEVT_SCROLL_LINEDOWN:
 204     {
 205       nScrollInc = 1;
 206       break;
 207     }
 208     case wxEVT_SCROLL_PAGEUP:
 209     {
 210       if (orient == wxHORIZONTAL)
 211         nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
 212       else
 213         nScrollInc = -GetScrollPageSize(wxVERTICAL);
 214       break;
 215     }
 216     case wxEVT_SCROLL_PAGEDOWN:
 217     {
 218       if (orient == wxHORIZONTAL)
 219         nScrollInc = GetScrollPageSize(wxHORIZONTAL);
 220       else
 221         nScrollInc = GetScrollPageSize(wxVERTICAL);
 222       break;
 223     }
 224     case wxEVT_SCROLL_THUMBTRACK:
 225     {
 226       if (orient == wxHORIZONTAL)
 227         nScrollInc = pos - m_xScrollPosition;
 228       else
 229         nScrollInc = pos - m_yScrollPosition;
 230       break;
 231     }
 232     default:
 233     {
 234       break;
 235     }
 236   }
 237   if (orient == wxHORIZONTAL)
 238   {
 239     if (m_xScrollPixelsPerLine > 0) {
 240       int w, h;
 241       GetClientSize(&w, &h);
 242
 243       int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
 244       int noPositions = (int) ( ((nMaxWidth - w)/(float)m_xScrollPixelsPerLine) + 0.5 );
 245       if (noPositions < 0)
 246         noPositions = 0;
 247
 248       if ( (m_xScrollPosition + nScrollInc) < 0 )
 249         nScrollInc = -m_xScrollPosition; // As -ve as we can go
 250       else if ( (m_xScrollPosition + nScrollInc) > noPositions )
 251         nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
 252     }
 253     else
 254       Refresh();
 255   }
 256   else
 257   {
 258     if (m_yScrollPixelsPerLine > 0) {
 259       int w, h;
 260       GetClientSize(&w, &h);
 261
 262       int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
 263       int noPositions = (int) ( ((nMaxHeight - h)/(float)m_yScrollPixelsPerLine) + 0.5 );
 264       if (noPositions < 0)
 265         noPositions = 0;
 266
 267       if ( (m_yScrollPosition + nScrollInc) < 0 )
 268         nScrollInc = -m_yScrollPosition; // As -ve as we can go
 269       else if ( (m_yScrollPosition + nScrollInc) > noPositions )
 270         nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
 271     }
 272     else
 273       Refresh();
 274   }
 275
 276   return nScrollInc;
 277 }
 278
 279 // Adjust the scrollbars - new version.
 280 void wxScrolledWindow::AdjustScrollbars(void)
 281 {
 282     int w, h;
 283     GetClientSize(&w, &h);
 284
 285     if (m_xScrollLines > 0)
 286     {
 287         // Calculate page size i.e. number of scroll units you get on the
 288         // current client window
 289         int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 );
 290         if (noPagePositions < 1) noPagePositions = 1;
 291
 292         // Correct position if greater than extent of canvas minus
 293         // the visible portion of it or if below zero
 294         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
 295         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 296
 297         SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
 298 //      SetScrollPageSize(wxHORIZONTAL, noPagePositions);
 299     }
 300     else
 301     {
 302         m_xScrollPosition = 0;
 303         SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
 304     }
 305
 306     if (m_yScrollLines > 0)
 307     {
 308         // Calculate page size i.e. number of scroll units you get on the
 309         // current client window
 310         int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 );
 311         if (noPagePositions < 1) noPagePositions = 1;
 312
 313         // Correct position if greater than extent of canvas minus
 314         // the visible portion of it or if below zero
 315         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 316         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 317
 318         SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
 319 //      SetScrollPageSize(wxVERTICAL, noPagePositions);
 320     }
 321     else
 322     {
 323         m_yScrollPosition = 0;
 324         SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
 325     }
 326 }
 327
 328 // Default OnSize resets scrollbars, if any
 329 void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
 330 {
 331 #if wxUSE_CONSTRAINTS
 332     if (GetAutoLayout()) Layout();
 333 #endif
 334
 335     AdjustScrollbars();
 336 }
 337
 338 // This calls OnDraw, having adjusted the origin according to the current
 339 // scroll position
 340 void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
 341 {
 342     wxPaintDC dc(this);
 343     PrepareDC(dc);
 344
 345     OnDraw(dc);
 346 }
 347
 348 // Override this function if you don't want to have wxScrolledWindow
 349 // automatically change the origin according to the scroll position.
 350 void wxScrolledWindow::PrepareDC(wxDC& dc)
 351 {
 352     dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
 353                         -m_yScrollPosition * m_yScrollPixelsPerLine );
 354     dc.SetUserScale( m_scaleX, m_scaleY );
 355 }
 356
 357 #if WXWIN_COMPATIBILITY
 358 void wxScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
 359 {
 360       *x_page = GetScrollPageSize(wxHORIZONTAL);
 361       *y_page = GetScrollPageSize(wxVERTICAL);
 362 }
 363 #endif
 364
 365 void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
 366 {
 367       *x_unit = m_xScrollPixelsPerLine;
 368       *y_unit = m_yScrollPixelsPerLine;
 369 }
 370
 371 int wxScrolledWindow::GetScrollPageSize(int orient) const
 372 {
 373     if ( orient == wxHORIZONTAL )
 374         return m_xScrollLinesPerPage;
 375     else
 376         return m_yScrollLinesPerPage;
 377 }
 378
 379 void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
 380 {
 381     if ( orient == wxHORIZONTAL )
 382         m_xScrollLinesPerPage = pageSize;
 383     else
 384         m_yScrollLinesPerPage = pageSize;
 385 }
 386
 387 /*
 388  * Scroll to given position (scroll position, not pixel position)
 389  */
 390 void wxScrolledWindow::Scroll( int x_pos, int y_pos )
 391 {
 392     if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
 393         ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
 394
 395     int w, h;
 396     GetClientSize(&w, &h);
 397
 398     if (x_pos != -1)
 399     {
 400         m_xScrollPosition = x_pos;
 401
 402         // Calculate page size i.e. number of scroll units you get on the
 403         // current client window
 404         int noPagePositions = (int) ( (w/(float)m_xScrollPixelsPerLine) + 0.5 );
 405         if (noPagePositions < 1) noPagePositions = 1;
 406
 407         // Correct position if greater than extent of canvas minus
 408         // the visible portion of it or if below zero
 409         m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
 410         m_xScrollPosition = wxMax( 0, m_xScrollPosition );
 411
 412         SetScrollPos( wxHORIZONTAL, m_xScrollPosition, TRUE );
 413     }
 414     if (y_pos != -1)
 415     {
 416         m_yScrollPosition = y_pos;
 417
 418         // Calculate page size i.e. number of scroll units you get on the
 419         // current client window
 420         int noPagePositions = (int) ( (h/(float)m_yScrollPixelsPerLine) + 0.5 );
 421         if (noPagePositions < 1) noPagePositions = 1;
 422
 423         // Correct position if greater than extent of canvas minus
 424         // the visible portion of it or if below zero
 425         m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
 426         m_yScrollPosition = wxMax( 0, m_yScrollPosition );
 427
 428         SetScrollPos( wxVERTICAL, m_yScrollPosition, TRUE );
 429     }
 430
 431     Refresh();
 432
 433 #ifdef __WXMSW__
 434     ::UpdateWindow ((HWND) GetHWND());
 435 #endif
 436 }
 437
 438 void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
 439 {
 440     m_xScrollingEnabled = x_scroll;
 441     m_yScrollingEnabled = y_scroll;
 442 }
 443
 444 void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
 445 {
 446     *x = m_xScrollPixelsPerLine * m_xScrollLines;
 447     *y = m_yScrollPixelsPerLine * m_yScrollLines;
 448 }
 449
 450 // Where the current view starts from
 451 void wxScrolledWindow::ViewStart (int *x, int *y) const
 452 {
 453     *x = m_xScrollPosition;
 454     *y = m_yScrollPosition;
 455 }
 456
 457 void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
 458 {
 459     *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
 460     *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
 461 }
 462
 463 void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
 464 {
 465     *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
 466     *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
 467 }
 468
 469