[OpenSPARC-T2-SAM] / sam-t2 / devtools / amd64 / lib / python2.4 / site-packages / Pmw / Pmw_1_2 / lib / PmwScrolledFrame.py

import string
import types
import Tkinter
import Pmw

class ScrolledFrame(Pmw.MegaWidget):
    def __init__(self, parent = None, **kw):

	# Define the megawidget options.
	INITOPT = Pmw.INITOPT
	optiondefs = (
	    ('borderframe',    1,            INITOPT),
	    ('horizflex',      'fixed',      self._horizflex),
	    ('horizfraction',  0.05,         INITOPT),
	    ('hscrollmode',    'dynamic',    self._hscrollMode),
	    ('labelmargin',    0,            INITOPT),
	    ('labelpos',       None,         INITOPT),
	    ('scrollmargin',   2,            INITOPT),
	    ('usehullsize',    0,            INITOPT),
	    ('vertflex',       'fixed',      self._vertflex),
	    ('vertfraction',   0.05,         INITOPT),
	    ('vscrollmode',    'dynamic',    self._vscrollMode),
	)
	self.defineoptions(kw, optiondefs)

	# Initialise the base class (after defining the options).
	Pmw.MegaWidget.__init__(self, parent)

	# Create the components.
	self.origInterior = Pmw.MegaWidget.interior(self)

	if self['usehullsize']:
	    self.origInterior.grid_propagate(0)

	if self['borderframe']:
	    # Create a frame widget to act as the border of the clipper. 
	    self._borderframe = self.createcomponent('borderframe',
		    (), None,
		    Tkinter.Frame, (self.origInterior,),
		    relief = 'sunken',
		    borderwidth = 2,
	    )
	    self._borderframe.grid(row = 2, column = 2, sticky = 'news')

	    # Create the clipping window.
	    self._clipper = self.createcomponent('clipper',
		    (), None,
		    Tkinter.Frame, (self._borderframe,),
		    width = 400,
		    height = 300,
		    highlightthickness = 0,
		    borderwidth = 0,
	    )
	    self._clipper.pack(fill = 'both', expand = 1)
	else:
	    # Create the clipping window.
	    self._clipper = self.createcomponent('clipper',
		    (), None,
		    Tkinter.Frame, (self.origInterior,),
		    width = 400,
		    height = 300,
		    relief = 'sunken',
		    borderwidth = 2,
	    )
	    self._clipper.grid(row = 2, column = 2, sticky = 'news')

	self.origInterior.grid_rowconfigure(2, weight = 1, minsize = 0)
	self.origInterior.grid_columnconfigure(2, weight = 1, minsize = 0)
	
	# Create the horizontal scrollbar
	self._horizScrollbar = self.createcomponent('horizscrollbar',
		(), 'Scrollbar',
		Tkinter.Scrollbar, (self.origInterior,),
	        orient='horizontal',
		command=self.xview
	)

	# Create the vertical scrollbar
	self._vertScrollbar = self.createcomponent('vertscrollbar',
		(), 'Scrollbar',
		Tkinter.Scrollbar, (self.origInterior,),
		orient='vertical',
		command=self.yview
	)

	self.createlabel(self.origInterior, childCols = 3, childRows = 3)

	# Initialise instance variables.
	self._horizScrollbarOn = 0
	self._vertScrollbarOn = 0
	self.scrollTimer = None
	self._scrollRecurse = 0
	self._horizScrollbarNeeded = 0
	self._vertScrollbarNeeded = 0
	self.startX = 0
	self.startY = 0
	self._flexoptions = ('fixed', 'expand', 'shrink', 'elastic')

	# Create a frame in the clipper to contain the widgets to be
	# scrolled.
	self._frame = self.createcomponent('frame',
		(), None,
		Tkinter.Frame, (self._clipper,)
	)

	# Whenever the clipping window or scrolled frame change size,
	# update the scrollbars.
	self._frame.bind('<Configure>', self._reposition)
	self._clipper.bind('<Configure>', self._reposition)

        # Work around a bug in Tk where the value returned by the
        # scrollbar get() method is (0.0, 0.0, 0.0, 0.0) rather than
        # the expected 2-tuple.  This occurs if xview() is called soon
        # after the Pmw.ScrolledFrame has been created.
        self._horizScrollbar.set(0.0, 1.0)
        self._vertScrollbar.set(0.0, 1.0)

	# Check keywords and initialise options.
	self.initialiseoptions()

    def destroy(self):
	if self.scrollTimer is not None:
	    self.after_cancel(self.scrollTimer)
	    self.scrollTimer = None
	Pmw.MegaWidget.destroy(self)

    # ======================================================================

    # Public methods.

    def interior(self):
	return self._frame

    # Set timer to call real reposition method, so that it is not
    # called multiple times when many things are reconfigured at the
    # same time.
    def reposition(self):
	if self.scrollTimer is None:
	    self.scrollTimer = self.after_idle(self._scrollBothNow)

    # Called when the user clicks in the horizontal scrollbar. 
    # Calculates new position of frame then calls reposition() to
    # update the frame and the scrollbar.
    def xview(self, mode = None, value = None, units = None):

        if type(value) == types.StringType:
            value = string.atof(value)
        if mode is None:
            return self._horizScrollbar.get()
	elif mode == 'moveto':
	    frameWidth = self._frame.winfo_reqwidth()
	    self.startX = value * float(frameWidth)
	else: # mode == 'scroll'
	    clipperWidth = self._clipper.winfo_width()
	    if units == 'units':
		jump = int(clipperWidth * self['horizfraction'])
	    else:
		jump = clipperWidth
            self.startX = self.startX + value * jump

	self.reposition()

    # Called when the user clicks in the vertical scrollbar. 
    # Calculates new position of frame then calls reposition() to
    # update the frame and the scrollbar.
    def yview(self, mode = None, value = None, units = None):

        if type(value) == types.StringType:
            value = string.atof(value)
        if mode is None:
            return self._vertScrollbar.get()
	elif mode == 'moveto':
	    frameHeight = self._frame.winfo_reqheight()
	    self.startY = value * float(frameHeight)
	else: # mode == 'scroll'
	    clipperHeight = self._clipper.winfo_height()
	    if units == 'units':
		jump = int(clipperHeight * self['vertfraction'])
	    else:
		jump = clipperHeight
            self.startY = self.startY + value * jump

	self.reposition()

    # ======================================================================

    # Configuration methods.

    def _hscrollMode(self):
	# The horizontal scroll mode has been configured.

	mode = self['hscrollmode']

	if mode == 'static':
	    if not self._horizScrollbarOn:
		self._toggleHorizScrollbar()
	elif mode == 'dynamic':
	    if self._horizScrollbarNeeded != self._horizScrollbarOn:
		self._toggleHorizScrollbar()
	elif mode == 'none':
	    if self._horizScrollbarOn:
		self._toggleHorizScrollbar()
	else:
	    message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
	    raise ValueError, message

    def _vscrollMode(self):
	# The vertical scroll mode has been configured.

	mode = self['vscrollmode']

	if mode == 'static':
	    if not self._vertScrollbarOn:
		self._toggleVertScrollbar()
	elif mode == 'dynamic':
	    if self._vertScrollbarNeeded != self._vertScrollbarOn:
		self._toggleVertScrollbar()
	elif mode == 'none':
	    if self._vertScrollbarOn:
		self._toggleVertScrollbar()
	else:
	    message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
	    raise ValueError, message

    def _horizflex(self):
	# The horizontal flex mode has been configured.

	flex = self['horizflex']

	if flex not in self._flexoptions:
	    message = 'bad horizflex option "%s": should be one of %s' % \
		    (flex, str(self._flexoptions))
	    raise ValueError, message

	self.reposition()

    def _vertflex(self):
	# The vertical flex mode has been configured.

	flex = self['vertflex']

	if flex not in self._flexoptions:
	    message = 'bad vertflex option "%s": should be one of %s' % \
		    (flex, str(self._flexoptions))
	    raise ValueError, message

	self.reposition()

    # ======================================================================

    # Private methods.

    def _reposition(self, event):
	self.reposition()

    def _getxview(self):

	# Horizontal dimension.
	clipperWidth = self._clipper.winfo_width()
	frameWidth = self._frame.winfo_reqwidth()
	if frameWidth <= clipperWidth:
	    # The scrolled frame is smaller than the clipping window.

	    self.startX = 0
	    endScrollX = 1.0

	    if self['horizflex'] in ('expand', 'elastic'):
		relwidth = 1
	    else:
		relwidth = ''
	else:
	    # The scrolled frame is larger than the clipping window.

	    if self['horizflex'] in ('shrink', 'elastic'):
		self.startX = 0
		endScrollX = 1.0
		relwidth = 1
	    else:
		if self.startX + clipperWidth > frameWidth:
		    self.startX = frameWidth - clipperWidth
		    endScrollX = 1.0
		else:
		    if self.startX < 0:
			self.startX = 0
		    endScrollX = (self.startX + clipperWidth) / float(frameWidth)
		relwidth = ''

	# Position frame relative to clipper.
	self._frame.place(x = -self.startX, relwidth = relwidth)
	return (self.startX / float(frameWidth), endScrollX)

    def _getyview(self):

	# Vertical dimension.
	clipperHeight = self._clipper.winfo_height()
	frameHeight = self._frame.winfo_reqheight()
	if frameHeight <= clipperHeight:
	    # The scrolled frame is smaller than the clipping window.

	    self.startY = 0
	    endScrollY = 1.0

	    if self['vertflex'] in ('expand', 'elastic'):
		relheight = 1
	    else:
		relheight = ''
	else:
	    # The scrolled frame is larger than the clipping window.

	    if self['vertflex'] in ('shrink', 'elastic'):
		self.startY = 0
		endScrollY = 1.0
		relheight = 1
	    else:
		if self.startY + clipperHeight > frameHeight:
		    self.startY = frameHeight - clipperHeight
		    endScrollY = 1.0
		else:
		    if self.startY < 0:
			self.startY = 0
		    endScrollY = (self.startY + clipperHeight) / float(frameHeight)
		relheight = ''

	# Position frame relative to clipper.
	self._frame.place(y = -self.startY, relheight = relheight)
	return (self.startY / float(frameHeight), endScrollY)

    # According to the relative geometries of the frame and the
    # clipper, reposition the frame within the clipper and reset the
    # scrollbars.
    def _scrollBothNow(self):
	self.scrollTimer = None

        # Call update_idletasks to make sure that the containing frame
        # has been resized before we attempt to set the scrollbars. 
        # Otherwise the scrollbars may be mapped/unmapped continuously.
        self._scrollRecurse = self._scrollRecurse + 1
        self.update_idletasks()
        self._scrollRecurse = self._scrollRecurse - 1
        if self._scrollRecurse != 0:
            return

	xview = self._getxview()
	yview = self._getyview()
	self._horizScrollbar.set(xview[0], xview[1])
	self._vertScrollbar.set(yview[0], yview[1])

	self._horizScrollbarNeeded = (xview != (0.0, 1.0))
	self._vertScrollbarNeeded = (yview != (0.0, 1.0))

	# If both horizontal and vertical scrollmodes are dynamic and
	# currently only one scrollbar is mapped and both should be
	# toggled, then unmap the mapped scrollbar.  This prevents a
	# continuous mapping and unmapping of the scrollbars. 
	if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
		self._horizScrollbarNeeded != self._horizScrollbarOn and
		self._vertScrollbarNeeded != self._vertScrollbarOn and
		self._vertScrollbarOn != self._horizScrollbarOn):
	    if self._horizScrollbarOn:
		self._toggleHorizScrollbar()
	    else:
		self._toggleVertScrollbar()
	    return

	if self['hscrollmode'] == 'dynamic':
	    if self._horizScrollbarNeeded != self._horizScrollbarOn:
		self._toggleHorizScrollbar()

	if self['vscrollmode'] == 'dynamic':
	    if self._vertScrollbarNeeded != self._vertScrollbarOn:
		self._toggleVertScrollbar()

    def _toggleHorizScrollbar(self):

	self._horizScrollbarOn = not self._horizScrollbarOn

	interior = self.origInterior
	if self._horizScrollbarOn:
	    self._horizScrollbar.grid(row = 4, column = 2, sticky = 'news')
	    interior.grid_rowconfigure(3, minsize = self['scrollmargin'])
	else:
	    self._horizScrollbar.grid_forget()
	    interior.grid_rowconfigure(3, minsize = 0)

    def _toggleVertScrollbar(self):

	self._vertScrollbarOn = not self._vertScrollbarOn

	interior = self.origInterior
	if self._vertScrollbarOn:
	    self._vertScrollbar.grid(row = 2, column = 4, sticky = 'news')
	    interior.grid_columnconfigure(3, minsize = self['scrollmargin'])
	else:
	    self._vertScrollbar.grid_forget()
	    interior.grid_columnconfigure(3, minsize = 0)
