]> git.saurik.com Git - wxWidgets.git/blob - src/generic/scrlwing.cpp
ignore clicks on a toolbar but outside any button
[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 // search for m_handler in the handler list
393 if ( m_win && m_handler )
394 {
395 if ( m_win->RemoveEventHandler(m_handler) )
396 {
397 delete m_handler;
398 }
399 //else: something is very wrong, so better [maybe] leak memory than
400 // risk a crash because of double deletion
401
402 m_handler = NULL;
403 }
404 }
405
406 void wxScrollHelper::SetWindow(wxWindow *win)
407 {
408 wxCHECK_RET( win, _T("wxScrollHelper needs a window to scroll") );
409
410 m_win = win;
411
412 // by default, the associated window is also the target window
413 DoSetTargetWindow(win);
414 }
415
416 void wxScrollHelper::DoSetTargetWindow(wxWindow *target)
417 {
418 m_targetWindow = target;
419
420 // install the event handler which will intercept the events we're
421 // interested in (but only do it for our real window, not the target window
422 // which we scroll - we don't need to hijack its events)
423 if ( m_targetWindow == m_win )
424 {
425 // if we already have a handler, delete it first
426 DeleteEvtHandler();
427
428 m_handler = new wxScrollHelperEvtHandler(this);
429 m_targetWindow->PushEventHandler(m_handler);
430 }
431 }
432
433 void wxScrollHelper::SetTargetWindow(wxWindow *target)
434 {
435 wxCHECK_RET( target, wxT("target window must not be NULL") );
436
437 if ( target == m_targetWindow )
438 return;
439
440 DoSetTargetWindow(target);
441 }
442
443 wxWindow *wxScrollHelper::GetTargetWindow() const
444 {
445 return m_targetWindow;
446 }
447
448 // ----------------------------------------------------------------------------
449 // scrolling implementation itself
450 // ----------------------------------------------------------------------------
451
452 void wxScrollHelper::HandleOnScroll(wxScrollWinEvent& event)
453 {
454 int nScrollInc = CalcScrollInc(event);
455 if ( nScrollInc == 0 )
456 {
457 // can't scroll further
458 event.Skip();
459
460 return;
461 }
462
463 int orient = event.GetOrientation();
464 if (orient == wxHORIZONTAL)
465 {
466 m_xScrollPosition += nScrollInc;
467 m_win->SetScrollPos(wxHORIZONTAL, m_xScrollPosition);
468 }
469 else
470 {
471 m_yScrollPosition += nScrollInc;
472 m_win->SetScrollPos(wxVERTICAL, m_yScrollPosition);
473 }
474
475 bool needsRefresh = FALSE;
476 int dx = 0,
477 dy = 0;
478 if (orient == wxHORIZONTAL)
479 {
480 if ( m_xScrollingEnabled )
481 {
482 dx = -m_xScrollPixelsPerLine * nScrollInc;
483 }
484 else
485 {
486 needsRefresh = TRUE;
487 }
488 }
489 else
490 {
491 if ( m_yScrollingEnabled )
492 {
493 dy = -m_yScrollPixelsPerLine * nScrollInc;
494 }
495 else
496 {
497 needsRefresh = TRUE;
498 }
499 }
500
501 if ( needsRefresh )
502 {
503 m_targetWindow->Refresh(TRUE, GetRect());
504 }
505 else
506 {
507 m_targetWindow->ScrollWindow(dx, dy, GetRect());
508 }
509
510 #ifdef __WXMAC__
511 m_targetWindow->MacUpdateImmediately() ;
512 #endif
513 }
514
515 int wxScrollHelper::CalcScrollInc(wxScrollWinEvent& event)
516 {
517 int pos = event.GetPosition();
518 int orient = event.GetOrientation();
519
520 int nScrollInc = 0;
521 if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)
522 {
523 if (orient == wxHORIZONTAL)
524 nScrollInc = - m_xScrollPosition;
525 else
526 nScrollInc = - m_yScrollPosition;
527 } else
528 if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
529 {
530 if (orient == wxHORIZONTAL)
531 nScrollInc = m_xScrollLines - m_xScrollPosition;
532 else
533 nScrollInc = m_yScrollLines - m_yScrollPosition;
534 } else
535 if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
536 {
537 nScrollInc = -1;
538 } else
539 if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
540 {
541 nScrollInc = 1;
542 } else
543 if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
544 {
545 if (orient == wxHORIZONTAL)
546 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
547 else
548 nScrollInc = -GetScrollPageSize(wxVERTICAL);
549 } else
550 if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
551 {
552 if (orient == wxHORIZONTAL)
553 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
554 else
555 nScrollInc = GetScrollPageSize(wxVERTICAL);
556 } else
557 if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
558 (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
559 {
560 if (orient == wxHORIZONTAL)
561 nScrollInc = pos - m_xScrollPosition;
562 else
563 nScrollInc = pos - m_yScrollPosition;
564 }
565
566 if (orient == wxHORIZONTAL)
567 {
568 if (m_xScrollPixelsPerLine > 0)
569 {
570 int w, h;
571 GetTargetSize(&w, &h);
572
573 int nMaxWidth = m_xScrollLines*m_xScrollPixelsPerLine;
574 int noPositions = (int) ( ((nMaxWidth - w)/(double)m_xScrollPixelsPerLine) + 0.5 );
575 if (noPositions < 0)
576 noPositions = 0;
577
578 if ( (m_xScrollPosition + nScrollInc) < 0 )
579 nScrollInc = -m_xScrollPosition; // As -ve as we can go
580 else if ( (m_xScrollPosition + nScrollInc) > noPositions )
581 nScrollInc = noPositions - m_xScrollPosition; // As +ve as we can go
582 }
583 else
584 m_targetWindow->Refresh(TRUE, GetRect());
585 }
586 else
587 {
588 if (m_yScrollPixelsPerLine > 0)
589 {
590 int w, h;
591 GetTargetSize(&w, &h);
592
593 int nMaxHeight = m_yScrollLines*m_yScrollPixelsPerLine;
594 int noPositions = (int) ( ((nMaxHeight - h)/(double)m_yScrollPixelsPerLine) + 0.5 );
595 if (noPositions < 0)
596 noPositions = 0;
597
598 if ( (m_yScrollPosition + nScrollInc) < 0 )
599 nScrollInc = -m_yScrollPosition; // As -ve as we can go
600 else if ( (m_yScrollPosition + nScrollInc) > noPositions )
601 nScrollInc = noPositions - m_yScrollPosition; // As +ve as we can go
602 }
603 else
604 m_targetWindow->Refresh(TRUE, GetRect());
605 }
606
607 return nScrollInc;
608 }
609
610 // Adjust the scrollbars - new version.
611 void wxScrollHelper::AdjustScrollbars()
612 {
613 #ifdef __WXMAC__
614 m_targetWindow->MacUpdateImmediately();
615 #endif
616
617 int w, h;
618 GetTargetSize(&w, &h);
619
620 int oldXScroll = m_xScrollPosition;
621 int oldYScroll = m_yScrollPosition;
622
623 if (m_xScrollLines > 0)
624 {
625 // Calculate page size i.e. number of scroll units you get on the
626 // current client window
627 int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
628 if (noPagePositions < 1) noPagePositions = 1;
629 if ( noPagePositions > m_xScrollLines )
630 noPagePositions = m_xScrollLines;
631
632 // Correct position if greater than extent of canvas minus
633 // the visible portion of it or if below zero
634 m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition);
635 m_xScrollPosition = wxMax( 0, m_xScrollPosition );
636
637 m_win->SetScrollbar(wxHORIZONTAL, m_xScrollPosition, noPagePositions, m_xScrollLines);
638 // The amount by which we scroll when paging
639 SetScrollPageSize(wxHORIZONTAL, noPagePositions);
640 }
641 else
642 {
643 m_xScrollPosition = 0;
644 m_win->SetScrollbar (wxHORIZONTAL, 0, 0, 0, FALSE);
645 }
646
647 if (m_yScrollLines > 0)
648 {
649 // Calculate page size i.e. number of scroll units you get on the
650 // current client window
651 int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
652 if (noPagePositions < 1) noPagePositions = 1;
653 if ( noPagePositions > m_yScrollLines )
654 noPagePositions = m_yScrollLines;
655
656 // Correct position if greater than extent of canvas minus
657 // the visible portion of it or if below zero
658 m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
659 m_yScrollPosition = wxMax( 0, m_yScrollPosition );
660
661 m_win->SetScrollbar(wxVERTICAL, m_yScrollPosition, noPagePositions, m_yScrollLines);
662 // The amount by which we scroll when paging
663 SetScrollPageSize(wxVERTICAL, noPagePositions);
664 }
665 else
666 {
667 m_yScrollPosition = 0;
668 m_win->SetScrollbar (wxVERTICAL, 0, 0, 0, FALSE);
669 }
670
671 if (oldXScroll != m_xScrollPosition)
672 {
673 if (m_xScrollingEnabled)
674 m_targetWindow->ScrollWindow( m_xScrollPixelsPerLine * (oldXScroll-m_xScrollPosition), 0,
675 GetRect() );
676 else
677 m_targetWindow->Refresh(TRUE, GetRect());
678 }
679
680 if (oldYScroll != m_yScrollPosition)
681 {
682 if (m_yScrollingEnabled)
683 m_targetWindow->ScrollWindow( 0, m_yScrollPixelsPerLine * (oldYScroll-m_yScrollPosition),
684 GetRect() );
685 else
686 m_targetWindow->Refresh(TRUE, GetRect());
687 }
688
689 #ifdef __WXMAC__
690 m_targetWindow->MacUpdateImmediately();
691 #endif
692 }
693
694 void wxScrollHelper::DoPrepareDC(wxDC& dc)
695 {
696 wxPoint pt = dc.GetDeviceOrigin();
697 dc.SetDeviceOrigin( pt.x - m_xScrollPosition * m_xScrollPixelsPerLine,
698 pt.y - m_yScrollPosition * m_yScrollPixelsPerLine );
699 dc.SetUserScale( m_scaleX, m_scaleY );
700 }
701
702 void wxScrollHelper::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
703 {
704 if ( x_unit )
705 *x_unit = m_xScrollPixelsPerLine;
706 if ( y_unit )
707 *y_unit = m_yScrollPixelsPerLine;
708 }
709
710 int wxScrollHelper::GetScrollPageSize(int orient) const
711 {
712 if ( orient == wxHORIZONTAL )
713 return m_xScrollLinesPerPage;
714 else
715 return m_yScrollLinesPerPage;
716 }
717
718 void wxScrollHelper::SetScrollPageSize(int orient, int pageSize)
719 {
720 if ( orient == wxHORIZONTAL )
721 m_xScrollLinesPerPage = pageSize;
722 else
723 m_yScrollLinesPerPage = pageSize;
724 }
725
726 /*
727 * Scroll to given position (scroll position, not pixel position)
728 */
729 void wxScrollHelper::Scroll( int x_pos, int y_pos )
730 {
731 if (!m_targetWindow)
732 return;
733
734 if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
735 ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
736
737 #ifdef __WXMAC__
738 m_targetWindow->MacUpdateImmediately();
739 #endif
740
741 int w, h;
742 GetTargetSize(&w, &h);
743
744 if ((x_pos != -1) && (m_xScrollPixelsPerLine))
745 {
746 int old_x = m_xScrollPosition;
747 m_xScrollPosition = x_pos;
748
749 // Calculate page size i.e. number of scroll units you get on the
750 // current client window
751 int noPagePositions = (int) ( (w/(double)m_xScrollPixelsPerLine) + 0.5 );
752 if (noPagePositions < 1) noPagePositions = 1;
753
754 // Correct position if greater than extent of canvas minus
755 // the visible portion of it or if below zero
756 m_xScrollPosition = wxMin( m_xScrollLines-noPagePositions, m_xScrollPosition );
757 m_xScrollPosition = wxMax( 0, m_xScrollPosition );
758
759 if (old_x != m_xScrollPosition) {
760 m_win->SetScrollPos( wxHORIZONTAL, m_xScrollPosition );
761 m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0,
762 GetRect() );
763 }
764 }
765 if ((y_pos != -1) && (m_yScrollPixelsPerLine))
766 {
767 int old_y = m_yScrollPosition;
768 m_yScrollPosition = y_pos;
769
770 // Calculate page size i.e. number of scroll units you get on the
771 // current client window
772 int noPagePositions = (int) ( (h/(double)m_yScrollPixelsPerLine) + 0.5 );
773 if (noPagePositions < 1) noPagePositions = 1;
774
775 // Correct position if greater than extent of canvas minus
776 // the visible portion of it or if below zero
777 m_yScrollPosition = wxMin( m_yScrollLines-noPagePositions, m_yScrollPosition );
778 m_yScrollPosition = wxMax( 0, m_yScrollPosition );
779
780 if (old_y != m_yScrollPosition) {
781 m_win->SetScrollPos( wxVERTICAL, m_yScrollPosition );
782 m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine,
783 GetRect() );
784 }
785 }
786
787 #ifdef __WXMAC__
788 m_targetWindow->MacUpdateImmediately();
789 #endif
790
791 }
792
793 void wxScrollHelper::EnableScrolling (bool x_scroll, bool y_scroll)
794 {
795 m_xScrollingEnabled = x_scroll;
796 m_yScrollingEnabled = y_scroll;
797 }
798
799 void wxScrollHelper::GetVirtualSize (int *x, int *y) const
800 {
801 if ( x )
802 *x = m_xScrollPixelsPerLine * m_xScrollLines;
803 if ( y )
804 *y = m_yScrollPixelsPerLine * m_yScrollLines;
805 }
806
807 // Where the current view starts from
808 void wxScrollHelper::GetViewStart (int *x, int *y) const
809 {
810 if ( x )
811 *x = m_xScrollPosition;
812 if ( y )
813 *y = m_yScrollPosition;
814 }
815
816 void wxScrollHelper::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
817 {
818 if ( xx )
819 *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
820 if ( yy )
821 *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
822 }
823
824 void wxScrollHelper::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
825 {
826 if ( xx )
827 *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
828 if ( yy )
829 *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
830 }
831
832 // ----------------------------------------------------------------------------
833 // event handlers
834 // ----------------------------------------------------------------------------
835
836 // Default OnSize resets scrollbars, if any
837 void wxScrollHelper::HandleOnSize(wxSizeEvent& WXUNUSED(event))
838 {
839 #if wxUSE_CONSTRAINTS
840 if ( m_win->GetAutoLayout() )
841 m_win->Layout();
842 #endif
843
844 AdjustScrollbars();
845 }
846
847 // This calls OnDraw, having adjusted the origin according to the current
848 // scroll position
849 void wxScrollHelper::HandleOnPaint(wxPaintEvent& WXUNUSED(event))
850 {
851 // don't use m_targetWindow here, this is always called for ourselves
852 wxPaintDC dc(m_win);
853 DoPrepareDC(dc);
854
855 OnDraw(dc);
856 }
857
858 // kbd handling: notice that we use OnChar() and not OnKeyDown() for
859 // compatibility here - if we used OnKeyDown(), the programs which process
860 // arrows themselves in their OnChar() would never get the message and like
861 // this they always have the priority
862 void wxScrollHelper::HandleOnChar(wxKeyEvent& event)
863 {
864 int stx, sty, // view origin
865 szx, szy, // view size (total)
866 clix, cliy; // view size (on screen)
867
868 GetViewStart(&stx, &sty);
869 GetTargetSize(&clix, &cliy);
870 GetVirtualSize(&szx, &szy);
871
872 if( m_xScrollPixelsPerLine )
873 {
874 clix /= m_xScrollPixelsPerLine;
875 szx /= m_xScrollPixelsPerLine;
876 }
877 else
878 {
879 clix = 0;
880 szx = -1;
881 }
882 if( m_yScrollPixelsPerLine )
883 {
884 cliy /= m_yScrollPixelsPerLine;
885 szy /= m_yScrollPixelsPerLine;
886 }
887 else
888 {
889 cliy = 0;
890 szy = -1;
891 }
892
893 int xScrollOld = m_xScrollPosition,
894 yScrollOld = m_yScrollPosition;
895
896 int dsty;
897 switch ( event.KeyCode() )
898 {
899 case WXK_PAGEUP:
900 case WXK_PRIOR:
901 dsty = sty - (5 * cliy / 6);
902 Scroll(-1, (dsty == -1) ? 0 : dsty);
903 break;
904
905 case WXK_PAGEDOWN:
906 case WXK_NEXT:
907 Scroll(-1, sty + (5 * cliy / 6));
908 break;
909
910 case WXK_HOME:
911 Scroll(0, event.ControlDown() ? 0 : -1);
912 break;
913
914 case WXK_END:
915 Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
916 break;
917
918 case WXK_UP:
919 Scroll(-1, sty - 1);
920 break;
921
922 case WXK_DOWN:
923 Scroll(-1, sty + 1);
924 break;
925
926 case WXK_LEFT:
927 Scroll(stx - 1, -1);
928 break;
929
930 case WXK_RIGHT:
931 Scroll(stx + 1, -1);
932 break;
933
934 default:
935 // not for us
936 event.Skip();
937 }
938
939 if ( m_xScrollPosition != xScrollOld )
940 {
941 wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_xScrollPosition,
942 wxHORIZONTAL);
943 event.SetEventObject(m_win);
944 m_win->GetEventHandler()->ProcessEvent(event);
945 }
946
947 if ( m_yScrollPosition != yScrollOld )
948 {
949 wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, m_yScrollPosition,
950 wxVERTICAL);
951 event.SetEventObject(m_win);
952 m_win->GetEventHandler()->ProcessEvent(event);
953 }
954 }
955
956 // ----------------------------------------------------------------------------
957 // autoscroll stuff: these functions deal with sending fake scroll events when
958 // a captured mouse is being held outside the window
959 // ----------------------------------------------------------------------------
960
961 bool wxScrollHelper::SendAutoScrollEvents(wxScrollWinEvent& event) const
962 {
963 // only send the event if the window is scrollable in this direction
964 wxWindow *win = (wxWindow *)event.GetEventObject();
965 return win->HasScrollbar(event.GetOrientation());
966 }
967
968 void wxScrollHelper::StopAutoScrolling()
969 {
970 if ( m_timerAutoScroll )
971 {
972 delete m_timerAutoScroll;
973 m_timerAutoScroll = (wxTimer *)NULL;
974 }
975 }
976
977 void wxScrollHelper::HandleOnMouseEnter(wxMouseEvent& event)
978 {
979 StopAutoScrolling();
980
981 event.Skip();
982 }
983
984 void wxScrollHelper::HandleOnMouseLeave(wxMouseEvent& event)
985 {
986 // don't prevent the usual processing of the event from taking place
987 event.Skip();
988
989 // when a captured mouse leave a scrolled window we start generate
990 // scrolling events to allow, for example, extending selection beyond the
991 // visible area in some controls
992 if ( wxWindow::GetCapture() == m_targetWindow )
993 {
994 // where is the mouse leaving?
995 int pos, orient;
996 wxPoint pt = event.GetPosition();
997 if ( pt.x < 0 )
998 {
999 orient = wxHORIZONTAL;
1000 pos = 0;
1001 }
1002 else if ( pt.y < 0 )
1003 {
1004 orient = wxVERTICAL;
1005 pos = 0;
1006 }
1007 else // we're lower or to the right of the window
1008 {
1009 wxSize size = m_targetWindow->GetClientSize();
1010 if ( pt.x > size.x )
1011 {
1012 orient = wxHORIZONTAL;
1013 pos = m_xScrollLines;
1014 }
1015 else if ( pt.y > size.y )
1016 {
1017 orient = wxVERTICAL;
1018 pos = m_yScrollLines;
1019 }
1020 else // this should be impossible
1021 {
1022 // but seems to happen sometimes under wxMSW - maybe it's a bug
1023 // there but for now just ignore it
1024
1025 //wxFAIL_MSG( _T("can't understand where has mouse gone") );
1026
1027 return;
1028 }
1029 }
1030
1031 // only start the auto scroll timer if the window can be scrolled in
1032 // this direction
1033 if ( !m_targetWindow->HasScrollbar(orient) )
1034 return;
1035
1036 delete m_timerAutoScroll;
1037 m_timerAutoScroll = new wxAutoScrollTimer
1038 (
1039 m_targetWindow, this,
1040 pos == 0 ? wxEVT_SCROLLWIN_LINEUP
1041 : wxEVT_SCROLLWIN_LINEDOWN,
1042 pos,
1043 orient
1044 );
1045 m_timerAutoScroll->Start(50); // FIXME: make configurable
1046 }
1047 }
1048
1049 #if wxUSE_MOUSEWHEEL
1050
1051 void wxScrollHelper::HandleOnMouseWheel(wxMouseEvent& event)
1052 {
1053 m_wheelRotation += event.GetWheelRotation();
1054 int lines = m_wheelRotation / event.GetWheelDelta();
1055 m_wheelRotation -= lines * event.GetWheelDelta();
1056
1057 if (lines != 0)
1058 {
1059 lines *= event.GetLinesPerAction();
1060
1061 wxScrollWinEvent newEvent;
1062
1063 newEvent.SetPosition(0);
1064 newEvent.SetOrientation(wxVERTICAL);
1065 newEvent.m_eventObject = m_win;
1066 if (lines > 0)
1067 newEvent.m_eventType = wxEVT_SCROLLWIN_LINEUP;
1068 else
1069 newEvent.m_eventType = wxEVT_SCROLLWIN_LINEDOWN;
1070
1071 int times = abs(lines);
1072 for (; times > 0; times --)
1073 m_win->GetEventHandler()->ProcessEvent(newEvent);
1074
1075 /* Old Way */
1076 // int vsx, vsy;
1077 // GetViewStart(&vsx, &vsy);
1078 // Scroll(-1, vsy - lines);
1079 }
1080 }
1081
1082 #endif // wxUSE_MOUSEWHEEL
1083
1084 // ----------------------------------------------------------------------------
1085 // wxGenericScrolledWindow implementation
1086 // ----------------------------------------------------------------------------
1087
1088 IMPLEMENT_DYNAMIC_CLASS(wxGenericScrolledWindow, wxPanel)
1089
1090 BEGIN_EVENT_TABLE(wxGenericScrolledWindow, wxPanel)
1091 EVT_PAINT(wxGenericScrolledWindow::OnPaint)
1092 END_EVENT_TABLE()
1093
1094 bool wxGenericScrolledWindow::Create(wxWindow *parent,
1095 wxWindowID id,
1096 const wxPoint& pos,
1097 const wxSize& size,
1098 long style,
1099 const wxString& name)
1100 {
1101 m_targetWindow = this;
1102
1103 bool ok = wxPanel::Create(parent, id, pos, size, style, name);
1104
1105 return ok;
1106 }
1107
1108 wxGenericScrolledWindow::~wxGenericScrolledWindow()
1109 {
1110 }
1111
1112 void wxGenericScrolledWindow::OnPaint(wxPaintEvent& event)
1113 {
1114 // the user code didn't really draw the window if we got here, so set this
1115 // flag to try to call OnDraw() later
1116 m_handler->ResetDrawnFlag();
1117
1118 event.Skip();
1119 }
1120
1121 #ifdef __WXMSW__
1122 long
1123 wxGenericScrolledWindow::MSWWindowProc(WXUINT nMsg,
1124 WXWPARAM wParam,
1125 WXLPARAM lParam)
1126 {
1127 long rc = wxPanel::MSWWindowProc(nMsg, wParam, lParam);
1128
1129 // we need to process arrows ourselves for scrolling
1130 if ( nMsg == WM_GETDLGCODE )
1131 {
1132 rc |= DLGC_WANTARROWS;
1133 }
1134
1135 return rc;
1136 }
1137
1138 #endif // __WXMSW__
1139
1140 #if WXWIN_COMPATIBILITY
1141
1142 void wxGenericScrolledWindow::GetScrollUnitsPerPage (int *x_page, int *y_page) const
1143 {
1144 *x_page = GetScrollPageSize(wxHORIZONTAL);
1145 *y_page = GetScrollPageSize(wxVERTICAL);
1146 }
1147
1148 void wxGenericScrolledWindow::CalcUnscrolledPosition(int x, int y, float *xx, float *yy) const
1149 {
1150 if ( xx )
1151 *xx = (float)(x + m_xScrollPosition * m_xScrollPixelsPerLine);
1152 if ( yy )
1153 *yy = (float)(y + m_yScrollPosition * m_yScrollPixelsPerLine);
1154 }
1155
1156 #endif // WXWIN_COMPATIBILITY
1157
1158 #endif // !wxGTK
1159