1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
#----------------------------------------------------------------------------
# Name: scrolledpanel.py
# Author: Will Sadkin
# Created: 03/21/2003
# Copyright: (c) 2003 by Will Sadkin
# RCS-ID: $Id$
# License: wxWindows license
#----------------------------------------------------------------------------
# 12/11/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o 2.5 compatability update.
#
# 12/21/2003 - Jeff Grimmett (grimmtooth@softhome.net)
#
# o wxScrolledPanel -> ScrolledPanel
#
import wx
import math
class ScrolledPanel( wx.PyScrolledWindow ):
""" ScrolledPanel fills a "hole" in the implementation of
wx.ScrolledWindow, providing automatic scrollbar and scrolling
behavior and the tab traversal management that wxScrolledWindow
lacks. This code was based on the original demo code showing how
to do this, but is now available for general use as a proper class
(and the demo is now converted to just use it.)
It is assumed that the ScrolledPanel will have a sizer, as it is
used to calculate the minimal virtual size of the panel and etc.
"""
def __init__(self, parent, id=-1, pos = wx.DefaultPosition,
size = wx.DefaultSize, style = wx.TAB_TRAVERSAL,
name = "scrolledpanel"):
wx.PyScrolledWindow.__init__(self, parent, id,
pos=pos, size=size,
style=style, name=name)
self.scrollIntoView = True
self.SetInitialSize(size)
self.Bind(wx.EVT_CHILD_FOCUS, self.OnChildFocus)
def SetupScrolling(self, scroll_x=True, scroll_y=True, rate_x=20, rate_y=20,
scrollToTop=True, scrollIntoView=True):
"""
This function sets up the event handling necessary to handle
scrolling properly. It should be called within the __init__
function of any class that is derived from ScrolledPanel,
once the controls on the panel have been constructed and
thus the size of the scrolling area can be determined.
"""
self.scrollIntoView = scrollIntoView
# The following is all that is needed to integrate the sizer and the scrolled window
if not scroll_x: rate_x = 0
if not scroll_y: rate_y = 0
# Round up the virtual size to be a multiple of the scroll rate
sizer = self.GetSizer()
if sizer:
w, h = sizer.GetMinSize()
if rate_x:
w += rate_x - (w % rate_x)
if rate_y:
h += rate_y - (h % rate_y)
self.SetVirtualSize( (w, h) )
self.SetScrollRate(rate_x, rate_y)
wx.CallAfter(self._SetupAfter, scrollToTop) # scroll back to top after initial events
def _SetupAfter(self, scrollToTop):
self.SetVirtualSize(self.GetBestVirtualSize())
if scrollToTop:
self.Scroll(0,0)
def OnChildFocus(self, evt):
"""
If the child window that gets the focus is not fully visible,
this handler will try to scroll enough to see it.
"""
child = evt.GetWindow()
if self.scrollIntoView:
self.ScrollChildIntoView(child)
evt.Skip()
def ScrollChildIntoView(self, child):
"""
Scroll the panel so that the specified child window is in
view. NOTE. This method looks redundant if evt.Skip() is
called as well - the base wx.ScrolledWindow widget now seems
to be doing the same thing anyway
"""
sppu_x, sppu_y = self.GetScrollPixelsPerUnit()
vs_x, vs_y = self.GetViewStart()
cr = child.GetRect()
clntsz = self.GetClientSize()
new_vs_x, new_vs_y = -1, -1
# is it before the left edge?
if cr.x < 0 and sppu_x > 0:
new_vs_x = vs_x + (cr.x / sppu_x)
# is it above the top?
if cr.y < 0 and sppu_y > 0:
new_vs_y = vs_y + (cr.y / sppu_y)
# For the right and bottom edges, scroll enough to show the
# whole control if possible, but if not just scroll such that
# the top/left edges are still visible
# is it past the right edge ?
if cr.right > clntsz.width and sppu_x > 0:
diff = math.ceil(1.0 * (cr.right - clntsz.width + 1) / sppu_x)
if cr.x - diff * sppu_x > 0:
new_vs_x = vs_x + diff
else:
new_vs_x = vs_x + (cr.x / sppu_x)
# is it below the bottom ?
if cr.bottom > clntsz.height and sppu_y > 0:
diff = math.ceil(1.0 * (cr.bottom - clntsz.height + 1) / sppu_y)
if cr.y - diff * sppu_y > 0:
new_vs_y = vs_y + diff
else:
new_vs_y = vs_y + (cr.y / sppu_y)
# if we need to adjust
if new_vs_x != -1 or new_vs_y != -1:
#print "%s: (%s, %s)" % (self.GetName(), new_vs_x, new_vs_y)
self.Scroll(new_vs_x, new_vs_y)
|
