]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/gtk1/scrolwin.cpp
projects / wxWidgets.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
implemented system menu handling in wxUniv
[wxWidgets.git] / src / gtk1 / scrolwin.cpp
... / ...
CommitLineData
1/////////////////////////////////////////////////////////////////////////////
2// Name: gtk/scrolwin.cpp
3// Purpose: wxScrolledWindow implementation
4// Author: Julian Smart
5// Modified by:
6// Created: 01/02/97
7// RCS-ID: $Id$
8// Copyright: (c) Julian Smart and Markus Holzem
9// Licence: wxWindows license
10/////////////////////////////////////////////////////////////////////////////
11
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
20#ifdef __GNUG__
21 #pragma implementation "scrolwin.h"
22#endif
23
24// For compilers that support precompilation, includes "wx.h".
25#include "wx/wxprec.h"
26
27#ifdef __BORLANDC__
28 #pragma hdrstop
29#endif
30
31#include "wx/utils.h"
32#include "wx/dcclient.h"
33
34#include "wx/scrolwin.h"
35#include "wx/panel.h"
36
37#include "wx/gtk/private.h"
38#include "wx/gtk/win_gtk.h"
39
40// ----------------------------------------------------------------------------
41// event tables
42// ----------------------------------------------------------------------------
43
44BEGIN_EVENT_TABLE(wxScrolledWindow, wxPanel)
45 EVT_SCROLLWIN(wxScrolledWindow::OnScroll)
46 EVT_SIZE(wxScrolledWindow::OnSize)
47 EVT_PAINT(wxScrolledWindow::OnPaint)
48 EVT_CHAR(wxScrolledWindow::OnChar)
49END_EVENT_TABLE()
50
51IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow, wxPanel)
52
53// ============================================================================
54// implementation
55// ============================================================================
56
57//-----------------------------------------------------------------------------
58// data
59//-----------------------------------------------------------------------------
60
61extern bool g_blockEventsOnDrag;
62extern bool g_blockEventsOnScroll;
63
64//-----------------------------------------------------------------------------
65// idle system
66//-----------------------------------------------------------------------------
67
68extern void wxapp_install_idle_handler();
69extern bool g_isIdle;
70
71//-----------------------------------------------------------------------------
72// "value_changed" from m_vAdjust
73//-----------------------------------------------------------------------------
74
75static void gtk_scrolled_window_vscroll_callback( GtkAdjustment *adjust,
76 SCROLLBAR_CBACK_ARG
77 wxScrolledWindow *win )
78{
79 if (g_isIdle)
80 wxapp_install_idle_handler();
81
82 if (g_blockEventsOnDrag) return;
83
84 if (!win->m_hasVMT) return;
85
86 win->GtkVScroll( adjust->value,
87 GET_SCROLL_TYPE(GTK_SCROLLED_WINDOW(win->m_widget)->vscrollbar) );
88}
89
90//-----------------------------------------------------------------------------
91// "value_changed" from m_hAdjust
92//-----------------------------------------------------------------------------
93
94static void gtk_scrolled_window_hscroll_callback( GtkAdjustment *adjust,
95 SCROLLBAR_CBACK_ARG
96 wxScrolledWindow *win )
97{
98 if (g_isIdle)
99 wxapp_install_idle_handler();
100
101 if (g_blockEventsOnDrag) return;
102 if (!win->m_hasVMT) return;
103
104 win->GtkHScroll( adjust->value,
105 GET_SCROLL_TYPE(GTK_SCROLLED_WINDOW(win->m_widget)->hscrollbar) );
106}
107
108//-----------------------------------------------------------------------------
109// "button_press_event" from scrollbar
110//-----------------------------------------------------------------------------
111
112static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
113 GdkEventButton *gdk_event,
114 wxWindowGTK *win)
115{
116 if (g_isIdle)
117 wxapp_install_idle_handler();
118
119 g_blockEventsOnScroll = TRUE;
120
121 // FIXME: there is no slider field any more, what was meant here?
122#ifndef __WXGTK20__
123 win->m_isScrolling = (gdk_event->window == widget->slider);
124#endif
125
126 return FALSE;
127}
128
129//-----------------------------------------------------------------------------
130// "button_release_event" from scrollbar
131//-----------------------------------------------------------------------------
132
133static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
134 GdkEventButton *WXUNUSED(gdk_event),
135 wxWindowGTK *win)
136{
137// don't test here as we can release the mouse while being over
138// a different window than the slider
139//
140// if (gdk_event->window != widget->slider) return FALSE;
141
142 g_blockEventsOnScroll = FALSE;
143
144 if (win->m_isScrolling)
145 {
146 wxEventType command = wxEVT_SCROLLWIN_THUMBRELEASE;
147 int value = -1;
148 int dir = -1;
149
150 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(win->m_widget);
151 if (widget == GTK_RANGE(scrolledWindow->hscrollbar))
152 {
153 value = (int)(win->m_hAdjust->value+0.5);
154 dir = wxHORIZONTAL;
155 }
156 if (widget == GTK_RANGE(scrolledWindow->vscrollbar))
157 {
158 value = (int)(win->m_vAdjust->value+0.5);
159 dir = wxVERTICAL;
160 }
161
162 wxScrollWinEvent event( command, value, dir );
163 event.SetEventObject( win );
164 win->GetEventHandler()->ProcessEvent( event );
165 }
166
167 win->m_isScrolling = FALSE;
168
169 return FALSE;
170}
171
172//-----------------------------------------------------------------------------
173// InsertChild for wxScrolledWindow
174//-----------------------------------------------------------------------------
175
176static void wxInsertChildInScrolledWindow( wxWindow* parent, wxWindow* child )
177{
178 // The window might have been scrolled already, do we
179 // have to adapt the position.
180 GtkPizza *pizza = GTK_PIZZA(parent->m_wxwindow);
181 child->m_x += pizza->xoffset;
182 child->m_y += pizza->yoffset;
183
184 gtk_pizza_put( GTK_PIZZA(parent->m_wxwindow),
185 GTK_WIDGET(child->m_widget),
186 child->m_x,
187 child->m_y,
188 child->m_width,
189 child->m_height );
190}
191
192// ----------------------------------------------------------------------------
193// wxScrolledWindow creation
194// ----------------------------------------------------------------------------
195
196void wxScrolledWindow::Init()
197{
198 m_xScrollPixelsPerLine = 0;
199 m_yScrollPixelsPerLine = 0;
200 m_xScrollingEnabled = TRUE;
201 m_yScrollingEnabled = TRUE;
202 m_xScrollPosition = 0;
203 m_yScrollPosition = 0;
204 m_xScrollLines = 0;
205 m_yScrollLines = 0;
206 m_xScrollLinesPerPage = 0;
207 m_yScrollLinesPerPage = 0;
208 m_targetWindow = (wxWindow*) NULL;
209 m_scaleX = 1.0;
210 m_scaleY = 1.0;
211 m_hasScrolling = TRUE;
212}
213
214bool wxScrolledWindow::Create(wxWindow *parent,
215 wxWindowID id,
216 const wxPoint& pos,
217 const wxSize& size,
218 long style,
219 const wxString& name)
220{
221 Init();
222
223 if (!PreCreation( parent, pos, size ) ||
224 !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ))
225 {
226 wxFAIL_MSG( wxT("wxWindow creation failed") );
227 return FALSE;
228 }
229
230 m_insertCallback = wxInsertChildInScrolledWindow;
231
232 m_targetWindow = this;
233
234 m_widget = gtk_scrolled_window_new( (GtkAdjustment *) NULL, (GtkAdjustment *) NULL );
235 GTK_WIDGET_UNSET_FLAGS( m_widget, GTK_CAN_FOCUS );
236
237 GtkScrolledWindow *scrolledWindow = GTK_SCROLLED_WINDOW(m_widget);
238
239 GtkScrolledWindowClass *scroll_class = GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget) );
240 scroll_class->scrollbar_spacing = 0;
241
242 gtk_scrolled_window_set_policy( scrolledWindow, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
243
244 m_hAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->hscrollbar) );
245 m_vAdjust = gtk_range_get_adjustment( GTK_RANGE(scrolledWindow->vscrollbar) );
246
247 m_wxwindow = gtk_pizza_new();
248
249 gtk_container_add( GTK_CONTAINER(m_widget), m_wxwindow );
250
251 GtkPizza *pizza = GTK_PIZZA(m_wxwindow);
252
253 if (HasFlag(wxRAISED_BORDER))
254 {
255 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_OUT );
256 }
257 else if (HasFlag(wxSUNKEN_BORDER))
258 {
259 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_IN );
260 }
261 else if (HasFlag(wxSIMPLE_BORDER))
262 {
263 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_THIN );
264 }
265 else
266 {
267 gtk_pizza_set_shadow_type( pizza, GTK_MYSHADOW_NONE );
268 }
269
270 GTK_WIDGET_SET_FLAGS( m_wxwindow, GTK_CAN_FOCUS );
271 m_acceptsFocus = TRUE;
272
273 // I _really_ don't want scrollbars in the beginning
274 m_vAdjust->lower = 0.0;
275 m_vAdjust->upper = 1.0;
276 m_vAdjust->value = 0.0;
277 m_vAdjust->step_increment = 1.0;
278 m_vAdjust->page_increment = 1.0;
279 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
280 m_hAdjust->lower = 0.0;
281 m_hAdjust->upper = 1.0;
282 m_hAdjust->value = 0.0;
283 m_hAdjust->step_increment = 1.0;
284 m_hAdjust->page_increment = 1.0;
285 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
286
287 // Handlers for new scrollbar values
288 GtkVConnectEvent();
289 GtkHConnectEvent();
290
291 // these handlers block mouse events to any window during scrolling such as
292 // motion events and prevent GTK and wxWindows from fighting over where the
293 // slider should be
294
295 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
296 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
297
298 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_press_event",
299 (GtkSignalFunc)gtk_scrollbar_button_press_callback, (gpointer) this );
300
301 gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_release_event",
302 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
303
304 gtk_signal_connect( GTK_OBJECT(scrolledWindow->hscrollbar), "button_release_event",
305 (GtkSignalFunc)gtk_scrollbar_button_release_callback, (gpointer) this );
306
307 gtk_widget_show( m_wxwindow );
308
309 if (m_parent)
310 m_parent->DoAddChild( this );
311
312 m_focusWidget = m_wxwindow;
313
314 PostCreation();
315
316 Show( TRUE );
317
318 return TRUE;
319}
320
321// ----------------------------------------------------------------------------
322// setting scrolling parameters
323// ----------------------------------------------------------------------------
324
325/*
326 * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
327 * noUnitsX/noUnitsY: : no. units per scrollbar
328 */
329void wxScrolledWindow::SetScrollbars (int pixelsPerUnitX, int pixelsPerUnitY,
330 int noUnitsX, int noUnitsY,
331 int xPos, int yPos, bool noRefresh )
332{
333 int old_x = m_xScrollPixelsPerLine * m_xScrollPosition;
334 int old_y = m_yScrollPixelsPerLine * m_yScrollPosition;
335
336 m_xScrollPixelsPerLine = pixelsPerUnitX;
337 m_yScrollPixelsPerLine = pixelsPerUnitY;
338 m_xScrollLines = noUnitsX;
339 m_yScrollLines = noUnitsY;
340 m_xScrollPosition = xPos;
341 m_yScrollPosition = yPos;
342
343 m_hAdjust->lower = 0.0;
344 m_hAdjust->upper = noUnitsX;
345 m_hAdjust->value = xPos;
346 m_hAdjust->step_increment = 1.0;
347 m_hAdjust->page_increment = 2.0;
348
349 m_vAdjust->lower = 0.0;
350 m_vAdjust->upper = noUnitsY;
351 m_vAdjust->value = yPos;
352 m_vAdjust->step_increment = 1.0;
353 m_vAdjust->page_increment = 2.0;
354
355 AdjustScrollbars();
356
357 if (!noRefresh)
358 {
359 int new_x = m_xScrollPixelsPerLine * m_xScrollPosition;
360 int new_y = m_yScrollPixelsPerLine * m_yScrollPosition;
361
362 m_targetWindow->ScrollWindow( old_x-new_x, old_y-new_y );
363 }
364}
365
366void wxScrolledWindow::AdjustScrollbars()
367{
368 int w, h;
369 m_targetWindow->GetClientSize( &w, &h );
370
371 if (m_xScrollPixelsPerLine == 0)
372 m_hAdjust->page_size = 1.0;
373 else
374 m_hAdjust->page_size = (w / m_xScrollPixelsPerLine);
375
376 if (m_yScrollPixelsPerLine == 0)
377 m_vAdjust->page_size = 1.0;
378 else
379 m_vAdjust->page_size = (h / m_yScrollPixelsPerLine);
380
381 m_xScrollLinesPerPage = (int)(m_hAdjust->page_size + 0.5);
382 m_yScrollLinesPerPage = (int)(m_vAdjust->page_size + 0.5);
383
384 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
385 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
386}
387
388// ----------------------------------------------------------------------------
389// target window handling
390// ----------------------------------------------------------------------------
391
392void wxScrolledWindow::SetTargetWindow( wxWindow *target, bool WXUNUSED(pushEventHandler) )
393{
394 wxASSERT_MSG( target, wxT("target window must not be NULL") );
395 m_targetWindow = target;
396}
397
398wxWindow *wxScrolledWindow::GetTargetWindow()
399{
400 return m_targetWindow;
401}
402
403// Override this function if you don't want to have wxScrolledWindow
404// automatically change the origin according to the scroll position.
405void wxScrolledWindow::PrepareDC(wxDC& dc)
406{
407 dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
408 -m_yScrollPosition * m_yScrollPixelsPerLine );
409}
410
411void wxScrolledWindow::GetScrollPixelsPerUnit (int *x_unit, int *y_unit) const
412{
413 if ( x_unit )
414 *x_unit = m_xScrollPixelsPerLine;
415 if ( y_unit )
416 *y_unit = m_yScrollPixelsPerLine;
417}
418
419int wxScrolledWindow::GetScrollPageSize(int orient) const
420{
421 if ( orient == wxHORIZONTAL )
422 return m_xScrollLinesPerPage;
423 else
424 return m_yScrollLinesPerPage;
425}
426
427void wxScrolledWindow::SetScrollPageSize(int orient, int pageSize)
428{
429 if ( orient == wxHORIZONTAL )
430 m_xScrollLinesPerPage = pageSize;
431 else
432 m_yScrollLinesPerPage = pageSize;
433}
434
435void wxScrolledWindow::OnScroll(wxScrollWinEvent& event)
436{
437 int orient = event.GetOrientation();
438
439 int nScrollInc = CalcScrollInc(event);
440 if (nScrollInc == 0) return;
441
442 if (orient == wxHORIZONTAL)
443 {
444 int newPos = m_xScrollPosition + nScrollInc;
445 SetScrollPos(wxHORIZONTAL, newPos, TRUE );
446 }
447 else
448 {
449 int newPos = m_yScrollPosition + nScrollInc;
450 SetScrollPos(wxVERTICAL, newPos, TRUE );
451 }
452
453 if (orient == wxHORIZONTAL)
454 {
455 m_xScrollPosition += nScrollInc;
456 }
457 else
458 {
459 m_yScrollPosition += nScrollInc;
460 }
461
462 if (orient == wxHORIZONTAL)
463 {
464 if (m_xScrollingEnabled)
465 m_targetWindow->ScrollWindow(-m_xScrollPixelsPerLine * nScrollInc, 0, (const wxRect *) NULL);
466 else
467 m_targetWindow->Refresh();
468 }
469 else
470 {
471 if (m_yScrollingEnabled)
472 m_targetWindow->ScrollWindow(0, -m_yScrollPixelsPerLine * nScrollInc, (const wxRect *) NULL);
473 else
474 m_targetWindow->Refresh();
475 }
476}
477
478void wxScrolledWindow::Scroll( int x_pos, int y_pos )
479{
480 if (!m_targetWindow)
481 return;
482
483 if (((x_pos == -1) || (x_pos == m_xScrollPosition)) &&
484 ((y_pos == -1) || (y_pos == m_yScrollPosition))) return;
485
486 if ((x_pos != -1) && (m_xScrollPixelsPerLine))
487 {
488 int max = (int)(m_hAdjust->upper - m_hAdjust->page_size + 0.5);
489 if (max < 0) max = 0;
490 if (x_pos > max) x_pos = max;
491 if (x_pos < 0) x_pos = 0;
492
493 int old_x = m_xScrollPosition;
494 m_xScrollPosition = x_pos;
495 m_hAdjust->value = x_pos;
496
497 m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
498
499 // Just update the scrollbar, don't send any wxWindows event
500 GtkHDisconnectEvent();
501 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
502 GtkHConnectEvent();
503 }
504
505 if ((y_pos != -1) && (m_yScrollPixelsPerLine))
506 {
507 int max = (int)(m_vAdjust->upper - m_vAdjust->page_size + 0.5);
508 if (max < 0) max = 0;
509 if (y_pos > max) y_pos = max;
510 if (y_pos < 0) y_pos = 0;
511
512 int old_y = m_yScrollPosition;
513 m_yScrollPosition = y_pos;
514 m_vAdjust->value = y_pos;
515
516 m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
517
518 // Just update the scrollbar, don't send any wxWindows event
519 GtkVDisconnectEvent();
520 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
521 GtkVConnectEvent();
522 }
523}
524
525// TODO: [VH]Scroll functions should be combined
526
527void wxScrolledWindow::GtkVScroll( float value, unsigned int scroll_type )
528{
529 if (!m_targetWindow)
530 return;
531
532 if (m_yScrollPixelsPerLine == 0)
533 return;
534
535 int y_pos = (int)(value+0.5);
536
537 if (y_pos == m_yScrollPosition)
538 return;
539
540 wxEventType command = GtkScrollWinTypeToWx(scroll_type);
541
542 wxScrollWinEvent event( command, y_pos, wxVERTICAL );
543 event.SetEventObject( this );
544 GetEventHandler()->ProcessEvent( event );
545}
546
547void wxScrolledWindow::GtkHScroll( float value, unsigned int scroll_type )
548{
549 if (!m_targetWindow)
550 return;
551
552 if (m_xScrollPixelsPerLine == 0)
553 return;
554
555 int x_pos = (int)(value+0.5);
556
557 if (x_pos == m_xScrollPosition)
558 return;
559
560 wxEventType command = GtkScrollWinTypeToWx(scroll_type);
561
562 wxScrollWinEvent event( command, x_pos, wxHORIZONTAL );
563 event.SetEventObject( this );
564 GetEventHandler()->ProcessEvent( event );
565}
566
567void wxScrolledWindow::EnableScrolling (bool x_scroll, bool y_scroll)
568{
569 m_xScrollingEnabled = x_scroll;
570 m_yScrollingEnabled = y_scroll;
571}
572
573void wxScrolledWindow::GetVirtualSize (int *x, int *y) const
574{
575 if ( x )
576 *x = m_xScrollPixelsPerLine * m_xScrollLines;
577 if ( y )
578 *y = m_yScrollPixelsPerLine * m_yScrollLines;
579}
580
581// Where the current view starts from
582void wxScrolledWindow::GetViewStart (int *x, int *y) const
583{
584 if ( x )
585 *x = m_xScrollPosition;
586 if ( y )
587 *y = m_yScrollPosition;
588}
589
590void wxScrolledWindow::CalcScrolledPosition(int x, int y, int *xx, int *yy) const
591{
592 if ( xx )
593 *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
594 if ( yy )
595 *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
596}
597
598void wxScrolledWindow::CalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
599{
600 if ( xx )
601 *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
602 if ( yy )
603 *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
604}
605
606int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
607{
608 int pos = event.GetPosition();
609 int orient = event.GetOrientation();
610
611 int nScrollInc = 0;
612 if (event.GetEventType() == wxEVT_SCROLLWIN_TOP)
613 {
614 if (orient == wxHORIZONTAL)
615 nScrollInc = - m_xScrollPosition;
616 else
617 nScrollInc = - m_yScrollPosition;
618 } else
619 if (event.GetEventType() == wxEVT_SCROLLWIN_BOTTOM)
620 {
621 if (orient == wxHORIZONTAL)
622 nScrollInc = m_xScrollLines - m_xScrollPosition;
623 else
624 nScrollInc = m_yScrollLines - m_yScrollPosition;
625 } else
626 if (event.GetEventType() == wxEVT_SCROLLWIN_LINEUP)
627 {
628 nScrollInc = -1;
629 } else
630 if (event.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN)
631 {
632 nScrollInc = 1;
633 } else
634 if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEUP)
635 {
636 if (orient == wxHORIZONTAL)
637 nScrollInc = -GetScrollPageSize(wxHORIZONTAL);
638 else
639 nScrollInc = -GetScrollPageSize(wxVERTICAL);
640 } else
641 if (event.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN)
642 {
643 if (orient == wxHORIZONTAL)
644 nScrollInc = GetScrollPageSize(wxHORIZONTAL);
645 else
646 nScrollInc = GetScrollPageSize(wxVERTICAL);
647 } else
648 if ((event.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK) ||
649 (event.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE))
650 {
651 if (orient == wxHORIZONTAL)
652 nScrollInc = pos - m_xScrollPosition;
653 else
654 nScrollInc = pos - m_yScrollPosition;
655 }
656
657 if (orient == wxHORIZONTAL)
658 {
659 if (m_xScrollPixelsPerLine > 0)
660 {
661 int max = (int)(m_hAdjust->upper - m_hAdjust->page_size + 0.5);
662 if (max < 0) max = 0;
663
664 if ( (m_xScrollPosition + nScrollInc) < 0 )
665 nScrollInc = -m_xScrollPosition; // As -ve as we can go
666 else if ( (m_xScrollPosition + nScrollInc) > max )
667 nScrollInc = max - m_xScrollPosition; // As +ve as we can go
668 }
669 else
670 m_targetWindow->Refresh();
671 }
672 else
673 {
674 if (m_yScrollPixelsPerLine > 0)
675 {
676 int max = (int)(m_vAdjust->upper - m_vAdjust->page_size + 0.5);
677 if (max < 0) max = 0;
678
679 if ( (m_yScrollPosition + nScrollInc) < 0 )
680 nScrollInc = -m_yScrollPosition; // As -ve as we can go
681 else if ( (m_yScrollPosition + nScrollInc) > max )
682 nScrollInc = max - m_yScrollPosition; // As +ve as we can go
683 }
684 else
685 m_targetWindow->Refresh();
686 }
687
688 return nScrollInc;
689}
690
691void wxScrolledWindow::SetScrollPos( int orient, int pos, bool refresh )
692{
693 wxCHECK_RET( m_widget != NULL, wxT("invalid window") );
694
695 wxCHECK_RET( m_wxwindow != NULL, wxT("window needs client area for scrolling") );
696
697 if (orient == wxHORIZONTAL)
698 {
699 int max = (int)(m_hAdjust->upper - m_hAdjust->page_size + 0.5);
700 if (max < 0) max = 0;
701
702 if (pos > max) pos = 0;
703 if (pos < 0) pos = 0;
704
705 if (pos == (int)(m_hAdjust->value+0.5)) return;
706 m_hAdjust->value = pos;
707 }
708 else
709 {
710 int max = (int)(m_vAdjust->upper - m_vAdjust->page_size + 0.5);
711 if (max < 0) max = 0;
712
713 if (pos > max) pos = 0;
714 if (pos < 0) pos = 0;
715
716 if (pos == (int)(m_vAdjust->value+0.5)) return;
717 m_vAdjust->value = pos;
718 }
719
720 if (m_wxwindow->window)
721 {
722 if (orient == wxHORIZONTAL)
723 {
724 // Just update the scrollbar, don't send any wxWindows event
725 GtkHDisconnectEvent();
726 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
727 GtkHConnectEvent();
728 }
729 else
730 {
731 // Just update the scrollbar, don't send any wxWindows event
732 GtkVDisconnectEvent();
733 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
734 GtkVConnectEvent();
735 }
736 }
737}
738
739void wxScrolledWindow::GtkVConnectEvent()
740{
741 gtk_signal_connect( GTK_OBJECT(m_vAdjust), "value_changed",
742 (GtkSignalFunc) gtk_scrolled_window_vscroll_callback, (gpointer) this );
743}
744
745void wxScrolledWindow::GtkHConnectEvent()
746{
747 gtk_signal_connect( GTK_OBJECT(m_hAdjust), "value_changed",
748 (GtkSignalFunc) gtk_scrolled_window_hscroll_callback, (gpointer) this );
749}
750
751void wxScrolledWindow::GtkHDisconnectEvent()
752{
753 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust),
754 (GtkSignalFunc) gtk_scrolled_window_hscroll_callback, (gpointer) this );
755}
756
757void wxScrolledWindow::GtkVDisconnectEvent()
758{
759 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust),
760 (GtkSignalFunc) gtk_scrolled_window_vscroll_callback, (gpointer) this );
761}
762
763// ----------------------------------------------------------------------------
764// event handlers
765// ----------------------------------------------------------------------------
766
767// Default OnSize resets scrollbars, if any
768void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
769{
770#if wxUSE_CONSTRAINTS
771 if (GetAutoLayout())
772 Layout();
773#endif
774
775 AdjustScrollbars();
776}
777
778// This calls OnDraw, having adjusted the origin according to the current
779// scroll position
780void wxScrolledWindow::OnPaint(wxPaintEvent& WXUNUSED(event))
781{
782 wxPaintDC dc(this);
783 PrepareDC(dc);
784
785 OnDraw(dc);
786}
787
788// kbd handling: notice that we use OnChar() and not OnKeyDown() for
789// compatibility here - if we used OnKeyDown(), the programs which process
790// arrows themselves in their OnChar() would never get the message and like
791// this they always have the priority
792void wxScrolledWindow::OnChar(wxKeyEvent& event)
793{
794 int stx, sty, // view origin
795 szx, szy, // view size (total)
796 clix, cliy; // view size (on screen)
797
798 ViewStart(&stx, &sty);
799 GetClientSize(&clix, &cliy);
800 GetVirtualSize(&szx, &szy);
801
802 if( m_xScrollPixelsPerLine )
803 {
804 clix /= m_xScrollPixelsPerLine;
805 szx /= m_xScrollPixelsPerLine;
806 }
807 else
808 {
809 clix = 0;
810 szx = -1;
811 }
812 if( m_yScrollPixelsPerLine )
813 {
814 cliy /= m_yScrollPixelsPerLine;
815 szy /= m_yScrollPixelsPerLine;
816 }
817 else
818 {
819 cliy = 0;
820 szy = -1;
821 }
822
823 int xScrollOld = GetScrollPos(wxHORIZONTAL),
824 yScrollOld = GetScrollPos(wxVERTICAL);
825
826 int dsty;
827 switch ( event.KeyCode() )
828 {
829 case WXK_PAGEUP:
830 case WXK_PRIOR:
831 dsty = sty - (5 * cliy / 6);
832 Scroll(-1, (dsty == -1) ? 0 : dsty);
833 break;
834
835 case WXK_PAGEDOWN:
836 case WXK_NEXT:
837 Scroll(-1, sty + (5 * cliy / 6));
838 break;
839
840 case WXK_HOME:
841 Scroll(0, event.ControlDown() ? 0 : -1);
842 break;
843
844 case WXK_END:
845 Scroll(szx - clix, event.ControlDown() ? szy - cliy : -1);
846 break;
847
848 case WXK_UP:
849 Scroll(-1, sty - 1);
850 break;
851
852 case WXK_DOWN:
853 Scroll(-1, sty + 1);
854 break;
855
856 case WXK_LEFT:
857 Scroll(stx - 1, -1);
858 break;
859
860 case WXK_RIGHT:
861 Scroll(stx + 1, -1);
862 break;
863
864 default:
865 // not for us
866 event.Skip();
867 return;
868 }
869
870 int xScroll = GetScrollPos(wxHORIZONTAL);
871 if ( xScroll != xScrollOld )
872 {
873 wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, xScroll,
874 wxHORIZONTAL);
875 event.SetEventObject(this);
876 GetEventHandler()->ProcessEvent(event);
877 }
878
879 int yScroll = GetScrollPos(wxVERTICAL);
880 if ( yScroll != yScrollOld )
881 {
882 wxScrollWinEvent event(wxEVT_SCROLLWIN_THUMBTRACK, yScroll,
883 wxVERTICAL);
884 event.SetEventObject(this);
885 GetEventHandler()->ProcessEvent(event);
886 }
887}
888
wxWidgets (Impactor)