diff --git a/src/gui/DamarisGUI.py b/src/gui/DamarisGUI.py index 12a9e6f..8598794 100644 --- a/src/gui/DamarisGUI.py +++ b/src/gui/DamarisGUI.py @@ -18,16 +18,20 @@ import xdg.BaseDirectory # import 3rd party modules # gui graphics import gobject -gobject.threads_init() + +gobject.threads_init( ) import pygtk -pygtk.require("2.0") + +pygtk.require( "2.0" ) import gtk -gtk_version_missmatch=gtk.check_version(2, 8, 0) + +gtk_version_missmatch = gtk.check_version( 2, 8, 0 ) if gtk_version_missmatch: - raise Exception("insufficient gtk version: "+gtk_version_missmatch) + raise Exception( "insufficient gtk version: " + gtk_version_missmatch ) import gtk.gdk -gtk.gdk.threads_init() + +gtk.gdk.threads_init( ) import gtk.glade import pango @@ -39,26 +43,29 @@ import numpy # math graphics import matplotlib # force noninteractive and use of numpy -#matplotlib.rcParams["numerix"]="numpy" -matplotlib.rcParams["interactive"]="False" -matplotlib.rcParams["text.usetex"]="False" -matplotlib.rcParams["axes.formatter.limits"]="-3,3" +# matplotlib.rcParams["numerix"]="numpy" +matplotlib.rcParams[ "interactive" ] = "False" +matplotlib.rcParams[ "text.usetex" ] = "False" +matplotlib.rcParams[ "axes.formatter.limits" ] = "-3,3" -if matplotlib.rcParams["backend"]=="GTK": +if matplotlib.rcParams[ "backend" ] == "GTK": from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas - max_points_to_display=0 # no limit -elif matplotlib.rcParams["backend"]=="GTKCairo": + + max_points_to_display = 0 # no limit +elif matplotlib.rcParams[ "backend" ] == "GTKCairo": from matplotlib.backends.backend_gtkcairo import FigureCanvasGTKCairo as FigureCanvas - max_points_to_display=1<<14 # cairo cannot render longer paths than 18??? + + max_points_to_display = 1 << 14 # cairo cannot render longer paths than 18??? else: # default from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas - max_points_to_display=0 + + max_points_to_display = 0 import matplotlib.axes import matplotlib.figure #for printing issues -if hasattr(gtk, "PrintOperation"): +if hasattr( gtk, "PrintOperation" ): import matplotlib.backends.backend_cairo # import our own stuff @@ -70,179 +77,179 @@ from damaris.gui.gtkcodebuffer import CodeBuffer, SyntaxLoader from damaris.data import DataPool, Accumulation, ADC_Result, MeasurementResult # default, can be set to true from start script -debug=False +debug = False # version info -__version__="0.14-svn-$Revision$" +__version__ = "0.14-svn-$Revision$" + class logstream: - gui_log=None - text_log=sys.__stdout__ + gui_log = None + text_log = sys.__stdout__ - def write(self, message): + def write( self, message ): # default for stdout and stderr if self.gui_log is not None: - self.gui_log(message) + self.gui_log( message ) if debug or self.gui_log is None: - self.text_log.write(message) - self.text_log.flush() + self.text_log.write( message ) + self.text_log.flush( ) - def __call__(self,message): - self.write(message) + def __call__( self, message ): + self.write( message ) - def __del__(self): + def __del__( self ): pass -global log -log=logstream() -sys.stdout=log -sys.stderr=log -ExperimentHandling.log=log -ResultHandling.log=log -ResultReader.log=log -ExperimentWriter.log=log -BackendDriver.log=log -DataPool.log=log +global log +log = logstream( ) +sys.stdout = log +sys.stderr = log + +ExperimentHandling.log = log +ResultHandling.log = log +ResultReader.log = log +ExperimentWriter.log = log +BackendDriver.log = log +DataPool.log = log + class DamarisGUI: + ExpScript_Display = 0 + ResScript_Display = 1 + Monitor_Display = 2 + Log_Display = 3 + Config_Display = 4 - ExpScript_Display=0 - ResScript_Display=1 - Monitor_Display=2 - Log_Display=3 - Config_Display=4 - - Edit_State=0 - Run_State=1 - Pause_State=2 - Stop_State=3 - Quit_State=4 - - def __init__(self, exp_script_filename=None, res_script_filename=None): - + Edit_State = 0 + Run_State = 1 + Pause_State = 2 + Stop_State = 3 + Quit_State = 4 + def __init__( self, exp_script_filename=None, res_script_filename=None ): # state: edit, run, stop, quit # state transitions: # edit -> run|quit # run -> pause|stop # pause -> run|stop # stop -> edit - self.state=DamarisGUI.Edit_State + self.state = DamarisGUI.Edit_State # script execution engines and backend driver self.si = None # produced and displayed data self.data = None - - self.glade_layout_init() + + self.glade_layout_init( ) # my notebook - self.main_notebook = self.xml_gui.get_widget("main_notebook") - - self.log=LogWindow(self.xml_gui) + self.main_notebook = self.xml_gui.get_widget( "main_notebook" ) - self.sw=ScriptWidgets(self.xml_gui) + self.log = LogWindow( self.xml_gui ) - self.toolbar_init() + self.sw = ScriptWidgets( self.xml_gui ) - self.documentation_init() + self.toolbar_init( ) - self.monitor=MonitorWidgets(self.xml_gui) + self.documentation_init( ) - self.config=ConfigTab(self.xml_gui) + self.monitor = MonitorWidgets( self.xml_gui ) - exp_script=u"" - if exp_script_filename is not None and exp_script_filename!="": - self.sw.exp_script_filename=exp_script_filename[:] - if os.path.isfile(exp_script_filename) and os.access(exp_script_filename, os.R_OK): - exp_script = self.sw.load_file_as_unicode(exp_script_filename) + self.config = ConfigTab( self.xml_gui ) - res_script=u"" - if res_script_filename is not None and res_script_filename!="": - self.sw.res_script_filename=res_script_filename[:] - if os.path.isfile(res_script_filename) and os.access(res_script_filename, os.R_OK): - res_script = self.sw.load_file_as_unicode(res_script_filename) - self.sw.set_scripts(exp_script, res_script) + exp_script = u"" + if exp_script_filename is not None and exp_script_filename != "": + self.sw.exp_script_filename = exp_script_filename[ : ] + if os.path.isfile( exp_script_filename ) and os.access( exp_script_filename, os.R_OK ): + exp_script = self.sw.load_file_as_unicode( exp_script_filename ) - self.statusbar_init() + res_script = u"" + if res_script_filename is not None and res_script_filename != "": + self.sw.res_script_filename = res_script_filename[ : ] + if os.path.isfile( res_script_filename ) and os.access( res_script_filename, os.R_OK ): + res_script = self.sw.load_file_as_unicode( res_script_filename ) + self.sw.set_scripts( exp_script, res_script ) - self.main_window.show_all() - self.main_window.present() + self.statusbar_init( ) - def glade_layout_init(self): - glade_file=os.path.join(os.path.dirname(__file__),"damaris.glade") - self.xml_gui = gtk.glade.XML(glade_file) - self.main_window = self.xml_gui.get_widget("main_window") - self.main_window.connect("delete-event", self.quit_event) - self.main_window.set_icon_from_file(os.path.join(os.path.dirname(__file__),"DAMARIS.png")) - self.main_window.set_title(u"DAMARIS-%s"%__version__) - - def statusbar_init(self): + self.main_window.show_all( ) + self.main_window.present( ) + + def glade_layout_init( self ): + glade_file = os.path.join( os.path.dirname( __file__ ), "damaris.glade" ) + self.xml_gui = gtk.glade.XML( glade_file ) + self.main_window = self.xml_gui.get_widget( "main_window" ) + self.main_window.connect( "delete-event", self.quit_event ) + self.main_window.set_icon_from_file( os.path.join( os.path.dirname( __file__ ), "DAMARIS.png" ) ) + self.main_window.set_title( u"DAMARIS-%s" % __version__ ) + + def statusbar_init( self ): """ experiment and result thread status, backend state """ - self.experiment_script_statusbar_label = self.xml_gui.get_widget("statusbar_experiment_script_label") - self.data_handling_statusbar_label = self.xml_gui.get_widget("statusbar_data_handling_label") - self.backend_statusbar_label = self.xml_gui.get_widget("statusbar_core_label") + self.experiment_script_statusbar_label = self.xml_gui.get_widget( "statusbar_experiment_script_label" ) + self.data_handling_statusbar_label = self.xml_gui.get_widget( "statusbar_data_handling_label" ) + self.backend_statusbar_label = self.xml_gui.get_widget( "statusbar_core_label" ) - def toolbar_init(self): + def toolbar_init( self ): """ buttons like save and run... """ - self.toolbar_stop_button = self.xml_gui.get_widget("toolbar_stop_button") - self.toolbar_run_button = self.xml_gui.get_widget("toolbar_run_button") - self.toolbar_pause_button = self.xml_gui.get_widget("toolbar_pause_button") + self.toolbar_stop_button = self.xml_gui.get_widget( "toolbar_stop_button" ) + self.toolbar_run_button = self.xml_gui.get_widget( "toolbar_run_button" ) + self.toolbar_pause_button = self.xml_gui.get_widget( "toolbar_pause_button" ) # print button - self.toolbar_print_button=self.xml_gui.get_widget("toolbar_print_button") - if not hasattr(gtk, "PrintOperation"): - self.toolbar_print_button.set_sensitive(False) + self.toolbar_print_button = self.xml_gui.get_widget( "toolbar_print_button" ) + if not hasattr( gtk, "PrintOperation" ): + self.toolbar_print_button.set_sensitive( False ) print "Printing is not supported by GTK+ version in use" else: - self.toolbar_print_button.set_sensitive(True) - self.xml_gui.signal_connect("on_toolbar_print_button_clicked", self.print_button_switch) + self.toolbar_print_button.set_sensitive( True ) + self.xml_gui.signal_connect( "on_toolbar_print_button_clicked", self.print_button_switch ) # prepare for edit state - self.toolbar_run_button.set_sensitive(True) - self.toolbar_stop_button.set_sensitive(False) - self.toolbar_pause_button.set_sensitive(False) + self.toolbar_run_button.set_sensitive( True ) + self.toolbar_stop_button.set_sensitive( False ) + self.toolbar_pause_button.set_sensitive( False ) # and their events - self.xml_gui.signal_connect("on_toolbar_run_button_clicked", self.start_experiment) - self.xml_gui.signal_connect("on_toolbar_pause_button_toggled", self.pause_experiment) - self.xml_gui.signal_connect("on_toolbar_stop_button_clicked", self.stop_experiment) - self.xml_gui.signal_connect("on_doc_menu_activate",self.show_doc_menu) - self.xml_gui.signal_connect("on_toolbar_manual_button_clicked",self.show_manual) + self.xml_gui.signal_connect( "on_toolbar_run_button_clicked", self.start_experiment ) + self.xml_gui.signal_connect( "on_toolbar_pause_button_toggled", self.pause_experiment ) + self.xml_gui.signal_connect( "on_toolbar_stop_button_clicked", self.stop_experiment ) + self.xml_gui.signal_connect( "on_doc_menu_activate", self.show_doc_menu ) + self.xml_gui.signal_connect( "on_toolbar_manual_button_clicked", self.show_manual ) - def run(self): + def run( self ): # prolong lifetime of clipboard till the very end (avoid error message) self.main_clipboard = self.sw.main_clipboard - gtk.gdk.threads_enter() - gtk.main() - gtk.gdk.threads_leave() + gtk.gdk.threads_enter( ) + gtk.main( ) + gtk.gdk.threads_leave( ) - self.si=None - self.sw=None - self.config=None - self.xml_gui=None + self.si = None + self.sw = None + self.config = None + self.xml_gui = None # event handling: the real acitons in gui programming # first global events - def quit_event(self, widget, data=None): + def quit_event( self, widget, data=None ): """ expecting quit event for main application """ - if self.state in [DamarisGUI.Edit_State, DamarisGUI.Quit_State]: - self.state=DamarisGUI.Quit_State + if self.state in [ DamarisGUI.Edit_State, DamarisGUI.Quit_State ]: + self.state = DamarisGUI.Quit_State # do a cleanup... print "ToDo: Cleanup, Save Dialogs ..." - self.config=None - self.sw=None - self.monitor=None - self.log=None + self.config = None + self.sw = None + self.monitor = None + self.log = None # and quit - gtk.main_quit() + gtk.main_quit( ) return True else: print "Stop Experiment please! (ToDo: Dialog)" @@ -250,303 +257,304 @@ class DamarisGUI: # toolbar related events: - def start_experiment(self, widget, data = None): - + def start_experiment( self, widget, data=None ): + # something running? if self.si is not None: print "Last Experiment is not clearly stopped!" self.si = None # get config values: - actual_config = self.config.get() + actual_config = self.config.get( ) # get scripts and start script interface - self.sw.disable_editing() - exp_script, res_script=self.sw.get_scripts() - if not actual_config["start_result_script"]: - res_script="" - if not actual_config["start_experiment_script"]: - exp_script="" - backend=actual_config["backend_executable"] - if not actual_config["start_backend"]: - backend="" + self.sw.disable_editing( ) + exp_script, res_script = self.sw.get_scripts( ) + if not actual_config[ "start_result_script" ]: + res_script = "" + if not actual_config[ "start_experiment_script" ]: + exp_script = "" + backend = actual_config[ "backend_executable" ] + if not actual_config[ "start_backend" ]: + backend = "" - if (backend=="" and exp_script=="" and res_script==""): + if (backend == "" and exp_script == "" and res_script == ""): print "nothing to do...so doing nothing!" - self.sw.enable_editing() + self.sw.enable_editing( ) return # check whether scripts are syntacticaly valid # should be merged with check script function - exp_code=None - if exp_script!="": + exp_code = None + if exp_script != "": try: - exp_code=compile(exp_script, "Experiment Script", "exec") + exp_code = compile( exp_script, "Experiment Script", "exec" ) except SyntaxError, e: - ln=e.lineno - lo=e.offset - if type(ln) is not types.IntType: - ln=0 - if type(lo) is not types.IntType: - lo=0 - print "Experiment Script: %s at line %d, col %d:"%(e.__class__.__name__, ln, lo) - if e.text!="": - print "\"%s\""%e.text + ln = e.lineno + lo = e.offset + if type( ln ) is not types.IntType: + ln = 0 + if type( lo ) is not types.IntType: + lo = 0 + print "Experiment Script: %s at line %d, col %d:" % (e.__class__.__name__, ln, lo) + if e.text != "": + print "\"%s\"" % e.text # print " "*(e.offset+1)+"^" # nice idea, but needs monospaced fonts pass print e - res_code=None - if res_script!="": + res_code = None + if res_script != "": try: - res_code=compile(res_script, "Result Script", "exec") + res_code = compile( res_script, "Result Script", "exec" ) except SyntaxError, e: - ln=e.lineno - lo=e.offset - if type(ln) is not types.IntType: - ln=0 - if type(lo) is not types.IntType: - lo=0 - print "Result script: %s at line %d, col %d:"%(e.__class__.__name__,ln, lo) - if e.text!="": - print "\"%s\""%e.text + ln = e.lineno + lo = e.offset + if type( ln ) is not types.IntType: + ln = 0 + if type( lo ) is not types.IntType: + lo = 0 + print "Result script: %s at line %d, col %d:" % (e.__class__.__name__, ln, lo) + if e.text != "": + print "\"%s\"" % e.text # print " "*(e.offset+1)+"^" # nice idea, but needs monospaced fonts pass print e # detect error - if (exp_script!="" and exp_code is None) or \ - (res_script!="" and res_code is None): - self.main_notebook.set_current_page(DamarisGUI.Log_Display) - self.sw.enable_editing() + if (exp_script != "" and exp_code is None) or \ + (res_script != "" and res_code is None): + self.main_notebook.set_current_page( DamarisGUI.Log_Display ) + self.sw.enable_editing( ) return # prepare to run - self.state=DamarisGUI.Run_State - self.toolbar_run_button.set_sensitive(False) - self.toolbar_stop_button.set_sensitive(True) - self.toolbar_pause_button.set_sensitive(True) - self.toolbar_pause_button.set_active(False) + self.state = DamarisGUI.Run_State + self.toolbar_run_button.set_sensitive( False ) + self.toolbar_stop_button.set_sensitive( True ) + self.toolbar_pause_button.set_sensitive( True ) + self.toolbar_pause_button.set_active( False ) # delete old data self.data = None - self.monitor.observe_data_pool(self.data) + self.monitor.observe_data_pool( self.data ) # set the text mark for hdf logging - if self.log.textbuffer.get_mark("lastdumped") is None: - self.log.textbuffer.create_mark("lastdumped", self.log.textbuffer.get_end_iter(), left_gravity=True) + if self.log.textbuffer.get_mark( "lastdumped" ) is None: + self.log.textbuffer.create_mark( "lastdumped", self.log.textbuffer.get_end_iter( ), left_gravity=True ) # start experiment try: - self.spool_dir=os.path.abspath(actual_config["spool_dir"]) + self.spool_dir = os.path.abspath( actual_config[ "spool_dir" ] ) # setup script engines - self.si=ScriptInterface(exp_code, - res_code, - backend, - self.spool_dir, - clear_jobs=actual_config["del_jobs_after_execution"], - clear_results=actual_config["del_results_after_processing"]) + self.si = ScriptInterface( exp_code, + res_code, + backend, + self.spool_dir, + clear_jobs=actual_config[ "del_jobs_after_execution" ], + clear_results=actual_config[ "del_results_after_processing" ] ) - self.data=self.si.data + self.data = self.si.data # run frontend and script engines - self.monitor.observe_data_pool(self.data) - self.si.runScripts() + self.monitor.observe_data_pool( self.data ) + self.si.runScripts( ) except Exception, e: #print "ToDo evaluate exception",str(e), "at",traceback.extract_tb(sys.exc_info()[2])[-1][1:3] #print "Full traceback:" - traceback_file=cStringIO.StringIO() - traceback.print_tb(sys.exc_info()[2], None, traceback_file) - self.main_notebook.set_current_page(DamarisGUI.Log_Display) - print "Error while executing scripts: %s\n"%str(e)+traceback_file.getvalue() - traceback_file=None + traceback_file = cStringIO.StringIO( ) + traceback.print_tb( sys.exc_info( )[ 2 ], None, traceback_file ) + self.main_notebook.set_current_page( DamarisGUI.Log_Display ) + print "Error while executing scripts: %s\n" % str( e ) + traceback_file.getvalue( ) + traceback_file = None - self.data=None + self.data = None if self.si is not None: - still_running=filter(None,[self.si.exp_handling,self.si.res_handling,self.si.back_driver]) + still_running = filter( None, [ self.si.exp_handling, self.si.res_handling, self.si.back_driver ] ) for r in still_running: - r.quit_flag.set() + r.quit_flag.set( ) print "waiting for threads stoping...", - still_running=filter(lambda x:x is not None and x.isAlive(), - [self.si.exp_handling, self.si.res_handling, self.si.back_driver]) + still_running = filter( lambda x: x is not None and x.isAlive( ), + [ self.si.exp_handling, self.si.res_handling, self.si.back_driver ] ) for t in still_running: - t.join() + t.join( ) print "done" # cleanup - self.si=None - self.state=DamarisGUI.Edit_State - self.sw.enable_editing() - self.toolbar_run_button.set_sensitive(True) - self.toolbar_stop_button.set_sensitive(False) - self.toolbar_pause_button.set_sensitive(False) - self.toolbar_pause_button.set_active(False) + self.si = None + self.state = DamarisGUI.Edit_State + self.sw.enable_editing( ) + self.toolbar_run_button.set_sensitive( True ) + self.toolbar_stop_button.set_sensitive( False ) + self.toolbar_pause_button.set_sensitive( False ) + self.toolbar_pause_button.set_active( False ) return # switch to grapics - self.main_notebook.set_current_page(DamarisGUI.Monitor_Display) + self.main_notebook.set_current_page( DamarisGUI.Monitor_Display ) # set running if self.si.exp_handling is not None: - self.experiment_script_statusbar_label.set_text("Experiment Script Running (0)") + self.experiment_script_statusbar_label.set_text( "Experiment Script Running (0)" ) else: - self.experiment_script_statusbar_label.set_text("Experiment Script Idle") + self.experiment_script_statusbar_label.set_text( "Experiment Script Idle" ) if self.si.res_handling is not None: - self.data_handling_statusbar_label.set_text("Result Script Running (0)") + self.data_handling_statusbar_label.set_text( "Result Script Running (0)" ) else: - self.data_handling_statusbar_label.set_text("Result Script Idle") - + self.data_handling_statusbar_label.set_text( "Result Script Idle" ) + if self.si.back_driver is not None: - self.backend_statusbar_label.set_text("Backend Running") + self.backend_statusbar_label.set_text( "Backend Running" ) else: - self.backend_statusbar_label.set_text("Backend Idle") + self.backend_statusbar_label.set_text( "Backend Idle" ) # start data dump - self.dump_thread=None - self.save_thread=None - self.dump_filename="" - if actual_config["data_pool_name"]!="": - self.dump_states(init=True) - gobject.timeout_add(200, self.observe_running_experiment) + self.dump_thread = None + self.save_thread = None + self.dump_filename = "" + if actual_config[ "data_pool_name" ] != "": + self.dump_states( init=True ) + gobject.timeout_add( 200, self.observe_running_experiment ) - def observe_running_experiment(self): + def observe_running_experiment( self ): """ periodically look at running threads """ # look at components and update them # test whether backend and scripts are done - r=self.si.data.get("__recentresult",-1)+1 - b=self.si.data.get("__resultsinadvance",-1)+1 - e=self.si.data.get("__recentexperiment",-1)+1 - e_text=None - r_text=None - b_text=None + r = self.si.data.get( "__recentresult", -1 ) + 1 + b = self.si.data.get( "__resultsinadvance", -1 ) + 1 + e = self.si.data.get( "__recentexperiment", -1 ) + 1 + e_text = None + r_text = None + b_text = None if self.si.exp_handling is not None: - if not self.si.exp_handling.isAlive(): - self.si.exp_handling.join() + if not self.si.exp_handling.isAlive( ): + self.si.exp_handling.join( ) if self.si.exp_handling.raised_exception: - print "experiment script failed at line %d (function %s): %s"%(self.si.exp_handling.location[0], - self.si.exp_handling.location[1], - self.si.exp_handling.raised_exception) + print "experiment script failed at line %d (function %s): %s" % (self.si.exp_handling.location[ 0 ], + self.si.exp_handling.location[ 1 ], + self.si.exp_handling.raised_exception) print "Full traceback", self.si.exp_handling.traceback - e_text="Experiment Script Failed (%d)"%e + e_text = "Experiment Script Failed (%d)" % e else: - e_text="Experiment Script Finished (%d)"%e + e_text = "Experiment Script Finished (%d)" % e print "experiment script finished" self.si.exp_handling = None else: - e_text="Experiment Script Running (%d)"%e + e_text = "Experiment Script Running (%d)" % e if self.si.res_handling is not None: - if not self.si.res_handling.isAlive(): - self.si.res_handling.join() + if not self.si.res_handling.isAlive( ): + self.si.res_handling.join( ) if self.si.res_handling.raised_exception: - print "result script failed at line %d (function %s): %s"%(self.si.res_handling.location[0], - self.si.res_handling.location[1], - self.si.res_handling.raised_exception) + print "result script failed at line %d (function %s): %s" % (self.si.res_handling.location[ 0 ], + self.si.res_handling.location[ 1 ], + self.si.res_handling.raised_exception) print "Full traceback", self.si.res_handling.traceback - r_text="Result Script Failed (%d)"%r + r_text = "Result Script Failed (%d)" % r else: - r_text="Result Script Finished (%d)"%r + r_text = "Result Script Finished (%d)" % r self.si.res_handling = None else: - r_text="Result Script Running (%d)"%r + r_text = "Result Script Running (%d)" % r if self.si.back_driver is not None: - if not self.si.back_driver.isAlive(): + if not self.si.back_driver.isAlive( ): if self.si.back_driver.raised_exception: - b_text="Backend Failed" + b_text = "Backend Failed" else: - b_text="Backend Finished" - self.si.back_driver.join() + b_text = "Backend Finished" + self.si.back_driver.join( ) self.si.back_driver = None else: - b_text="Backend Running" - if b!=0: - b_text+=" (%d)"%b + b_text = "Backend Running" + if b != 0: + b_text += " (%d)" % b if self.dump_thread is not None: - if self.dump_thread.isAlive(): - sys.stdout.write(".") - self.dump_dots+=1 - if self.dump_dots>80: + if self.dump_thread.isAlive( ): + sys.stdout.write( "." ) + self.dump_dots += 1 + if self.dump_dots > 80: print - self.dump_dots=0 + self.dump_dots = 0 else: - self.dump_thread.join() - self.dump_thread=None - dump_size=os.stat(self.dump_filename).st_size/1e6 - print "done (%.1f s, %.1f MB)"%(time.time()-self.dump_start_time, dump_size) + self.dump_thread.join( ) + self.dump_thread = None + dump_size = os.stat( self.dump_filename ).st_size / 1e6 + print "done (%.1f s, %.1f MB)" % (time.time( ) - self.dump_start_time, dump_size) - gtk.gdk.threads_enter() + gtk.gdk.threads_enter( ) if e_text: - self.experiment_script_statusbar_label.set_text(e_text) + self.experiment_script_statusbar_label.set_text( e_text ) if r_text: - self.data_handling_statusbar_label.set_text(r_text) + self.data_handling_statusbar_label.set_text( r_text ) if b_text: - self.backend_statusbar_label.set_text(b_text) - gtk.gdk.threads_leave() + self.backend_statusbar_label.set_text( b_text ) + gtk.gdk.threads_leave( ) - still_running=filter(None,[self.si.exp_handling, self.si.res_handling, self.si.back_driver, self.dump_thread]) - if len(still_running)==0: - if self.save_thread is None and self.dump_filename!="": + still_running = filter( None, + [ self.si.exp_handling, self.si.res_handling, self.si.back_driver, self.dump_thread ] ) + if len( still_running ) == 0: + if self.save_thread is None and self.dump_filename != "": print "all subprocesses ended, saving data pool" # thread to save data... - self.save_thread=threading.Thread(target=self.dump_states, name="dump states") - self.save_thread.start() - self.dump_start_time=time.time() - self.dump_dots=0 + self.save_thread = threading.Thread( target=self.dump_states, name="dump states" ) + self.save_thread.start( ) + self.dump_start_time = time.time( ) + self.dump_dots = 0 self.state = DamarisGUI.Stop_State if self.state == DamarisGUI.Stop_State: - gtk.gdk.threads_enter() - self.toolbar_pause_button.set_sensitive(False) - self.toolbar_stop_button.set_sensitive(False) - gtk.gdk.threads_leave() - if len(still_running)!=0: - print "subprocess(es) still running: "+', '.join(map(lambda s:s.getName(),still_running)) + gtk.gdk.threads_enter( ) + self.toolbar_pause_button.set_sensitive( False ) + self.toolbar_stop_button.set_sensitive( False ) + gtk.gdk.threads_leave( ) + if len( still_running ) != 0: + print "subprocess(es) still running: " + ', '.join( map( lambda s: s.getName( ), still_running ) ) return True else: if self.save_thread is not None: - if self.save_thread.isAlive(): - sys.stdout.write(".") - self.dump_dots+=1 - if self.dump_dots>80: + if self.save_thread.isAlive( ): + sys.stdout.write( "." ) + self.dump_dots += 1 + if self.dump_dots > 80: print - self.dump_dots=0 + self.dump_dots = 0 return True - self.save_thread.join() - self.save_thread=None - dump_size=os.stat(self.dump_filename).st_size/1e6 - print "done (%.1f s, %.1f MB)"%(time.time()-self.dump_start_time, dump_size) + self.save_thread.join( ) + self.save_thread = None + dump_size = os.stat( self.dump_filename ).st_size / 1e6 + print "done (%.1f s, %.1f MB)" % (time.time( ) - self.dump_start_time, dump_size) # now everything is stopped - self.state=DamarisGUI.Edit_State - gtk.gdk.threads_enter() - self.sw.enable_editing() - self.toolbar_run_button.set_sensitive(True) - self.toolbar_stop_button.set_sensitive(False) - self.toolbar_pause_button.set_sensitive(False) - gtk.gdk.threads_leave() + self.state = DamarisGUI.Edit_State + gtk.gdk.threads_enter( ) + self.sw.enable_editing( ) + self.toolbar_run_button.set_sensitive( True ) + self.toolbar_stop_button.set_sensitive( False ) + self.toolbar_pause_button.set_sensitive( False ) + gtk.gdk.threads_leave( ) # keep data to display but throw away everything else - self.si=None + self.si = None return False # dump states? - if self.dump_thread is None and self.dump_filename!="" and \ - self.dump_timeinterval!=0 and self.last_dumped+self.dump_timeinterval 0: + os.rename( dump_filename_pattern % (last_backup - 1), dump_filename_pattern % last_backup ) + last_backup -= 1 + os.rename( self.dump_filename, dump_filename_pattern % 0 ) + if cummulated_size > (1 << 30): + print "Warning: the cummulated backups size of '%s' is %d MByte" % (self.dump_filename, + cummulated_size / (1 << 20)) + # init is finnished now - last_backup=0 - cummulated_size=os.stat(self.dump_filename).st_size - while os.path.isfile(dump_filename_pattern%last_backup): - cummulated_size+=os.stat(dump_filename_pattern%last_backup).st_size - last_backup+=1 - while last_backup>0: - os.rename(dump_filename_pattern%(last_backup-1),dump_filename_pattern%last_backup) - last_backup-=1 - os.rename(self.dump_filename,dump_filename_pattern%0) - if cummulated_size>(1<<30): - print "Warning: the cummulated backups size of '%s' is %d MByte"%(self.dump_filename, - cummulated_size/(1<<20)) - # init is finnished now - # now it's time to create the hdf file - dump_file=None - if not os.path.isfile(self.dump_filename): + dump_file = None + if not os.path.isfile( self.dump_filename ): if not init: - print "dump file \"%s\" vanished unexpectedly, creating new one"%self.dump_filename + print "dump file \"%s\" vanished unexpectedly, creating new one" % self.dump_filename # have a look to the path and create necessary directories - dir_stack=[] - dir_trunk=os.path.dirname(os.path.abspath(self.dump_filename)) - while dir_trunk!="" and not os.path.isdir(dir_trunk): - dir_stack.append(os.path.basename(dir_trunk)) - dir_trunk=os.path.dirname(dir_trunk) + dir_stack = [ ] + dir_trunk = os.path.dirname( os.path.abspath( self.dump_filename ) ) + while dir_trunk != "" and not os.path.isdir( dir_trunk ): + dir_stack.append( os.path.basename( dir_trunk ) ) + dir_trunk = os.path.dirname( dir_trunk ) try: - while len(dir_stack): - dir_trunk=os.path.join(dir_trunk, dir_stack.pop()) - if os.path.isdir(dir_trunk): continue - os.mkdir(dir_trunk) + while len( dir_stack ): + dir_trunk = os.path.join( dir_trunk, dir_stack.pop( ) ) + if os.path.isdir( dir_trunk ): + continue + os.mkdir( dir_trunk ) except OSError, e: print e - print "coud not create dump directory '%s', so hdf5 dumps disabled"%dir_trunk - self.dump_filename="" - self.dump_timeinterval=0 + print "coud not create dump directory '%s', so hdf5 dumps disabled" % dir_trunk + self.dump_filename = "" + self.dump_timeinterval = 0 return True # create new dump file - dump_file=tables.openFile(self.dump_filename,mode="w",title="DAMARIS experiment data") + dump_file = tables.openFile( self.dump_filename, mode="w", title="DAMARIS experiment data" ) # write scripts and other useful information - scriptgroup=dump_file.createGroup("/","scripts","Used Scripts") - exp_text, res_text=self.sw.get_scripts() + scriptgroup = dump_file.createGroup( "/", "scripts", "Used Scripts" ) + exp_text, res_text = self.sw.get_scripts( ) if self.si.exp_script: - dump_file.createArray(scriptgroup,"experiment_script", exp_text) + dump_file.createArray( scriptgroup, "experiment_script", exp_text ) if self.si.res_script: - dump_file.createArray(scriptgroup,"result_script", res_text) + dump_file.createArray( scriptgroup, "result_script", res_text ) if self.si.backend_executable: - dump_file.createArray(scriptgroup,"backend_executable", self.si.backend_executable) + dump_file.createArray( scriptgroup, "backend_executable", self.si.backend_executable ) if self.spool_dir: - dump_file.createArray(scriptgroup,"spool_directory", self.spool_dir) - timeline_tablecols=numpy.recarray(0,dtype=([("time","S17"), - ("experiments","int64"), - ("results","int64")])) - timeline_table=dump_file.createTable("/","timeline", timeline_tablecols, title="Timeline of Experiment") - if tables.__version__[0]=="1": - logarray=dump_file.createVLArray(where=dump_file.root, - name="log", - atom=tables.StringAtom(length=120), - title="log messages", - filters=tables.Filters(complevel=9, complib='zlib')) + dump_file.createArray( scriptgroup, "spool_directory", self.spool_dir ) + timeline_tablecols = numpy.recarray( 0, dtype=([ ("time", "S17"), + ("experiments", "int64"), + ("results", "int64") ]) ) + timeline_table = dump_file.createTable( "/", "timeline", timeline_tablecols, + title="Timeline of Experiment" ) + if tables.__version__[ 0 ] == "1": + logarray = dump_file.createVLArray( where=dump_file.root, + name="log", + atom=tables.StringAtom( length=120 ), + title="log messages", + filters=tables.Filters( complevel=9, complib='zlib' ) ) else: - logarray=dump_file.createEArray(where=dump_file.root, - name="log", - atom=tables.StringAtom(itemsize=120), - shape=(0,), - title="log messages", - filters=tables.Filters(complevel=9, complib='zlib')) - - if dump_file is None and os.path.isfile(self.dump_filename) and tables.isPyTablesFile(self.dump_filename): + logarray = dump_file.createEArray( where=dump_file.root, + name="log", + atom=tables.StringAtom( itemsize=120 ), + shape=(0,), + title="log messages", + filters=tables.Filters( complevel=9, complib='zlib' ) ) + + if dump_file is None and os.path.isfile( self.dump_filename ) and tables.isPyTablesFile( self.dump_filename ): # take some data from dump file and repack - os.rename(self.dump_filename, self.dump_filename+".bak") - old_dump_file=tables.openFile(self.dump_filename+".bak", mode="r+") + os.rename( self.dump_filename, self.dump_filename + ".bak" ) + old_dump_file = tables.openFile( self.dump_filename + ".bak", mode="r+" ) if "data_pool" in old_dump_file.root: - old_dump_file.removeNode(where="/", name="data_pool", recursive=True) - old_dump_file.copyFile(self.dump_filename) - old_dump_file.close() + old_dump_file.removeNode( where="/", name="data_pool", recursive=True ) + old_dump_file.copyFile( self.dump_filename ) + old_dump_file.close( ) del old_dump_file - os.remove(self.dump_filename+".bak") + os.remove( self.dump_filename + ".bak" ) # prepare for update - dump_file=tables.openFile(self.dump_filename, mode="r+") - + dump_file = tables.openFile( self.dump_filename, mode="r+" ) + if dump_file is None: # exit! - print "coud not create dump directory '%s', so hdf5 dumps disabled"%dir_trunk - self.dump_filename="" - self.dump_timeinterval=0 + print "coud not create dump directory '%s', so hdf5 dumps disabled" % dir_trunk + self.dump_filename = "" + self.dump_timeinterval = 0 return True # no undo please! - if dump_file.isUndoEnabled(): - dump_file.disableUndo() - + if dump_file.isUndoEnabled( ): + dump_file.disableUndo( ) + # save the data! - self.data.write_hdf5(dump_file, where="/", name="data_pool", - complib=self.dump_complib, complevel=self.dump_complevel) + self.data.write_hdf5( dump_file, where="/", name="data_pool", + complib=self.dump_complib, complevel=self.dump_complevel ) # now save additional information - e=self.si.data.get("__recentexperiment",-1)+1 - r=self.si.data.get("__recentresult",-1)+1 - timeline_table=dump_file.root.timeline - timeline_row=timeline_table.row - timeline_row["time"]=time.strftime("%Y%m%d %H:%M:%S") - timeline_row["experiments"]=e - timeline_row["results"]=r - timeline_row.append() - timeline_table.flush() + e = self.si.data.get( "__recentexperiment", -1 ) + 1 + r = self.si.data.get( "__recentresult", -1 ) + 1 + timeline_table = dump_file.root.timeline + timeline_row = timeline_table.row + timeline_row[ "time" ] = time.strftime( "%Y%m%d %H:%M:%S" ) + timeline_row[ "experiments" ] = e + timeline_row[ "results" ] = r + timeline_row.append( ) + timeline_table.flush( ) # save log window information: # also save backend's logfile information? - logtextbuffer=self.log.textbuffer - last_end=logtextbuffer.get_mark("lastdumped") + logtextbuffer = self.log.textbuffer + last_end = logtextbuffer.get_mark( "lastdumped" ) if last_end is None: - last_end=logtextbuffer.create_mark("lastdumped", logtextbuffer.get_start_iter(), left_gravity=True) - logtext_start=logtextbuffer.get_iter_at_mark(last_end) - logtext_end=logtextbuffer.get_end_iter() - logtextbuffer.move_mark(last_end, logtext_end) + last_end = logtextbuffer.create_mark( "lastdumped", logtextbuffer.get_start_iter( ), left_gravity=True ) + logtext_start = logtextbuffer.get_iter_at_mark( last_end ) + logtext_end = logtextbuffer.get_end_iter( ) + logtextbuffer.move_mark( last_end, logtext_end ) # recode from unicode - logtext=codecs.getencoder("iso-8859-15")(logtextbuffer.get_text(logtext_start , logtext_end),"replace")[0] + logtext = codecs.getencoder( "iso-8859-15" )( logtextbuffer.get_text( logtext_start, logtext_end ), "replace" )[ + 0 ] # avoid circular references (seems to be necessary with gtk-2.12) del logtextbuffer, logtext_start, logtext_end, last_end - for l in logtext.splitlines(): - dump_file.root.log.append(numpy.array([l], dtype="S120")) + for l in logtext.splitlines( ): + dump_file.root.log.append( numpy.array( [ l ], dtype="S120" ) ) - dump_file.flush() - dump_file.close() - self.last_dumped=time.time() + dump_file.flush( ) + dump_file.close( ) + self.last_dumped = time.time( ) del dump_file return True - - def pause_experiment(self, widget, data = None): + + def pause_experiment( self, widget, data=None ): """ pause experiment execution (that means delay backend and let others run) """ - if self.si is None: return False - pause_state=self.toolbar_pause_button.get_active() + if self.si is None: + return False + pause_state = self.toolbar_pause_button.get_active( ) if pause_state: - if self.state!=DamarisGUI.Run_State: return False - if self.spool_dir is None: return False - no=self.si.data.get("__recentresult",-1)+1 - result_pattern=os.path.join(self.spool_dir, "job.%09d.result") - job_pattern=os.path.join(self.spool_dir, "job.%09d") - while os.path.isfile(result_pattern%no): - no+=1 - i=0 - self.pause_files=[] - while i<3 and os.path.isfile(job_pattern%(no+i)): - pause_file=(job_pattern%(no+i))+".pause" - os.rename(job_pattern%(no+i), pause_file ) - self.pause_files.append(pause_file) - i+=1 - self.state=DamarisGUI.Pause_State - self.backend_statusbar_label.set_text("Backend Paused") - + if self.state != DamarisGUI.Run_State: + return False + if self.spool_dir is None: + return False + no = self.si.data.get( "__recentresult", -1 ) + 1 + result_pattern = os.path.join( self.spool_dir, "job.%09d.result" ) + job_pattern = os.path.join( self.spool_dir, "job.%09d" ) + while os.path.isfile( result_pattern % no ): + no += 1 + i = 0 + self.pause_files = [ ] + while i < 3 and os.path.isfile( job_pattern % (no + i) ): + pause_file = (job_pattern % (no + i)) + ".pause" + os.rename( job_pattern % (no + i), pause_file ) + self.pause_files.append( pause_file ) + i += 1 + self.state = DamarisGUI.Pause_State + self.backend_statusbar_label.set_text( "Backend Paused" ) + else: - if self.state!=DamarisGUI.Pause_State: return False - self.state=DamarisGUI.Run_State + if self.state != DamarisGUI.Pause_State: + return False + self.state = DamarisGUI.Run_State for f in self.pause_files: - os.rename(f, f[:-6]) - self.pause_files=None - self.backend_statusbar_label.set_text("Backend Running") + os.rename( f, f[ :-6 ] ) + self.pause_files = None + self.backend_statusbar_label.set_text( "Backend Running" ) - def stop_experiment(self, widget, data = None): - if self.state in [DamarisGUI.Run_State, DamarisGUI.Pause_State]: - if self.si is None: return - still_running=filter(None,[self.si.exp_handling,self.si.res_handling,self.si.back_driver]) + def stop_experiment( self, widget, data=None ): + if self.state in [ DamarisGUI.Run_State, DamarisGUI.Pause_State ]: + if self.si is None: + return + still_running = filter( None, [ self.si.exp_handling, self.si.res_handling, self.si.back_driver ] ) for r in still_running: - r.quit_flag.set() - self.state=DamarisGUI.Stop_State + r.quit_flag.set( ) + self.state = DamarisGUI.Stop_State - def print_button_switch(self, widget): + def print_button_switch( self, widget ): """ decides what to print... and prints, layout is done by responsible class """ - if not hasattr(gtk, "PrintOperation"): + if not hasattr( gtk, "PrintOperation" ): return # copied and modified from pygtk-2.10.1/examples/pygtk-demo/demos/print_editor.py - print_ = gtk.PrintOperation() + print_ = gtk.PrintOperation( ) # will come from config - settings=None + settings = None if settings is not None: - print_.set_print_settings(settings) + print_.set_print_settings( settings ) - page_setup=None + page_setup = None if page_setup is not None: - print_.set_default_page_setup(page_setup) + print_.set_default_page_setup( page_setup ) #print_.set_property("allow_async",True) - current_page=self.main_notebook.get_current_page() - print_data = {} - if current_page in [0,1]: - print_.connect("begin_print", self.sw.begin_print, print_data) - print_.connect("draw_page", self.sw.draw_page, print_data) + current_page = self.main_notebook.get_current_page( ) + print_data = { } + if current_page in [ 0, 1 ]: + print_.connect( "begin_print", self.sw.begin_print, print_data ) + print_.connect( "draw_page", self.sw.draw_page, print_data ) elif current_page == 2: - print_.connect("begin_print", self.monitor.begin_print, print_data) - print_.connect("draw_page", self.monitor.draw_page, print_data) + print_.connect( "begin_print", self.monitor.begin_print, print_data ) + print_.connect( "draw_page", self.monitor.draw_page, print_data ) else: return - + try: - res = print_.run(gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG, self.main_window) + res = print_.run( gtk.PRINT_OPERATION_ACTION_PRINT_DIALOG, self.main_window ) except gobject.GError, ex: - error_dialog = gtk.MessageDialog(self.main_window, - gtk.DIALOG_DESTROY_WITH_PARENT, - gtk._MESSAGE_ERROR, - gtk.BUTTONS_CLOSE, - ("Error printing file:\n%s" % str(ex))) - error_dialog.connect("response", gtk.Widget.destroy) - error_dialog.show() + error_dialog = gtk.MessageDialog( self.main_window, + gtk.DIALOG_DESTROY_WITH_PARENT, + gtk._MESSAGE_ERROR, + gtk.BUTTONS_CLOSE, + ("Error printing file:\n%s" % str( ex )) ) + error_dialog.connect( "response", gtk.Widget.destroy ) + error_dialog.show( ) else: if res == gtk.PRINT_OPERATION_RESULT_APPLY: - settings = print_.get_print_settings() + settings = print_.get_print_settings( ) - def documentation_init(self): + def documentation_init( self ): - self.doc_urls={ + self.doc_urls = { "Python DAMARIS": None, "DAMARIS Homepage": "http://damaris.berlios.de/", - "Python": "http://www.python.org/doc/%d.%d/"%(sys.version_info[:2]), + "Python": "http://www.python.org/doc/%d.%d/" % (sys.version_info[ :2 ]), "numpy/scipy": "http://docs.scipy.org/", "pytables": "http://www.pytables.org/docs/manual/", "DAMARIS backends": None, "DAMARIS Repository": "http://svn.berlios.de/viewvc/damaris" - } + } - if os.path.isdir("/usr/share/doc/python%d.%d-doc/html"%(sys.version_info[:2])): - self.doc_urls["Python"]="file:///usr/share/doc/python%d.%d-doc/html/index.html"%(sys.version_info[:2]) + if os.path.isdir( "/usr/share/doc/python%d.%d-doc/html" % (sys.version_info[ :2 ]) ): + self.doc_urls[ "Python" ] = "file:///usr/share/doc/python%d.%d-doc/html/index.html" % ( + sys.version_info[ :2 ]) - if os.path.isdir("/usr/share/doc/python-tables-doc/html"): - self.doc_urls["pytables"]="file:///usr/share/doc/python-tables-doc/html/index.html" + if os.path.isdir( "/usr/share/doc/python-tables-doc/html" ): + self.doc_urls[ "pytables" ] = "file:///usr/share/doc/python-tables-doc/html/index.html" - doc_index_url=None + doc_index_url = None # local installation - installation_base=__file__ - for i in xrange(5): - installation_base=os.path.dirname(installation_base) - if os.path.isfile(os.path.join(installation_base, "share", "python-damaris", "doc", "index.html")): - self.doc_urls["Python DAMARIS"]=os.path.join(installation_base, "share", "python-damaris", "doc", "index.html") - elif os.path.isfile("/usr/share/doc/python-damaris/html/index.html"): + installation_base = __file__ + for i in xrange( 5 ): + installation_base = os.path.dirname( installation_base ) + if os.path.isfile( os.path.join( installation_base, "share", "python-damaris", "doc", "index.html" ) ): + self.doc_urls[ "Python DAMARIS" ] = os.path.join( installation_base, "share", "python-damaris", "doc", + "index.html" ) + elif os.path.isfile( "/usr/share/doc/python-damaris/html/index.html" ): # check generic debian location - self.doc_urls["Python DAMARIS"]="file:///usr/share/doc/python-damaris/html/index.html" + self.doc_urls[ "Python DAMARIS" ] = "file:///usr/share/doc/python-damaris/html/index.html" else: - self.doc_urls["Python DAMARIS"]="http://damaris.berlios.de/wiki/index.php/Tutorial" + self.doc_urls[ "Python DAMARIS" ] = "http://damaris.berlios.de/wiki/index.php/Tutorial" - self.doc_browser=None + self.doc_browser = None - def show_doc_menu(self, widget, data=None): + def show_doc_menu( self, widget, data=None ): """ offer a wide variety of docs, prefer local installations """ - if type(widget) is gtk.MenuItem: - requested_doc=widget.get_child().get_text() + if type( widget ) is gtk.MenuItem: + requested_doc = widget.get_child( ).get_text( ) else: - requested_doc="Python DAMARIS" - - if requested_doc in self.doc_urls and self.doc_urls[requested_doc] is not None: + requested_doc = "Python DAMARIS" + + if requested_doc in self.doc_urls and self.doc_urls[ requested_doc ] is not None: if self.doc_browser is not None: - if not self.doc_browser.isAlive(): - self.doc_browser.join() + if not self.doc_browser.isAlive( ): + self.doc_browser.join( ) if self.doc_browser.my_webbrowser is not None: print "new browser tab" - self.doc_browser.my_webbrowser.open_new_tab(self.doc_urls[requested_doc]) + self.doc_browser.my_webbrowser.open_new_tab( self.doc_urls[ requested_doc ] ) else: del self.doc_browser - self.doc_browser=start_browser(self.doc_urls[requested_doc]) - self.doc_browser.start() + self.doc_browser = start_browser( self.doc_urls[ requested_doc ] ) + self.doc_browser.start( ) else: - self.doc_browser=start_browser(self.doc_urls[requested_doc]) - self.doc_browser.start() + self.doc_browser = start_browser( self.doc_urls[ requested_doc ] ) + self.doc_browser.start( ) else: - print "missing docs for '%s'"%(requested_doc) + print "missing docs for '%s'" % (requested_doc) - show_manual=show_doc_menu + show_manual = show_doc_menu -class start_browser(threading.Thread): - def __init__(self, url): - threading.Thread.__init__(self, name="manual browser") - self.my_webbrowser=None - self.my_webbrowser_process=None - self.start_url=url - - def run(self): +class start_browser( threading.Thread ): + def __init__( self, url ): + threading.Thread.__init__( self, name="manual browser" ) + self.my_webbrowser = None + self.my_webbrowser_process = None + self.start_url = url + + def run( self ): """ start a webbrowser """ - if sys.hexversion>=0x02050000: - if sys.platform=="linux2" and self.my_webbrowser is None: + if sys.hexversion >= 0x02050000: + if sys.platform == "linux2" and self.my_webbrowser is None: # try for debian linux - self.my_webbrowser=webbrowser.get("x-www-browser") + self.my_webbrowser = webbrowser.get( "x-www-browser" ) if self.my_webbrowser is None: # this is what it should be everywhere! - self.my_webbrowser=webbrowser.get() + self.my_webbrowser = webbrowser.get( ) if self.my_webbrowser is not None: print "starting web browser (module webbrowser)" - self.my_webbrowser.open(self.start_url) + self.my_webbrowser.open( self.start_url ) return True # last resort print "starting web browser (webbrowser.py)" - self.my_webbrowser_process=os.spawnl(os.P_NOWAIT, - sys.executable, - os.path.basename(sys.executable), - "-c", - "import webbrowser\nwebbrowser.open('%s')"%self.start_url) + self.my_webbrowser_process = os.spawnl( os.P_NOWAIT, + sys.executable, + os.path.basename( sys.executable ), + "-c", + "import webbrowser\nwebbrowser.open('%s')" % self.start_url ) return True + class LogWindow: """ writes messages to the log window """ - def __init__(self, xml_gui): - - self.xml_gui=xml_gui - self.textview=self.xml_gui.get_widget("messages_textview") - self.textbuffer=self.textview.get_buffer() - self.logstream=log - self.logstream.gui_log=self - self.last_timetag=None - self("Started in directory %s\n" % os.getcwd()) + def __init__( self, xml_gui ): - def __call__(self, message): - timetag=time.time() - gobject.idle_add(self.add_message_callback,timetag,message,priority=gobject.PRIORITY_LOW) + self.xml_gui = xml_gui + self.textview = self.xml_gui.get_widget( "messages_textview" ) + self.textbuffer = self.textview.get_buffer( ) + self.logstream = log + self.logstream.gui_log = self + self.last_timetag = None + self( "Started in directory %s\n" % os.getcwd( ) ) - def add_message_callback(self, timetag, message): - date_tag=u"" - if self.last_timetag is None or (message!="\n" and self.last_timetag+600 and ln<=tb.get_line_count(): - new_place=tb.get_iter_at_line_offset(ln-1,0) - if lo>0 and lo<=new_place.get_chars_in_line(): - new_place.set_line_offset(lo) - tb.place_cursor(new_place) - tv.scroll_to_iter(new_place, 0.2, False, 0,0) + if type( ln ) is not types.IntType: + ln = 0 + if type( lo ) is not types.IntType: + lo = 0 + print "Syntax Error:\n%s in %s at line %d, offset %d" % ( + str( se ), se.filename, ln, lo) + "\n(ToDo: Dialog)" + if ln > 0 and ln <= tb.get_line_count( ): + new_place = tb.get_iter_at_line_offset( ln - 1, 0 ) + if lo > 0 and lo <= new_place.get_chars_in_line( ): + new_place.set_line_offset( lo ) + tb.place_cursor( new_place ) + tv.scroll_to_iter( new_place, 0.2, False, 0, 0 ) except Exception, e: - print "Compilation Error:\n"+str(e)+"\n(ToDo: Dialog)" + print "Compilation Error:\n" + str( e ) + "\n(ToDo: Dialog)" - def notebook_page_switched(self, notebook, page, pagenumber): - self.set_toolbuttons_status() + def notebook_page_switched( self, notebook, page, pagenumber ): + self.set_toolbuttons_status( ) - def column_line_widgets_changed_event(self, data=None): - widget_name=data.name - text_name=None - if widget_name.startswith("data_handling"): - text_name="data_handling" - elif widget_name.startswith("experiment_script"): - text_name="experiment_script" + def column_line_widgets_changed_event( self, data=None ): + widget_name = data.name + text_name = None + if widget_name.startswith( "data_handling" ): + text_name = "data_handling" + elif widget_name.startswith( "experiment_script" ): + text_name = "experiment_script" else: print "unknown line/column selector" return - textview=self.__dict__[text_name+"_textview"] - textbuffer=textview.get_buffer() - newline=self.__dict__[text_name+"_line_indicator"].get_value_as_int()-1 - newcol=self.__dict__[text_name+"_column_indicator"].get_value_as_int()-1 + textview = self.__dict__[ text_name + "_textview" ] + textbuffer = textview.get_buffer( ) + newline = self.__dict__[ text_name + "_line_indicator" ].get_value_as_int( ) - 1 + newcol = self.__dict__[ text_name + "_column_indicator" ].get_value_as_int( ) - 1 #if newline>textbuffer.get_end_iter().get_line(): # return - new_place=textbuffer.get_iter_at_line(newline) - if not newcol>new_place.get_chars_in_line(): - new_place.set_line_offset(newcol) + new_place = textbuffer.get_iter_at_line( newline ) + if not newcol > new_place.get_chars_in_line( ): + new_place.set_line_offset( newcol ) else: - self.__dict__[text_name+"_column_indicator"].set_value(1) - if len(textbuffer.get_selection_bounds())!=0: - textbuffer.move_mark_by_name("insert", new_place) + self.__dict__[ text_name + "_column_indicator" ].set_value( 1 ) + if len( textbuffer.get_selection_bounds( ) ) != 0: + textbuffer.move_mark_by_name( "insert", new_place ) else: - textbuffer.place_cursor(new_place) + textbuffer.place_cursor( new_place ) - textview.scroll_mark_onscreen(textbuffer.get_insert()) - textview.grab_focus() + textview.scroll_mark_onscreen( textbuffer.get_insert( ) ) + textview.grab_focus( ) return True - def textviews_modified(self, data = None): + def textviews_modified( self, data=None ): # mix into toolbar affairs - self.set_toolbuttons_status() + self.set_toolbuttons_status( ) - def textviews_clicked(self, widget, event): - return self.textviews_moved(widget) + def textviews_clicked( self, widget, event ): + return self.textviews_moved( widget ) - def textviews_moved(self, widget, text=None, count=None, ext_selection=None, data = None): - textbuffer=widget.get_buffer() - cursor_mark=textbuffer.get_insert() - cursor_iter=textbuffer.get_iter_at_mark(cursor_mark) + def textviews_moved( self, widget, text=None, count=None, ext_selection=None, data=None ): + textbuffer = widget.get_buffer( ) + cursor_mark = textbuffer.get_insert( ) + cursor_iter = textbuffer.get_iter_at_mark( cursor_mark ) if textbuffer is self.experiment_script_textbuffer: - line_indicator=self.experiment_script_line_indicator - column_indicator=self.experiment_script_column_indicator + line_indicator = self.experiment_script_line_indicator + column_indicator = self.experiment_script_column_indicator if textbuffer is self.data_handling_textbuffer: - line_indicator=self.data_handling_line_indicator - column_indicator=self.data_handling_column_indicator + line_indicator = self.data_handling_line_indicator + column_indicator = self.data_handling_column_indicator # do only necessary updates! - li_range_new=textbuffer.get_end_iter().get_line()+1 - if line_indicator.get_range()[1]!=li_range_new: - line_indicator.set_range(1, li_range_new) - ci_range_new=cursor_iter.get_chars_in_line()+1 - if column_indicator.get_range()[1]!=ci_range_new: - column_indicator.set_range(1, ci_range_new) - cursor_line=cursor_iter.get_line()+1 - cursor_lineoffset=cursor_iter.get_line_offset()+1 - if line_indicator.get_value()!=cursor_line: - line_indicator.set_value(cursor_line) - if column_indicator.get_value()!=cursor_lineoffset: - column_indicator.set_value(cursor_lineoffset) + li_range_new = textbuffer.get_end_iter( ).get_line( ) + 1 + if line_indicator.get_range( )[ 1 ] != li_range_new: + line_indicator.set_range( 1, li_range_new ) + ci_range_new = cursor_iter.get_chars_in_line( ) + 1 + if column_indicator.get_range( )[ 1 ] != ci_range_new: + column_indicator.set_range( 1, ci_range_new ) + cursor_line = cursor_iter.get_line( ) + 1 + cursor_lineoffset = cursor_iter.get_line_offset( ) + 1 + if line_indicator.get_value( ) != cursor_line: + line_indicator.set_value( cursor_line ) + if column_indicator.get_value( ) != cursor_lineoffset: + column_indicator.set_value( cursor_lineoffset ) return False - def textviews_keypress(self, widget, event, data = None): + def textviews_keypress( self, widget, event, data=None ): """ helpful tab and return key functions """ #print "keypress", event.state, event.keyval - if event.state>k.gdk.CONTROL_MASK!=0: - if event.keyval==gtk.gdk.keyval_from_name("c"): - if self.main_notebook.get_current_page() == 0: - self.experiment_script_textbuffer.copy_clipboard(self.main_clipboard) - elif self.main_notebook.get_current_page() == 1: - self.data_handling_textbuffer.copy_clipboard(self.main_clipboard) + if event.state & gtk.gdk.CONTROL_MASK != 0: + if event.keyval == gtk.gdk.keyval_from_name( "c" ): + if self.main_notebook.get_current_page( ) == 0: + self.experiment_script_textbuffer.copy_clipboard( self.main_clipboard ) + elif self.main_notebook.get_current_page( ) == 1: + self.data_handling_textbuffer.copy_clipboard( self.main_clipboard ) return True - elif event.keyval==gtk.gdk.keyval_from_name("x"): + elif event.keyval == gtk.gdk.keyval_from_name( "x" ): # cut_clipboard(clipboard, textview editable?) - if self.main_notebook.get_current_page() == 0: - self.experiment_script_textbuffer.cut_clipboard(self.main_clipboard, True) - elif self.main_notebook.get_current_page() == 1: - self.data_handling_textbuffer.cut_clipboard(self.main_clipboard, True) + if self.main_notebook.get_current_page( ) == 0: + self.experiment_script_textbuffer.cut_clipboard( self.main_clipboard, True ) + elif self.main_notebook.get_current_page( ) == 1: + self.data_handling_textbuffer.cut_clipboard( self.main_clipboard, True ) return True - elif event.keyval==gtk.gdk.keyval_from_name("v"): + elif event.keyval == gtk.gdk.keyval_from_name( "v" ): # paste_clipboard(clipboard, textpos (None = Cursor), textview editable?) - if self.main_notebook.get_current_page() == 0: - self.experiment_script_textbuffer.paste_clipboard(self.main_clipboard, None, True) - elif self.main_notebook.get_current_page() == 1: - self.data_handling_textbuffer.paste_clipboard(self.main_clipboard, None, True) + if self.main_notebook.get_current_page( ) == 0: + self.experiment_script_textbuffer.paste_clipboard( self.main_clipboard, None, True ) + elif self.main_notebook.get_current_page( ) == 1: + self.data_handling_textbuffer.paste_clipboard( self.main_clipboard, None, True ) return True - elif event.keyval==gtk.gdk.keyval_from_name("s"): + elif event.keyval == gtk.gdk.keyval_from_name( "s" ): # save buffer - page=self.main_notebook.get_current_page() - if (self.exp_script_filename,self.res_script_filename)[page] is None: - self.save_file_as() + page = self.main_notebook.get_current_page( ) + if (self.exp_script_filename, self.res_script_filename)[ page ] is None: + self.save_file_as( ) else: - self.save_file() + self.save_file( ) return True - elif event.keyval==gtk.gdk.keyval_from_name("S"): + elif event.keyval == gtk.gdk.keyval_from_name( "S" ): # save both buffers print "ToDo: save both buffers" - self.save_all_files(None, None) + self.save_all_files( None, None ) return True return 0 @@ -1273,382 +1295,394 @@ class ScriptWidgets: # tab keyval 0xff09 # backspace keyval 0xff08 # to do check if modified event is called after all - if(event.keyval==0xFF09 or event.keyval==0xFF08): - textbuffer=widget.get_buffer() + if (event.keyval == 0xFF09 or event.keyval == 0xFF08): + textbuffer = widget.get_buffer( ) # do not do things during selection - if (textbuffer.get_selection_bounds()): return 0 - cursor_mark=textbuffer.get_insert() - cursor_iter=textbuffer.get_iter_at_mark(cursor_mark) - if (cursor_iter.starts_line()): + if (textbuffer.get_selection_bounds( )): + return 0 + cursor_mark = textbuffer.get_insert( ) + cursor_iter = textbuffer.get_iter_at_mark( cursor_mark ) + if (cursor_iter.starts_line( )): # backspace with normal function at line start - if (event.keyval==0xFF08): - self.textviews_moved(widget) + if (event.keyval == 0xFF08): + self.textviews_moved( widget ) return 0 # now get iterator at line start - linestart_iter=cursor_iter.copy() - linestart_iter.set_line_offset(0) - linebegin=textbuffer.get_text(linestart_iter,cursor_iter).expandtabs() - if (len(linebegin)!=0 and not linebegin.isspace()): + linestart_iter = cursor_iter.copy( ) + linestart_iter.set_line_offset( 0 ) + linebegin = textbuffer.get_text( linestart_iter, cursor_iter ).expandtabs( ) + if (len( linebegin ) != 0 and not linebegin.isspace( )): # just make the spaces go away - textbuffer.delete(linestart_iter,cursor_iter) - textbuffer.insert(linestart_iter,linebegin) - self.textviews_moved(widget) + textbuffer.delete( linestart_iter, cursor_iter ) + textbuffer.insert( linestart_iter, linebegin ) + self.textviews_moved( widget ) return 0 # find all space at the begin - while(not cursor_iter.ends_line() - and not cursor_iter.is_end() - and cursor_iter.get_char().isspace()): - cursor_iter.forward_char() - linebegin=textbuffer.get_text(linestart_iter,cursor_iter) - if (event.keyval==0xFF08): + while (not cursor_iter.ends_line( ) + and not cursor_iter.is_end( ) + and cursor_iter.get_char( ).isspace( )): + cursor_iter.forward_char( ) + linebegin = textbuffer.get_text( linestart_iter, cursor_iter ) + if (event.keyval == 0xFF08): # backspace shortens space - linebegin=u' '*((len(linebegin)-1)/4)*4 - elif (event.keyval==0xFF09): + linebegin = u' ' * ((len( linebegin ) - 1) / 4) * 4 + elif (event.keyval == 0xFF09): # tab widens space - linebegin=u' '*((len(linebegin)+4)/4)*4 - - textbuffer.delete(linestart_iter,cursor_iter) - textbuffer.insert(linestart_iter,linebegin) - self.textviews_moved(widget) + linebegin = u' ' * ((len( linebegin ) + 4) / 4) * 4 + + textbuffer.delete( linestart_iter, cursor_iter ) + textbuffer.insert( linestart_iter, linebegin ) + self.textviews_moved( widget ) return 1 # implement convenience function for enter key - elif (event.keyval==0xFF0D): - textbuffer=widget.get_buffer() + elif (event.keyval == 0xFF0D): + textbuffer = widget.get_buffer( ) # do not do things during selection - if (textbuffer.get_selection_bounds()): return 0 - cursor_mark=textbuffer.get_insert() - cursor_iter=textbuffer.get_iter_at_mark(cursor_mark) + if (textbuffer.get_selection_bounds( )): + return 0 + cursor_mark = textbuffer.get_insert( ) + cursor_iter = textbuffer.get_iter_at_mark( cursor_mark ) # determine this line's indent count - linestart_iter=cursor_iter.copy() - linestart_iter.set_line_offset(0) - spaceend_iter=linestart_iter.copy() - while(not spaceend_iter.ends_line() - and not spaceend_iter.is_end() - and spaceend_iter.get_char().isspace()): - spaceend_iter.forward_char() - linebegin=textbuffer.get_text(linestart_iter,spaceend_iter).expandtabs() - indent_length=len(linebegin) - textbuffer.delete(linestart_iter,spaceend_iter) - textbuffer.insert(linestart_iter,u' '*indent_length) + linestart_iter = cursor_iter.copy( ) + linestart_iter.set_line_offset( 0 ) + spaceend_iter = linestart_iter.copy( ) + while (not spaceend_iter.ends_line( ) + and not spaceend_iter.is_end( ) + and spaceend_iter.get_char( ).isspace( )): + spaceend_iter.forward_char( ) + linebegin = textbuffer.get_text( linestart_iter, spaceend_iter ).expandtabs( ) + indent_length = len( linebegin ) + textbuffer.delete( linestart_iter, spaceend_iter ) + textbuffer.insert( linestart_iter, u' ' * indent_length ) # start with the real work - cursor_iter=textbuffer.get_iter_at_mark(cursor_mark) - if (not cursor_iter.starts_line()): + cursor_iter = textbuffer.get_iter_at_mark( cursor_mark ) + if (not cursor_iter.starts_line( )): # find last char before cursor - lastchar_iter=cursor_iter.copy() - lastchar_iter.backward_char() - if (lastchar_iter.get_char()==u":"): indent_length+=4 + lastchar_iter = cursor_iter.copy( ) + lastchar_iter.backward_char( ) + if (lastchar_iter.get_char( ) == u":"): + indent_length += 4 # now find indent of next line... - textbuffer.insert(cursor_iter,u'\n'+(u' '*indent_length)) - widget.scroll_to_mark(cursor_mark,0.0,0) - self.textviews_moved(widget) + textbuffer.insert( cursor_iter, u'\n' + (u' ' * indent_length) ) + widget.scroll_to_mark( cursor_mark, 0.0, 0 ) + self.textviews_moved( widget ) return 1 #self.textviews_moved(widget) return 0 - def load_file_as_unicode(self, script_filename): - script_file = file(script_filename, "rU") + def load_file_as_unicode( self, script_filename ): + script_file = file( script_filename, "rU" ) script_string = u"" for line in script_file: - script_string += unicode(line,encoding="iso-8859-15", errors="replace") - script_file.close() + script_string += unicode( line, encoding="iso-8859-15", errors="replace" ) + script_file.close( ) return script_string - def open_file(self, widget, Data = None): + def open_file( self, widget, Data=None ): """ do the open file dialog, if necessary ask for save """ # ignore - if not self.editing_state: return 0 - + if not self.editing_state: + return 0 + # Determining the tab which is currently open - current_page=self.main_notebook.get_current_page() + current_page = self.main_notebook.get_current_page( ) if current_page == 0: - open_dialog_title="Open Experiment Script..." - modified=self.experiment_script_textbuffer.get_modified() + open_dialog_title = "Open Experiment Script..." + modified = self.experiment_script_textbuffer.get_modified( ) elif current_page == 1: - open_dialog_title="Open Result Script..." - modified=self.data_handling_textbuffer.get_modified() + open_dialog_title = "Open Result Script..." + modified = self.data_handling_textbuffer.get_modified( ) else: return 0 if modified: print "ToDo: Save First Dialog" - def response(self, response_id, script_widget): + def response( self, response_id, script_widget ): if response_id == gtk.RESPONSE_OK: - file_name = dialog.get_filename() + file_name = dialog.get_filename( ) if file_name is None: return - script_filename=os.path.abspath(file_name) - if not os.access(script_filename, os.R_OK): - outer_space.show_error_dialog("File I/O Error","Cannot read from file %s" % script_filename) + script_filename = os.path.abspath( file_name ) + if not os.access( script_filename, os.R_OK ): + outer_space.show_error_dialog( "File I/O Error", "Cannot read from file %s" % script_filename ) return True - script_string = script_widget.load_file_as_unicode(script_filename) + script_string = script_widget.load_file_as_unicode( script_filename ) + + if script_widget.main_notebook.get_current_page( ) == 0: + script_widget.exp_script_filename = script_filename + script_widget.set_scripts( script_string, None ) + elif script_widget.main_notebook.get_current_page( ) == 1: + script_widget.res_script_filename = script_filename + script_widget.set_scripts( None, script_string ) - if script_widget.main_notebook.get_current_page() == 0: - script_widget.exp_script_filename=script_filename - script_widget.set_scripts(script_string,None) - elif script_widget.main_notebook.get_current_page() == 1: - script_widget.res_script_filename=script_filename - script_widget.set_scripts(None, script_string) - return True - - parent_window=self.xml_gui.get_widget("main_window") - dialog = gtk.FileChooserDialog(title=open_dialog_title, - parent=parent_window, - action=gtk.FILE_CHOOSER_ACTION_OPEN, - buttons = (gtk.STOCK_OPEN, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL) - ) - dialog.set_default_response(gtk.RESPONSE_OK) - dialog.set_select_multiple(False) + + parent_window = self.xml_gui.get_widget( "main_window" ) + dialog = gtk.FileChooserDialog( title=open_dialog_title, + parent=parent_window, + action=gtk.FILE_CHOOSER_ACTION_OPEN, + buttons=(gtk.STOCK_OPEN, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL) + ) + dialog.set_default_response( gtk.RESPONSE_OK ) + dialog.set_select_multiple( False ) # Event-Handler for responce-signal (when one of the button is pressed) - dialog.connect("response", response, self) + dialog.connect( "response", response, self ) - dialog.run() - dialog.destroy() + dialog.run( ) + dialog.destroy( ) # update title and so on... return True - def save_file(self, widget = None, Data = None): + def save_file( self, widget=None, Data=None ): """ save file to associated filename """ # ignore - if not self.editing_state: return 0 - + if not self.editing_state: + return 0 + # Determining the tab which is currently open - current_page=self.main_notebook.get_current_page() + current_page = self.main_notebook.get_current_page( ) if current_page == 0: - filename=self.exp_script_filename + filename = self.exp_script_filename elif current_page == 1: - filename=self.res_script_filename + filename = self.res_script_filename else: return 0 - if filename is None: return 0 + if filename is None: + return 0 # save file - if current_page==0: - script=self.get_scripts()[0] - elif current_page==1: - script=self.get_scripts()[1] + if current_page == 0: + script = self.get_scripts( )[ 0 ] + elif current_page == 1: + script = self.get_scripts( )[ 1 ] else: return 0 # encode from unicode to iso-8859-15 - filecontents=codecs.getencoder("iso-8859-15")(script,"replace")[0] - file(filename,"w").write(filecontents) + filecontents = codecs.getencoder( "iso-8859-15" )( script, "replace" )[ 0 ] + file( filename, "w" ).write( filecontents ) if current_page == 0: - self.experiment_script_textbuffer.set_modified(False) + self.experiment_script_textbuffer.set_modified( False ) elif current_page == 1: - self.data_handling_textbuffer.set_modified(False) - self.set_toolbuttons_status() + self.data_handling_textbuffer.set_modified( False ) + self.set_toolbuttons_status( ) - - def save_file_as(self, widget = None, Data = None): - def response(self, response_id, script_widget): + def save_file_as( self, widget=None, Data=None ): + + def response( self, response_id, script_widget ): if response_id == gtk.RESPONSE_OK: - file_name = dialog.get_filename() + file_name = dialog.get_filename( ) if file_name is None: return True - absfilename=os.path.abspath(file_name) - if os.access(file_name, os.F_OK): + absfilename = os.path.abspath( file_name ) + if os.access( file_name, os.F_OK ): print "ToDo: Overwrite file question" - current_page=script_widget.main_notebook.get_current_page() - if current_page==0: - script_widget.exp_script_filename=absfilename - elif current_page==1: - script_widget.res_script_filename=absfilename - script_widget.save_file() - + current_page = script_widget.main_notebook.get_current_page( ) + if current_page == 0: + script_widget.exp_script_filename = absfilename + elif current_page == 1: + script_widget.res_script_filename = absfilename + script_widget.save_file( ) + return True - + # Determining the tab which is currently open - current_page=self.main_notebook.get_current_page() - if current_page == 0: - dialog_title="Save Experiment Script As..." + current_page = self.main_notebook.get_current_page( ) + if current_page == 0: + dialog_title = "Save Experiment Script As..." elif current_page == 1: - dialog_title="Save Result Script As..." + dialog_title = "Save Result Script As..." else: return - - parent_window=self.xml_gui.get_widget("main_window") - dialog = gtk.FileChooserDialog(title = dialog_title, - parent = parent_window, - action = gtk.FILE_CHOOSER_ACTION_SAVE, - buttons = (gtk.STOCK_SAVE, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) - dialog.set_default_response(gtk.RESPONSE_OK) - dialog.set_select_multiple(False) + parent_window = self.xml_gui.get_widget( "main_window" ) + dialog = gtk.FileChooserDialog( title=dialog_title, + parent=parent_window, + action=gtk.FILE_CHOOSER_ACTION_SAVE, + buttons=( + gtk.STOCK_SAVE, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL) ) + + dialog.set_default_response( gtk.RESPONSE_OK ) + dialog.set_select_multiple( False ) # Event-Handler for responce-signal (when one of the button is pressed) - dialog.connect("response", response, self) + dialog.connect( "response", response, self ) - dialog.run() - dialog.destroy() + dialog.run( ) + dialog.destroy( ) return True - def save_all_files(self, widget, Data = None): + def save_all_files( self, widget, Data=None ): + + current_page = self.main_notebook.get_current_page( ) - current_page=self.main_notebook.get_current_page() - # change page and call save dialog - self.main_notebook.set_current_page(0) + self.main_notebook.set_current_page( 0 ) if self.exp_script_filename is None: - self.save_file_as() + self.save_file_as( ) else: - self.save_file() + self.save_file( ) - self.main_notebook.set_current_page(1) + self.main_notebook.set_current_page( 1 ) if self.res_script_filename is None: - self.save_file_as() + self.save_file_as( ) else: - self.save_file() + self.save_file( ) - self.main_notebook.set_current_page(current_page) + self.main_notebook.set_current_page( current_page ) - def new_file(self, widget, Data = None): - - if not self.editing_state: return 0 - current_page=self.main_notebook.get_current_page() - if current_page==0: - if self.experiment_script_textbuffer.get_modified(): + def new_file( self, widget, Data=None ): + + if not self.editing_state: + return 0 + current_page = self.main_notebook.get_current_page( ) + if current_page == 0: + if self.experiment_script_textbuffer.get_modified( ): print "ToDo: Save before Clear Dialog" - self.set_scripts("", None) - self.exp_script_filename=None - elif current_page==1: - if self.data_handling_textbuffer.get_modified(): + self.set_scripts( "", None ) + self.exp_script_filename = None + elif current_page == 1: + if self.data_handling_textbuffer.get_modified( ): print "ToDo: Save before Clear Dialog" - self.set_scripts(None, "") - self.res_script_filename=None - self.set_toolbuttons_status() + self.set_scripts( None, "" ) + self.res_script_filename = None + self.set_toolbuttons_status( ) - def begin_print(self, operation, context, print_data): + def begin_print( self, operation, context, print_data ): """ layout of all pages """ # copied and modified from pygtk-2.10.1/examples/pygtk-demo/demos/print_editor.py # Determining the tab which is currently open - current_page=self.main_notebook.get_current_page() - script="" + current_page = self.main_notebook.get_current_page( ) + script = "" # get script text - if current_page==0: - script=self.get_scripts()[0] - elif current_page==1: - script=self.get_scripts()[1] - - width = context.get_width() - height = context.get_height() - layout = context.create_pango_layout() - layout.set_font_description(pango.FontDescription("Monospace 12")) - layout.set_width(int(width*pango.SCALE)) - layout.set_text(script) - num_lines = layout.get_line_count() + if current_page == 0: + script = self.get_scripts( )[ 0 ] + elif current_page == 1: + script = self.get_scripts( )[ 1 ] - page_breaks = [] + width = context.get_width( ) + height = context.get_height( ) + layout = context.create_pango_layout( ) + layout.set_font_description( pango.FontDescription( "Monospace 12" ) ) + layout.set_width( int( width * pango.SCALE ) ) + layout.set_text( script ) + num_lines = layout.get_line_count( ) + + page_breaks = [ ] page_height = 0 - for line in xrange(num_lines): - layout_line = layout.get_line(line) - ink_rect, logical_rect = layout_line.get_extents() + for line in xrange( num_lines ): + layout_line = layout.get_line( line ) + ink_rect, logical_rect = layout_line.get_extents( ) lx, ly, lwidth, lheight = logical_rect line_height = lheight / 1024.0 if page_height + line_height > height: - page_breaks.append(line) + page_breaks.append( line ) page_height = 0 page_height += line_height - operation.set_n_pages(len(page_breaks) + 1) - print_data["page_breaks"] = page_breaks - print_data["layout"]=layout + operation.set_n_pages( len( page_breaks ) + 1 ) + print_data[ "page_breaks" ] = page_breaks + print_data[ "layout" ] = layout - def draw_page(self, operation, context, page_nr, print_data): + def draw_page( self, operation, context, page_nr, print_data ): """ render a single page """ # copied and modified from pygtk-2.10.1/examples/pygtk-demo/demos/print_editor.py - assert isinstance(print_data["page_breaks"], list) + assert isinstance( print_data[ "page_breaks" ], list ) if page_nr == 0: start = 0 else: - start = print_data["page_breaks"][page_nr - 1] + start = print_data[ "page_breaks" ][ page_nr - 1 ] try: - end = print_data["page_breaks"][page_nr] + end = print_data[ "page_breaks" ][ page_nr ] except IndexError: - end = print_data["layout"].get_line_count() - - cr = context.get_cairo_context() + end = print_data[ "layout" ].get_line_count( ) + + cr = context.get_cairo_context( ) + + cr.set_source_rgb( 0, 0, 0 ) - cr.set_source_rgb(0, 0, 0) - i = 0 start_pos = 0 - iter = print_data["layout"].get_iter() + iter = print_data[ "layout" ].get_iter( ) while 1: if i >= start: - line = iter.get_line() - _, logical_rect = iter.get_line_extents() + line = iter.get_line( ) + _, logical_rect = iter.get_line_extents( ) lx, ly, lwidth, lheight = logical_rect - baseline = iter.get_baseline() + baseline = iter.get_baseline( ) if i == start: start_pos = ly / 1024.0; - cr.move_to(lx / 1024.0, baseline / 1024.0 - start_pos) - cr.show_layout_line(line) + cr.move_to( lx / 1024.0, baseline / 1024.0 - start_pos ) + cr.show_layout_line( line ) i += 1 - if not (i < end and iter.next_line()): + if not (i < end and iter.next_line( )): break + class ConfigTab: """ by now all values are saved in the GUI widgets """ - def __init__(self, xml_gui): - self.xml_gui=xml_gui + def __init__( self, xml_gui ): + self.xml_gui = xml_gui self.configname = "damaris/python-damaris.xml" self.system_default_filename = None self.system_backend_folder = "/usr/lib/damaris/backends/" - if sys.platform[:5] == "linux" or "darwin": + if sys.platform[ :5 ] == "linux" or "darwin": xdg_dirs = xdg.BaseDirectory.xdg_config_dirs - xdg_dirs.remove(xdg.BaseDirectory.xdg_config_home) - self.user_default_filename = os.path.join(xdg.BaseDirectory.xdg_config_home, self.configname) - self.system_default_filenames = [os.path.join(syscfg,self.configname) for syscfg in xdg_dirs] + xdg_dirs.remove( xdg.BaseDirectory.xdg_config_home ) + self.user_default_filename = os.path.join( xdg.BaseDirectory.xdg_config_home, self.configname ) + self.system_default_filenames = [ os.path.join( syscfg, self.configname ) for syscfg in xdg_dirs ] - self.config_start_backend_checkbutton=self.xml_gui.get_widget("start_backend_checkbutton") - self.config_backend_executable_entry=self.xml_gui.get_widget("backend_executable_entry") - self.config_spool_dir_entry=self.xml_gui.get_widget("spool_dir_entry") - self.config_start_experiment_script_checkbutton=self.xml_gui.get_widget("start_experiment_script_checkbutton") - self.config_start_result_script_checkbutton=self.xml_gui.get_widget("start_result_script_checkbutton") - self.config_del_results_after_processing_checkbutton=self.xml_gui.get_widget("del_results_after_processing_checkbutton") - self.config_del_jobs_after_execution_checkbutton=self.xml_gui.get_widget("del_jobs_after_execution_checkbutton") - self.config_data_pool_name_entry=self.xml_gui.get_widget("data_pool_name_entry") - self.config_data_pool_write_interval_entry=self.xml_gui.get_widget("data_pool_write_interval_entry") - self.config_data_pool_complib=self.xml_gui.get_widget("CompLibs") - self.config_data_pool_comprate=self.xml_gui.get_widget("CompRatio") - self.config_info_textview=self.xml_gui.get_widget("info_textview") - self.config_script_font_button=self.xml_gui.get_widget("script_fontbutton") - self.config_printer_setup_button=self.xml_gui.get_widget("printer_setup_button") - if not hasattr(gtk, "print_run_page_setup_dialog" ): - self.config_printer_setup_button.set_sensitive(False) + self.config_start_backend_checkbutton = self.xml_gui.get_widget( "start_backend_checkbutton" ) + self.config_backend_executable_entry = self.xml_gui.get_widget( "backend_executable_entry" ) + self.config_spool_dir_entry = self.xml_gui.get_widget( "spool_dir_entry" ) + self.config_start_experiment_script_checkbutton = self.xml_gui.get_widget( + "start_experiment_script_checkbutton" ) + self.config_start_result_script_checkbutton = self.xml_gui.get_widget( "start_result_script_checkbutton" ) + self.config_del_results_after_processing_checkbutton = self.xml_gui.get_widget( + "del_results_after_processing_checkbutton" ) + self.config_del_jobs_after_execution_checkbutton = self.xml_gui.get_widget( + "del_jobs_after_execution_checkbutton" ) + self.config_data_pool_name_entry = self.xml_gui.get_widget( "data_pool_name_entry" ) + self.config_data_pool_write_interval_entry = self.xml_gui.get_widget( "data_pool_write_interval_entry" ) + self.config_data_pool_complib = self.xml_gui.get_widget( "CompLibs" ) + self.config_data_pool_comprate = self.xml_gui.get_widget( "CompRatio" ) + self.config_info_textview = self.xml_gui.get_widget( "info_textview" ) + self.config_script_font_button = self.xml_gui.get_widget( "script_fontbutton" ) + self.config_printer_setup_button = self.xml_gui.get_widget( "printer_setup_button" ) + if not hasattr( gtk, "print_run_page_setup_dialog" ): + self.config_printer_setup_button.set_sensitive( False ) # insert version informations - components_text=u""" + components_text = u""" operating system %(os)s gtk version %(gtk)s glib version %(glib)s @@ -1659,483 +1693,486 @@ pytables version %(pytables)s, using %(pytables_libs)s pygtk version %(pygtk)s pygobject version %(pygobject)s """ - if hasattr(gobject, "glib_version"): - glib_version="%d.%d.%d"%gobject.glib_version + if hasattr( gobject, "glib_version" ): + glib_version = "%d.%d.%d" % gobject.glib_version else: - glib_version="? (no pygobject module)" - if hasattr(gobject, "pygobject_version"): - pygobject_version="%d.%d.%d"%gobject.pygobject_version + glib_version = "? (no pygobject module)" + if hasattr( gobject, "pygobject_version" ): + pygobject_version = "%d.%d.%d" % gobject.pygobject_version else: - pygobject_version="? (no gobject version number)" + pygobject_version = "? (no gobject version number)" - numpy_version="none" + numpy_version = "none" try: import numpy except ImportError: pass else: - numpy_version=numpy.__version__ + numpy_version = numpy.__version__ components_versions = { - "os": platform.platform() , - "gtk": "%d.%d.%d"%gtk.gtk_version, - "glib": glib_version, - "python": sys.version , + "os": platform.platform( ), + "gtk": "%d.%d.%d" % gtk.gtk_version, + "glib": glib_version, + "python": sys.version, "matplotlib": matplotlib.__version__, - "matplotlib_backend": FigureCanvas.__name__[12:], - "numpy": numpy_version, - "pytables": tables.getPyTablesVersion(), + "matplotlib_backend": FigureCanvas.__name__[ 12: ], + "numpy": numpy_version, + "pytables": tables.getPyTablesVersion( ), "pytables_libs": "", - "pygtk": "%d.%d.%d"%gtk.pygtk_version, - "pygobject": pygobject_version - } + "pygtk": "%d.%d.%d" % gtk.pygtk_version, + "pygobject": pygobject_version + } # pytables modules: # find compression extensions for combo box and write version numbers # list is taken from ValueError output of tables.whichLibVersion("") - model=self.config_data_pool_complib.get_model() - for libname in ('hdf5', 'zlib', 'lzo', 'ucl', 'bzip2'): - version_info=None + model = self.config_data_pool_complib.get_model( ) + for libname in ('hdf5', 'zlib', 'lzo', 'ucl', 'bzip2'): + version_info = None try: - version_info=tables.whichLibVersion(libname) + version_info = tables.whichLibVersion( libname ) except ValueError: continue if version_info: - components_versions["pytables_libs"]+="\n %s: %s"%(libname, str(version_info)) - if libname!="hdf5": + components_versions[ "pytables_libs" ] += "\n %s: %s" % (libname, str( version_info )) + if libname != "hdf5": # a compression library, add it to combo box - if isinstance(model,gtk.ListStore): - model.append([libname]) - elif isinstance(model,gtk.TreeStore): - model.append(None,[libname]) + if isinstance( model, gtk.ListStore ): + model.append( [ libname ] ) + elif isinstance( model, gtk.TreeStore ): + model.append( None, [ libname ] ) else: - print "cannot append compression lib name to %s"%model.__class__.__name__ + print "cannot append compression lib name to %s" % model.__class__.__name__ # debug message if debug: print "DAMARIS", __version__ - print components_text%components_versions - - # set no compression as default... - self.config_data_pool_complib.set_active(0) + print components_text % components_versions - info_textbuffer=self.config_info_textview.get_buffer() - info_text=info_textbuffer.get_text(info_textbuffer.get_start_iter(),info_textbuffer.get_end_iter()) - info_text%={"moduleversions": components_text%components_versions, "damarisversion": __version__ } - info_textbuffer.set_text(info_text) + # set no compression as default... + self.config_data_pool_complib.set_active( 0 ) + + info_textbuffer = self.config_info_textview.get_buffer( ) + info_text = info_textbuffer.get_text( info_textbuffer.get_start_iter( ), info_textbuffer.get_end_iter( ) ) + info_text %= { "moduleversions": components_text % components_versions, "damarisversion": __version__ } + info_textbuffer.set_text( info_text ) del info_textbuffer, info_text, components_text, components_versions - self.xml_gui.signal_connect("on_config_save_button_clicked", self.save_config_handler) - self.xml_gui.signal_connect("on_config_load_button_clicked", self.load_config_handler) - self.xml_gui.signal_connect("on_backend_executable_browse_button_clicked", - self.browse_backend_executable_dialog) - self.xml_gui.signal_connect("on_fontbutton_font_set",self.set_script_font_handler) - self.xml_gui.signal_connect("on_printer_setup_button_clicked", self.printer_setup_handler) + self.xml_gui.signal_connect( "on_config_save_button_clicked", self.save_config_handler ) + self.xml_gui.signal_connect( "on_config_load_button_clicked", self.load_config_handler ) + self.xml_gui.signal_connect( "on_backend_executable_browse_button_clicked", + self.browse_backend_executable_dialog ) + self.xml_gui.signal_connect( "on_fontbutton_font_set", self.set_script_font_handler ) + self.xml_gui.signal_connect( "on_printer_setup_button_clicked", self.printer_setup_handler ) for self.system_default_filename in self.system_default_filenames: if self.system_default_filename: - if os.access(self.system_default_filename, os.R_OK): - self.load_config(self.system_default_filename) + if os.access( self.system_default_filename, os.R_OK ): + self.load_config( self.system_default_filename ) else: - print "can not read system defaults from %s, ask your instrument responsible if required"%self.system_default_filename + print "can not read system defaults from %s, ask your instrument responsible if required" % self.system_default_filename - self.config_from_system = self.get() - self.load_config() + self.config_from_system = self.get( ) + self.load_config( ) - def get(self): + def get( self ): """ returns a dictionary of actual config values """ - complib_iter=self.config_data_pool_complib.get_active_iter() - complib=self.config_data_pool_complib.get_model().get_value(complib_iter,0) + complib_iter = self.config_data_pool_complib.get_active_iter( ) + complib = self.config_data_pool_complib.get_model( ).get_value( complib_iter, 0 ) return { - "start_backend": self.config_start_backend_checkbutton.get_active(), - "start_result_script": self.config_start_result_script_checkbutton.get_active(), - "start_experiment_script": self.config_start_experiment_script_checkbutton.get_active(), - "spool_dir": self.config_spool_dir_entry.get_text(), - "backend_executable" : self.config_backend_executable_entry.get_text(), - "data_pool_name" : self.config_data_pool_name_entry.get_text(), - "del_results_after_processing" : self.config_del_results_after_processing_checkbutton.get_active(), - "del_jobs_after_execution" : self.config_del_jobs_after_execution_checkbutton.get_active(), - "data_pool_write_interval" : self.config_data_pool_write_interval_entry.get_text(), + "start_backend": self.config_start_backend_checkbutton.get_active( ), + "start_result_script": self.config_start_result_script_checkbutton.get_active( ), + "start_experiment_script": self.config_start_experiment_script_checkbutton.get_active( ), + "spool_dir": self.config_spool_dir_entry.get_text( ), + "backend_executable": self.config_backend_executable_entry.get_text( ), + "data_pool_name": self.config_data_pool_name_entry.get_text( ), + "del_results_after_processing": self.config_del_results_after_processing_checkbutton.get_active( ), + "del_jobs_after_execution": self.config_del_jobs_after_execution_checkbutton.get_active( ), + "data_pool_write_interval": self.config_data_pool_write_interval_entry.get_text( ), "data_pool_complib": complib, - "data_pool_comprate": self.config_data_pool_comprate.get_value_as_int(), - "script_font": self.config_script_font_button.get_font_name() - } + "data_pool_comprate": self.config_data_pool_comprate.get_value_as_int( ), + "script_font": self.config_script_font_button.get_font_name( ) + } - def set(self, config): + def set( self, config ): if "start_backend" in config: - self.config_start_backend_checkbutton.set_active(config["start_backend"]) + self.config_start_backend_checkbutton.set_active( config[ "start_backend" ] ) if "start_experiment_script" in config: - self.config_start_experiment_script_checkbutton.set_active(config["start_experiment_script"]) + self.config_start_experiment_script_checkbutton.set_active( config[ "start_experiment_script" ] ) if "start_result_script" in config: - self.config_start_result_script_checkbutton.set_active(config["start_result_script"]) + self.config_start_result_script_checkbutton.set_active( config[ "start_result_script" ] ) if "spool_dir" in config: - self.config_spool_dir_entry.set_text(config["spool_dir"]) + self.config_spool_dir_entry.set_text( config[ "spool_dir" ] ) if "backend_executable" in config: - self.config_backend_executable_entry.set_text(config["backend_executable"]) + self.config_backend_executable_entry.set_text( config[ "backend_executable" ] ) if "del_results_after_processing" in config: - self.config_del_results_after_processing_checkbutton.set_active(config["del_results_after_processing"]) + self.config_del_results_after_processing_checkbutton.set_active( config[ "del_results_after_processing" ] ) if "del_jobs_after_execution" in config: - self.config_del_jobs_after_execution_checkbutton.set_active(config["del_jobs_after_execution"]) + self.config_del_jobs_after_execution_checkbutton.set_active( config[ "del_jobs_after_execution" ] ) if "data_pool_write_interval" in config: - self.config_data_pool_write_interval_entry.set_text(config["data_pool_write_interval"]) + self.config_data_pool_write_interval_entry.set_text( config[ "data_pool_write_interval" ] ) if "data_pool_name" in config: - self.config_data_pool_name_entry.set_text(config["data_pool_name"]) + self.config_data_pool_name_entry.set_text( config[ "data_pool_name" ] ) if "data_pool_comprate" in config: - self.config_data_pool_comprate.set_value(float(config["data_pool_comprate"])) + self.config_data_pool_comprate.set_value( float( config[ "data_pool_comprate" ] ) ) if "script_font" in config: - self.config_script_font_button.set_font_name(config["script_font"]) - self.set_script_font_handler(None) + self.config_script_font_button.set_font_name( config[ "script_font" ] ) + self.set_script_font_handler( None ) if "data_pool_complib" in config: # find combo-box entry and make it active... - model=self.config_data_pool_complib.get_model() - iter=model.get_iter_first() + model = self.config_data_pool_complib.get_model( ) + iter = model.get_iter_first( ) while iter is not None: - if model.get(iter,0)[0]==config["data_pool_complib"]: - self.config_data_pool_complib.set_active_iter(iter) + if model.get( iter, 0 )[ 0 ] == config[ "data_pool_complib" ]: + self.config_data_pool_complib.set_active_iter( iter ) break - iter=model.iter_next(iter) + iter = model.iter_next( iter ) # if this compression method is not supported, warn and do nothing if iter is None: - print "compression method %s is not supported"%config["data_pool_complib"] + print "compression method %s is not supported" % config[ "data_pool_complib" ] - def load_config_handler(self, widget): + def load_config_handler( self, widget ): if self.system_default_filename: - self.load_config(self.system_default_filename) - self.load_config() + self.load_config( self.system_default_filename ) + self.load_config( ) - def save_config_handler(self, widget): - self.save_config() + def save_config_handler( self, widget ): + self.save_config( ) - def set_script_font_handler(self, widget): + def set_script_font_handler( self, widget ): """ handles changes in font name also sets the fonts to the text views (fast implementation: breaking encapsulation) """ - font=self.config_script_font_button.get_font_name() - experiment_script_textview = self.xml_gui.get_widget("experiment_script_textview") + font = self.config_script_font_button.get_font_name( ) + experiment_script_textview = self.xml_gui.get_widget( "experiment_script_textview" ) if experiment_script_textview: - experiment_script_textview.modify_font(pango.FontDescription(font)) - data_handling_textview = self.xml_gui.get_widget("data_handling_textview") + experiment_script_textview.modify_font( pango.FontDescription( font ) ) + data_handling_textview = self.xml_gui.get_widget( "data_handling_textview" ) if data_handling_textview: - data_handling_textview.modify_font(pango.FontDescription(font)) + data_handling_textview.modify_font( pango.FontDescription( font ) ) - def printer_setup_handler(self, widget): + def printer_setup_handler( self, widget ): """ changes to printer setup """ - if not (hasattr(gtk, "PrintSettings") and hasattr(gtk, "print_run_page_setup_dialog")): + if not (hasattr( gtk, "PrintSettings" ) and hasattr( gtk, "print_run_page_setup_dialog" )): return - if not hasattr(self, "printer_setup"): - self.printer_setup = gtk.PrintSettings() + if not hasattr( self, "printer_setup" ): + self.printer_setup = gtk.PrintSettings( ) - if not hasattr(self, "page_setup"): + if not hasattr( self, "page_setup" ): self.page_setup = None - self.page_setup = gtk.print_run_page_setup_dialog(self.xml_gui.get_widget("main_window"), - self.page_setup, self.printer_setup) + self.page_setup = gtk.print_run_page_setup_dialog( self.xml_gui.get_widget( "main_window" ), + self.page_setup, self.printer_setup ) - def browse_backend_executable_dialog(self, widget): + def browse_backend_executable_dialog( self, widget ): """ do the open file dialog """ - backend_filename_dialog_title="find backend" + backend_filename_dialog_title = "find backend" - def response(self, response_id, script_widget): + def response( self, response_id, script_widget ): if response_id == gtk.RESPONSE_OK: - file_name = self.get_filename() + file_name = self.get_filename( ) if file_name is None: return - script_widget.config_backend_executable_entry.set_text(file_name) + script_widget.config_backend_executable_entry.set_text( file_name ) return True - parent_window=self.xml_gui.get_widget("main_window") - dialog = gtk.FileChooserDialog(title=backend_filename_dialog_title, - parent=parent_window, - action=gtk.FILE_CHOOSER_ACTION_OPEN, - buttons = (gtk.STOCK_OPEN, - gtk.RESPONSE_OK, - gtk.STOCK_CANCEL, - gtk.RESPONSE_CANCEL)) - dialog.set_default_response(gtk.RESPONSE_OK) - dialog.set_select_multiple(False) - dialog.set_filename(os.path.abspath(self.config_backend_executable_entry.get_text())) - if os.path.isdir(self.system_backend_folder) \ - and os.access(self.system_backend_folder, os.R_OK): - dialog.add_shortcut_folder(self.system_backend_folder) + parent_window = self.xml_gui.get_widget( "main_window" ) + dialog = gtk.FileChooserDialog( title=backend_filename_dialog_title, + parent=parent_window, + action=gtk.FILE_CHOOSER_ACTION_OPEN, + buttons=(gtk.STOCK_OPEN, + gtk.RESPONSE_OK, + gtk.STOCK_CANCEL, + gtk.RESPONSE_CANCEL) ) + dialog.set_default_response( gtk.RESPONSE_OK ) + dialog.set_select_multiple( False ) + dialog.set_filename( os.path.abspath( self.config_backend_executable_entry.get_text( ) ) ) + if os.path.isdir( self.system_backend_folder ) \ + and os.access( self.system_backend_folder, os.R_OK ): + dialog.add_shortcut_folder( self.system_backend_folder ) # Event-Handler for responce-signal (when one of the button is pressed) - dialog.connect("response", response, self) - f=gtk.FileFilter() - f.add_custom(gtk.FILE_FILTER_FILENAME, lambda x:os.access(x[0],os.X_OK)) - dialog.set_filter(f) + dialog.connect( "response", response, self ) + f = gtk.FileFilter( ) + f.add_custom( gtk.FILE_FILTER_FILENAME, lambda x: os.access( x[ 0 ], os.X_OK ) ) + dialog.set_filter( f ) - dialog.run() - dialog.destroy() + dialog.run( ) + dialog.destroy( ) return True - def load_config(self, filename=None): + def load_config( self, filename=None ): """ set config from an xml file """ if filename is None: - filename=self.user_default_filename + filename = self.user_default_filename try: - readfile = file(filename, "r") + readfile = file( filename, "r" ) except Exception, e: if debug: - print "Could not open %s: %s" % (filename, str(e)) + print "Could not open %s: %s" % (filename, str( e )) return # parser functions - def start_element(name, attrs, config): + def start_element( name, attrs, config ): if name == "config" and "key" in attrs: - config["__this_key__"]=attrs["key"] + config[ "__this_key__" ] = attrs[ "key" ] if "type" in attrs: - config["__this_type__"]=attrs["type"] - config[attrs["key"]]="" - - def end_element(name, config): + config[ "__this_type__" ] = attrs[ "type" ] + config[ attrs[ "key" ] ] = "" + + def end_element( name, config ): if "__this_type__" in config and "__this_key__" in config: - if config["__this_type__"] == "Boolean": - if config[config["__this_key__"]] == "True": - config[config["__this_key__"]]=True + if config[ "__this_type__" ] == "Boolean": + if config[ config[ "__this_key__" ] ] == "True": + config[ config[ "__this_key__" ] ] = True else: - config[config["__this_key__"]]=False - elif config["__this_type__"] == "Integer": - config[config["__this_key__"]]=int(config[config["__this_key__"]]) + config[ config[ "__this_key__" ] ] = False + elif config[ "__this_type__" ] == "Integer": + config[ config[ "__this_key__" ] ] = int( config[ config[ "__this_key__" ] ] ) if "__this_type__" in config: - del config["__this_type__"] + del config[ "__this_type__" ] if "__this_key__" in config: - del config["__this_key__"] + del config[ "__this_key__" ] - - def char_data(data, config): + + def char_data( data, config ): if "__this_key__" in config: - config[config["__this_key__"]]+=data + config[ config[ "__this_key__" ] ] += data # parse file contents to dictionary - config={} - p = xml.parsers.expat.ParserCreate() - p.StartElementHandler = lambda n,a: start_element(n,a, config) - p.EndElementHandler = lambda n: end_element(n, config) - p.CharacterDataHandler = lambda d: char_data(d, config) - p.ParseFile(readfile) + config = { } + p = xml.parsers.expat.ParserCreate( ) + p.StartElementHandler = lambda n, a: start_element( n, a, config ) + p.EndElementHandler = lambda n: end_element( n, config ) + p.CharacterDataHandler = lambda d: char_data( d, config ) + p.ParseFile( readfile ) - self.set(config) + self.set( config ) - def save_config(self, filename=None): + def save_config( self, filename=None ): """ write config as an xml file """ - config=self.get() + config = self.get( ) if filename is None: - filename=self.user_default_filename - dirs = os.path.dirname(filename) - if not os.path.isdir(dirs): - os.makedirs(dirs) + filename = self.user_default_filename + dirs = os.path.dirname( filename ) + if not os.path.isdir( dirs ): + os.makedirs( dirs ) - configfile=file(filename, "w") - configfile.write("\n") - configfile.write("\n") - for k,v in config.iteritems(): + configfile = file( filename, "w" ) + configfile.write( "\n" ) + configfile.write( "\n" ) + for k, v in config.iteritems( ): if k in self.config_from_system \ - and self.config_from_system[k] == v: + and self.config_from_system[ k ] == v: if debug: print "Ignoring for write, because system value for %r is %r equal to %r" % \ - (k, self.config_from_system[k],v) + (k, self.config_from_system[ k ], v) continue - val="" - typename="" - if type(v) is types.BooleanType: - typename="Boolean" + val = "" + typename = "" + if type( v ) is types.BooleanType: + typename = "Boolean" if v: - val="True" + val = "True" else: - val="False" - elif type(v) is types.StringType: - typename="String" - val=v - elif type(v) is types.IntType: - typename="Integer" - val=str(v) - configfile.write(" %s\n"%(k, typename, val)) - configfile.write("\n") - + val = "False" + elif type( v ) is types.StringType: + typename = "String" + val = v + elif type( v ) is types.IntType: + typename = "Integer" + val = str( v ) + configfile.write( " %s\n" % (k, typename, val) ) + configfile.write( "\n" ) + + class MonitorWidgets: - - def __init__(self, xml_gui): + def __init__( self, xml_gui ): """ initialize matplotlib widgets and stuff around """ - self.xml_gui=xml_gui - self.main_window = self.xml_gui.get_widget("main_window") - self.display_settings_frame = self.xml_gui.get_widget("display_settings_frame") + self.xml_gui = xml_gui + self.main_window = self.xml_gui.get_widget( "main_window" ) + self.display_settings_frame = self.xml_gui.get_widget( "display_settings_frame" ) # Display footer: - self.display_x_scaling_combobox = self.xml_gui.get_widget("display_x_scaling_combobox") - self.display_x_scaling_combobox.remove_text(1) # remove base-e log - self.display_x_scaling_combobox.set_sensitive(False) - self.display_y_scaling_combobox = self.xml_gui.get_widget("display_y_scaling_combobox") - self.display_y_scaling_combobox.remove_text(1) # remove base-e log - self.display_y_scaling_combobox.set_sensitive(False) - self.display_autoscaling_checkbutton = self.xml_gui.get_widget("display_autoscaling_checkbutton") - self.display_statistics_checkbutton = self.xml_gui.get_widget("display_statistics_checkbutton") + self.display_x_scaling_combobox = self.xml_gui.get_widget( "display_x_scaling_combobox" ) + self.display_x_scaling_combobox.remove_text( 1 ) # remove base-e log + self.display_x_scaling_combobox.set_sensitive( False ) + self.display_y_scaling_combobox = self.xml_gui.get_widget( "display_y_scaling_combobox" ) + self.display_y_scaling_combobox.remove_text( 1 ) # remove base-e log + self.display_y_scaling_combobox.set_sensitive( False ) + self.display_autoscaling_checkbutton = self.xml_gui.get_widget( "display_autoscaling_checkbutton" ) + self.display_statistics_checkbutton = self.xml_gui.get_widget( "display_statistics_checkbutton" ) # insert monitor # Matplot (Display_Table, 1st Row) -------------------------------------------------------- # Neue Abbildung erstellen - self.matplot_figure = matplotlib.figure.Figure() + self.matplot_figure = matplotlib.figure.Figure( ) # the plot area surrounded by axes - self.matplot_axes = self.matplot_figure.add_axes([0.1,0.15,0.8,0.7]) - + self.matplot_axes = self.matplot_figure.add_axes( [ 0.1, 0.15, 0.8, 0.7 ] ) + # Achsen beschriften & Gitternetzlinien sichtbar machen - self.matplot_axes.grid(True) + self.matplot_axes.grid( True ) # Ersten Plot erstellen und Referenz des ersten Eintrags im zurueckgegebenen Tupel speichern # Voerst: graphen[0,1] = Real und Img-Kanal; [2,3] = Real-Fehler, [4,5] = Img-Fehler #self.graphen = [] #self.measurementresultgraph=None - self.matplot_axes.set_ylim([0.0,1.0]) - self.matplot_axes.set_xlim([0.0,1.0]) - self.matplot_axes.set_autoscale_on(self.display_autoscaling_checkbutton.get_active()) - + self.matplot_axes.set_ylim( [ 0.0, 1.0 ] ) + self.matplot_axes.set_xlim( [ 0.0, 1.0 ] ) + self.matplot_axes.set_autoscale_on( self.display_autoscaling_checkbutton.get_active( ) ) + # Lineare y-/x-Skalierung - self.matplot_axes.set_yscale("linear") - self.matplot_axes.set_xscale("linear") + self.matplot_axes.set_yscale( "linear" ) + self.matplot_axes.set_xscale( "linear" ) # Matplot in einen GTK-Rahmen stopfen - self.matplot_canvas = FigureCanvas(self.matplot_figure) + self.matplot_canvas = FigureCanvas( self.matplot_figure ) - self.display_table = self.xml_gui.get_widget("display_table") - self.display_table.attach(self.matplot_canvas, 0, 6, 0, 1, gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 0, 0) - self.matplot_canvas.show() + self.display_table = self.xml_gui.get_widget( "display_table" ) + self.display_table.attach( self.matplot_canvas, 0, 6, 0, 1, gtk.EXPAND | gtk.FILL, gtk.EXPAND | gtk.FILL, 0, 0 ) + self.matplot_canvas.show( ) # Matplot Toolbar hinzufuegen (Display_Table, 2. Zeile) - self.matplot_toolbar = matplotlib.backends.backend_gtk.NavigationToolbar2GTK(self.matplot_canvas, self.main_window) - - self.display_table.attach(self.matplot_toolbar, 0, 1, 1, 2, gtk.FILL | gtk.EXPAND, 0, 0, 0) - self.matplot_toolbar.show() + self.matplot_toolbar = matplotlib.backends.backend_gtk.NavigationToolbar2GTK( self.matplot_canvas, + self.main_window ) + + self.display_table.attach( self.matplot_toolbar, 0, 1, 1, 2, gtk.FILL | gtk.EXPAND, 0, 0, 0 ) + self.matplot_toolbar.show( ) # /Mathplot -------------------------------------------------------------------------------- # display source - self.display_source_combobox = self.xml_gui.get_widget("display_source_combobox") - self.display_source_treestore = gtk.TreeStore(gobject.TYPE_STRING) - self.display_source_combobox.set_model(self.display_source_treestore) - display_source_cell = gtk.CellRendererText() - self.display_source_combobox.pack_start(display_source_cell, True) - self.display_source_combobox.add_attribute(display_source_cell, 'text', 0) - self.source_list_reset() - self.display_source_path_label = self.xml_gui.get_widget("display_source_path_label") - + self.display_source_combobox = self.xml_gui.get_widget( "display_source_combobox" ) + self.display_source_treestore = gtk.TreeStore( gobject.TYPE_STRING ) + self.display_source_combobox.set_model( self.display_source_treestore ) + display_source_cell = gtk.CellRendererText( ) + self.display_source_combobox.pack_start( display_source_cell, True ) + self.display_source_combobox.add_attribute( display_source_cell, 'text', 0 ) + self.source_list_reset( ) + self.display_source_path_label = self.xml_gui.get_widget( "display_source_path_label" ) + # display scaling: ToDo enable scaling - self.display_x_scaling_combobox.set_active(0) - self.display_y_scaling_combobox.set_active(0) - self.display_x_scaling_combobox.set_sensitive(True) - self.display_y_scaling_combobox.set_sensitive(True) + self.display_x_scaling_combobox.set_active( 0 ) + self.display_y_scaling_combobox.set_active( 0 ) + self.display_x_scaling_combobox.set_sensitive( True ) + self.display_y_scaling_combobox.set_sensitive( True ) # and events... - self.display_source_combobox.connect("changed", self.display_source_changed_event) - self.xml_gui.signal_connect("on_display_autoscaling_checkbutton_toggled", self.display_autoscaling_toggled) - self.xml_gui.signal_connect("on_display_statistics_checkbutton_toggled", self.display_statistics_toggled) - self.xml_gui.signal_connect("on_display_x_scaling_combobox_changed", self.display_scaling_changed) - self.xml_gui.signal_connect("on_display_y_scaling_combobox_changed", self.display_scaling_changed) - self.xml_gui.signal_connect("on_display_save_data_as_text_button_clicked", self.save_display_data_as_text) - self.xml_gui.signal_connect("on_display_copy_data_to_clipboard_button_clicked", self.copy_display_data_to_clipboard) + self.display_source_combobox.connect( "changed", self.display_source_changed_event ) + self.xml_gui.signal_connect( "on_display_autoscaling_checkbutton_toggled", self.display_autoscaling_toggled ) + self.xml_gui.signal_connect( "on_display_statistics_checkbutton_toggled", self.display_statistics_toggled ) + self.xml_gui.signal_connect( "on_display_x_scaling_combobox_changed", self.display_scaling_changed ) + self.xml_gui.signal_connect( "on_display_y_scaling_combobox_changed", self.display_scaling_changed ) + self.xml_gui.signal_connect( "on_display_save_data_as_text_button_clicked", self.save_display_data_as_text ) + self.xml_gui.signal_connect( "on_display_copy_data_to_clipboard_button_clicked", + self.copy_display_data_to_clipboard ) # data to observe - self.data_pool=None + self.data_pool = None # name of displayed data and reference to data - self.displayed_data=[None,None] - self.__rescale=True - self.update_counter=0 - self.update_counter_lock=threading.Lock() + self.displayed_data = [ None, None ] + self.__rescale = True + self.update_counter = 0 + self.update_counter_lock = threading.Lock( ) - def source_list_reset(self): - self.display_source_treestore.clear() - self.source_list_add(u'None') - none_iter=self.source_list_find([u'None']) - if none_iter is not None: self.display_source_combobox.set_active_iter(none_iter) + def source_list_reset( self ): + self.display_source_treestore.clear( ) + self.source_list_add( u'None' ) + none_iter = self.source_list_find( [ u'None' ] ) + if none_iter is not None: + self.display_source_combobox.set_active_iter( none_iter ) - def source_list_find_one(self, model, iter, what): + def source_list_find_one( self, model, iter, what ): """find node in subcategory""" while iter is not None: - if model.get(iter,0)[0] == what: + if model.get( iter, 0 )[ 0 ] == what: return iter - iter = model.iter_next(iter) + iter = model.iter_next( iter ) return iter - def source_list_find(self, namelist): + def source_list_find( self, namelist ): """ namelist sequence of names, e.g. ["a", "b", "c" ] for "a/b/c" """ model = self.display_source_treestore retval = None - iter = model.get_iter_root() - while iter is not None and len(namelist) > 0: - name = namelist[0] - iter = self.source_list_find_one(model, iter, name) + iter = model.get_iter_root( ) + while iter is not None and len( namelist ) > 0: + name = namelist[ 0 ] + iter = self.source_list_find_one( model, iter, name ) if iter is not None: retval = iter - namelist.pop(0) - iter = model.iter_children(retval) + namelist.pop( 0 ) + iter = model.iter_children( retval ) return retval - def source_list_add(self, source_name, parent=None): - namelist = source_name.split("/") - found = self.source_list_find(namelist) + def source_list_add( self, source_name, parent=None ): + namelist = source_name.split( "/" ) + found = self.source_list_find( namelist ) if parent is None: parent = found for rest_name in namelist: # append() returns iter for the new row - parent = self.display_source_treestore.append(parent, [rest_name]) - - def source_list_remove(self, source_name): - namelist = source_name.split("/") - pwd = namelist[:] - iter = self.source_list_find(namelist) - if iter is None or len(namelist) > 0: + parent = self.display_source_treestore.append( parent, [ rest_name ] ) + + def source_list_remove( self, source_name ): + namelist = source_name.split( "/" ) + pwd = namelist[ : ] + iter = self.source_list_find( namelist ) + if iter is None or len( namelist ) > 0: print "source_list_remove: WARNING: Not found" return model = self.display_source_treestore - if model.iter_has_child(iter): + if model.iter_has_child( iter ): print "source_list_remove: WARNING: Request to delete a tree" return while True: - parent = model.iter_parent(iter) - model.remove(iter) - pwd.pop() + parent = model.iter_parent( iter ) + model.remove( iter ) + pwd.pop( ) # We now test, if we want to remove parent too if parent is None: break - if model.iter_has_child(parent): + if model.iter_has_child( parent ): # The parent has other children break - if "/".join(pwd) in self.data_pool: + if "/".join( pwd ) in self.data_pool: # The parent has data connected to it break iter = parent - def source_list_current(self): - ai = self.display_source_combobox.get_active_iter() - namelist = [] + def source_list_current( self ): + ai = self.display_source_combobox.get_active_iter( ) + namelist = [ ] while ai is not None: - namelist.insert(0, str(self.display_source_treestore.get(ai,0)[0])) - ai = self.display_source_treestore.iter_parent(ai) - cur_source_name = "/".join(namelist) + namelist.insert( 0, str( self.display_source_treestore.get( ai, 0 )[ 0 ] ) ) + ai = self.display_source_treestore.iter_parent( ai ) + cur_source_name = "/".join( namelist ) return cur_source_name - def observe_data_pool(self, data_pool): + def observe_data_pool( self, data_pool ): """ register a listener and save reference to data assume to be in gtk/gdk lock @@ -2143,70 +2180,72 @@ class MonitorWidgets: if not self.data_pool is None: # maybe some extra cleanup needed print "ToDo: cleanup widgets" - if self.displayed_data[1] is not None and hasattr(self.displayed_data[1], "unregister_listener"): - self.displayed_data[1].unregister_listener(self.datastructures_listener) - self.displayed_data[1]=None - self.displayed_data=[None,None] - self.data_pool.unregister_listener(self.datapool_listener) - self.data_pool=None + if self.displayed_data[ 1 ] is not None and hasattr( self.displayed_data[ 1 ], "unregister_listener" ): + self.displayed_data[ 1 ].unregister_listener( self.datastructures_listener ) + self.displayed_data[ 1 ] = None + self.displayed_data = [ None, None ] + self.data_pool.unregister_listener( self.datapool_listener ) + self.data_pool = None - self.source_list_reset() - self.update_counter_lock.acquire() - self.update_counter=0 - self.update_counter_lock.release() + self.source_list_reset( ) + self.update_counter_lock.acquire( ) + self.update_counter = 0 + self.update_counter_lock.release( ) # display states - self.__rescale=True - self.displayed_data=[None,None] - self.display_source_path_label.set_label(u"") - self.clear_display() + self.__rescale = True + self.displayed_data = [ None, None ] + self.display_source_path_label.set_label( u"" ) + self.clear_display( ) if data_pool is not None: # keep track of data - self.data_pool=data_pool - self.data_pool.register_listener(self.datapool_listener) + self.data_pool = data_pool + self.data_pool.register_listener( self.datapool_listener ) #################### observing data structures and produce idle events - def datapool_listener(self, event): + def datapool_listener( self, event ): """ sort data as fast as possible and get rid of non-interesting data """ - if event.subject.startswith("__"): return - if debug and self.update_counter<0: + if event.subject.startswith( "__" ): + return + if debug and self.update_counter < 0: print "negative event count!", self.update_counter - if self.update_counter>5: + if self.update_counter > 5: if debug: print "sleeping to find time for grapics updates" - threading.Event().wait(0.05) - while self.update_counter>15: - threading.Event().wait(0.05) - if event.what==DataPool.Event.updated_value: - if self.displayed_data[0] is None or event.subject!=self.displayed_data[0]: + threading.Event( ).wait( 0.05 ) + while self.update_counter > 15: + threading.Event( ).wait( 0.05 ) + if event.what == DataPool.Event.updated_value: + if self.displayed_data[ 0 ] is None or event.subject != self.displayed_data[ 0 ]: # do nothing, forget it return - displayed_object=self.displayed_data[1] - object_to_display=self.data_pool.get(event.subject) + displayed_object = self.displayed_data[ 1 ] + object_to_display = self.data_pool.get( event.subject ) if displayed_object is None or object_to_display is None: - self.update_counter_lock.acquire() - self.update_counter+=1 - self.update_counter_lock.release() - gobject.idle_add(self.datapool_idle_listener,event,priority=gobject.PRIORITY_DEFAULT_IDLE) + self.update_counter_lock.acquire( ) + self.update_counter += 1 + self.update_counter_lock.release( ) + gobject.idle_add( self.datapool_idle_listener, event, priority=gobject.PRIORITY_DEFAULT_IDLE ) else: - if event.what==DataPool.Event.updated_value and \ - (displayed_object is object_to_display or displayed_object.__class__ is object_to_display.__class__): + if event.what == DataPool.Event.updated_value and \ + ( + displayed_object is object_to_display or displayed_object.__class__ is object_to_display.__class__): # oh, another category - self.update_counter+=1 - gobject.idle_add(self.update_display_idle_event,self.displayed_data[0][:], - priority=gobject.PRIORITY_DEFAULT_IDLE) + self.update_counter += 1 + gobject.idle_add( self.update_display_idle_event, self.displayed_data[ 0 ][ : ], + priority=gobject.PRIORITY_DEFAULT_IDLE ) else: - self.update_counter_lock.acquire() - self.update_counter+=1 - self.update_counter_lock.release() - gobject.idle_add(self.datapool_idle_listener,event,priority=gobject.PRIORITY_DEFAULT_IDLE) + self.update_counter_lock.acquire( ) + self.update_counter += 1 + self.update_counter_lock.release( ) + gobject.idle_add( self.datapool_idle_listener, event, priority=gobject.PRIORITY_DEFAULT_IDLE ) - if event.what in [DataPool.Event.updated_value, DataPool.Event.new_key]: + if event.what in [ DataPool.Event.updated_value, DataPool.Event.new_key ]: #print "Update hdf5 file ..." # TODO: incremental hdf5 update pass @@ -2214,557 +2253,569 @@ class MonitorWidgets: del displayed_object del object_to_display - def datastructures_listener(self, event): + def datastructures_listener( self, event ): """ do fast work selecting important events """ - if debug and self.update_counter<0: + if debug and self.update_counter < 0: print "negative event count!", self.update_counter - if self.update_counter>5: + if self.update_counter > 5: if debug: print "sleeping to find time for graphics updates" - threading.Event().wait(0.05) - while self.update_counter>15: - threading.Event().wait(0.05) - if event.origin is not self.displayed_data[1]: return - self.update_counter_lock.acquire() - self.update_counter+=1 - self.update_counter_lock.release() - gobject.idle_add(self.update_display_idle_event,self.displayed_data[0][:],priority=gobject.PRIORITY_DEFAULT_IDLE) + threading.Event( ).wait( 0.05 ) + while self.update_counter > 15: + threading.Event( ).wait( 0.05 ) + if event.origin is not self.displayed_data[ 1 ]: + return + self.update_counter_lock.acquire( ) + self.update_counter += 1 + self.update_counter_lock.release( ) + gobject.idle_add( self.update_display_idle_event, self.displayed_data[ 0 ][ : ], + priority=gobject.PRIORITY_DEFAULT_IDLE ) ################### consume idle events - def datapool_idle_listener(self,event): + def datapool_idle_listener( self, event ): """ here dictionary changes are done """ - self.update_counter_lock.acquire() - self.update_counter-=1 - self.update_counter_lock.release() + self.update_counter_lock.acquire( ) + self.update_counter -= 1 + self.update_counter_lock.release( ) - if event.what==DataPool.Event.updated_value: - if (self.displayed_data[0] is not None and - self.displayed_data[0]==event.subject): - new_data_struct=self.data_pool[self.displayed_data[0]] - if self.displayed_data[1] is new_data_struct: + if event.what == DataPool.Event.updated_value: + if (self.displayed_data[ 0 ] is not None and + self.displayed_data[ 0 ] == event.subject): + new_data_struct = self.data_pool[ self.displayed_data[ 0 ] ] + if self.displayed_data[ 1 ] is new_data_struct: # update display only - if self.update_counter>10: - print "update queue too long (%d>10): skipping one update"%self.update_counter + if self.update_counter > 10: + print "update queue too long (%d>10): skipping one update" % self.update_counter else: - gtk.gdk.threads_enter() + gtk.gdk.threads_enter( ) try: - self.update_display() + self.update_display( ) finally: - gtk.gdk.threads_leave() + gtk.gdk.threads_leave( ) else: # unregister old one - if self.displayed_data[1] is not None and hasattr(self.displayed_data[1], "unregister_listener"): - self.displayed_data[1].unregister_listener(self.datastructures_listener) - self.displayed_data[1]=None + if self.displayed_data[ 1 ] is not None and hasattr( self.displayed_data[ 1 ], + "unregister_listener" ): + self.displayed_data[ 1 ].unregister_listener( self.datastructures_listener ) + self.displayed_data[ 1 ] = None # register new one - if hasattr(new_data_struct, "register_listener"): - new_data_struct.register_listener(self.datastructures_listener) - self.displayed_data[1]=new_data_struct - if self.update_counter>10: - print "update queue too long (%d>10): skipping one update"%self.update_counter + if hasattr( new_data_struct, "register_listener" ): + new_data_struct.register_listener( self.datastructures_listener ) + self.displayed_data[ 1 ] = new_data_struct + if self.update_counter > 10: + print "update queue too long (%d>10): skipping one update" % self.update_counter else: - gtk.gdk.threads_enter() + gtk.gdk.threads_enter( ) try: - self.renew_display() + self.renew_display( ) finally: - gtk.gdk.threads_leave() - new_data_struct=None - elif event.what==DataPool.Event.new_key: + gtk.gdk.threads_leave( ) + new_data_struct = None + elif event.what == DataPool.Event.new_key: # update combo-box by inserting and rely on consistent information - gtk.gdk.threads_enter() - self.source_list_add(event.subject) - gtk.gdk.threads_leave() - elif event.what==DataPool.Event.deleted_key: + gtk.gdk.threads_enter( ) + self.source_list_add( event.subject ) + gtk.gdk.threads_leave( ) + elif event.what == DataPool.Event.deleted_key: # update combo-box by removing and rely on consistent information - gtk.gdk.threads_enter() - if (not self.displayed_data[0] is None and - self.displayed_data[0]==event.subject): - self.displayed_data=[None,None] - none_iter=self.source_list_find([u'None']) - if none_iter is not None: self.display_source_combobox.set_active_iter(none_iter) + gtk.gdk.threads_enter( ) + if (not self.displayed_data[ 0 ] is None and + self.displayed_data[ 0 ] == event.subject): + self.displayed_data = [ None, None ] + none_iter = self.source_list_find( [ u'None' ] ) + if none_iter is not None: + self.display_source_combobox.set_active_iter( none_iter ) # not necessary, because event will be submitted #self.clear_display() - self.source_list_remove(event.subject) - gtk.gdk.threads_leave() - elif event.what==DataPool.Event.destroy: - gtk.gdk.threads_enter() - self.source_list_reset('None') - self.displayed_data=[None,None] - self.clear_display() - gtk.gdk.threads_leave() + self.source_list_remove( event.subject ) + gtk.gdk.threads_leave( ) + elif event.what == DataPool.Event.destroy: + gtk.gdk.threads_enter( ) + self.source_list_reset( 'None' ) + self.displayed_data = [ None, None ] + self.clear_display( ) + gtk.gdk.threads_leave( ) return - def update_display_idle_event(self, subject=None): + def update_display_idle_event( self, subject=None ): - self.update_counter_lock.acquire() - self.update_counter-=1 - self.update_counter_lock.release() + self.update_counter_lock.acquire( ) + self.update_counter -= 1 + self.update_counter_lock.release( ) # print "update display", self.update_counter - if self.update_counter>10: - print "update queue too long (%d>10): skipping one update"%self.update_counter + if self.update_counter > 10: + print "update queue too long (%d>10): skipping one update" % self.update_counter return - if self.displayed_data[0] is None or subject!=self.displayed_data[0]: + if self.displayed_data[ 0 ] is None or subject != self.displayed_data[ 0 ]: return - gtk.gdk.threads_enter() + gtk.gdk.threads_enter( ) try: - self.update_display() + self.update_display( ) finally: - gtk.gdk.threads_leave() + gtk.gdk.threads_leave( ) ######################## events from buttons - def display_source_changed_event(self, widget, data=None): - - new_data_name = self.source_list_current() - if (self.displayed_data[0] is None and new_data_name==u"None"): return - if (self.displayed_data[0]==new_data_name): return - if self.displayed_data[1] is not None and hasattr(self.displayed_data[1], "unregister_listener"): - self.displayed_data[1].unregister_listener(self.datastructures_listener) - self.displayed_data[1]=None + def display_source_changed_event( self, widget, data=None ): + + new_data_name = self.source_list_current( ) + if (self.displayed_data[ 0 ] is None and new_data_name == u"None"): + return + if (self.displayed_data[ 0 ] == new_data_name): + return + if self.displayed_data[ 1 ] is not None and hasattr( self.displayed_data[ 1 ], "unregister_listener" ): + self.displayed_data[ 1 ].unregister_listener( self.datastructures_listener ) + self.displayed_data[ 1 ] = None # register new one - if new_data_name==u"None": - self.display_source_path_label.set_label(u"") - self.displayed_data=[None,None] - self.clear_display() + if new_data_name == u"None": + self.display_source_path_label.set_label( u"" ) + self.displayed_data = [ None, None ] + self.clear_display( ) elif self.data_pool is None or new_data_name not in self.data_pool: - none_iter=self.source_list_find([u'None']) - if none_iter is not None: self.display_source_combobox.set_active_iter(none_iter) - self.display_source_path_label.set_label(u"") + none_iter = self.source_list_find( [ u'None' ] ) + if none_iter is not None: + self.display_source_combobox.set_active_iter( none_iter ) + self.display_source_path_label.set_label( u"" ) else: - new_data_struct=self.data_pool[new_data_name] - if hasattr(new_data_struct, "register_listener"): - new_data_struct.register_listener(self.datastructures_listener) - self.displayed_data=[new_data_name, new_data_struct] - dirpart=new_data_name.rfind("/") - if dirpart>=0: - self.display_source_path_label.set_label(u"in "+new_data_name[:dirpart]) + new_data_struct = self.data_pool[ new_data_name ] + if hasattr( new_data_struct, "register_listener" ): + new_data_struct.register_listener( self.datastructures_listener ) + self.displayed_data = [ new_data_name, new_data_struct ] + dirpart = new_data_name.rfind( "/" ) + if dirpart >= 0: + self.display_source_path_label.set_label( u"in " + new_data_name[ :dirpart ] ) else: - self.display_source_path_label.set_label(u"") - self.clear_display() - # renew display via idle event - self.update_counter_lock.acquire() - self.update_counter+=1 - self.update_counter_lock.release() - event=DataPool.Event(DataPool.Event.updated_value, new_data_name) - gobject.idle_add(self.datapool_idle_listener,event,priority=gobject.PRIORITY_DEFAULT_IDLE) + self.display_source_path_label.set_label( u"" ) + self.clear_display( ) + # renew display via idle event + self.update_counter_lock.acquire( ) + self.update_counter += 1 + self.update_counter_lock.release( ) + event = DataPool.Event( DataPool.Event.updated_value, new_data_name ) + gobject.idle_add( self.datapool_idle_listener, event, priority=gobject.PRIORITY_DEFAULT_IDLE ) - def display_autoscaling_toggled(self, widget, data=None): - self.matplot_axes.set_autoscale_on(self.display_autoscaling_checkbutton.get_active()) - if self.displayed_data[0] is not None: - self.update_display(self.displayed_data[0][:]) + def display_autoscaling_toggled( self, widget, data=None ): + self.matplot_axes.set_autoscale_on( self.display_autoscaling_checkbutton.get_active( ) ) + if self.displayed_data[ 0 ] is not None: + self.update_display( self.displayed_data[ 0 ][ : ] ) - def display_scaling_changed(self, widget, data=None): - self.__rescale=True - if self.displayed_data[0] is not None: - self.update_display(self.displayed_data[0][:]) + def display_scaling_changed( self, widget, data=None ): + self.__rescale = True + if self.displayed_data[ 0 ] is not None: + self.update_display( self.displayed_data[ 0 ][ : ] ) - def display_statistics_toggled(self, widget, data=None): - if self.displayed_data[0] is not None: - self.update_display(self.displayed_data[0][:]) + def display_statistics_toggled( self, widget, data=None ): + if self.displayed_data[ 0 ] is not None: + self.update_display( self.displayed_data[ 0 ][ : ] ) - def save_display_data_as_text(self, widget, data=None): + def save_display_data_as_text( self, widget, data=None ): """ copy data to tmp file and show save dialog """ - data_to_save=self.displayed_data[:] - if self.displayed_data[1] is None: + data_to_save = self.displayed_data[ : ] + if self.displayed_data[ 1 ] is None: # nothing to save return - if not hasattr(data_to_save[1], "write_to_csv"): - log("do not know how to save %s of class/type %s"%(data_to_save[0],type(data_to_save[1]))) + if not hasattr( data_to_save[ 1 ], "write_to_csv" ): + log( "do not know how to save %s of class/type %s" % (data_to_save[ 0 ], type( data_to_save[ 1 ] )) ) return # save them to a temporary file (in memory) - tmpdata=os.tmpfile() - tmpdata.write("# saved from monitor as %s\n"%data_to_save[0]) - data_to_save[1].write_to_csv(tmpdata) - + tmpdata = os.tmpfile( ) + tmpdata.write( "# saved from monitor as %s\n" % data_to_save[ 0 ] ) + data_to_save[ 1 ].write_to_csv( tmpdata ) + # show save dialog - def response(self, response_id, tmpfile): + def response( self, response_id, tmpfile ): if response_id == gtk.RESPONSE_OK: - file_name = dialog.get_filename() + file_name = dialog.get_filename( ) if file_name is None: return True - absfilename=os.path.abspath(file_name) - if os.access(file_name, os.F_OK): - log("ToDo: Overwrite file question") + absfilename = os.path.abspath( file_name ) + if os.access( file_name, os.F_OK ): + log( "ToDo: Overwrite file question" ) - textfile=file(absfilename,"w") - tmpfile.seek(0) + textfile = file( absfilename, "w" ) + tmpfile.seek( 0 ) for l in tmpfile: - textfile.write(l) - textfile.close() - textfile=None - tmpfile=None + textfile.write( l ) + textfile.close( ) + textfile = None + tmpfile = None return True - - # Determining the tab which is currently open - dialog_title="Save %s in file"%data_to_save[0] - - dialog = gtk.FileChooserDialog(title = dialog_title, - parent = self.main_window, - action = gtk.FILE_CHOOSER_ACTION_SAVE, - buttons = (gtk.STOCK_SAVE, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) - dialog.set_default_response(gtk.RESPONSE_OK) - dialog.set_current_name(data_to_save[0]) - dialog.set_select_multiple(False) + # Determining the tab which is currently open + dialog_title = "Save %s in file" % data_to_save[ 0 ] + + dialog = gtk.FileChooserDialog( title=dialog_title, + parent=self.main_window, + action=gtk.FILE_CHOOSER_ACTION_SAVE, + buttons=( + gtk.STOCK_SAVE, gtk.RESPONSE_OK, gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL) ) + + dialog.set_default_response( gtk.RESPONSE_OK ) + dialog.set_current_name( data_to_save[ 0 ] ) + dialog.set_select_multiple( False ) # Event-Handler for responce-signal (when one of the button is pressed) - dialog.connect("response", response, tmpdata) + dialog.connect( "response", response, tmpdata ) del tmpdata, data_to_save - dialog.run() - dialog.destroy() + dialog.run( ) + dialog.destroy( ) return True - def copy_display_data_to_clipboard(self, widget, data=None): - data_to_save=self.displayed_data[:] - if self.displayed_data[1] is None: + def copy_display_data_to_clipboard( self, widget, data=None ): + data_to_save = self.displayed_data[ : ] + if self.displayed_data[ 1 ] is None: # nothing to save return - if not hasattr(data_to_save[1], "write_to_csv"): - log("do not know how to save %s of class/type %s"%(data_to_save[0],type(data_to_save[1]))) + if not hasattr( data_to_save[ 1 ], "write_to_csv" ): + log( "do not know how to save %s of class/type %s" % (data_to_save[ 0 ], type( data_to_save[ 1 ] )) ) return # tested with qtiplot, labplot, openoffice # tab delimiters necessary # comments are not welcome :-( - tmpdata=cStringIO.StringIO() - data_to_save[1].write_to_csv(tmpdata, delimiter=u"\t") + tmpdata = cStringIO.StringIO( ) + data_to_save[ 1 ].write_to_csv( tmpdata, delimiter=u"\t" ) # cut away comments - tmpstring=u"" - tmpdata.seek(0) + tmpstring = u"" + tmpdata.seek( 0 ) for line in tmpdata: - if line[0]=="#": continue - tmpstring+=line + if line[ 0 ] == "#": + continue + tmpstring += line del tmpdata - clipboard=gtk.clipboard_get() - clipboard.set_text(tmpstring) + clipboard = gtk.clipboard_get( ) + clipboard.set_text( tmpstring ) del tmpstring, clipboard ##################### functions to feed display - def clear_display(self): + def clear_display( self ): """ unconditionally throw away everything we are inside gtk/gdk lock """ - self.display_x_scaling_combobox.set_sensitive(False) - self.display_y_scaling_combobox.set_sensitive(False) - if not hasattr(self, "__rescale"): + self.display_x_scaling_combobox.set_sensitive( False ) + self.display_y_scaling_combobox.set_sensitive( False ) + if not hasattr( self, "__rescale" ): self.__rescale = True - if not hasattr(self,"measurementresultline"): - self.measurementresultline=None + if not hasattr( self, "measurementresultline" ): + self.measurementresultline = None elif self.measurementresultline is not None: - # clear line plot - self.matplot_axes.lines.remove(self.measurementresultline[0]) - self.measurementresultline=None + # clear line plot + self.matplot_axes.lines.remove( self.measurementresultline[ 0 ] ) + self.measurementresultline = None - if not hasattr(self,"measurementresultgraph"): - self.measurementresultgraph=None + if not hasattr( self, "measurementresultgraph" ): + self.measurementresultgraph = None elif self.measurementresultgraph is not None: # clear errorbars - self.matplot_axes.lines.remove(self.measurementresultgraph[0]) - for l in self.measurementresultgraph[1]: - self.matplot_axes.lines.remove(l) - for l in self.measurementresultgraph[2]: - self.matplot_axes.collections.remove(l) - self.measurementresultgraph=None - self.matplot_axes.clear() - self.matplot_axes.grid(True) - if not hasattr(self,"graphen"): - self.graphen=[] + self.matplot_axes.lines.remove( self.measurementresultgraph[ 0 ] ) + for l in self.measurementresultgraph[ 1 ]: + self.matplot_axes.lines.remove( l ) + for l in self.measurementresultgraph[ 2 ]: + self.matplot_axes.collections.remove( l ) + self.measurementresultgraph = None + self.matplot_axes.clear( ) + self.matplot_axes.grid( True ) + if not hasattr( self, "graphen" ): + self.graphen = [ ] elif self.graphen: for l in self.graphen: - self.matplot_axes.lines.remove(l) - self.graphen=[] - self.matplot_axes.clear() - self.matplot_axes.grid(True) - self.matplot_canvas.draw_idle() + self.matplot_axes.lines.remove( l ) + self.graphen = [ ] + self.matplot_axes.clear( ) + self.matplot_axes.grid( True ) + self.matplot_canvas.draw_idle( ) - def update_display(self, subject=None): + def update_display( self, subject=None ): """ try to recycle labels, data, lines.... assume, object is not changed we are inside gtk/gdk lock """ - in_result=self.data_pool.get(self.displayed_data[0]) + in_result = self.data_pool.get( self.displayed_data[ 0 ] ) if in_result is None: - self.clear_display() + self.clear_display( ) return - if isinstance(in_result, Accumulation) or isinstance(in_result, ADC_Result): + if isinstance( in_result, Accumulation ) or isinstance( in_result, ADC_Result ): # directly taken from bluedamaris - xmin = in_result.get_xmin() - xmax = in_result.get_xmax() - ymin = in_result.get_ymin() - ymax = in_result.get_ymax() + xmin = in_result.get_xmin( ) + xmax = in_result.get_xmax( ) + ymin = in_result.get_ymin( ) + ymax = in_result.get_ymax( ) # Check for log-scale if xmin <= 0 or xmax <= 0: - self.display_x_scaling_combobox.set_sensitive(False) - self.display_x_scaling_combobox.set_active(0) + self.display_x_scaling_combobox.set_sensitive( False ) + self.display_x_scaling_combobox.set_active( 0 ) else: - self.display_x_scaling_combobox.set_sensitive(True) + self.display_x_scaling_combobox.set_sensitive( True ) if ymin <= 0 or ymax <= 0: - self.display_y_scaling_combobox.set_sensitive(False) - self.display_y_scaling_combobox.set_active(0) + self.display_y_scaling_combobox.set_sensitive( False ) + self.display_y_scaling_combobox.set_active( 0 ) else: - self.display_y_scaling_combobox.set_sensitive(False) + self.display_y_scaling_combobox.set_sensitive( False ) # Initial rescaling needed? if self.__rescale: - x_scale=self.display_x_scaling_combobox.get_active_text() - y_scale=self.display_y_scaling_combobox.get_active_text() - if xmin<=0 or x_scale=="lin": - self.matplot_axes.set_xscale("linear") - if ymin<=0 or y_scale=="lin": - self.matplot_axes.set_yscale("linear") - self.matplot_axes.set_xlim(xmin, xmax) - self.matplot_axes.set_ylim(ymin, ymax) + x_scale = self.display_x_scaling_combobox.get_active_text( ) + y_scale = self.display_y_scaling_combobox.get_active_text( ) + if xmin <= 0 or x_scale == "lin": + self.matplot_axes.set_xscale( "linear" ) + if ymin <= 0 or y_scale == "lin": + self.matplot_axes.set_yscale( "linear" ) + self.matplot_axes.set_xlim( xmin, xmax ) + self.matplot_axes.set_ylim( ymin, ymax ) self.__rescale = False # Autoscaling activated? - elif self.display_autoscaling_checkbutton.get_active(): + elif self.display_autoscaling_checkbutton.get_active( ): - xlim_min, xlim_max=self.matplot_axes.get_xlim() - if xlim_min!= xmin or xlim_max!=xmax : - self.matplot_axes.set_xlim(xmin, xmax) + xlim_min, xlim_max = self.matplot_axes.get_xlim( ) + if xlim_min != xmin or xlim_max != xmax: + self.matplot_axes.set_xlim( xmin, xmax ) # Rescale if new max is much larger than old ymax, simialar rules apply to ymin - ylim_min, ylim_max = self.matplot_axes.get_ylim() - ydiff=ymax-ymin + ylim_min, ylim_max = self.matplot_axes.get_ylim( ) + ydiff = ymax - ymin if (ylim_max < ymax or ylim_min > ymin or - ylim_max > ymax+0.2*ydiff or ylim_min < ymin-0.2*ydiff): - self.matplot_axes.set_ylim(ymin, ymax) + ylim_max > ymax + 0.2 * ydiff or ylim_min < ymin - 0.2 * ydiff): + self.matplot_axes.set_ylim( ymin, ymax ) - xdata=in_result.get_xdata() - chans = in_result.get_number_of_channels() - data = [] - colors = [(0,0,0.8,1), (0.7,0,0,1), (0,0.7,0,1), (0.7,0.5,0,1), (0,0,0,1)] # rgba tuples: blue, red, green, yellow - - for i in xrange(chans): - data.append(in_result.get_ydata(i)) - - moving_average=data_slice=None - if max_points_to_display>0 and len(xdata)>max_points_to_display: - print "decimating data to %d points by moving average (prevent crash of matplotlib)"%max_points_to_display - n=numpy.ceil(len(xdata)/max_points_to_display) - moving_average=numpy.ones(n, dtype="float")/n - data_slice=numpy.array(numpy.floor(numpy.arange(max_points_to_display, dtype="float") \ - /max_points_to_display*len(xdata)), - dtype="int") - xdata=xdata.take(data_slice) # no average !? - for i in xrange(chans): - data[i] = numpy.convolve(data[i], moving_average, "same").take(data_slice) + xdata = in_result.get_xdata( ) + chans = in_result.get_number_of_channels( ) + data = [ ] + colors = [ (0, 0, 0.8, 1), (0.7, 0, 0, 1), (0, 0.7, 0, 1), (0.7, 0.5, 0, 1), + (0, 0, 0, 1) ] # rgba tuples: blue, red, green, yellow - if len(self.graphen)==0: - for i in xrange(chans): - self.graphen.extend(self.matplot_axes.plot(xdata, data[i], linestyle="-", color=colors[i], linewidth = 2)) - for i in xrange(chans): + for i in xrange( chans ): + data.append( in_result.get_ydata( i ) ) + + moving_average = data_slice = None + if max_points_to_display > 0 and len( xdata ) > max_points_to_display: + print "decimating data to %d points by moving average (prevent crash of matplotlib)" % max_points_to_display + n = numpy.ceil( len( xdata ) / max_points_to_display ) + moving_average = numpy.ones( n, dtype="float" ) / n + data_slice = numpy.array( numpy.floor( numpy.arange( max_points_to_display, dtype="float" ) \ + / max_points_to_display * len( xdata ) ), + dtype="int" ) + xdata = xdata.take( data_slice ) # no average !? + for i in xrange( chans ): + data[ i ] = numpy.convolve( data[ i ], moving_average, "same" ).take( data_slice ) + + if len( self.graphen ) == 0: + for i in xrange( chans ): + self.graphen.extend( + self.matplot_axes.plot( xdata, data[ i ], linestyle="-", color=colors[ i ], linewidth=2 ) ) + for i in xrange( chans ): # initialize error bars - self.graphen.extend(self.matplot_axes.plot([0.0], [0.0], linestyle="-", color=colors[i], linewidth = 0.5)) - self.graphen.extend(self.matplot_axes.plot([0.0], [0.0], linestyle="-", color=colors[i], linewidth = 0.5)) + self.graphen.extend( + self.matplot_axes.plot( [ 0.0 ], [ 0.0 ], linestyle="-", color=colors[ i ], linewidth=0.5 ) ) + self.graphen.extend( + self.matplot_axes.plot( [ 0.0 ], [ 0.0 ], linestyle="-", color=colors[ i ], linewidth=0.5 ) ) else: - for i in xrange(chans): - self.graphen[i].set_data(xdata, data[i]) + for i in xrange( chans ): + self.graphen[ i ].set_data( xdata, data[ i ] ) # Statistics activated? - if (self.display_statistics_checkbutton.get_active() and - in_result.uses_statistics() and in_result.ready_for_drawing_error()): - - for i in xrange(chans): - err = in_result.get_yerr(i) + if (self.display_statistics_checkbutton.get_active( ) and + in_result.uses_statistics( ) and in_result.ready_for_drawing_error( )): + + for i in xrange( chans ): + err = in_result.get_yerr( i ) if moving_average is not None: - err = numpy.convolve(err, moving_average, "same").take(data_slice) - self.graphen[chans+2*i].set_data(xdata, data[i] + err) - self.graphen[chans+2*i+1].set_data(xdata, data[i] - err) + err = numpy.convolve( err, moving_average, "same" ).take( data_slice ) + self.graphen[ chans + 2 * i ].set_data( xdata, data[ i ] + err ) + self.graphen[ chans + 2 * i + 1 ].set_data( xdata, data[ i ] - err ) else: - for i in xrange(chans): - self.graphen[chans+2*i].set_data([0.0],[0.0]) - self.graphen[chans+2*i+1].set_data([0.0],[0.0]) - moving_average=data_mask=None - data=None + for i in xrange( chans ): + self.graphen[ chans + 2 * i ].set_data( [ 0.0 ], [ 0.0 ] ) + self.graphen[ chans + 2 * i + 1 ].set_data( [ 0.0 ], [ 0.0 ] ) + moving_average = data_mask = None + data = None # Any title to be set? - in_result_title=in_result.get_title() + in_result_title = in_result.get_title( ) if in_result_title is not None: - col=101 - while len(in_result_title)-col>10: - in_result_title=in_result_title[:col]+"\n"+in_result_title[col:] - col+=101 - self.matplot_axes.set_title(in_result_title) + col = 101 + while len( in_result_title ) - col > 10: + in_result_title = in_result_title[ :col ] + "\n" + in_result_title[ col: ] + col += 101 + self.matplot_axes.set_title( in_result_title ) else: - self.matplot_axes.set_title("") + self.matplot_axes.set_title( "" ) # Any labels to be set? - if in_result.get_xlabel() is not None: - self.matplot_axes.set_xlabel(in_result.get_xlabel()) + if in_result.get_xlabel( ) is not None: + self.matplot_axes.set_xlabel( in_result.get_xlabel( ) ) else: - self.matplot_axes.set_xlabel("") + self.matplot_axes.set_xlabel( "" ) - if in_result.get_ylabel() is not None: - self.matplot_axes.set_ylabel(in_result.get_ylabel()) + if in_result.get_ylabel( ) is not None: + self.matplot_axes.set_ylabel( in_result.get_ylabel( ) ) else: - self.matplot_axes.set_ylabel("") + self.matplot_axes.set_ylabel( "" ) - # Any variables to be set? -# if False: -# if isinstance(in_result, Accumulation): -# descriptions = in_result.common_descriptions -# elif isinstance(in_result, ADC_Result): -# descriptions = in_result.description -# else: pass -# actual_config = self.config.get() -# if (descriptions is not None) : #--markusro -# print actual_config['pretty_descriptions'] -# pass -# description_string = "" -# for key in descriptions.keys(): -# description_string += "%s = %s\n" % (key,descriptions[key]) -# self.matplot_axes.text(0.7,0.95, description_string[:-1], -# size=8, -# transform=self.matplot_axes.transAxes, -# va='top', -# backgroundcolor='white') -# + # Any variables to be set? + # if False: + # if isinstance(in_result, Accumulation): + # descriptions = in_result.common_descriptions + # elif isinstance(in_result, ADC_Result): + # descriptions = in_result.description + # else: pass + # actual_config = self.config.get() + # if (descriptions is not None) : #--markusro + # print actual_config['pretty_descriptions'] + # pass + # description_string = "" + # for key in descriptions.keys(): + # description_string += "%s = %s\n" % (key,descriptions[key]) + # self.matplot_axes.text(0.7,0.95, description_string[:-1], + # size=8, + # transform=self.matplot_axes.transAxes, + # va='top', + # backgroundcolor='white') + # # Draw it! - self.matplot_canvas.draw_idle() + self.matplot_canvas.draw_idle( ) del in_result - - elif isinstance(in_result, MeasurementResult): + + elif isinstance( in_result, MeasurementResult ): # remove lines and error bars if self.measurementresultgraph is not None: - self.matplot_axes.lines.remove(self.measurementresultgraph[0]) + self.matplot_axes.lines.remove( self.measurementresultgraph[ 0 ] ) # remove caps - for l in self.measurementresultgraph[1]: - self.matplot_axes.lines.remove(l) + for l in self.measurementresultgraph[ 1 ]: + self.matplot_axes.lines.remove( l ) # and columns - for l in self.measurementresultgraph[2]: - self.matplot_axes.collections.remove(l) - self.measurementresultgraph=None + for l in self.measurementresultgraph[ 2 ]: + self.matplot_axes.collections.remove( l ) + self.measurementresultgraph = None if self.measurementresultline is not None: - self.matplot_axes.lines.remove(self.measurementresultline[0]) - self.measurementresultline=None + self.matplot_axes.lines.remove( self.measurementresultline[ 0 ] ) + self.measurementresultline = None + [ k, v, e ] = in_result.get_errorplotdata( ) + if k.shape[ 0 ] != 0: + xmin = k.min( ) + ymin = (v - e).min( ) - [k,v,e]=in_result.get_errorplotdata() - if k.shape[0]!=0: - xmin=k.min() - ymin=(v-e).min() - - if xmin>0: - self.display_x_scaling_combobox.set_sensitive(True) + if xmin > 0: + self.display_x_scaling_combobox.set_sensitive( True ) else: # force switch to lin scale - self.display_x_scaling_combobox.set_sensitive(False) - if self.display_x_scaling_combobox.get_active_text()!="lin": - self.__rescale=True + self.display_x_scaling_combobox.set_sensitive( False ) + if self.display_x_scaling_combobox.get_active_text( ) != "lin": + self.__rescale = True # and reset to linear - self.display_x_scaling_combobox.set_active(0) - if ymin>0: - self.display_y_scaling_combobox.set_sensitive(True) + self.display_x_scaling_combobox.set_active( 0 ) + if ymin > 0: + self.display_y_scaling_combobox.set_sensitive( True ) else: # force switch to lin scale - self.display_y_scaling_combobox.set_sensitive(False) - if self.display_y_scaling_combobox.get_active_text()!="lin": - self.__rescale=True + self.display_y_scaling_combobox.set_sensitive( False ) + if self.display_y_scaling_combobox.get_active_text( ) != "lin": + self.__rescale = True # and reset to linear - self.display_y_scaling_combobox.set_active(0) + self.display_y_scaling_combobox.set_active( 0 ) - x_scale=self.display_x_scaling_combobox.get_active_text() - y_scale=self.display_y_scaling_combobox.get_active_text() + x_scale = self.display_x_scaling_combobox.get_active_text( ) + y_scale = self.display_y_scaling_combobox.get_active_text( ) # Initial rescaling needed? - if self.__rescale: # or self.display_autoscaling_checkbutton.get_active(): - xmax=k.max() - ymax=(v+e).max() + if self.__rescale: # or self.display_autoscaling_checkbutton.get_active(): + xmax = k.max( ) + ymax = (v + e).max( ) # is there a range problem? - if xmin==xmax or ymin==ymax: + if xmin == xmax or ymin == ymax: # fix range and scaling problems - if xmin==xmax: - if xmin!=0: - (xmin,xmax)=(xmin-abs(xmin/10.0), xmin+abs(xmin/10.0)) + if xmin == xmax: + if xmin != 0: + (xmin, xmax) = (xmin - abs( xmin / 10.0 ), xmin + abs( xmin / 10.0 )) else: - (xmin,xmax)=(-1,1) - if ymin==ymax: - if ymin==0: - (ymin,ymax)=(ymin-abs(ymin/10.0), ymin+abs(ymin/10.0)) + (xmin, xmax) = (-1, 1) + if ymin == ymax: + if ymin == 0: + (ymin, ymax) = (ymin - abs( ymin / 10.0 ), ymin + abs( ymin / 10.0 )) else: - (ymin, ymax)=(-1,1) + (ymin, ymax) = (-1, 1) - if xmin<=0 or x_scale=="lin": - self.matplot_axes.set_xscale("linear") - if ymin<=0 or y_scale=="lin": - self.matplot_axes.set_yscale("linear") + if xmin <= 0 or x_scale == "lin": + self.matplot_axes.set_xscale( "linear" ) + if ymin <= 0 or y_scale == "lin": + self.matplot_axes.set_yscale( "linear" ) - self.matplot_axes.set_xlim(xmin, xmax) - self.matplot_axes.set_ylim(ymin, ymax) + self.matplot_axes.set_xlim( xmin, xmax ) + self.matplot_axes.set_ylim( ymin, ymax ) # finally decide about x log plot - if x_scale=="log10" and xmin>0: - self.matplot_axes.set_xscale("log", basex=10.0) + if x_scale == "log10" and xmin > 0: + self.matplot_axes.set_xscale( "log", basex=10.0 ) self.matplot_axes.fmt_xdata = lambda x: "%g" % x #elif x_scale=="log" and xmin>0: # e scaling implementation not really useful # self.matplot_axes.set_xscale("log", basex=numpy.e) - if y_scale=="log10" and ymin>0: - self.matplot_axes.set_yscale("log", basex=10.0) + if y_scale == "log10" and ymin > 0: + self.matplot_axes.set_yscale( "log", basex=10.0 ) self.matplot_axes.fmt_ydata = lambda x: "%g" % x - self.__rescale=False + self.__rescale = False - self.measurementresultgraph=self.matplot_axes.errorbar(x=k, y=v, yerr=e, fmt="bx") - + self.measurementresultgraph = self.matplot_axes.errorbar( x=k, y=v, yerr=e, fmt="bx" ) - [k,v]=in_result.get_lineplotdata() - if k.shape[0]!=0 and v.shape==k.shape: - self.measurementresultline = self.matplot_axes.plot(k, v, 'r-') + [ k, v ] = in_result.get_lineplotdata( ) + if k.shape[ 0 ] != 0 and v.shape == k.shape: + self.measurementresultline = self.matplot_axes.plot( k, v, 'r-' ) # Any title to be set? - title=in_result.get_title()+"" + title = in_result.get_title( ) + "" if title is not None: - self.matplot_axes.set_title(title) + self.matplot_axes.set_title( title ) else: - self.matplot_axes.set_title("") + self.matplot_axes.set_title( "" ) - self.matplot_canvas.draw_idle() - del k,v,e + self.matplot_canvas.draw_idle( ) + del k, v, e del in_result - def renew_display(self): + def renew_display( self ): """ set all properties of display we are inside gtk/gdk lock """ - self.clear_display() - to_draw=self.data_pool[self.displayed_data[0]] + self.clear_display( ) + to_draw = self.data_pool[ self.displayed_data[ 0 ] ] - if to_draw is None: return - self.update_display() + if to_draw is None: + return + self.update_display( ) - def begin_print(self, operation, context, print_data): + def begin_print( self, operation, context, print_data ): """ layout of one page with matplotlib graph """ operation.set_n_pages( 1 ) - def draw_page(self, operation, context, page_nr, print_data): + def draw_page( self, operation, context, page_nr, print_data ): """ render a single page """ @@ -2775,105 +2826,119 @@ class MonitorWidgets: # check page dimensions # all lengths in inch: name *_in - page_setup=context.get_page_setup() - dpi=context.get_dpi_x() - if dpi!=context.get_dpi_y(): + page_setup = context.get_page_setup( ) + dpi = context.get_dpi_x( ) + if dpi != context.get_dpi_y( ): print "draw_page: dpi_x!=dpi_y, I am not prepared for that" - freewidth_in = float(context.get_width())/dpi - freeheight_in = float(context.get_height())/dpi - fc = self.matplot_canvas.switch_backends(matplotlib.backends.backend_cairo.FigureCanvasCairo) - fc.figure.dpi.set(dpi) - orig_w_in, orig_h_in = fc.figure.get_size_inches() - orig_f_color=fc.figure.get_facecolor() - orig_e_color=fc.figure.get_edgecolor() + freewidth_in = float( context.get_width( ) ) / dpi + freeheight_in = float( context.get_height( ) ) / dpi + fc = self.matplot_canvas.switch_backends( matplotlib.backends.backend_cairo.FigureCanvasCairo ) + fc.figure.dpi.set( dpi ) + orig_w_in, orig_h_in = fc.figure.get_size_inches( ) + orig_f_color = fc.figure.get_facecolor( ) + orig_e_color = fc.figure.get_edgecolor( ) # scale to maximum - fc.figure.set_facecolor("w") - fc.figure.set_edgecolor("w") + fc.figure.set_facecolor( "w" ) + fc.figure.set_edgecolor( "w" ) # maximum scale with constant aspect - scale=min(freewidth_in/orig_w_in, freeheight_in/orig_h_in) - fc.figure.set_size_inches(orig_w_in*scale, orig_h_in*scale) + scale = min( freewidth_in / orig_w_in, freeheight_in / orig_h_in ) + fc.figure.set_size_inches( orig_w_in * scale, orig_h_in * scale ) width_in_points, height_in_points = orig_w_in * dpi * scale, orig_h_in * dpi * scale - renderer = matplotlib.backends.backend_cairo.RendererCairo (fc.figure.dpi) - renderer.width = width_in_points + renderer = matplotlib.backends.backend_cairo.RendererCairo( fc.figure.dpi ) + renderer.width = width_in_points renderer.height = height_in_points # centered picture - renderer.matrix_flipy = cairo.Matrix (yy=-1,xx=1, - y0=page_setup.get_top_margin(gtk.UNIT_POINTS)+(height_in_points+freeheight_in*dpi)/2.0, - x0=page_setup.get_left_margin(gtk.UNIT_POINTS)+(freewidth_in*dpi-width_in_points)/2.0) - - renderer.set_ctx_from_surface (context.get_cairo_context().get_target()) + renderer.matrix_flipy = cairo.Matrix( yy=-1, xx=1, + y0=page_setup.get_top_margin( gtk.UNIT_POINTS ) + ( + height_in_points + freeheight_in * dpi) / 2.0, + x0=page_setup.get_left_margin( gtk.UNIT_POINTS ) + ( + freewidth_in * dpi - width_in_points) / 2.0 ) + + renderer.set_ctx_from_surface( context.get_cairo_context( ).get_target( ) ) # unfortunateley there is need for extra treatment of text - renderer.ctx.translate(page_setup.get_left_margin(gtk.UNIT_POINTS)+(freewidth_in*dpi-width_in_points)/2.0, - page_setup.get_top_margin(gtk.UNIT_POINTS)-height_in_points/2.0+freeheight_in*dpi/2.0) - renderer.ctx.save() # important! there will be no effect of previous statement without save - fc.figure.draw(renderer) + renderer.ctx.translate( + page_setup.get_left_margin( gtk.UNIT_POINTS ) + (freewidth_in * dpi - width_in_points) / 2.0, + page_setup.get_top_margin( gtk.UNIT_POINTS ) - height_in_points / 2.0 + freeheight_in * dpi / 2.0 ) + renderer.ctx.save( ) # important! there will be no effect of previous statement without save + fc.figure.draw( renderer ) # restore the figure's settings - fc.figure.set_size_inches(orig_w_in, orig_h_in) - fc.figure.set_facecolor(orig_f_color) - fc.figure.set_edgecolor(orig_e_color) - + fc.figure.set_size_inches( orig_w_in, orig_h_in ) + fc.figure.set_facecolor( orig_f_color ) + fc.figure.set_edgecolor( orig_e_color ) + + class ScriptInterface: """ texts or code objects are executed as experiment and result script the backend is started with sufficient arguments """ - - def __init__(self, exp_script=None, res_script=None, backend_executable=None, spool_dir="spool", clear_jobs=True, clear_results=True): + + def __init__( self, exp_script=None, res_script=None, backend_executable=None, spool_dir="spool", clear_jobs=True, + clear_results=True ): """ run experiment scripts and result scripts """ - self.exp_script=exp_script - self.res_script=res_script - self.backend_executable=str(backend_executable) - self.spool_dir=os.path.abspath(spool_dir) - self.clear_jobs=clear_jobs - self.clear_results=clear_results - self.exp_handling=self.res_handling=None + self.exp_script = exp_script + self.res_script = res_script + self.backend_executable = str( backend_executable ) + self.spool_dir = os.path.abspath( spool_dir ) + self.clear_jobs = clear_jobs + self.clear_results = clear_results + self.exp_handling = self.res_handling = None - self.exp_writer=self.res_reader=self.back_driver=None - if self.backend_executable is not None and self.backend_executable!="": - self.back_driver=BackendDriver.BackendDriver(self.backend_executable, spool_dir, clear_jobs, clear_results) - if self.exp_script: self.exp_writer=self.back_driver.get_exp_writer() - if self.res_script: self.res_reader=self.back_driver.get_res_reader() + self.exp_writer = self.res_reader = self.back_driver = None + if self.backend_executable is not None and self.backend_executable != "": + self.back_driver = BackendDriver.BackendDriver( self.backend_executable, spool_dir, clear_jobs, + clear_results ) + if self.exp_script: + self.exp_writer = self.back_driver.get_exp_writer( ) + if self.res_script: + self.res_reader = self.back_driver.get_res_reader( ) elif self.exp_script and self.res_script: - self.back_driver=None - self.res_reader=ResultReader.BlockingResultReader(spool_dir, clear_jobs=self.clear_jobs, clear_results=self.clear_results) - self.exp_writer=ExperimentWriter.ExperimentWriter(spool_dir, inform_last_job=self.res_reader) + self.back_driver = None + self.res_reader = ResultReader.BlockingResultReader( spool_dir, clear_jobs=self.clear_jobs, + clear_results=self.clear_results ) + self.exp_writer = ExperimentWriter.ExperimentWriter( spool_dir, inform_last_job=self.res_reader ) else: - self.back_driver=None - if self.exp_script: self.exp_writer=ExperimentWriter.ExperimentWriter(spool_dir) - if self.res_script: self.res_reader=ResultReader.ResultReader(spool_dir, clear_jobs=self.clear_jobs, clear_results=self.clear_results) - self.data=DataPool() + self.back_driver = None + if self.exp_script: + self.exp_writer = ExperimentWriter.ExperimentWriter( spool_dir ) + if self.res_script: + self.res_reader = ResultReader.ResultReader( spool_dir, clear_jobs=self.clear_jobs, + clear_results=self.clear_results ) + self.data = DataPool( ) - def runScripts(self): + def runScripts( self ): try: # get script engines - self.exp_handling=self.res_handling=None + self.exp_handling = self.res_handling = None if self.exp_script and self.exp_writer: - self.exp_handling=ExperimentHandling.ExperimentHandling(self.exp_script, self.exp_writer, self.data) + self.exp_handling = ExperimentHandling.ExperimentHandling( self.exp_script, self.exp_writer, self.data ) if self.res_script and self.res_reader: - self.res_handling=ResultHandling.ResultHandling(self.res_script, self.res_reader, self.data) + self.res_handling = ResultHandling.ResultHandling( self.res_script, self.res_reader, self.data ) # start them if self.back_driver is not None: - self.back_driver.start() - while (not self.back_driver.quit_flag.isSet() and \ - self.back_driver.core_pid is None and self.back_driver.core_pid<=0): - self.back_driver.quit_flag.wait(0.1) - if self.exp_handling: self.exp_handling.start() - if self.res_handling: self.res_handling.start() + self.back_driver.start( ) + while (not self.back_driver.quit_flag.isSet( ) and \ + self.back_driver.core_pid is None and self.back_driver.core_pid <= 0): + self.back_driver.quit_flag.wait( 0.1 ) + if self.exp_handling: + self.exp_handling.start( ) + if self.res_handling: + self.res_handling.start( ) finally: - self.exp_writer=self.res_reader=None + self.exp_writer = self.res_reader = None - def __del__(self): - self.exp_writer=None - self.res_reader=None - self.back_driver=None - self.data=None - self.exp_handling=None - self.res_handling=None + def __del__( self ): + self.exp_writer = None + self.res_reader = None + self.back_driver = None + self.data = None + self.exp_handling = None + self.res_handling = None