1 /////////////////////////////////////////////////////////////////////////////
2 // Name: gtk/scrolwin.cpp
3 // Purpose: wxScrolledWindow implementation
4 // Author: Julian Smart
8 // Copyright: (c) Julian Smart and Markus Holzem
9 // Licence: wxWindows license
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
21 #pragma implementation "scrolwin.h"
24 // For compilers that support precompilation, includes "wx.h".
25 #include "wx/wxprec.h"
32 #include "wx/dcclient.h"
34 #include "wx/gtk/scrolwin.h"
38 #include "wx/gtk/win_gtk.h"
40 // ----------------------------------------------------------------------------
42 // ----------------------------------------------------------------------------
44 BEGIN_EVENT_TABLE(wxScrolledWindow
, wxPanel
)
45 EVT_SCROLLWIN(wxScrolledWindow
::OnScroll
)
46 EVT_SIZE(wxScrolledWindow
::OnSize
)
47 EVT_PAINT(wxScrolledWindow
::OnPaint
)
48 EVT_CHAR(wxScrolledWindow
::OnChar
)
51 IMPLEMENT_DYNAMIC_CLASS(wxScrolledWindow
, wxPanel
)
53 // ============================================================================
55 // ============================================================================
57 //-----------------------------------------------------------------------------
59 //-----------------------------------------------------------------------------
61 extern bool g_blockEventsOnDrag
;
62 extern bool g_blockEventsOnScroll
;
64 //-----------------------------------------------------------------------------
66 //-----------------------------------------------------------------------------
68 extern void wxapp_install_idle_handler();
71 //-----------------------------------------------------------------------------
72 // "value_changed" from m_vAdjust
73 //-----------------------------------------------------------------------------
75 static void gtk_scrolled_window_vscroll_callback( GtkAdjustment
*adjust
, wxScrolledWindow
*win
)
78 wxapp_install_idle_handler();
80 if (g_blockEventsOnDrag
) return;
82 if (!win
->m_hasVMT
) return;
84 win
->GtkVScroll( adjust
->value
);
87 //-----------------------------------------------------------------------------
88 // "value_changed" from m_hAdjust
89 //-----------------------------------------------------------------------------
91 static void gtk_scrolled_window_hscroll_callback( GtkAdjustment
*adjust
, wxScrolledWindow
*win
)
94 wxapp_install_idle_handler();
96 if (g_blockEventsOnDrag
) return;
97 if (!win
->m_hasVMT
) return;
99 win
->GtkHScroll( adjust
->value
);
102 //-----------------------------------------------------------------------------
103 // "button_press_event" from scrollbar
104 //-----------------------------------------------------------------------------
106 static gint
gtk_scrollbar_button_press_callback( GtkRange
*widget
,
107 GdkEventButton
*gdk_event
,
111 wxapp_install_idle_handler();
113 g_blockEventsOnScroll
= TRUE
;
114 win
->m_isScrolling
= (gdk_event
->window
== widget
->slider
);
119 //-----------------------------------------------------------------------------
120 // "button_release_event" from scrollbar
121 //-----------------------------------------------------------------------------
123 static gint
gtk_scrollbar_button_release_callback( GtkRange
*widget
,
124 GdkEventButton
*WXUNUSED(gdk_event
),
127 // don't test here as we can release the mouse while being over
128 // a different window than the slider
130 // if (gdk_event->window != widget->slider) return FALSE;
132 g_blockEventsOnScroll
= FALSE
;
134 if (win
->m_isScrolling
)
136 wxEventType command
= wxEVT_SCROLLWIN_THUMBRELEASE
;
140 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(win
->m_widget
);
141 if (widget
== GTK_RANGE(scrolledWindow
->hscrollbar
))
143 value
= (int)(win
->m_hAdjust
->value
+0.5);
146 if (widget
== GTK_RANGE(scrolledWindow
->vscrollbar
))
148 value
= (int)(win
->m_vAdjust
->value
+0.5);
152 wxScrollWinEvent
event( command
, value
, dir
);
153 event
.SetEventObject( win
);
154 win
->GetEventHandler()->ProcessEvent( event
);
157 win
->m_isScrolling
= FALSE
;
162 //-----------------------------------------------------------------------------
163 // InsertChild for wxScrolledWindow
164 //-----------------------------------------------------------------------------
166 static void wxInsertChildInScrolledWindow( wxWindow
* parent
, wxWindow
* child
)
168 // The window might have been scrolled already, do we
169 // have to adapt the position.
170 GtkPizza
*pizza
= GTK_PIZZA(parent
->m_wxwindow
);
171 child
->m_x
+= pizza
->xoffset
;
172 child
->m_y
+= pizza
->yoffset
;
174 gtk_pizza_put( GTK_PIZZA(parent
->m_wxwindow
),
175 GTK_WIDGET(child
->m_widget
),
182 // ----------------------------------------------------------------------------
183 // wxScrolledWindow creation
184 // ----------------------------------------------------------------------------
186 void wxScrolledWindow
::Init()
188 m_xScrollPixelsPerLine
= 0;
189 m_yScrollPixelsPerLine
= 0;
190 m_xScrollingEnabled
= TRUE
;
191 m_yScrollingEnabled
= TRUE
;
192 m_xScrollPosition
= 0;
193 m_yScrollPosition
= 0;
196 m_xScrollLinesPerPage
= 0;
197 m_yScrollLinesPerPage
= 0;
198 m_targetWindow
= (wxWindow
*) NULL
;
201 m_hasScrolling
= TRUE
;
204 bool wxScrolledWindow
::Create(wxWindow
*parent
,
209 const wxString
& name
)
213 if (!PreCreation( parent
, pos
, size
) ||
214 !CreateBase( parent
, id
, pos
, size
, style
, wxDefaultValidator
, name
))
216 wxFAIL_MSG( wxT("wxWindow creation failed") );
220 m_insertCallback
= wxInsertChildInScrolledWindow
;
222 m_targetWindow
= this;
224 m_widget
= gtk_scrolled_window_new( (GtkAdjustment
*) NULL
, (GtkAdjustment
*) NULL
);
225 GTK_WIDGET_UNSET_FLAGS( m_widget
, GTK_CAN_FOCUS
);
227 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
229 GtkScrolledWindowClass
*scroll_class
= GTK_SCROLLED_WINDOW_CLASS( GTK_OBJECT_GET_CLASS(m_widget
) );
230 scroll_class
->scrollbar_spacing
= 0;
232 gtk_scrolled_window_set_policy( scrolledWindow
, GTK_POLICY_AUTOMATIC
, GTK_POLICY_AUTOMATIC
);
234 m_hAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->hscrollbar
) );
235 m_vAdjust
= gtk_range_get_adjustment( GTK_RANGE(scrolledWindow
->vscrollbar
) );
237 m_wxwindow
= gtk_pizza_new();
239 gtk_container_add( GTK_CONTAINER(m_widget
), m_wxwindow
);
241 GtkPizza
*pizza
= GTK_PIZZA(m_wxwindow
);
243 if (HasFlag(wxRAISED_BORDER
))
245 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_OUT
);
247 else if (HasFlag(wxSUNKEN_BORDER
))
249 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_IN
);
251 else if (HasFlag(wxSIMPLE_BORDER
))
253 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_THIN
);
257 gtk_pizza_set_shadow_type( pizza
, GTK_MYSHADOW_NONE
);
260 GTK_WIDGET_SET_FLAGS( m_wxwindow
, GTK_CAN_FOCUS
);
261 m_acceptsFocus
= TRUE
;
263 // I _really_ don't want scrollbars in the beginning
264 m_vAdjust
->lower
= 0.0;
265 m_vAdjust
->upper
= 1.0;
266 m_vAdjust
->value
= 0.0;
267 m_vAdjust
->step_increment
= 1.0;
268 m_vAdjust
->page_increment
= 1.0;
269 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
270 m_hAdjust
->lower
= 0.0;
271 m_hAdjust
->upper
= 1.0;
272 m_hAdjust
->value
= 0.0;
273 m_hAdjust
->step_increment
= 1.0;
274 m_hAdjust
->page_increment
= 1.0;
275 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
277 // Handlers for new scrollbar values
281 // these handlers block mouse events to any window during scrolling such as
282 // motion events and prevent GTK and wxWindows from fighting over where the
285 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_press_event",
286 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
288 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_press_event",
289 (GtkSignalFunc
)gtk_scrollbar_button_press_callback
, (gpointer
) this );
291 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->vscrollbar
), "button_release_event",
292 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
294 gtk_signal_connect( GTK_OBJECT(scrolledWindow
->hscrollbar
), "button_release_event",
295 (GtkSignalFunc
)gtk_scrollbar_button_release_callback
, (gpointer
) this );
297 gtk_widget_show( m_wxwindow
);
300 m_parent
->DoAddChild( this );
302 m_focusWidget
= m_wxwindow
;
311 // ----------------------------------------------------------------------------
312 // setting scrolling parameters
313 // ----------------------------------------------------------------------------
316 * pixelsPerUnitX/pixelsPerUnitY: number of pixels per unit (e.g. pixels per text line)
317 * noUnitsX/noUnitsY: : no. units per scrollbar
319 void wxScrolledWindow
::SetScrollbars (int pixelsPerUnitX
, int pixelsPerUnitY
,
320 int noUnitsX
, int noUnitsY
,
321 int xPos
, int yPos
, bool noRefresh
)
323 // Update any invalidates areas before the get moved/scrolled.
326 int old_x
= m_xScrollPixelsPerLine
* m_xScrollPosition
;
327 int old_y
= m_yScrollPixelsPerLine
* m_yScrollPosition
;
329 m_xScrollPixelsPerLine
= pixelsPerUnitX
;
330 m_yScrollPixelsPerLine
= pixelsPerUnitY
;
331 m_xScrollLines
= noUnitsX
;
332 m_yScrollLines
= noUnitsY
;
333 m_xScrollPosition
= xPos
;
334 m_yScrollPosition
= yPos
;
336 m_hAdjust
->lower
= 0.0;
337 m_hAdjust
->upper
= noUnitsX
;
338 m_hAdjust
->value
= xPos
;
339 m_hAdjust
->step_increment
= 1.0;
340 m_hAdjust
->page_increment
= 2.0;
342 m_vAdjust
->lower
= 0.0;
343 m_vAdjust
->upper
= noUnitsY
;
344 m_vAdjust
->value
= yPos
;
345 m_vAdjust
->step_increment
= 1.0;
346 m_vAdjust
->page_increment
= 2.0;
352 int new_x
= m_xScrollPixelsPerLine
* m_xScrollPosition
;
353 int new_y
= m_yScrollPixelsPerLine
* m_yScrollPosition
;
355 m_targetWindow
->ScrollWindow( old_x
-new_x
, old_y
-new_y
);
359 void wxScrolledWindow
::AdjustScrollbars()
361 // Update any invalidates areas before the get moved/scrolled.
365 m_targetWindow
->GetClientSize( &w
, &h
);
367 if (m_xScrollPixelsPerLine
== 0)
368 m_hAdjust
->page_size
= 1.0;
370 m_hAdjust
->page_size
= (w
/ m_xScrollPixelsPerLine
);
372 if (m_yScrollPixelsPerLine
== 0)
373 m_vAdjust
->page_size
= 1.0;
375 m_vAdjust
->page_size
= (h
/ m_yScrollPixelsPerLine
);
377 m_xScrollLinesPerPage
= (int)(m_hAdjust
->page_size
+ 0.5);
378 m_yScrollLinesPerPage
= (int)(m_vAdjust
->page_size
+ 0.5);
380 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "changed" );
381 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "changed" );
384 // ----------------------------------------------------------------------------
385 // target window handling
386 // ----------------------------------------------------------------------------
388 void wxScrolledWindow
::SetTargetWindow( wxWindow
*target
, bool WXUNUSED(pushEventHandler
) )
390 wxASSERT_MSG( target
, wxT("target window must not be NULL") );
391 m_targetWindow
= target
;
394 wxWindow
*wxScrolledWindow
::GetTargetWindow()
396 return m_targetWindow
;
399 // Override this function if you don't want to have wxScrolledWindow
400 // automatically change the origin according to the scroll position.
401 void wxScrolledWindow
::PrepareDC(wxDC
& dc
)
403 dc
.SetDeviceOrigin( -m_xScrollPosition
* m_xScrollPixelsPerLine
,
404 -m_yScrollPosition
* m_yScrollPixelsPerLine
);
407 void wxScrolledWindow
::GetScrollPixelsPerUnit (int *x_unit
, int *y_unit
) const
410 *x_unit
= m_xScrollPixelsPerLine
;
412 *y_unit
= m_yScrollPixelsPerLine
;
415 int wxScrolledWindow
::GetScrollPageSize(int orient
) const
417 if ( orient
== wxHORIZONTAL
)
418 return m_xScrollLinesPerPage
;
420 return m_yScrollLinesPerPage
;
423 void wxScrolledWindow
::SetScrollPageSize(int orient
, int pageSize
)
425 if ( orient
== wxHORIZONTAL
)
426 m_xScrollLinesPerPage
= pageSize
;
428 m_yScrollLinesPerPage
= pageSize
;
431 void wxScrolledWindow
::OnScroll(wxScrollWinEvent
& event
)
433 int orient
= event
.GetOrientation();
435 int nScrollInc
= CalcScrollInc(event
);
436 if (nScrollInc
== 0) return;
438 // Update any invalidates areas before the get moved/scrolled.
441 if (orient
== wxHORIZONTAL
)
443 int newPos
= m_xScrollPosition
+ nScrollInc
;
444 SetScrollPos(wxHORIZONTAL
, newPos
, TRUE
);
448 int newPos
= m_yScrollPosition
+ nScrollInc
;
449 SetScrollPos(wxVERTICAL
, newPos
, TRUE
);
452 if (orient
== wxHORIZONTAL
)
454 m_xScrollPosition
+= nScrollInc
;
458 m_yScrollPosition
+= nScrollInc
;
461 if (orient
== wxHORIZONTAL
)
463 if (m_xScrollingEnabled
)
464 m_targetWindow
->ScrollWindow(-m_xScrollPixelsPerLine
* nScrollInc
, 0, (const wxRect
*) NULL
);
466 m_targetWindow
->Refresh();
470 if (m_yScrollingEnabled
)
471 m_targetWindow
->ScrollWindow(0, -m_yScrollPixelsPerLine
* nScrollInc
, (const wxRect
*) NULL
);
473 m_targetWindow
->Refresh();
477 void wxScrolledWindow
::Scroll( int x_pos
, int y_pos
)
482 if (((x_pos
== -1) || (x_pos
== m_xScrollPosition
)) &&
483 ((y_pos
== -1) || (y_pos
== m_yScrollPosition
))) return;
485 // Update any invalidates areas before the get moved/scrolled.
488 if ((x_pos
!= -1) && (m_xScrollPixelsPerLine
))
490 int max
= (int)(m_hAdjust
->upper
- m_hAdjust
->page_size
+ 0.5);
491 if (max
< 0) max
= 0;
492 if (x_pos
> max
) x_pos
= max
;
493 if (x_pos
< 0) x_pos
= 0;
495 int old_x
= m_xScrollPosition
;
496 m_xScrollPosition
= x_pos
;
497 m_hAdjust
->value
= x_pos
;
499 m_targetWindow
->ScrollWindow( (old_x
-m_xScrollPosition
)*m_xScrollPixelsPerLine
, 0 );
501 // Just update the scrollbar, don't send any wxWindows event
502 GtkHDisconnectEvent();
503 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
507 if ((y_pos
!= -1) && (m_yScrollPixelsPerLine
))
509 int max
= (int)(m_vAdjust
->upper
- m_vAdjust
->page_size
+ 0.5);
510 if (max
< 0) max
= 0;
511 if (y_pos
> max
) y_pos
= max
;
512 if (y_pos
< 0) y_pos
= 0;
514 int old_y
= m_yScrollPosition
;
515 m_yScrollPosition
= y_pos
;
516 m_vAdjust
->value
= y_pos
;
518 m_targetWindow
->ScrollWindow( 0, (old_y
-m_yScrollPosition
)*m_yScrollPixelsPerLine
);
520 // Just update the scrollbar, don't send any wxWindows event
521 GtkVDisconnectEvent();
522 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
527 void wxScrolledWindow
::GtkVScroll( float value
)
532 if (m_yScrollPixelsPerLine
== 0)
535 int y_pos
= (int)(value
+0.5);
537 if (y_pos
== m_yScrollPosition
)
540 // Update any invalidates areas before the get moved/scrolled.
543 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
544 GtkRange
*range
= GTK_RANGE(scrolledWindow
->vscrollbar
);
546 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
547 if (range
->scroll_type
== GTK_SCROLL_STEP_BACKWARD
) command
= wxEVT_SCROLLWIN_LINEUP
;
548 else if (range
->scroll_type
== GTK_SCROLL_STEP_FORWARD
) command
= wxEVT_SCROLLWIN_LINEDOWN
;
549 else if (range
->scroll_type
== GTK_SCROLL_PAGE_BACKWARD
) command
= wxEVT_SCROLLWIN_PAGEUP
;
550 else if (range
->scroll_type
== GTK_SCROLL_PAGE_FORWARD
) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
552 wxScrollWinEvent
event( command
, y_pos
, wxVERTICAL
);
553 event
.SetEventObject( this );
554 GetEventHandler()->ProcessEvent( event
);
557 void wxScrolledWindow
::GtkHScroll( float value
)
562 if (m_xScrollPixelsPerLine
== 0)
565 int x_pos
= (int)(value
+0.5);
567 if (x_pos
== m_xScrollPosition
)
570 // Update any invalidates areas before the get moved/scrolled.
573 GtkScrolledWindow
*scrolledWindow
= GTK_SCROLLED_WINDOW(m_widget
);
574 GtkRange
*range
= GTK_RANGE(scrolledWindow
->hscrollbar
);
576 wxEventType command
= wxEVT_SCROLLWIN_THUMBTRACK
;
577 if (range
->scroll_type
== GTK_SCROLL_STEP_BACKWARD
) command
= wxEVT_SCROLLWIN_LINEUP
;
578 else if (range
->scroll_type
== GTK_SCROLL_STEP_FORWARD
) command
= wxEVT_SCROLLWIN_LINEDOWN
;
579 else if (range
->scroll_type
== GTK_SCROLL_PAGE_BACKWARD
) command
= wxEVT_SCROLLWIN_PAGEUP
;
580 else if (range
->scroll_type
== GTK_SCROLL_PAGE_FORWARD
) command
= wxEVT_SCROLLWIN_PAGEDOWN
;
582 wxScrollWinEvent
event( command
, x_pos
, wxHORIZONTAL
);
583 event
.SetEventObject( this );
584 GetEventHandler()->ProcessEvent( event
);
587 void wxScrolledWindow
::EnableScrolling (bool x_scroll
, bool y_scroll
)
589 m_xScrollingEnabled
= x_scroll
;
590 m_yScrollingEnabled
= y_scroll
;
593 void wxScrolledWindow
::GetVirtualSize (int *x
, int *y
) const
596 *x
= m_xScrollPixelsPerLine
* m_xScrollLines
;
598 *y
= m_yScrollPixelsPerLine
* m_yScrollLines
;
601 // Where the current view starts from
602 void wxScrolledWindow
::GetViewStart (int *x
, int *y
) const
605 *x
= m_xScrollPosition
;
607 *y
= m_yScrollPosition
;
610 void wxScrolledWindow
::CalcScrolledPosition(int x
, int y
, int *xx
, int *yy
) const
613 *xx
= x
- m_xScrollPosition
* m_xScrollPixelsPerLine
;
615 *yy
= y
- m_yScrollPosition
* m_yScrollPixelsPerLine
;
618 void wxScrolledWindow
::CalcUnscrolledPosition(int x
, int y
, int *xx
, int *yy
) const
621 *xx
= x
+ m_xScrollPosition
* m_xScrollPixelsPerLine
;
623 *yy
= y
+ m_yScrollPosition
* m_yScrollPixelsPerLine
;
626 int wxScrolledWindow
::CalcScrollInc(wxScrollWinEvent
& event
)
628 int pos
= event
.GetPosition();
629 int orient
= event
.GetOrientation();
632 if (event
.GetEventType() == wxEVT_SCROLLWIN_TOP
)
634 if (orient
== wxHORIZONTAL
)
635 nScrollInc
= - m_xScrollPosition
;
637 nScrollInc
= - m_yScrollPosition
;
639 if (event
.GetEventType() == wxEVT_SCROLLWIN_BOTTOM
)
641 if (orient
== wxHORIZONTAL
)
642 nScrollInc
= m_xScrollLines
- m_xScrollPosition
;
644 nScrollInc
= m_yScrollLines
- m_yScrollPosition
;
646 if (event
.GetEventType() == wxEVT_SCROLLWIN_LINEUP
)
650 if (event
.GetEventType() == wxEVT_SCROLLWIN_LINEDOWN
)
654 if (event
.GetEventType() == wxEVT_SCROLLWIN_PAGEUP
)
656 if (orient
== wxHORIZONTAL
)
657 nScrollInc
= -GetScrollPageSize(wxHORIZONTAL
);
659 nScrollInc
= -GetScrollPageSize(wxVERTICAL
);
661 if (event
.GetEventType() == wxEVT_SCROLLWIN_PAGEDOWN
)
663 if (orient
== wxHORIZONTAL
)
664 nScrollInc
= GetScrollPageSize(wxHORIZONTAL
);
666 nScrollInc
= GetScrollPageSize(wxVERTICAL
);
668 if ((event
.GetEventType() == wxEVT_SCROLLWIN_THUMBTRACK
) ||
669 (event
.GetEventType() == wxEVT_SCROLLWIN_THUMBRELEASE
))
671 if (orient
== wxHORIZONTAL
)
672 nScrollInc
= pos
- m_xScrollPosition
;
674 nScrollInc
= pos
- m_yScrollPosition
;
677 if (orient
== wxHORIZONTAL
)
679 if (m_xScrollPixelsPerLine
> 0)
681 int max
= (int)(m_hAdjust
->upper
- m_hAdjust
->page_size
+ 0.5);
682 if (max
< 0) max
= 0;
684 if ( (m_xScrollPosition
+ nScrollInc
) < 0 )
685 nScrollInc
= -m_xScrollPosition
; // As -ve as we can go
686 else if ( (m_xScrollPosition
+ nScrollInc
) > max
)
687 nScrollInc
= max
- m_xScrollPosition
; // As +ve as we can go
690 m_targetWindow
->Refresh();
694 if (m_yScrollPixelsPerLine
> 0)
696 int max
= (int)(m_vAdjust
->upper
- m_vAdjust
->page_size
+ 0.5);
697 if (max
< 0) max
= 0;
699 if ( (m_yScrollPosition
+ nScrollInc
) < 0 )
700 nScrollInc
= -m_yScrollPosition
; // As -ve as we can go
701 else if ( (m_yScrollPosition
+ nScrollInc
) > max
)
702 nScrollInc
= max
- m_yScrollPosition
; // As +ve as we can go
705 m_targetWindow
->Refresh();
711 void wxScrolledWindow
::SetScrollPos( int orient
, int pos
, bool refresh
)
713 wxCHECK_RET( m_widget
!= NULL
, wxT("invalid window") );
715 wxCHECK_RET( m_wxwindow
!= NULL
, wxT("window needs client area for scrolling") );
717 // Update any invalidates areas before the get moved/scrolled.
718 // We ignore the refresh parameter here because it is meant
719 // to control the behaviour AFTER scrolling happens.
722 if (orient
== wxHORIZONTAL
)
724 int max
= (int)(m_hAdjust
->upper
- m_hAdjust
->page_size
+ 0.5);
725 if (max
< 0) max
= 0;
727 if (pos
> max
) pos
= 0;
728 if (pos
< 0) pos
= 0;
730 if (pos
== (int)(m_hAdjust
->value
+0.5)) return;
731 m_hAdjust
->value
= pos
;
735 int max
= (int)(m_vAdjust
->upper
- m_vAdjust
->page_size
+ 0.5);
736 if (max
< 0) max
= 0;
738 if (pos
> max
) pos
= 0;
739 if (pos
< 0) pos
= 0;
741 if (pos
== (int)(m_vAdjust
->value
+0.5)) return;
742 m_vAdjust
->value
= pos
;
745 if (m_wxwindow
->window
)
747 if (orient
== wxHORIZONTAL
)
749 // Just update the scrollbar, don't send any wxWindows event
750 GtkHDisconnectEvent();
751 gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust
), "value_changed" );
756 // Just update the scrollbar, don't send any wxWindows event
757 GtkVDisconnectEvent();
758 gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust
), "value_changed" );
764 void wxScrolledWindow
::GtkVConnectEvent()
766 gtk_signal_connect( GTK_OBJECT(m_vAdjust
), "value_changed",
767 (GtkSignalFunc
) gtk_scrolled_window_vscroll_callback
, (gpointer
) this );
770 void wxScrolledWindow
::GtkHConnectEvent()
772 gtk_signal_connect( GTK_OBJECT(m_hAdjust
), "value_changed",
773 (GtkSignalFunc
) gtk_scrolled_window_hscroll_callback
, (gpointer
) this );
776 void wxScrolledWindow
::GtkHDisconnectEvent()
778 gtk_signal_disconnect_by_func( GTK_OBJECT(m_hAdjust
),
779 (GtkSignalFunc
) gtk_scrolled_window_hscroll_callback
, (gpointer
) this );
782 void wxScrolledWindow
::GtkVDisconnectEvent()
784 gtk_signal_disconnect_by_func( GTK_OBJECT(m_vAdjust
),
785 (GtkSignalFunc
) gtk_scrolled_window_vscroll_callback
, (gpointer
) this );
788 // ----------------------------------------------------------------------------
790 // ----------------------------------------------------------------------------
792 // Default OnSize resets scrollbars, if any
793 void wxScrolledWindow
::OnSize(wxSizeEvent
& WXUNUSED(event
))
795 #if wxUSE_CONSTRAINTS
803 // This calls OnDraw, having adjusted the origin according to the current
805 void wxScrolledWindow
::OnPaint(wxPaintEvent
& WXUNUSED(event
))
813 // kbd handling: notice that we use OnChar() and not OnKeyDown() for
814 // compatibility here - if we used OnKeyDown(), the programs which process
815 // arrows themselves in their OnChar() would never get the message and like
816 // this they always have the priority
817 void wxScrolledWindow
::OnChar(wxKeyEvent
& event
)
819 int stx
, sty
, // view origin
820 szx
, szy
, // view size (total)
821 clix
, cliy
; // view size (on screen)
823 ViewStart(&stx
, &sty
);
824 GetClientSize(&clix
, &cliy
);
825 GetVirtualSize(&szx
, &szy
);
827 if( m_xScrollPixelsPerLine
)
829 clix
/= m_xScrollPixelsPerLine
;
830 szx
/= m_xScrollPixelsPerLine
;
837 if( m_yScrollPixelsPerLine
)
839 cliy
/= m_yScrollPixelsPerLine
;
840 szy
/= m_yScrollPixelsPerLine
;
848 int xScrollOld
= GetScrollPos(wxHORIZONTAL
),
849 yScrollOld
= GetScrollPos(wxVERTICAL
);
852 switch ( event
.KeyCode() )
856 dsty
= sty
- (5 * cliy
/ 6);
857 Scroll(-1, (dsty
== -1) ?
0 : dsty
);
862 Scroll(-1, sty
+ (5 * cliy
/ 6));
866 Scroll(0, event
.ControlDown() ?
0 : -1);
870 Scroll(szx
- clix
, event
.ControlDown() ? szy
- cliy
: -1);
895 int xScroll
= GetScrollPos(wxHORIZONTAL
);
896 if ( xScroll
!= xScrollOld
)
898 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBTRACK
, xScroll
,
900 event
.SetEventObject(this);
901 GetEventHandler()->ProcessEvent(event
);
904 int yScroll
= GetScrollPos(wxVERTICAL
);
905 if ( yScroll
!= yScrollOld
)
907 wxScrollWinEvent
event(wxEVT_SCROLLWIN_THUMBTRACK
, yScroll
,
909 event
.SetEventObject(this);
910 GetEventHandler()->ProcessEvent(event
);