""" Demonstrates the use of the ProgressMeter class. Author: Tucker Beck Last Tested: 3/2/2009 Verified with: Python 2.6, Tkinter 8.4 """ from __future__ import division from Tkinter import * from random import randint from time import sleep class ProgressMeter( Frame ): """ The ProgressMeter is-a Frame widget provides a progress bar and accompanying information to a user regarding a long, computationaly intensive process. A ProgressMetar can control any generator function that returns string message or None after each iteration. Furthermore, the ProgressMeter can interrupt the process at any time. """ def __init__( self, parent, height=30 ): """ Initializes this ProgressMeter Arguments: parent: The master widget for this ProgressMeter height: The desired height of the progress bar """ self.parent = parent Frame.__init__( self, parent ) self.columnconfigure( 0, weight=1 ) # Forces the canv object to resize any time this widget is resized self.rowconfigure( 0, weight=1 ) self.statusMessage = 'Normal' self.w = 0 self.h = 0 self.canv = Canvas( self, height=height) # This canvas will display the progress bar and accompanying percentage text self.canv.grid( row=1, column=0, sticky=N+S+E+W ) self.canv.bind( '', lambda e: self.resize( e.width, e.height ) ) # When the canvas is resized the progress bar should be redrawn. self.killVar = IntVar() # The killBtn can cancel execution self.killVar.set( 0 ) self.killBtn = Button( self, text='Cancel', command=lambda: self.killVar.set(1) ) self.killBtn.configure( state=DISABLED ) self.killBtn.grid( row=1, column=1 ) self.targetGen = None # Placekeeper for the generator function that will be metered self.targetArgs = [] # Argument list for the generator function self.targetKwds = {} # Keyword dictionary for the generator funciton self.targetIdx = 0 # Keeps track of which step in iteration is currently being executed self.targetLen = 0 # Total number of steps in exectuion def resize( self, w, h ): """ Handles resize events for the canv widget. Adjusts the height and width of the canvas for the progress bar calculations. Arguments: w: The new width h: The new height """ self.w = w self.h = h self.canv.delete( 'frame' ) self.canv.create_rectangle( 1, 1, self.w, self.h, outline='black', fill='gray75', tag='frame' ) def reset( self ): """ Resets the control values or the generator function and also clears the progress bar """ self.canv.delete( 'bar' ) self.canv.delete( 'text' ) self.killBtn.configure( state=DISABLED ) self.targetGen = None self.targetArgs = [] self.targetKwds = [] self.killVar.set( 0 ) self.targetIdx = 0 self.targetLen = 0 def clearStatus( self ): """" Clears the statusMessage member. Might be used by parent GUI that reports child status. """ self.statusMessage = 'Normal' def drawBar( self ): """ Updates the status bar for the percentage of completion. """ pct = self.targetIdx / self.targetLen # The percentage of completion x0 = 2 # The bar is inset by 2 pixels x1 = pct * ( self.w - 3 ) + 2 y0 = 2 y1 = self.h self.canv.delete( 'bar' ) self.canv.create_rectangle( x0, y0, x1, y1, fill='SteelBlue3', outline='', tag='bar' ) self.canv.delete( 'text' ) pctTxt = '%02.2f%%' % ( pct*100, ) self.canv.create_text( self.w/2, self.h/2, text=pctTxt, anchor=CENTER, tag='text' ) def startGen( self, targetGen, targetLen, targetArgs=[], targetKwds={} ): """ Initializes the target generator function with supplied arguments and keyword. Requests Tk to call iterGen after all idle events have been handled. Arguments: targetGen: The target generator function targetLen: The number of iterations in the target generator targetArgs: The arguments for the generator function targetKwds: The keyword arguments fo the generator function Note: Having iterGen called by Tk ensures that redraws and other sorts of normal Tkinter events can be processed. Results in the status bar updating real-time with execution while allowing the GUI to function normally. """ self.targetGen = targetGen( *targetArgs, **targetKwds ) self.targetLen = targetLen self.killBtn.configure( state=NORMAL ) self.after_idle( self.iterGen ) def iterGen( self ): """ Iterates through the target generator using delayed self referencing funcition calls to allow GUI updates between iterations """ try: msg = self.targetGen.next() # Execute the next iteration of the genrator except StopIteration: self.reset() # When the generator is finished, a StopIteration exception is raised. This signals a normal finish in the generator self.statusMessage = 'Completed' self.event_generate( '<>' ) # A <> virtual event signals the GUI that the progress meter is finished return self.targetIdx += 1 self.drawBar() if msg == None: pass elif msg.startswith( 'AbortIteration' ): # The target generator can signal that something irrevocable has happend by yielding a value of 'AbortIteration' self.reset() self.statusMessage = msg self.event_generate( '<>' ) return else: self.statusMessage = msg # If the generator yields a value other than None or 'AbortIteration', this message will be sent out to the controlling gui self.event_generate( '<>' ) if self.killVar.get() == 1: # Occurs if the user clicks the killBtn self.reset() self.statusMessage = 'Canceled' self.event_generate( '<>' ) return self.update_idletasks() self.after_idle( self.iterGen ) def dummy_gen( alices, bobs ): """ A simple, stupid example of a ProgressMeter iterable generator function """ for alice in alices: for bob in bobs: if bob==alice: yield 'Match: %s==%s' % ( str(alice), str(bob) ) else: yield 'No Match: %s!=%s' % ( str(alice), str(bob) ) def main(): root = Tk() root.title( 'ProgressMeter Demo' ) pgress = ProgressMeter( root ) # Initialize the ProgressMeter with default arguments pgress.grid( row=1 ) alices = range( 53 ) bobs = [ randint( 0,53 ) for i in range( 53 ) ] btn = Button( root, text="Go!", command=lambda: pgress.startGen( dummy_gen, len(alices) * len(bobs), [alices, bobs] ) )# Starts the ProgressMeter going when the button is clicked btn.grid( row=0 ) statusVar = StringVar( root, 'None' ) status = Label( root, textvariable=statusVar ) status.grid( row=2 ) # This label will be used to display status messages from the ProgressMeter root.bind( '<>', lambda event: statusVar.set(pgress.statusMessage) ) root.bind( '<>', lambda event: statusVar.set( pgress.statusMessage ) ) root.mainloop() if __name__=='__main__': main()