def quit(self, *data): try: self.save_history() finally: self.logger.debug('gtkshell session stopped at %s.' % time.asctime()) gtk.main_quit()
def on_quit_button__clicked(self, button): gtk.main_quit() self.retval = False # oneiric didn't need this, but it is required for # precise for reasons unknown # application.py as well raise SystemExit
def __init__(self): # Create a new window self.window = gtk.Window(gtk.WINDOW_TOPLEVEL) self.window.set_title("Image'd Buttons!") # It's a good idea to do this for all windows. self.window.connect("destroy", lambda wid: gtk.main_quit()) self.window.connect("delete_event", lambda a1, a2: gtk.main_quit()) # Sets the border width of the window. self.window.set_border_width(10) # Create a new button button = gtk.Button() # Connect the "clicked" signal of the button to our callback button.connect("clicked", self.callback, "cool button") # This calls our box creating function box1 = xpm_label_box(self.window, "info.xpm", "cool button") # Pack and show all our widgets button.add(box1) box1.show() button.show() self.window.add(button) self.window.show()
def on_btnLaunchSave_clicked(self, savedialog): #Get pipeline info pipeline = self.builder.get_object("cmbPipeline").get_active_text() #For mothur, we require the file locations for the template, classifier seqs, and classifier taxa if (pipeline.lower() == "mothur"): classseqs = self.builder.get_object("txtMClassSeqs").get_text() classtaxa = self.builder.get_object("txtMClassTaxa").get_text() aligntemplate = self.builder.get_object("txtMAlign").get_text() if (classtaxa == "") | (classtaxa == None): error_dialogue("Classification Taxonomy file location must be provided.") return elif (classseqs == "") | (classseqs == None): error_dialogue("Classification Sequences file location must be provided.") return elif (aligntemplate == "") | (aligntemplate == None): error_dialogue("Alignment Template file location must be provided.") return chooser = gtk.FileChooserDialog(title="Save File",action=gtk.FILE_CHOOSER_ACTION_SAVE, \ buttons=(gtk.STOCK_CANCEL,gtk.RESPONSE_CANCEL,gtk.STOCK_SAVE,gtk.RESPONSE_OK)) chooser.set_default_response(gtk.RESPONSE_OK) chooser.set_filter(self.builder.get_object("ftrAx")) chooser.set_do_overwrite_confirmation(True) response = chooser.run() if response == gtk.RESPONSE_OK: print chooser.get_filename(), 'selected' self.save_session(chooser.get_filename()) chooser.destroy() print "File saved! Exiting..." gtk.main_quit() else: chooser.destroy()
def on_destroy(self, widget): """ Called when the window closes. """ # We kill gtk gtk.main_quit()
def quit_ui(self): try: gtk.main_quit() except RuntimeError: # main_quit throws a runtimeerror if it's called outside # of the gtk main loop. pass
def main_quit(obj): """main_quit function, it stops the thread and the gtk's main loop""" #Importing the fs object from the global scope global fs #Stopping the thread and the gtk's main loop fs.stop() gtk.main_quit()
def main(): socdir = os.path.join(os.path.expanduser("~"), ".pida2", "sockets") def reply(reactor, (address, command, args)): if command != "OK": print command gtk.main_quit()
def apply(self): self.proposals.apply() if len(self.proposals) == 0 and EtcProposalsConfigGtkDecorator().Fastexit(): gtk.main_quit() self.proposals.warmup_cache() self.view.paned.treeview.refresh() self.view.paned.changesview.update_changes(lambda: [])
def close_window(self, require_confirmation=True): if require_confirmation and self.has_unsaved_changes(): warn = gtk.MessageDialog(self, gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_NONE, "You have unsaved changes.\n" "Are you sure you want to quit?") warn.add_button("Don't Save", 0) warn.add_button(gtk.STOCK_CANCEL, 1) warn.add_button(gtk.STOCK_SAVE, 2) warn.show_all() x = warn.run() warn.destroy() if x == 1: return True elif x == 2: self.save(None) self.destroy() AppWindow.__total_app_window_count -= 1 if AppWindow.__total_app_window_count == 0: gtk.main_quit() return True
def unlock(self, widget, data=None): if len(data[0].get_text()) <= 4 : data[1].set_label(u"Contraseña incorrecta.") else: print self._get_username() print data[0].get_text() gtk.main_quit()
def quit(self, sw, textbuffer, vistas, window): sw = sw textbuffer = textbuffer vistas = vistas window = window i=int(0) k=int(0) j=int(0) n = nfiles(self, 'None', 0) while i!=-1: file = os.system('ls .archivo'+str(k)+'.dat') if file != 512: if textbuffer[k].get_modified() == True: changeverify(self, sw, textbuffer, vistas, k, 1) j=j+1 if k != 0: os.system('rm .archivo'+str(k)+'.dat') if j==n+1: i=-1 k=k+1 f = open('.n.dat', 'w') f1 = open('.archivo0.dat', 'w') f.write('0') f1.write('nuevo') f.close() f1.close() os.system('rm .*cg') gtk.main_quit()
def action_quit_kill_callback(self, foo=None, bar=None): """Quitte le programme sans sauver le newsrc""" self.window.destroy() try: self.tree_tab.window.visible = 0 except KeyError: pass gtk.main_quit() return False
def window_shutdown(self, widget): # kill gtk thread gtk.main_quit() # kill roscomms thread self.roscommsThread.join(0) # I think it is dead! # kill ros thread rospy.signal_shutdown("Because I said so!")
def terminate_program(self, save_current_file=False): """Run clean-up tasks and exit the program.""" self.hide() if gtk.main_level() > 0: gtk.main_quit() if prefs['auto load last file'] and self.filehandler.file_loaded: prefs['path to last file'] = self.imagehandler.get_real_path() prefs['page of last file'] = self.imagehandler.get_current_page() else: prefs['path to last file'] = '' prefs['page of last file'] = 1 if prefs['hide all'] and self.hide_all_forced and self.fullscreen: prefs['hide all'] = False self.write_config_files() self.filehandler.cleanup() self.imagehandler.cleanup() self.thumbnailsidebar.clear() backend.LibraryBackend().close() # This hack is to avoid Python issue #1856. for thread in threading.enumerate(): if thread is not threading.currentThread(): thread.join()
def _on_destroy(self, *args): """ Called when the window closes. """ # self.save_config() # We kill gtk gtk.main_quit()
def close(self, widget): try: self.run_lock.acquire() except: pass finally: gtk.main_quit()
def item_get_info_cb(result, item, data): if result is None: secret = item.get_secret() data.append(secret) else: print "get_item_info result:", result gtk.main_quit()
def quit(self, *args): self._config['orientation'] = self.orientation_mode self._config['precision'] = '%d:%d' % self._conv.precision self._config['view_mode'] = self._conv.mode self._config['base'] = self._conv.base self._config.save() gtk.main_quit()
def quit_cb (self, *args): self.w.hide() if (self.gsd.grid and self.gsd.grid.is_changed() and (not self.won)): self.save_game(self) if gtk.main_level() > 1: # If we are in an embedded mainloop, that means that one # of our "swallowed" dialogs is active, in which case we # have to quit that mainloop before we can quit # properly. if self.swallower.running: d = self.swallower.running d.response(gtk.RESPONSE_DELETE_EVENT) gtk.main_quit() # Quit the embedded mainloop gobject.idle_add(self.quit_cb, 100) # Call ourselves again # to quit the main # mainloop return # make sure we really go away before doing our saving -- # otherwise we appear sluggish. while gtk.events_pending(): gtk.main_iteration() self.stop_worker_thread() # allow KeyboardInterrupts, which calls quit_cb outside the main loop try: gtk.main_quit() except RuntimeError: pass
def _stop(self): self.stop_event.set() try: gtk.main_quit() except RuntimeError: # This can result from gtk having already quit. pass
def __init__(self): window = gtk.Window(gtk.WINDOW_TOPLEVEL) window.set_title("Event Box") window.connect("destroy", lambda w: gtk.main_quit()) window.set_border_width(10) # Create an EventBox and add it to our toplevel window event_box = gtk.EventBox() window.add(event_box) event_box.show() # Create a long label label = gtk.Label("Click here to quit, quit, quit, quit, quit") event_box.add(label) label.show() # Clip it short. label.set_size_request(110, 20) # And bind an action to it event_box.set_events(gtk.gdk.BUTTON_PRESS_MASK) event_box.connect("button_press_event", lambda w,e: gtk.main_quit()) # More things you need an X window for ... event_box.realize() event_box.window.set_cursor(gtk.gdk.Cursor(gtk.gdk.HAND1)) # Set background color to green event_box.modify_bg(gtk.STATE_NORMAL, event_box.get_colormap().alloc_color("green")) window.show()
def __monitor_deletion(self): if self.snapdeleter.isAlive() == True: self.progressbar.set_fraction(self.snapdeleter.progress) return True else: self.progressdialog.hide() self.progressbar.set_fraction(1.0) self.progressdialog.hide() if self.snapdeleter.errors: details = "" dialog = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, _("Some snapshots could not be deleted")) dialog.connect("response", self.__on_errordialog_response) for error in self.snapdeleter.errors: details = details + error dialog.format_secondary_text(details) dialog.show() # If we didn't shortcircut straight to the delete confirmation # dialog then the main dialog is visible so we rebuild the list # view. if len(self.shortcircuit) == 0: self.__refresh_view() else: gtk.main_quit() return False
def __timerCallback(self): """Handle gobject timeout""" try: self.onTick(_TIMER_INTERVAL_IN_MS) except KeyboardInterrupt: gtk.main_quit() return True # Return true to keep the timeout running
def stop(self): """Stop main loop by exiting from gtk mainloop""" try: self.__keyListener.unlock() gtk.main_quit() except: pass
def on_imgmenuFileQuit_activate(self, widget, data=None): "Close the program" plugins.signal_proxy('on_closing') if self.tempFilename and os.path.exists(self.tempFilename): os.remove(self.tempFilename) gtk.main_quit() return 0
def onQuit(self, data): self.__controller.shutdown() # Save the width/height self.__client.set_int('/facund/gui/width', self.__width) self.__client.set_int('/facund/gui/height', self.__height) gtk.main_quit()
def list_windows(screen): print screen.get_workspaces() for window in get_workspace_windows(screen): if window.get_window_type() == wnck.WINDOW_NORMAL: print window.get_application().get_name(), window.get_workspace().get_name() gtk.main_quit()
def _quit_ta(self, widget=None, e=None): ''' Save changes on exit ''' project_empty = self.tw.is_project_empty() if not project_empty: resp = self._show_save_dialog(e is None) if resp == gtk.RESPONSE_YES: if self.tw.is_new_project(): self._save_as() else: if self.tw.project_has_changed(): self._save_changes() elif resp == gtk.RESPONSE_CANCEL: return if hasattr(self, 'client'): self.client.set_int(self._ORIENTATION, self.tw.orientation) for plugin in self.tw.turtleart_plugins.values(): if hasattr(plugin, 'quit'): plugin.quit() # Clean up temporary files if os.path.exists(TMP_SVG_PATH): os.remove(TMP_SVG_PATH) if os.path.exists(TMP_ODP_PATH): os.remove(TMP_ODP_PATH) gtk.main_quit() exit()
def doquit(self, widget=None, data=None): ## FIXME!! what to do now ? try to close adeskbar nicely .. self.win.hide() for ind in self.plg_mgr.plugins: self.plg_mgr.plugins[ind].stop() self.win.destroy() gtk.main_quit()
def quit(self, an_event): """Quit zoom.py.""" gtk.main_quit()
def destroy(self, event): gtk.main_quit()
def __windowExit(widget, data=None): gtk.main_quit()
def action_quit(self, a): self.save_config() gtk.main_quit()
def destroy_cb(widget, data = None): gtk.main_quit()
def bye(self): gtk.main_quit() sys.exit(0)
def destroy(self, widget, data=None): gtk.main_quit()
def on_quit(self, widget, data=None): gtk.main_quit()
def destroy_progress(self, widget, data=None): gobject.source_remove(self.timer) self.timer = 0 gtk.main_quit() UDPSock.close()
def exit(self): self.window.destroy() gtk.main_quit()
def delete_event(self, widget, event, data=None): gtk.main_quit() return False
def on_child_exited(self, term): if self.terminal.get_child_exit_status() == 0: gtk.main_quit() else: self.show_notify(self.fail_message)
def destroy(self, widget, data=None): print "Quitting..." gtk.main_quit()
def destroy(widget, data=None): print "destroy event occurred", widget, data print "killing main loop" gtk.main_quit()
def close_app(self, *args): args[0].destroy() gtk.main_quit()
def keydown(self, widget, event): keystr = gtk.gdk.keyval_name(event.keyval) if keystr == 'Escape': gtk.main_quit()
def _info(exctyp, value, tb): trace = None dialog = gtk.MessageDialog(parent=None, flags=0, type=gtk.MESSAGE_WARNING, buttons=gtk.BUTTONS_NONE) dialog.set_title(_("Bug Detected")) if gtk.check_version(2, 4, 0) is not None: dialog.set_has_separator(False) primary = _( "<big><b>A programming error has been detected during the execution of this program.</b></big>" ) secondary = _( "It probably isn't fatal, but should be reported to the developers nonetheless." ) try: setsec = dialog.format_secondary_text except AttributeError: raise dialog.vbox.get_children()[0].get_children()[1].set_markup( '%s\n\n%s' % (primary, secondary)) #lbl.set_property ("use-markup", True) else: del setsec dialog.set_markup(primary) dialog.format_secondary_text(secondary) dialog.add_button(_("Details..."), 2) dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE) dialog.add_button(gtk.STOCK_QUIT, 1) while True: resp = dialog.run() if resp == 2: if trace == None: trace = analyse(exctyp, value, tb) # Show details... details = gtk.Dialog( _("Bug Details"), dialog, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, ( gtk.STOCK_CLOSE, gtk.RESPONSE_CLOSE, )) details.set_property("has-separator", False) details.add_button("Save to file...", 3) textview = gtk.TextView() textview.show() textview.set_editable(False) textview.modify_font(pango.FontDescription("Monospace")) sw = gtk.ScrolledWindow() sw.show() sw.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) sw.add(textview) details.vbox.add(sw) textbuffer = textview.get_buffer() textbuffer.set_text(trace.getvalue()) monitor = gtk.gdk.screen_get_default().get_monitor_at_window( dialog.window) area = gtk.gdk.screen_get_default().get_monitor_geometry(monitor) try: w = area.width // 1.6 h = area.height // 1.6 except SyntaxError: # python < 2.2 w = area.width / 1.6 h = area.height / 1.6 details.set_default_size(int(w), int(h)) detResp = details.run() if detResp != gtk.RESPONSE_CLOSE: saveStackTrace(trace.getvalue()) details.destroy() elif resp == 1 and gtk.main_level() > 0: gtk.main_quit() break else: break dialog.destroy()
#!/usr/bin/env python2 import gtk import webkit class WebView(webkit.WebView): def get_html(self): self.execute_script( 'oldtitle=document.title;document.title=document.documentElement.innerHTML;' ) html = self.get_main_frame().get_title() self.execute_script('document.title=oldtitle;') return html window = gtk.Window() view = WebView() view.open('http://www.google.com') window.add(view) window.show_all() window.connect('delete-event', lambda window, event: gtk.main_quit()) print view.get_html() gtk.main()
def do_quit(action): if __name__ == '__main__': gtk.main_quit()
def quit(*args): gtk.main_quit()
def __init__(self): self.display_mode = display_mode self.initvars() self.showstars = self.showgrid = self.showtri = True self.showdonut = self.showcubes = self.showrand = False self.showtext = self.enable = self.full = False self.anicount = self.cnt = 0 self.twinkle = 0.0 self.starcol = 0.3 self.zoffset = -50 self.arr = [] self.selarr = [] self.iconarr = [] #ttt = time.time() self.xrand = rand.XRand() #print "Random gen time", time.time() - ttt self.stars = [] for jj in range(300): self.stars.append( (rand.frand2(10.0), rand.frand2(10.0), \ rand.frand4(-3, -12), rand.frand(1))) self.bigstars = [] for jj in range(200): self.bigstars.append((rand.frand2(8.0), rand.frand2(8.0), \ rand.frand4(-3, -12), rand.frand(1) )) self.initfonts() self.initicons() self.inittextpads() self.BLACK = gtk.gdk.Color(0x0, 0x0, 0x0) self.RED = gtk.gdk.Color(0xffff, 0x0, 0x0) self.GREEN = gtk.gdk.Color(0x0, 0xffff, 0x0) self.BLUE = gtk.gdk.Color(0x0, 0x0, 0xffff) # Try to create a double buffered framebuffer, if not successful then # attempt to create a single buffered one. try: self.glconfig = gtk.gdkgl.Config(mode=self.display_mode) except gtk.gdkgl.NoMatches: print "Switching to non double mode" self.display_mode &= ~gtk.gdkgl.MODE_DOUBLE self.glconfig = gtk.gdkgl.Config(mode=self.display_mode) # Create the window for the app. self.win = gtk.Window() self.win.set_title('Python 3D File Manager') if sys.platform != 'win32': self.win.set_resize_mode(gtk.RESIZE_IMMEDIATE) self.win.set_reallocate_redraws(True) #self.win.set_border_width(10) self.win.connect('destroy', lambda quit: gtk.main_quit()) # DrawingArea for OpenGL rendering. self.glarea = gtk.gtkgl.DrawingArea(self.glconfig) #self.glarea.set_size_request(600, 600) www = gtk.gdk.screen_width() hhh = gtk.gdk.screen_height() #print "www/hhh", www, hhh self.glarea.set_size_request(www / 4, hhh / 4) self.win.set_position(gtk.WIN_POS_CENTER) self.win.fullscreen() self.full = True #print gtk.gdk.screen_width(), gtk.gdk.screen_height(); self.win.set_events(gtk.gdk.POINTER_MOTION_MASK | gtk.gdk.POINTER_MOTION_HINT_MASK | gtk.gdk.BUTTON_PRESS_MASK | gtk.gdk.BUTTON_RELEASE_MASK | gtk.gdk.KEY_PRESS_MASK | gtk.gdk.KEY_RELEASE_MASK | gtk.gdk.FOCUS_CHANGE_MASK) self.win.connect("motion-notify-event", self.area_motion) self.win.connect("key-press-event", self.area_key) self.win.connect("key-release-event", self.area_key) self.win.connect("button-press-event", self.area_button) self.win.connect("button-release-event", self.area_button) # connect to the relevant signals. self.glarea.connect_after('realize', self.__realize) self.glarea.connect('configure_event', self.__configure_event) self.glarea.connect('expose_event', self.__expose_event) self.glarea.connect('map_event', self.__map_event) self.glarea.connect('unmap_event', self.__unmap_event) self.glarea.connect('visibility_notify_event', self.__visibility_notify_event) self.glarea.add_events(gtk.gdk.VISIBILITY_NOTIFY_MASK) self.glarea.show() self.win.add(self.glarea) self.angle = 0.0 self.angle2 = 0.0 self.angle3 = 0.0 self.angle5 = 0.0 self.angle7 = 0.0 self.pos_y = 0.0 self.pos_y2 = 0.0 self.pos_x = 0.0 self.pos_x2 = 0.0 #self.__enable_timeout = False self.__enable_timeout = True self.__timeout_interval = 30 self.__timeout_id = 0
def onExit(self, widget): gtk.main_quit()
def clean_quit(self, widget=None, data=None): print "Clean Quit" gtk.main_quit()
def _quit(self, *args): print "bye..." gtk.main_quit()
self, enable_resize=False, shadow_radius=6, ): gtk.Plug.__init__(self, 0) self.shadow_radius = shadow_radius self.enable_resize = enable_resize self.background_color = (1, 1, 1, 0.93) # FIXME: Because mplayer don't allowed window redirect colormap to screen. # We build shadow window to emulate it, but shadow's visual effect # is not good enough, so we disable shadow temporary for future fixed. self.shadow_visible = False self.init() # Mix-in MplayerWindow methods (except __init__) to EmbedMplayerWindow EmbedMplayerWindow.__bases__ += (MplayerWindow, ) gobject.type_register(EmbedMplayerWindow) if __name__ == "__main__": window = MplayerWindow() window.connect("destroy", lambda w: gtk.main_quit()) window.set_size_request(500, 500) window.move(100, 100) # window.window_frame.add(gtk.Button("Linux Deepin")) window.show_window() gtk.main()
def _main_quit(*a, **kw): gtk.main_quit() return False
def on_destroy(mozembed): gtk.main_quit()
def runmain(): ts = np.linspace(0.01, 0.08, 15).tolist() mus = np.linspace(0, 1, 101).tolist() # mus = np.linspace(0, 1, 51).tolist() # mus = np.linspace(0, 0.25, 15).tolist() # ts = [0.01] # mus = [mus[1]] # mus = mus[0:10] # ts = [ts[0]] ts = np.linspace(0, 0.01, 11).tolist() # mus = [0.5] # ts = [np.linspace(0.01, 0.3, 10).tolist()[2]] # ts = [0.3] # ts = np.linspace(0.3, 0.3, 1).tolist() dims = [len(ts), len(mus)] ndims = dims + [numsites] finished = np.empty(dims, dtype=bool) E0res = np.empty(dims, dtype=object) fsres = np.empty(dims, dtype=object) nres = np.empty(dims, dtype=object) n2res = np.empty(dims, dtype=object) kres = np.empty(dims, dtype=object) nires = np.empty(ndims, dtype=object) ninres = np.empty(ndims, dtype=object) kires = np.empty(ndims, dtype=object) start = datetime.datetime.now() with concurrent.futures.ThreadPoolExecutor(max_workers=numthreads) as executor: futures = [executor.submit(runmc, i, tmu[0][0], tmu[0][1], tmu[1][0], tmu[1][1]) for i, tmu in enumerate(zip(itertools.product(ts, mus), itertools.product(range(0, len(ts)), range(0, len(mus)))))] for future in gprogress(concurrent.futures.as_completed(futures), size=len(futures)): pass data = pyalps.loadMeasurements(pyalps.getResultFiles(prefix=filenameprefix), measurements) for d in data: it = int(d[0].props['it']) imu = int(d[0].props['imu']) outfile = d[0].props['filename'][0:-12] + 'out.xml' tree = ET.parse(outfile) root = tree.getroot() finished[it][imu] = root[0].attrib['status'] == 'finished' for s in d: for case in switch(s.props['observable']): if case('Energy'): E0res[it][imu] = s.y[0] break if case('Stiffness'): fsres[it][imu] = L * s.y[0] break if case('Density'): nres[it][imu] = s.y[0] break if case('Density^2'): n2res[it][imu] = s.y[0] break if case('Local Density'): nires[it][imu] = s.y break if case('Local Density * Global Density'): ninres[it][imu] = s.y break kres[it][imu] = beta * (n2res[it][imu] - numsites * (nres[it][imu] ** 2)) kires[it][imu] = beta * (ninres[it][imu] - nires[it][imu] * nres[it][imu]) end = datetime.datetime.now() resi = sys.argv[1] if sys.platform == 'darwin': resfile = '/Users/Abuenameh/Documents/Simulation Results/BH-MC/res.' + str(resi) + '.txt' elif sys.platform == 'linux2': resfile = '/home/ubuntu/Dropbox/Amazon EC2/Simulation Results/BH-MC/res.' + str(resi) + '.txt' resf = open(resfile, 'w') res = '' res += 'finished[{0}]={1};\n'.format(resi, mathformat(finished)) res += 'delta[{0}]={1};\n'.format(resi, delta) # res += 'dres[{0}]={1};\n'.format(resi, d) res += 'Lres[{0}]={1};\n'.format(resi, L) res += 'Tres[{0}]={1};\n'.format(resi, T) res += 'thermres[{0}]={1};\n'.format(resi, thermalization) res += 'sweepsres[{0}]={1};\n'.format(resi, sweeps) res += 'limitres[{0}]={1};\n'.format(resi, limit) res += 'nmax[{0}]={1};\n'.format(resi, nmax) res += 'nures[{0}]={1};\n'.format(resi, mathformat(nu)) res += 'mures[{0}]={1};\n'.format(resi, mathformat(mus)) res += 'tres[{0}]={1};\n'.format(resi, mathformat(ts)) res += 'E0res[{0}]={1:mean};\n'.format(resi, mathformat(E0res)) res += 'E0reserr[{0}]={1:error};\n'.format(resi, mathformat(E0res)) res += 'fsres[{0}]={1:mean};\n'.format(resi, mathformat(fsres)) res += 'fsreserr[{0}]={1:error};\n'.format(resi, mathformat(fsres)) res += 'nres[{0}]={1:mean};\n'.format(resi, mathformat(nres)) res += 'nreserr[{0}]={1:error};\n'.format(resi, mathformat(nres)) res += 'n2res[{0}]={1:mean};\n'.format(resi, mathformat(n2res)) res += 'n2reserr[{0}]={1:error};\n'.format(resi, mathformat(n2res)) res += 'kres[{0}]={1:mean};\n'.format(resi, mathformat(kres)) res += 'kreserr[{0}]={1:error};\n'.format(resi, mathformat(kres)) res += 'nires[{0}]={1:mean};\n'.format(resi, mathformat(nires)) res += 'nireserr[{0}]={1:error};\n'.format(resi, mathformat(nires)) res += 'ninres[{0}]={1:mean};\n'.format(resi, mathformat(ninres)) res += 'ninreserr[{0}]={1:error};\n'.format(resi, mathformat(ninres)) res += 'kires[{0}]={1:mean};\n'.format(resi, mathformat(kires)) res += 'kireserr[{0}]={1:error};\n'.format(resi, mathformat(kires)) res += 'runtime[{0}]=\"{1}\";\n'.format(resi, end - start) resf.write(res) # print '{0}'.format(mathformat(finished)) # print '{0}'.format(mathformat(E0res)) # print '{0}'.format(mathformat(fsres)) # print '{0}'.format(mathformat(kres)) # print '{0}'.format(mathformat(nres)) # print '{0}'.format(mathformat(n2res)) gtk.main_quit()
# switch comments for gtk over gtkagg from matplotlib.backends.backend_gtk import FigureCanvasGTK as FigureCanvas #from matplotlib.backends.backend_gtkagg import FigureCanvasGTKAgg as FigureCanvas # or NavigationToolbar for classic from matplotlib.backends.backend_gtk import NavigationToolbar2GTK as NavigationToolbar from matplotlib.axes import Subplot from matplotlib.figure import Figure import gtk win = gtk.Window() win.set_title("Embedding in GTK") win.connect("destroy", lambda x: gtk.main_quit()) vbox = gtk.VBox() win.add(vbox) fig = Figure(figsize=(5,4), dpi=100) ax = fig.add_subplot(111) t = arange(0.0,3.0,0.01) s = sin(2*pi*t) ax.plot(t,s) canvas = FigureCanvas(fig) # a gtk.DrawingArea vbox.pack_start(canvas) toolbar = NavigationToolbar(canvas)
def __on_delete_window(self, window, event): gtk.main_quit() return True