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