Commit	Line	Data
920dae64 AT	1	import string
	2	import types
	3	import Tkinter
	4	import Pmw
	5
	6	class ScrolledFrame(Pmw.MegaWidget):
	7	def __init__(self, parent = None, **kw):
	8
	9	# Define the megawidget options.
	10	INITOPT = Pmw.INITOPT
	11	optiondefs = (
	12	('borderframe', 1, INITOPT),
	13	('horizflex', 'fixed', self._horizflex),
	14	('horizfraction', 0.05, INITOPT),
	15	('hscrollmode', 'dynamic', self._hscrollMode),
	16	('labelmargin', 0, INITOPT),
	17	('labelpos', None, INITOPT),
	18	('scrollmargin', 2, INITOPT),
	19	('usehullsize', 0, INITOPT),
	20	('vertflex', 'fixed', self._vertflex),
	21	('vertfraction', 0.05, INITOPT),
	22	('vscrollmode', 'dynamic', self._vscrollMode),
	23	)
	24	self.defineoptions(kw, optiondefs)
	25
	26	# Initialise the base class (after defining the options).
	27	Pmw.MegaWidget.__init__(self, parent)
	28
	29	# Create the components.
	30	self.origInterior = Pmw.MegaWidget.interior(self)
	31
	32	if self['usehullsize']:
	33	self.origInterior.grid_propagate(0)
	34
	35	if self['borderframe']:
	36	# Create a frame widget to act as the border of the clipper.
	37	self._borderframe = self.createcomponent('borderframe',
	38	(), None,
	39	Tkinter.Frame, (self.origInterior,),
	40	relief = 'sunken',
	41	borderwidth = 2,
	42	)
	43	self._borderframe.grid(row = 2, column = 2, sticky = 'news')
	44
	45	# Create the clipping window.
	46	self._clipper = self.createcomponent('clipper',
	47	(), None,
	48	Tkinter.Frame, (self._borderframe,),
	49	width = 400,
	50	height = 300,
	51	highlightthickness = 0,
	52	borderwidth = 0,
	53	)
	54	self._clipper.pack(fill = 'both', expand = 1)
	55	else:
	56	# Create the clipping window.
	57	self._clipper = self.createcomponent('clipper',
	58	(), None,
	59	Tkinter.Frame, (self.origInterior,),
	60	width = 400,
	61	height = 300,
	62	relief = 'sunken',
	63	borderwidth = 2,
	64	)
