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

# Based on iwidgets2.2.0/scrolledtext.itk code.   

import Tkinter
import Pmw

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

	# Define the megawidget options.
	INITOPT = Pmw.INITOPT
	optiondefs = (
	    ('borderframe',    0,            INITOPT),
	    ('columnheader',   0,            INITOPT),
	    ('hscrollmode',    'dynamic',    self._hscrollMode),
	    ('labelmargin',    0,            INITOPT),
	    ('labelpos',       None,         INITOPT),
	    ('rowcolumnheader',0,            INITOPT),
	    ('rowheader',      0,            INITOPT),
	    ('scrollmargin',   2,            INITOPT),
	    ('usehullsize',    0,            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.
	interior = self.interior()

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

	if self['borderframe']:
	    # Create a frame widget to act as the border of the text 
	    # widget.  Later, pack the text widget so that it fills
	    # the frame.  This avoids a problem in Tk, where window
	    # items in a text widget may overlap the border of the
	    # text widget.
	    self._borderframe = self.createcomponent('borderframe',
		    (), None,
		    Tkinter.Frame, (interior,),
		    relief = 'sunken',
		    borderwidth = 2,
	    )
	    self._borderframe.grid(row = 4, column = 4, sticky = 'news')

	    # Create the text widget.
	    self._textbox = self.createcomponent('text',
		    (), None,
		    Tkinter.Text, (self._borderframe,),
		    highlightthickness = 0,
		    borderwidth = 0,
	    )
	    self._textbox.pack(fill = 'both', expand = 1)

            bw = self._borderframe.cget('borderwidth'),
            ht = self._borderframe.cget('highlightthickness'),
	else:
	    # Create the text widget.
	    self._textbox = self.createcomponent('text',
		    (), None,
		    Tkinter.Text, (interior,),
	    )
	    self._textbox.grid(row = 4, column = 4, sticky = 'news')

            bw = self._textbox.cget('borderwidth'),
            ht = self._textbox.cget('highlightthickness'),

        # Create the header text widgets
        if self['columnheader']:
            self._columnheader = self.createcomponent('columnheader',
                    (), 'Header',
                    Tkinter.Text, (interior,),
                    height=1,
                    wrap='none',
                    borderwidth = bw,
                    highlightthickness = ht,
            )
            self._columnheader.grid(row = 2, column = 4, sticky = 'ew')
            self._columnheader.configure(
                    xscrollcommand = self._columnheaderscrolled)

        if self['rowheader']:
            self._rowheader = self.createcomponent('rowheader',
                    (), 'Header',
                    Tkinter.Text, (interior,),
                    wrap='none',
                    borderwidth = bw,
                    highlightthickness = ht,
            )
            self._rowheader.grid(row = 4, column = 2, sticky = 'ns')
            self._rowheader.configure(
                    yscrollcommand = self._rowheaderscrolled)

        if self['rowcolumnheader']:
            self._rowcolumnheader = self.createcomponent('rowcolumnheader',
                    (), 'Header',
                    Tkinter.Text, (interior,),
                    height=1,
                    wrap='none',
                    borderwidth = bw,
                    highlightthickness = ht,
            )
            self._rowcolumnheader.grid(row = 2, column = 2, sticky = 'nsew')

	interior.grid_rowconfigure(4, weight = 1, minsize = 0)
	interior.grid_columnconfigure(4, weight = 1, minsize = 0)

	# Create the horizontal scrollbar
	self._horizScrollbar = self.createcomponent('horizscrollbar',
		(), 'Scrollbar',
		Tkinter.Scrollbar, (interior,),
	        orient='horizontal',
		command=self._textbox.xview
	)

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

	self.createlabel(interior, childCols = 5, childRows = 5)

	# Initialise instance variables.
	self._horizScrollbarOn = 0
	self._vertScrollbarOn = 0
	self.scrollTimer = None
        self._scrollRecurse = 0
	self._horizScrollbarNeeded = 0
	self._vertScrollbarNeeded = 0
	self._textWidth = None

        # These four variables avoid an infinite loop caused by the
        # row or column header's scrollcommand causing the main text
        # widget's scrollcommand to be called and vice versa.
	self._textboxLastX = None
	self._textboxLastY = None
	self._columnheaderLastX = None
	self._rowheaderLastY = None

	# 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 clear(self):
	self.settext('')

    def importfile(self, fileName, where = 'end'):
	file = open(fileName, 'r')
	self._textbox.insert(where, file.read())
	file.close()

    def exportfile(self, fileName):
	file = open(fileName, 'w')
	file.write(self._textbox.get('1.0', 'end'))
	file.close()

    def settext(self, text):
	disabled = (str(self._textbox.cget('state')) == 'disabled')
	if disabled:
	    self._textbox.configure(state='normal')
	self._textbox.delete('0.0', 'end')
	self._textbox.insert('end', text)
	if disabled:
	    self._textbox.configure(state='disabled')

    # Override Tkinter.Text get method, so that if it is called with
    # no arguments, return all text (consistent with other widgets).
    def get(self, first=None, last=None):
	if first is None:
	    return self._textbox.get('1.0', 'end')
	else:
	    return self._textbox.get(first, last)

    def getvalue(self):
        return self.get()

    def setvalue(self, text):
        return self.settext(text)

    def appendtext(self, text):
        oldTop, oldBottom = self._textbox.yview()
     
        disabled = (str(self._textbox.cget('state')) == 'disabled')
        if disabled:
            self._textbox.configure(state='normal')
        self._textbox.insert('end', text)
        if disabled:
            self._textbox.configure(state='disabled')
     
        if oldBottom == 1.0:
            self._textbox.yview('moveto', 1.0)

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

    # 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

        self._configureScrollCommands()

    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

        self._configureScrollCommands()

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

    # Private methods.

    def _configureScrollCommands(self):
        # If both scrollmodes are not dynamic we can save a lot of
        # time by not having to create an idle job to handle the
        # scroll commands.

        # Clean up previous scroll commands to prevent memory leak.
        tclCommandName = str(self._textbox.cget('xscrollcommand'))
        if tclCommandName != '':   
            self._textbox.deletecommand(tclCommandName)
        tclCommandName = str(self._textbox.cget('yscrollcommand'))
        if tclCommandName != '':   
            self._textbox.deletecommand(tclCommandName)

	if self['hscrollmode'] == self['vscrollmode'] == 'dynamic':
            self._textbox.configure(
                    xscrollcommand=self._scrollBothLater,
                    yscrollcommand=self._scrollBothLater
            )
        else:
            self._textbox.configure(
                    xscrollcommand=self._scrollXNow,
                    yscrollcommand=self._scrollYNow
            )

    def _scrollXNow(self, first, last):
        self._horizScrollbar.set(first, last)
        self._horizScrollbarNeeded = ((first, last) != ('0', '1'))

        # This code is the same as in _scrollBothNow.  Keep it that way.
        if self['hscrollmode'] == 'dynamic':
            currentWidth = self._textbox.winfo_width()
            if self._horizScrollbarNeeded != self._horizScrollbarOn:
                if self._horizScrollbarNeeded or \
                        self._textWidth != currentWidth:
                    self._toggleHorizScrollbar()
            self._textWidth = currentWidth

        if self['columnheader']:
	    if self._columnheaderLastX != first:
		self._columnheaderLastX = first
		self._columnheader.xview('moveto', first)

    def _scrollYNow(self, first, last):
        if first == '0' and last == '0':
            return
        self._vertScrollbar.set(first, last)
        self._vertScrollbarNeeded = ((first, last) != ('0', '1'))

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

        if self['rowheader']:
	    if self._rowheaderLastY != first:
		self._rowheaderLastY = first
		self._rowheader.yview('moveto', first)

    def _scrollBothLater(self, first, last):
	# Called by the text widget to set the horizontal or vertical
	# scrollbar when it has scrolled or changed size or contents.

	if self.scrollTimer is None:
	    self.scrollTimer = self.after_idle(self._scrollBothNow)

    def _scrollBothNow(self):
        # This performs the function of _scrollXNow and _scrollYNow.
        # If one is changed, the other should be updated to match.
	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._textbox.xview()
	yview = self._textbox.yview()

	# The text widget returns a yview of (0.0, 0.0) just after it
	# has been created. Ignore this.
	if yview == (0.0, 0.0):
	    return

        if self['columnheader']:
	    if self._columnheaderLastX != xview[0]:
		self._columnheaderLastX = xview[0]
		self._columnheader.xview('moveto', xview[0])
        if self['rowheader']:
	    if self._rowheaderLastY != yview[0]:
		self._rowheaderLastY = yview[0]
		self._rowheader.yview('moveto', yview[0])

	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':

	    # The following test is done to prevent continuous
	    # mapping and unmapping of the horizontal scrollbar. 
	    # This may occur when some event (scrolling, resizing
	    # or text changes) modifies the displayed text such
	    # that the bottom line in the window is the longest
	    # line displayed.  If this causes the horizontal
	    # scrollbar to be mapped, the scrollbar may "cover up"
	    # the bottom line, which would mean that the scrollbar
	    # is no longer required.  If the scrollbar is then
	    # unmapped, the bottom line will then become visible
	    # again, which would cause the scrollbar to be mapped
	    # again, and so on...
	    #
	    # The idea is that, if the width of the text widget
	    # has not changed and the scrollbar is currently
	    # mapped, then do not unmap the scrollbar even if it
	    # is no longer required.  This means that, during
	    # normal scrolling of the text, once the horizontal
	    # scrollbar has been mapped it will not be unmapped
	    # (until the width of the text widget changes).

	    currentWidth = self._textbox.winfo_width()
	    if self._horizScrollbarNeeded != self._horizScrollbarOn:
		if self._horizScrollbarNeeded or \
			self._textWidth != currentWidth:
		    self._toggleHorizScrollbar()
	    self._textWidth = currentWidth

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

    def _columnheaderscrolled(self, first, last):
	if self._textboxLastX != first:
	    self._textboxLastX = first
	    self._textbox.xview('moveto', first)

    def _rowheaderscrolled(self, first, last):
	if self._textboxLastY != first:
	    self._textboxLastY = first
	    self._textbox.yview('moveto', first)

    def _toggleHorizScrollbar(self):

	self._horizScrollbarOn = not self._horizScrollbarOn

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

    def _toggleVertScrollbar(self):

	self._vertScrollbarOn = not self._vertScrollbarOn

	interior = self.interior()
	if self._vertScrollbarOn:
	    self._vertScrollbar.grid(row = 4, column = 6, sticky = 'news')
	    interior.grid_columnconfigure(5, minsize = self['scrollmargin'])
	else:
	    self._vertScrollbar.grid_forget()
	    interior.grid_columnconfigure(5, minsize = 0)

    # Need to explicitly forward this to override the stupid
    # (grid_)bbox method inherited from Tkinter.Frame.Grid.
    def bbox(self, index):
	return self._textbox.bbox(index)

Pmw.forwardmethods(ScrolledText, Tkinter.Text, '_textbox')
Commit	Line	Data
920dae64 AT	1	# Based on iwidgets2.2.0/scrolledtext.itk code.
	2
	3	import Tkinter
	4	import Pmw
	5
	6	class ScrolledText(Pmw.MegaWidget):
	7	def __init__(self, parent = None, **kw):
	8
	9	# Define the megawidget options.
	10	INITOPT = Pmw.INITOPT
	11	optiondefs = (
	12	('borderframe', 0, INITOPT),
	13	('columnheader', 0, INITOPT),
	14	('hscrollmode', 'dynamic', self._hscrollMode),
	15	('labelmargin', 0, INITOPT),
	16	('labelpos', None, INITOPT),
	17	('rowcolumnheader',0, INITOPT),
	18	('rowheader', 0, INITOPT),
	19	('scrollmargin', 2, INITOPT),
	20	('usehullsize', 0, INITOPT),
	21	('vscrollmode', 'dynamic', self._vscrollMode),
	22	)
	23	self.defineoptions(kw, optiondefs)
	24
	25	# Initialise the base class (after defining the options).
	26	Pmw.MegaWidget.__init__(self, parent)
	27
	28	# Create the components.
	29	interior = self.interior()
	30
	31	if self['usehullsize']:
	32	interior.grid_propagate(0)
	33
	34	if self['borderframe']:
	35	# Create a frame widget to act as the border of the text
	36	# widget. Later, pack the text widget so that it fills
	37	# the frame. This avoids a problem in Tk, where window
	38	# items in a text widget may overlap the border of the
	39	# text widget.
	40	self._borderframe = self.createcomponent('borderframe',
	41	(), None,
	42	Tkinter.Frame, (interior,),
	43	relief = 'sunken',
	44	borderwidth = 2,
	45	)
	46	self._borderframe.grid(row = 4, column = 4, sticky = 'news')
	47
	48	# Create the text widget.
	49	self._textbox = self.createcomponent('text',
	50	(), None,
	51	Tkinter.Text, (self._borderframe,),
	52	highlightthickness = 0,
	53	borderwidth = 0,
	54	)
	55	self._textbox.pack(fill = 'both', expand = 1)
	56
	57	bw = self._borderframe.cget('borderwidth'),
	58	ht = self._borderframe.cget('highlightthickness'),
	59	else:
	60	# Create the text widget.
	61	self._textbox = self.createcomponent('text',
	62	(), None,
	63	Tkinter.Text, (interior,),
	64	)
65	self._textbox.grid(row = 4, column = 4, sticky = 'news')
66
67	bw = self._textbox.cget('borderwidth'),
68	ht = self._textbox.cget('highlightthickness'),
69
70	# Create the header text widgets
71	if self['columnheader']:
72	self._columnheader = self.createcomponent('columnheader',
73	(), 'Header',
74	Tkinter.Text, (interior,),
75	height=1,
76	wrap='none',
77	borderwidth = bw,
78	highlightthickness = ht,
79	)
80	self._columnheader.grid(row = 2, column = 4, sticky = 'ew')
81	self._columnheader.configure(
82	xscrollcommand = self._columnheaderscrolled)
83
84	if self['rowheader']:
85	self._rowheader = self.createcomponent('rowheader',
86	(), 'Header',
87	Tkinter.Text, (interior,),
88	wrap='none',
89	borderwidth = bw,
90	highlightthickness = ht,
91	)
92	self._rowheader.grid(row = 4, column = 2, sticky = 'ns')
93	self._rowheader.configure(
94	yscrollcommand = self._rowheaderscrolled)
95
96	if self['rowcolumnheader']:
97	self._rowcolumnheader = self.createcomponent('rowcolumnheader',
98	(), 'Header',
99	Tkinter.Text, (interior,),
100	height=1,
101	wrap='none',
102	borderwidth = bw,
103	highlightthickness = ht,
104	)
105	self._rowcolumnheader.grid(row = 2, column = 2, sticky = 'nsew')
106
107	interior.grid_rowconfigure(4, weight = 1, minsize = 0)
108	interior.grid_columnconfigure(4, weight = 1, minsize = 0)
109
110	# Create the horizontal scrollbar
111	self._horizScrollbar = self.createcomponent('horizscrollbar',
112	(), 'Scrollbar',
113	Tkinter.Scrollbar, (interior,),
114	orient='horizontal',
115	command=self._textbox.xview
116	)
117
118	# Create the vertical scrollbar
119	self._vertScrollbar = self.createcomponent('vertscrollbar',
120	(), 'Scrollbar',
121	Tkinter.Scrollbar, (interior,),
122	orient='vertical',
123	command=self._textbox.yview
124	)
125
126	self.createlabel(interior, childCols = 5, childRows = 5)
127
128	# Initialise instance variables.
129	self._horizScrollbarOn = 0
130	self._vertScrollbarOn = 0
131	self.scrollTimer = None
132	self._scrollRecurse = 0
133	self._horizScrollbarNeeded = 0
134	self._vertScrollbarNeeded = 0
135	self._textWidth = None
136
137	# These four variables avoid an infinite loop caused by the
138	# row or column header's scrollcommand causing the main text
139	# widget's scrollcommand to be called and vice versa.
140	self._textboxLastX = None
141	self._textboxLastY = None
142	self._columnheaderLastX = None
143	self._rowheaderLastY = None
144
145	# Check keywords and initialise options.
146	self.initialiseoptions()
147
148	def destroy(self):
149	if self.scrollTimer is not None:
150	self.after_cancel(self.scrollTimer)
151	self.scrollTimer = None
152	Pmw.MegaWidget.destroy(self)
153
154	# ======================================================================
155
156	# Public methods.
157
158	def clear(self):
159	self.settext('')
160
161	def importfile(self, fileName, where = 'end'):
162	file = open(fileName, 'r')
163	self._textbox.insert(where, file.read())
164	file.close()
165
166	def exportfile(self, fileName):
167	file = open(fileName, 'w')
168	file.write(self._textbox.get('1.0', 'end'))
169	file.close()
170
171	def settext(self, text):
172	disabled = (str(self._textbox.cget('state')) == 'disabled')
173	if disabled:
174	self._textbox.configure(state='normal')
175	self._textbox.delete('0.0', 'end')
176	self._textbox.insert('end', text)
177	if disabled:
178	self._textbox.configure(state='disabled')
179
180	# Override Tkinter.Text get method, so that if it is called with
181	# no arguments, return all text (consistent with other widgets).
182	def get(self, first=None, last=None):
183	if first is None:
184	return self._textbox.get('1.0', 'end')
185	else:
186	return self._textbox.get(first, last)
187
188	def getvalue(self):
189	return self.get()
190
191	def setvalue(self, text):
192	return self.settext(text)
193
194	def appendtext(self, text):
195	oldTop, oldBottom = self._textbox.yview()
196
197	disabled = (str(self._textbox.cget('state')) == 'disabled')
198	if disabled:
199	self._textbox.configure(state='normal')
200	self._textbox.insert('end', text)
201	if disabled:
202	self._textbox.configure(state='disabled')
203
204	if oldBottom == 1.0:
205	self._textbox.yview('moveto', 1.0)
206
207	# ======================================================================
208
209	# Configuration methods.
210
211	def _hscrollMode(self):
212	# The horizontal scroll mode has been configured.
213
214	mode = self['hscrollmode']
215
216	if mode == 'static':
217	if not self._horizScrollbarOn:
218	self._toggleHorizScrollbar()
219	elif mode == 'dynamic':
220	if self._horizScrollbarNeeded != self._horizScrollbarOn:
221	self._toggleHorizScrollbar()
222	elif mode == 'none':
223	if self._horizScrollbarOn:
224	self._toggleHorizScrollbar()
225	else:
226	message = 'bad hscrollmode option "%s": should be static, dynamic, or none' % mode
227	raise ValueError, message
228
229	self._configureScrollCommands()
230
231	def _vscrollMode(self):
232	# The vertical scroll mode has been configured.
233
234	mode = self['vscrollmode']
235
236	if mode == 'static':
237	if not self._vertScrollbarOn:
238	self._toggleVertScrollbar()
239	elif mode == 'dynamic':
240	if self._vertScrollbarNeeded != self._vertScrollbarOn:
241	self._toggleVertScrollbar()
242	elif mode == 'none':
243	if self._vertScrollbarOn:
244	self._toggleVertScrollbar()
245	else:
246	message = 'bad vscrollmode option "%s": should be static, dynamic, or none' % mode
247	raise ValueError, message
248
249	self._configureScrollCommands()
250
251	# ======================================================================
252
253	# Private methods.
254
255	def _configureScrollCommands(self):
256	# If both scrollmodes are not dynamic we can save a lot of
257	# time by not having to create an idle job to handle the
258	# scroll commands.
259
260	# Clean up previous scroll commands to prevent memory leak.
261	tclCommandName = str(self._textbox.cget('xscrollcommand'))
262	if tclCommandName != '':
263	self._textbox.deletecommand(tclCommandName)
264	tclCommandName = str(self._textbox.cget('yscrollcommand'))
265	if tclCommandName != '':
266	self._textbox.deletecommand(tclCommandName)
267
268	if self['hscrollmode'] == self['vscrollmode'] == 'dynamic':
269	self._textbox.configure(
270	xscrollcommand=self._scrollBothLater,
271	yscrollcommand=self._scrollBothLater
272	)
273	else:
274	self._textbox.configure(
275	xscrollcommand=self._scrollXNow,
276	yscrollcommand=self._scrollYNow
277	)
278
279	def _scrollXNow(self, first, last):
280	self._horizScrollbar.set(first, last)
281	self._horizScrollbarNeeded = ((first, last) != ('0', '1'))
282
283	# This code is the same as in _scrollBothNow. Keep it that way.
284	if self['hscrollmode'] == 'dynamic':
285	currentWidth = self._textbox.winfo_width()
286	if self._horizScrollbarNeeded != self._horizScrollbarOn:
287	if self._horizScrollbarNeeded or \
288	self._textWidth != currentWidth:
289	self._toggleHorizScrollbar()
290	self._textWidth = currentWidth
291
292	if self['columnheader']:
293	if self._columnheaderLastX != first:
294	self._columnheaderLastX = first
295	self._columnheader.xview('moveto', first)
296
297	def _scrollYNow(self, first, last):
298	if first == '0' and last == '0':
299	return
300	self._vertScrollbar.set(first, last)
301	self._vertScrollbarNeeded = ((first, last) != ('0', '1'))
302
303	if self['vscrollmode'] == 'dynamic':
304	if self._vertScrollbarNeeded != self._vertScrollbarOn:
305	self._toggleVertScrollbar()
306
307	if self['rowheader']:
308	if self._rowheaderLastY != first:
309	self._rowheaderLastY = first
310	self._rowheader.yview('moveto', first)
311
312	def _scrollBothLater(self, first, last):
313	# Called by the text widget to set the horizontal or vertical
314	# scrollbar when it has scrolled or changed size or contents.
315
316	if self.scrollTimer is None:
317	self.scrollTimer = self.after_idle(self._scrollBothNow)
318
319	def _scrollBothNow(self):
320	# This performs the function of _scrollXNow and _scrollYNow.
321	# If one is changed, the other should be updated to match.
322	self.scrollTimer = None
323
324	# Call update_idletasks to make sure that the containing frame
325	# has been resized before we attempt to set the scrollbars.
326	# Otherwise the scrollbars may be mapped/unmapped continuously.
327	self._scrollRecurse = self._scrollRecurse + 1
328	self.update_idletasks()
329	self._scrollRecurse = self._scrollRecurse - 1
330	if self._scrollRecurse != 0:
331	return
332
333	xview = self._textbox.xview()
334	yview = self._textbox.yview()
335
336	# The text widget returns a yview of (0.0, 0.0) just after it
337	# has been created. Ignore this.
338	if yview == (0.0, 0.0):
339	return
340
341	if self['columnheader']:
342	if self._columnheaderLastX != xview[0]:
343	self._columnheaderLastX = xview[0]
344	self._columnheader.xview('moveto', xview[0])
345	if self['rowheader']:
346	if self._rowheaderLastY != yview[0]:
347	self._rowheaderLastY = yview[0]
348	self._rowheader.yview('moveto', yview[0])
349
350	self._horizScrollbar.set(xview[0], xview[1])
351	self._vertScrollbar.set(yview[0], yview[1])
352
353	self._horizScrollbarNeeded = (xview != (0.0, 1.0))
354	self._vertScrollbarNeeded = (yview != (0.0, 1.0))
355
356	# If both horizontal and vertical scrollmodes are dynamic and
357	# currently only one scrollbar is mapped and both should be
358	# toggled, then unmap the mapped scrollbar. This prevents a
359	# continuous mapping and unmapping of the scrollbars.
360	if (self['hscrollmode'] == self['vscrollmode'] == 'dynamic' and
361	self._horizScrollbarNeeded != self._horizScrollbarOn and
362	self._vertScrollbarNeeded != self._vertScrollbarOn and
363	self._vertScrollbarOn != self._horizScrollbarOn):
364	if self._horizScrollbarOn:
365	self._toggleHorizScrollbar()
366	else:
367	self._toggleVertScrollbar()
368	return
369
370	if self['hscrollmode'] == 'dynamic':
371
372	# The following test is done to prevent continuous
373	# mapping and unmapping of the horizontal scrollbar.
374	# This may occur when some event (scrolling, resizing
375	# or text changes) modifies the displayed text such
376	# that the bottom line in the window is the longest
377	# line displayed. If this causes the horizontal
378	# scrollbar to be mapped, the scrollbar may "cover up"
379	# the bottom line, which would mean that the scrollbar
380	# is no longer required. If the scrollbar is then
381	# unmapped, the bottom line will then become visible
382	# again, which would cause the scrollbar to be mapped
383	# again, and so on...
384	#
385	# The idea is that, if the width of the text widget
386	# has not changed and the scrollbar is currently
387	# mapped, then do not unmap the scrollbar even if it
388	# is no longer required. This means that, during
389	# normal scrolling of the text, once the horizontal
390	# scrollbar has been mapped it will not be unmapped
391	# (until the width of the text widget changes).
392
393	currentWidth = self._textbox.winfo_width()
394	if self._horizScrollbarNeeded != self._horizScrollbarOn:
395	if self._horizScrollbarNeeded or \
396	self._textWidth != currentWidth:
397	self._toggleHorizScrollbar()
398	self._textWidth = currentWidth
399
400	if self['vscrollmode'] == 'dynamic':
401	if self._vertScrollbarNeeded != self._vertScrollbarOn:
402	self._toggleVertScrollbar()
403
404	def _columnheaderscrolled(self, first, last):
405	if self._textboxLastX != first:
406	self._textboxLastX = first
407	self._textbox.xview('moveto', first)
408
409	def _rowheaderscrolled(self, first, last):
410	if self._textboxLastY != first:
411	self._textboxLastY = first
412	self._textbox.yview('moveto', first)
413
414	def _toggleHorizScrollbar(self):
415
416	self._horizScrollbarOn = not self._horizScrollbarOn
417
418	interior = self.interior()
419	if self._horizScrollbarOn:
420	self._horizScrollbar.grid(row = 6, column = 4, sticky = 'news')
421	interior.grid_rowconfigure(5, minsize = self['scrollmargin'])
422	else:
423	self._horizScrollbar.grid_forget()
424	interior.grid_rowconfigure(5, minsize = 0)
425
426	def _toggleVertScrollbar(self):
427
428	self._vertScrollbarOn = not self._vertScrollbarOn
429
430	interior = self.interior()
431	if self._vertScrollbarOn:
432	self._vertScrollbar.grid(row = 4, column = 6, sticky = 'news')
433	interior.grid_columnconfigure(5, minsize = self['scrollmargin'])
434	else:
435	self._vertScrollbar.grid_forget()
436	interior.grid_columnconfigure(5, minsize = 0)
437
438	# Need to explicitly forward this to override the stupid
439	# (grid_)bbox method inherited from Tkinter.Frame.Grid.
440	def bbox(self, index):
441	return self._textbox.bbox(index)
442
443	Pmw.forwardmethods(ScrolledText, Tkinter.Text, '_textbox')