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