GladeGen.py0100750000076400007640000002516310033055756012050 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # GladeGen.py # Dave Reed # 02/03/2004 #---------------------------------------------------------------------- import sys import os.path import time import re import inspect import xml.dom.minidom import GladeGenConfig #---------------------------------------------------------------------- class GladeGen: #------------------------------------------------------------------ def __init__(self, module, glade_file, class_name): '''__init__(self, module, glade_file, class_name): module: file name without .py exentsion glade_file: full name of Glade XML file class_name: name of class to create ''' self.module = module self.glade_file = glade_file self.class_name = class_name self.filename = '%s.py' % module # dict of function objects in the file # maps name to function object self.functions = {} # dict of class objects in the file # maps name to class object self.classes = {} # list of class methods in the file self.methods = [] # widgets to be able to acces - see GladeGenConfig.include_widget_types # for which types from the file will be included self.widgets = [] # handlers specified in the XML file self.handlers = [] # contains all lines in file self.lines = [] # contains handler methods that need to be added to .py file self.missing = [] # line number where init (not __init__) methods starts self.init_start = None # create file if doesn't exist if not os.path.exists(self.filename): f = file(self.filename, 'w') f.write(self.create_file()) f.close() # read existing file into self.lines f = file(self.filename, 'r') self.lines = f.readlines() f.close() #------------------------------------------------------------------ def create_file(self): '''create_file(self): create empty python file for the class''' lines = [] lines.append(self.create_header()) lines.append(GladeGenConfig.class_header % self.class_name) lines.append(GladeGenConfig.constructor) lines.append(self.create_footer()) return '\n'.join(lines) #------------------------------------------------------------------ def get_members(self): '''get_members(self): get information on functions, classes, methods, handlers, etc. from the Python code''' self.functions = {} self.classes = {} self.methods = [] self.module = __import__(self.module) # functions l = inspect.getmembers(self.module, inspect.isroutine) for name, obj in l: self.functions[name] = obj # classes l = inspect.getmembers(self.module, inspect.isclass) for name, obj in l: self.classes[name] = obj # methods in the class methods = inspect.getmembers(obj, inspect.ismethod) for m in methods: self.methods.append((name, m[0])) # find init method (not __init__) since we will be replacing # it with a new method each time if m[0] == 'init': self.init_lines, self.init_start = \ inspect.getsourcelines(m[1]) #---------------------------------------------------------------------- def get_xml(self): '''get_xml(self): parse the XML file to get widget and handler names''' self.widgets = [] self.handlers = [] self.top_window = None # load XML file doc = xml.dom.minidom.parse(self.glade_file) # look for widgets and get their widget type and name for node in doc.getElementsByTagName('widget'): widget = str(node.getAttribute('class')) name = str(node.getAttribute('id')) if self.top_window is None and widget == 'GtkWindow': self.top_window = name # if the widget type is in list of widgets user specified # in config file, include it in the list if widget in GladeGenConfig.include_widget_types: # (widget type, name) # ('GtkWindow', 'window1') self.widgets.append((widget, name)) # get signal handler names for node in doc.getElementsByTagName('signal'): name = str(node.getAttribute('handler')) if name not in self.handlers: self.handlers.append(name) #---------------------------------------------------------------------- def get_missing_methods(self): '''get_missing_methods(self): determine which handlers do not exist in the Python file''' self.missing = [] method_names = map(lambda x: x[1], self.methods) for h in self.handlers: if h not in method_names: self.missing.append(h) #---------------------------------------------------------------------- def get_init_method(self, indent): '''get_init_method(self, indent): create the init (not __init__) method''' indent1 = ' ' * indent indent2 = ' ' * indent indent3 = ' ' * indent lines = [] # method name lines.append('%sdef init(self):' % indent1) lines.append('') # specify Glade XML file lines.append("%sfilename = '%s'" % (indent2, self.glade_file)) lines.append('') # specify widgets the user wnats lines.append('%swidget_list = [' % indent2) for w in self.widgets: lines.append("%s'%s'," % (indent3, w[1])) lines.append('%s]' % indent3) lines.append('') # specify handlers lines.append('%shandlers = [' % indent2) for h in self.handlers: lines.append("%s'%s'," % (indent3, h)) lines.append('%s]' % indent3) lines.append('') # specify the top level window widget lines.append("%stop_window = '%s'" % (indent2, self.top_window)) # call the subclass constructor lines.append('%sGladeWindow.__init__(self, %s, %s, %s, %s)' % ( indent2, 'filename', 'top_window', 'widget_list', 'handlers')) lines.append('') return '\n'.join(lines) #---------------------------------------------------------------------- def insert_missing_methods(self): '''insert_missing_methods(self): insert the missing handlers in the Python code stored in self.lines also updates the init (not __init__) method''' # get lines for the class object obj = self.classes[self.class_name] lines, start = inspect.getsourcelines(obj) end = start + len(lines) # determine indentation level for class methods for l in lines: if re.search('\sdef', l) is not None: indent = l.find('def') # remove existing init method s_pos = self.init_start - start e_pos = s_pos + len(self.init_lines) if self.init_start is not None: del lines[s_pos:e_pos] # insert new init (not __init__ method) lines.insert(s_pos, self.get_init_method(indent)) # insert code for missing functions for m in self.missing: lines.append('%s#%s\n' % (indent * ' ', 70 * '-')) lines.append('\n') lines.append('%sdef %s(self, *args):\n' % (indent * ' ', m)) lines.append('%spass\n' % (2 * indent * ' ')) lines.append('\n') lines.append('\n') # delete class from self.lines del self.lines[start-1:end] # replace with updated class stored in lines self.lines.insert(start-1, ''.join(lines)) return self.lines #---------------------------------------------------------------------- def print_info(self): '''print_info(self): print stored information - useful for debugging''' print 'funcs' for k in self.functions: print k, self.functions[k] print print 'classes' for k in self.classes: print k, self.classes[k] print print 'methods' for k in self.methods: print k print print 'widgets' for k in self.widgets: print k print print 'handlers' for k in self.handlers: print k print #------------------------------------------------------------------ #------------------------------------------------------------------ def create_header(self): '''create_header(self): return header lines for Python file''' date = time.strftime(GladeGenConfig.date_format) header = '''#!/usr/bin/env python #---------------------------------------------------------------------- # %s # %s # %s #---------------------------------------------------------------------- import sys from GladeWindow import * #---------------------------------------------------------------------- ''' % (self.filename, GladeGenConfig.author, date) return header #------------------------------------------------------------------ def create_footer(self): '''return footer lines for Python file''' footer = """ #---------------------------------------------------------------------- def main(argv): w = %s() w.show() gtk.main() #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) """ % self.class_name return footer #------------------------------------------------------------------ #---------------------------------------------------------------------- def main(argv): if len(argv) != 4: print 'usage: GladeGen.py glade_file module_name class_name' return glade_file = argv[1] module = argv[2] class_name = argv[3] pg = GladeGen(module, glade_file, class_name) pg.get_members() pg.get_xml() pg.print_info() pg.get_missing_methods() lines = ''.join(pg.insert_missing_methods()) f = file('%s.py' % module, 'w') f.write(lines) f.close() #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) GladeGenConfig.py0100640000076400007640000000251010012741402013146 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # GladeGenConfig.py # Dave Reed # 02/03/2004 #---------------------------------------------------------------------- import sys #---------------------------------------------------------------------- # program author for header of generated file author = 'Dave Reed' # date format (this is mm/dd/yyyy) # see time.strftime format documentation date_format = '%m/%d/%Y' # widget types the user wants included in widget list include_widget_types = [ 'GtkWindow', 'GtkButton', 'GtkSpinButton', 'GtkCheckButton', 'GtkEntry', 'GtkCombo', 'GtkTextView', ] #---------------------------------------------------------------------- # default text for class and its methods class_header = 'class %s(GladeWindow):' constructor = """ #---------------------------------------------------------------------- def __init__(self): ''' ''' self.init() #---------------------------------------------------------------------- def init(self): ''' ''' pass """ #---------------------------------------------------------------------- def main(argv): pass #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) GladeWindow.py0100750000076400007640000001160010031357541012570 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # GladeWindow.py # Dave Reed # 12/15/2002 #---------------------------------------------------------------------- import os import gtk import gtk.glade #---------------------------------------------------------------------- def search_file(filename, search_path): """Given a search path, find file """ file_found = 0 paths = search_path.split(os.pathsep) for path in paths: if os.path.exists(os.path.join(path, filename)): file_found = 1 break if file_found: return os.path.abspath(os.path.join(path, filename)) else: return None #---------------------------------------------------------------------- class GladeWindow(object): '''A base class for displaying a GUI developed with Glade; create a subclass and add any callbacks and other code; the derived class __init__ method needs to call GladeWindow.__init__; callbacks that start with on_ are automatically connected''' #---------------------------------------------------------------------- def set_search_path(cls, path): '''set the search path for looking for the .glade files''' cls.search_path = path set_search_path = classmethod(set_search_path) #---------------------------------------------------------------------- def __init__(self, filename, top_window, widget_list, handlers, pull_down_dict=None): ''' __init__(self, filename, top_window, widget_list, pull_down_dict=None): filename: filename of the .glade file top_window: the glade name of the top level widget (this will then be accessible as self.top_window) widget_list: a list of glade names; the dictionary self.widgets will be created that maps these name to the actual widget object pull_down_dict: a dictionary that maps combo names to a tuple of strings to put in the combo ''' self.widget_list = widget_list try: search_path = GladeWindow.search_path except: search_path = './' fname = search_file(filename, search_path) self.xml = gtk.glade.XML(fname) # connect callbacks self.cb_dict = {} for f in handlers: self.cb_dict[f] = getattr(self, f) self.xml.signal_autoconnect(self.cb_dict) self.widgets = {} for w in self.widget_list: self.widgets[w] = self.xml.get_widget(w) if pull_down_dict is not None: for w, l in pull_down_dict.items(): self.widgets[w].set_popdown_strings(l) # set attribute for top_window so it can be accessed as self.top_window self.top_window = self.xml.get_widget(top_window) # window to show when this one is hidden self.prev_window = None # initialize callback func self.cb_func = None #---------------------------------------------------------------------- def set_top_window(self, top_window): '''set_top_window(self, top_window): notebook pages that are in containers need to be able to change their top window, especially so the dialog is set_transient_for the actual main window ''' self.top_window = top_window #---------------------------------------------------------------------- def set_callback_function(self, cb_func, *cb_args, **cb_kwargs): '''set_callback_function(cb_func, *cb_args, **cb_kwargs): stores the cb_func and its cb_args and cb_kwargs ''' self.cb_func = cb_func self.cb_args = cb_args self.cb_kwargs = cb_kwargs #---------------------------------------------------------------------- def show(self, center=1, prev_window=None, *args): '''show(self, center=1, prev_window=None, *args): display the top_window widget ''' if prev_window is not None: self.prev_window = prev_window if center: self.top_window.set_position(gtk.WIN_POS_CENTER_ALWAYS) else: self.top_window.set_position(gtk.WIN_POS_NONE) self.top_window.show() #---------------------------------------------------------------------- def hide(self): '''hide(self): hides the current window, shows self.prev_window if self.cb_func is not None, it is called with its cb_args and cb_kwargs ''' self.top_window.hide() if self.prev_window is not None: self.prev_window.show() if self.cb_func is not None: self.cb_func(*self.cb_args, **self.cb_kwargs) if self.prev_window is None: gtk.main_quit() #---------------------------------------------------------------------- MathFlash-create-short-lines.py0100644000076400007640000000417210031357656015760 0ustar dreeddreed#!/usr/bin/env python #-------------------------------------------- # MathFlash.py # Dave Reed # 02/28/2004 #-------------------------------------------- import sys from GladeWindow import * #-------------------------------------------- class MathFlash(GladeWindow): #---------------------------------------- def __init__(self): ''' ''' self.init() #---------------------------------------- def init(self): filename = 'mathflash.glade' widget_list = [ 'window1', 'plus_check', 'minus_check', 'multiply_check', 'divide_check', 'digits_spin', 'operators_spin', 'correct_entry', 'wrong_entry', 'pct_entry', 'problem_entry', 'answer_entry', 'submit_button', 'reset_button', 'exit_button', 'new_button', 'result_entry', ] handlers = [ 'on_operator_check_toggled', 'on_submit_button_clicked', 'on_reset_button_clicked', 'on_exit_button_clicked', 'on_new_button_clicked', ] top_window = 'window1' GladeWindow.__init__(self, filename, top_window, widget_list, handlers) #---------------------------------------- def on_operator_check_toggled(self, *args): pass #---------------------------------------- def on_submit_button_clicked(self, *args): pass #---------------------------------------- def on_reset_button_clicked(self, *args): pass #---------------------------------------- def on_exit_button_clicked(self, *args): pass #---------------------------------------- def on_new_button_clicked(self, *args): pass #---------------------------------------- def main(argv): w = MathFlash() w.show() gtk.main() #---------------------------------------- if __name__ == '__main__': main(sys.argv) MathFlash-create.py0100640000076400007640000000460610012753440013477 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # MathFlash.py # Dave Reed # 02/12/2004 #---------------------------------------------------------------------- import sys from GladeWindow import * #---------------------------------------------------------------------- class MathFlash(GladeWindow): #---------------------------------------------------------------------- def __init__(self): ''' ''' self.init() #---------------------------------------------------------------------- def init(self): filename = 'mathflash.glade' widget_list = [ 'window1', 'plus_check', 'minus_check', 'multiply_check', 'divide_check', 'digits_spin', 'operators_spin', 'correct_entry', 'wrong_entry', 'pct_entry', 'problem_entry', 'answer_entry', 'submit_button', 'reset_button', 'exit_button', 'new_button', 'result_entry', ] handlers = [ 'on_operator_check_toggled', 'on_submit_button_clicked', 'on_reset_button_clicked', 'on_exit_button_clicked', 'on_new_button_clicked', ] top_window = 'window1' GladeWindow.__init__(self, filename, top_window, widget_list, handlers) #---------------------------------------------------------------------- def on_operator_check_toggled(self, *args): pass #---------------------------------------------------------------------- def on_submit_button_clicked(self, *args): pass #---------------------------------------------------------------------- def on_reset_button_clicked(self, *args): pass #---------------------------------------------------------------------- def on_exit_button_clicked(self, *args): pass #---------------------------------------------------------------------- def on_new_button_clicked(self, *args): pass #---------------------------------------------------------------------- def main(argv): w = MathFlash() w.show() gtk.main() #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) MathFlash-final.py0100755000076400007640000001122010020250452013314 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # MathFlash.py # Dave Reed # 02/12/2004 #---------------------------------------------------------------------- import sys from random import randrange from GladeWindow import * #---------------------------------------------------------------------- def get_random_number(digits): num = 0 for i in range(digits): d = randrange(10) num = num * 10 + d return num #---------------------------------------------------------------------- class MathFlash(GladeWindow): #---------------------------------------------------------------------- def __init__(self): ''' ''' self.init() self.widgets['plus_check'].set_active(1) self.correct = 0 self.total = 0 self.show_results() #---------------------------------------------------------------------- def init(self): filename = 'mathflash.glade' widget_list = [ 'window1', 'plus_check', 'minus_check', 'multiply_check', 'divide_check', 'digits_spin', 'operators_spin', 'correct_entry', 'wrong_entry', 'pct_entry', 'problem_entry', 'answer_entry', 'submit_button', 'reset_button', 'exit_button', 'new_button', 'result_entry', ] handlers = [ 'on_operator_check_toggled', 'on_submit_button_clicked', 'on_reset_button_clicked', 'on_exit_button_clicked', 'on_new_button_clicked', ] top_window = 'window1' GladeWindow.__init__(self, filename, top_window, widget_list, handlers) #---------------------------------------------------------------------- def show_results(self): if self.total > 0: pct = '%0.1f%%' % (100.0 * self.correct / float(self.total)) else: pct = '' self.widgets['correct_entry'].set_text(str(self.correct)) self.widgets['wrong_entry'].set_text(str(self.total - self.correct)) self.widgets['pct_entry'].set_text(pct) #---------------------------------------------------------------------- def on_operator_check_toggled(self, *args): self.operators = [] if self.widgets['plus_check'].get_active(): self.operators.append('+') if self.widgets['minus_check'].get_active(): self.operators.append('-') if self.widgets['multiply_check'].get_active(): self.operators.append('*') if self.widgets['divide_check'].get_active(): self.operators.append('/') #---------------------------------------------------------------------- def on_submit_button_clicked(self, *args): prob = self.widgets['problem_entry'].get_text() ans = eval(prob) user = int(self.widgets['answer_entry'].get_text()) self.total += 1 if ans == user: self.correct += 1 self.widgets['result_entry'].set_text('Correct') else: self.widgets['result_entry'].set_text('Wrong, the answer is %d' % ans) self.show_results() #---------------------------------------------------------------------- def on_reset_button_clicked(self, *args): self.correct = 0 self.total = 0 self.show_results() #---------------------------------------------------------------------- def on_new_button_clicked(self, *args): num_digits = int(self.widgets['digits_spin'].get_text()) num_ops = int(self.widgets['operators_spin'].get_text()) prob = [] num = get_random_number(num_digits) prob.append(str(num)) for i in range(num_ops): op = self.operators[randrange(len(self.operators))] prob.append(op) num = get_random_number(num_digits) prob.append(str(num)) self.widgets['problem_entry'].set_text(''.join(prob)) self.widgets['result_entry'].set_text('') self.widgets['answer_entry'].set_text('') #---------------------------------------------------------------------- def on_exit_button_clicked(self, *args): gtk.main_quit() #---------------------------------------------------------------------- def main(argv): w = MathFlash() w.show() gtk.main() #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) MathFlash.py0100755000076400007640000001122010020255725012235 0ustar dreeddreed#!/usr/bin/env python #---------------------------------------------------------------------- # MathFlash.py # Dave Reed # 02/12/2004 #---------------------------------------------------------------------- import sys from random import randrange from GladeWindow import * #---------------------------------------------------------------------- def get_random_number(digits): num = 0 for i in range(digits): d = randrange(10) num = num * 10 + d return num #---------------------------------------------------------------------- class MathFlash(GladeWindow): #---------------------------------------------------------------------- def __init__(self): ''' ''' self.init() self.widgets['plus_check'].set_active(1) self.correct = 0 self.total = 0 self.show_results() #---------------------------------------------------------------------- def init(self): filename = 'mathflash.glade' widget_list = [ 'window1', 'plus_check', 'minus_check', 'multiply_check', 'divide_check', 'digits_spin', 'operators_spin', 'correct_entry', 'wrong_entry', 'pct_entry', 'problem_entry', 'answer_entry', 'submit_button', 'reset_button', 'exit_button', 'new_button', 'result_entry', ] handlers = [ 'on_operator_check_toggled', 'on_submit_button_clicked', 'on_reset_button_clicked', 'on_exit_button_clicked', 'on_new_button_clicked', ] top_window = 'window1' GladeWindow.__init__(self, filename, top_window, widget_list, handlers) #---------------------------------------------------------------------- def show_results(self): if self.total > 0: pct = '%0.1f%%' % (100.0 * self.correct / float(self.total)) else: pct = '' self.widgets['correct_entry'].set_text(str(self.correct)) self.widgets['wrong_entry'].set_text(str(self.total - self.correct)) self.widgets['pct_entry'].set_text(pct) #---------------------------------------------------------------------- def on_operator_check_toggled(self, *args): self.operators = [] if self.widgets['plus_check'].get_active(): self.operators.append('+') if self.widgets['minus_check'].get_active(): self.operators.append('-') if self.widgets['multiply_check'].get_active(): self.operators.append('*') if self.widgets['divide_check'].get_active(): self.operators.append('/') #---------------------------------------------------------------------- def on_submit_button_clicked(self, *args): prob = self.widgets['problem_entry'].get_text() ans = eval(prob) user = int(self.widgets['answer_entry'].get_text()) self.total += 1 if ans == user: self.correct += 1 self.widgets['result_entry'].set_text('Correct') else: self.widgets['result_entry'].set_text('Wrong, the answer is %d' % ans) self.show_results() #---------------------------------------------------------------------- def on_reset_button_clicked(self, *args): self.correct = 0 self.total = 0 self.show_results() #---------------------------------------------------------------------- def on_new_button_clicked(self, *args): num_digits = int(self.widgets['digits_spin'].get_text()) num_ops = int(self.widgets['operators_spin'].get_text()) prob = [] num = get_random_number(num_digits) prob.append(str(num)) for i in range(num_ops): op = self.operators[randrange(len(self.operators))] prob.append(op) num = get_random_number(num_digits) prob.append(str(num)) self.widgets['problem_entry'].set_text(''.join(prob)) self.widgets['result_entry'].set_text('') self.widgets['answer_entry'].set_text('') #---------------------------------------------------------------------- def on_exit_button_clicked(self, *args): gtk.main_quit() #---------------------------------------------------------------------- def main(argv): w = MathFlash() w.show() gtk.main() #---------------------------------------------------------------------- if __name__ == '__main__': main(sys.argv) mathflash.glade0100644000076400007640000006111110012763022012755 0ustar dreeddreed Math Flash GTK_WINDOW_TOPLEVEL GTK_WIN_POS_NONE False True False True False 0 True 0 0.5 GTK_SHADOW_ETCHED_IN True 4 4 True 6 4 True True + True GTK_RELIEF_NORMAL False False True 3 4 0 1 fill True True - True GTK_RELIEF_NORMAL False False True 3 4 1 2 fill True True * True GTK_RELIEF_NORMAL False False True 3 4 2 3 fill True True / True GTK_RELIEF_NORMAL False False True 3 4 3 4 fill True Number of Digits False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 0 1 fill True # of Operators False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 2 3 fill True Operators False False GTK_JUSTIFY_LEFT False False 1 0.5 0 0 2 3 0 1 fill True True 1 0 False GTK_UPDATE_ALWAYS False False 1 1 5 1 10 10 1 2 0 1 True True 1 0 False GTK_UPDATE_ALWAYS False False 1 1 5 1 10 10 1 2 2 3 True Configuration False False GTK_JUSTIFY_LEFT False False 0.5 0.5 0 0 label_item 0 True True 6 True 5 4 False 7 4 True # Correct False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 0 1 fill True # Wrong False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 2 3 0 1 fill True % Correct False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 1 2 fill True Problem False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 2 3 fill True True False True 0 True * False 1 2 0 1 True True False True 0 True * False 3 4 0 1 True True False True 0 True * False 1 2 1 2 True True False True 0 True * False 50 1 2 2 3 True Your Answer False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 2 3 2 3 fill True True True True 0 True * False 3 4 2 3 True True Submit Answer True GTK_RELIEF_NORMAL 3 4 3 4 True True Reset Stats True GTK_RELIEF_NORMAL 2 4 1 2 True True Exit True GTK_RELIEF_NORMAL 0 4 4 5 fill True True New Problem True GTK_RELIEF_NORMAL 2 3 3 4 True Result False False GTK_JUSTIFY_LEFT False False 0 0.5 0 0 0 1 3 4 fill True True True True 0 True * False 1 2 3 4 0 True True mathflash.gladep0100644000076400007640000000042710012763022013140 0ustar dreeddreed MathFlash mathflash FALSE