65	self._clipper.grid(row = 2, column = 2, sticky = 'news')
66
67	self.origInterior.grid_rowconfigure(2, weight = 1, minsize = 0)
68	self.origInterior.grid_columnconfigure(2, weight = 1, minsize = 0)
69
70	# Create the horizontal scrollbar
71	self._horizScrollbar = self.createcomponent('horizscrollbar',
72	(), 'Scrollbar',
73	Tkinter.Scrollbar, (self.origInterior,),
74	orient='horizontal',
75	command=self.xview
76	)
77
78	# Create the vertical scrollbar
79	self._vertScrollbar = self.createcomponent('vertscrollbar',
80	(), 'Scrollbar',
81	Tkinter.Scrollbar, (self.origInterior,),
82	orient='vertical',
83	command=self.yview
84	)
85
86	self.createlabel(self.origInterior, childCols = 3, childRows = 3)
87
88	# Initialise instance variables.
89	self._horizScrollbarOn = 0
90	self._vertScrollbarOn = 0
91	self.scrollTimer = None
92	self._scrollRecurse = 0
93	self._horizScrollbarNeeded = 0
94	self._vertScrollbarNeeded = 0
95	self.startX = 0
96	self.startY = 0
97	self._flexoptions = ('fixed', 'expand', 'shrink', 'elastic')
98
99	# Create a frame in the clipper to contain the widgets to be
100	# scrolled.
101	self._frame = self.createcomponent('frame',
102	(), None,
103	Tkinter.Frame, (self._clipper,)
104	)
105
106	# Whenever the clipping window or scrolled frame change size,
107	# update the scrollbars.
108	self._frame.bind('<Configure>', self._reposition)
109	self._clipper.bind('<Configure>', self._reposition)
110
111	# Work around a bug in Tk where the value returned by the
112	# scrollbar get() method is (0.0, 0.0, 0.0, 0.0) rather than
113	# the expected 2-tuple. This occurs if xview() is called soon
114	# after the Pmw.ScrolledFrame has been created.
115	self._horizScrollbar.set(0.0, 1.0)
116	self._vertScrollbar.set(0.0, 1.0)
117
118	# Check keywords and initialise options.
119	self.initialiseoptions()
120
121	def destroy(self):
122	if self.scrollTimer is not None:
123	self.after_cancel(self.scrollTimer)
124	self.scrollTimer = None
125	Pmw.MegaWidget.destroy(self)
126
127	# ======================================================================
128
129	# Public methods.
130
131	def interior(self):
132	return self._frame
133
134	# Set timer to call real reposition method, so that it is not
135	# called multiple times when many things are reconfigured at the
136	# same time.
137	def reposition(self):
138	if self.scrollTimer is None:
139	self.scrollTimer = self.after_idle(self._scrollBothNow)
140
141	# Called when the user clicks in the horizontal scrollbar.
142	# Calculates new position of frame then calls reposition() to
143	# update the frame and the scrollbar.
144	def xview(self, mode = None, value = None, units = None):
145
146	if type(value) == types.StringType:
147	value = string.atof(value)
148	if mode is None:
149	return self._horizScrollbar.get()
150	elif mode == 'moveto':
151	frameWidth = self._frame.winfo_reqwidth()
152	self.startX = value * float(frameWidth)
153	else: # mode == 'scroll'
154	clipperWidth = self._clipper.winfo_width()
155	if units == 'units':
156	jump = int(clipperWidth * self['horizfraction'])
157	else:
158	jump = clipperWidth
159	self.startX = self.startX + value * jump
160
161	self.reposition()
162
163	# Called when the user clicks in the vertical scrollbar.
164	# Calculates new position of frame then calls reposition() to
165	# update the frame and the scrollbar.
166	def yview(self, mode = None, value = None, units = None):
167
168	if type(value) == types.StringType:
169	value = string.atof(value)
170	if mode is None:
171	return self._vertScrollbar.get()
172	elif mode == 'moveto':
173	frameHeight = self._frame.winfo_reqheight()
174	self.startY = value * float(frameHeight)
175	else: # mode == 'scroll'
176	clipperHeight = self._clipper.winfo_height()
177	if units == 'units':
178	jump = int(clipperHeight * self['vertfraction'])
179	else:
180	jump = clipperHeight
181	self.startY = self.startY + value * jump
182
183	self.reposition()
184
185	# ======================================================================
186
187	# Configuration methods.
188
189	def _hscrollMode(self):
190	# The horizontal scroll mode has been configured.
191
192	mode = self['hscrollmode']
193
194	if mode == 'static':
195	if not self._horizScrollbarOn:
196	self._toggleHorizScrollbar()
197	elif mode == 'dynamic':
198	if self._horizScrollbarNeeded != self._horizScrollbarOn:
199	self._toggleHorizScrollbar()
200	elif mode == 'none':
201	if self._horizScrollbarOn:
202	self._toggleHorizScrollbar()
203	else:
204	message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
205	raise ValueError, message
206
207	def _vscrollMode(self):
208	# The vertical scroll mode has been configured.
209
210	mode = self['vscrollmode']
211
212	if mode == 'static':
213	if not self._vertScrollbarOn:
214	self._toggleVertScrollbar()
215	elif mode == 'dynamic':
216	if self._vertScrollbarNeeded != self._vertScrollbarOn:
217	self._toggleVertScrollbar()
218	elif mode == 'none':
219	if self._vertScrollbarOn:
220	self._toggleVertScrollbar()
221	else:
222	message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
223	raise ValueError, message
224
225	def _horizflex(self):
226	# The horizontal flex mode has been configured.
227
228	flex = self['horizflex']
229
230	if flex not in self._flexoptions:
231	message = 'bad horizflex option "%s": should be one of %s' % \
232	(flex, str(self._flexoptions))
233	raise ValueError, message
234
235	self.reposition()
236
237	def _vertflex(self):
238	# The vertical flex mode has been configured.
239
240	flex = self['vertflex']
241
242	if flex not in self._flexoptions:
243	message = 'bad vertflex option "%s": should be one of %s' % \
244	(flex, str(self._flexoptions))
245	raise ValueError, message
246
247	self.reposition()
248
249	# ======================================================================
250
251	# Private methods.
252
253	def _reposition(self, event):
254	self.reposition()
255
256	def _getxview(self):
257
258	# Horizontal dimension.
259	clipperWidth = self._clipper.winfo_width()
260	frameWidth = self._frame.winfo_reqwidth()
261	if frameWidth <= clipperWidth:
262	# The scrolled frame is smaller than the clipping window.
263
264	self.startX = 0
265	endScrollX = 1.0
266
267	if self['horizflex'] in ('expand', 'elastic'):
268	relwidth = 1
269	else:
270	relwidth = ''
271	else:
272	# The scrolled frame is larger than the clipping window.
273
274	if self['horizflex'] in ('shrink', 'elastic'):
275	self.startX = 0
276	endScrollX = 1.0
277	relwidth = 1
278	else:
279	if self.startX + clipperWidth > frameWidth:
280	self.startX = frameWidth - clipperWidth
281	endScrollX = 1.0
282	else:
283	if self.startX < 0:
284	self.startX = 0
285	endScrollX = (self.startX + clipperWidth) / float(frameWidth)
286	relwidth = ''
287
288	# Position frame relative to clipper.
289	self._frame.place(x = -self.startX, relwidth = relwidth)
290	return (self.startX / float(frameWidth), endScrollX)
291
292	def _getyview(self):
293
294	# Vertical dimension.
295	clipperHeight = self._clipper.winfo_height()
296	frameHeight = self._frame.winfo_reqheight()
297	if frameHeight <= clipperHeight:
298	# The scrolled frame is smaller than the clipping window.
299
300	self.startY = 0
301	endScrollY = 1.0
302
303	if self['vertflex'] in ('expand', 'elastic'):
304	relheight = 1
305	else:
306	relheight = ''
307	else:
308	# The scrolled frame is larger than the clipping window.
309
310	if self['vertflex'] in ('shrink', 'elastic'):
311	self.startY = 0
312	endScrollY = 1.0
313	relheight = 1
314	else:
315	if self.startY + clipperHeight > frameHeight:
316	self.startY = frameHeight - clipperHeight
317	endScrollY = 1.0
318	else:
319	if self.startY < 0:
320	self.startY = 0
321	endScrollY = (self.startY + clipperHeight) / float(frameHeight)
322	relheight = ''
323
324	# Position frame relative to clipper.
325	self._frame.place(y = -self.startY, relheight = relheight)
326	return (self.startY / float(frameHeight), endScrollY)
327
328	# According to the relative geometries of the frame and the
329	# clipper, reposition the frame within the clipper and reset the
330	# scrollbars.
331	def _scrollBothNow(self):
332	self.scrollTimer = None
333
334	# Call update_idletasks to make sure that the containing frame
335	# has been resized before we attempt to set the scrollbars.
336	# Otherwise the scrollbars may be mapped/unmapped continuously.
337	self._scrollRecurse = self._scrollRecurse + 1
338	self.update_idletasks()
339	self._scrollRecurse = self._scrollRecurse - 1
340	if self._scrollRecurse != 0:
341	return
342
343	xview = self._getxview()
344	yview = self._getyview()
345	self._horizScrollbar.set(xview[0], xview[1])
346	self._vertScrollbar.set(yview[0], yview[1])
347
348	self._horizScrollbarNeeded = (xview != (0.0, 1.0))
349	self._vertScrollbarNeeded = (yview != (0.0, 1.0))
350
351	# If both horizontal and vertical scrollmodes are dynamic and
352	# currently only one scrollbar is mapped and both should be
353	# toggled, then unmap the mapped scrollbar. This prevents a
354	# continuous mapping and unmapping of the scrollbars.
355	if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
356	self._horizScrollbarNeeded != self._horizScrollbarOn and
357	self._vertScrollbarNeeded != self._vertScrollbarOn and
358	self._vertScrollbarOn != self._horizScrollbarOn):
359	if self._horizScrollbarOn:
360	self._toggleHorizScrollbar()
361	else:
362	self._toggleVertScrollbar()
363	return
364
365	if self['hscrollmode'] == 'dynamic':
366	if self._horizScrollbarNeeded != self._horizScrollbarOn:
367	self._toggleHorizScrollbar()
368
369	if self['vscrollmode'] == 'dynamic':
370	if self._vertScrollbarNeeded != self._vertScrollbarOn:
371	self._toggleVertScrollbar()
372
373	def _toggleHorizScrollbar(self):
374
375	self._horizScrollbarOn = not self._horizScrollbarOn
376
377	interior = self.origInterior
378	if self._horizScrollbarOn:
379	self._horizScrollbar.grid(row = 4, column = 2, sticky = 'news')
380	interior.grid_rowconfigure(3, minsize = self['scrollmargin'])
381	else:
382	self._horizScrollbar.grid_forget()
383	interior.grid_rowconfigure(3, minsize = 0)
384
385	def _toggleVertScrollbar(self):
386
387	self._vertScrollbarOn = not self._vertScrollbarOn
388
389	interior = self.origInterior
390	if self._vertScrollbarOn:
391	self._vertScrollbar.grid(row = 2, column = 4, sticky = 'news')
392	interior.grid_columnconfigure(3, minsize = self['scrollmargin'])
393	else:
394	self._vertScrollbar.grid_forget()
395	interior.grid_columnconfigure(3, minsize = 0)