def update_kernel_model(self): self.set_busy() model = self.get_model() model.clear() self.mode = 'kernel' icon = get_icon_with_name('deb', 24) list = self.package_worker.list_unneeded_kerenl() self.total_num = len(list) self.__column.set_title(_('Packages')) while gtk.events_pending(): gtk.main_iteration() for pkg in list: desc = self.package_worker.get_pkgsummary(pkg) iter = model.append() model.set(iter, COLUMN_CHECK, False, COLUMN_ICON, icon, COLUMN_NAME, pkg, COLUMN_DESC, desc, COLUMN_DISPLAY, '<b>%s</b>\n%s' % (pkg, desc) ) self.unset_busy()
def _show_messages(self, trans): while gtk.events_pending(): gtk.main_iteration() for msg in trans._messages: d = AptMessageDialog(msg.enum, msg.details, parent=self.window_main) d.run() d.hide()
def runMainLoopWithReplay(self): while gtk.events_pending(): gtk.main_iteration() if self.delay: time.sleep(self.delay) if self.isActive(): self.describeAndRun()
def update_cache_model(self): self.set_busy() model = self.get_model() model.clear() self.mode = 'cache' cache_dir = '/var/cache/apt/archives' icon = get_icon_with_name('deb', 24) list = map(lambda file: '%s/%s' % (cache_dir, file), filter(lambda x:x.endswith('deb'), os.listdir(cache_dir))) self.total_num = len(list) self.__column.set_title(_('Package Cache')) while gtk.events_pending(): gtk.main_iteration() for pkg in list: size = str(os.path.getsize(pkg)) iter = model.append() model.set(iter, COLUMN_ICON, icon, COLUMN_CHECK, False, COLUMN_NAME, pkg, COLUMN_DESC, size, COLUMN_DISPLAY, _('<b>%s</b>\nTake %s of disk space') % (os.path.basename(pkg), filesizeformat(size)) ) self.unset_busy()
def createStatsTable(self, vbox, playerids, sitenos, limits, type, seats, groups, dates, games): startTime = time() show_detail = True # Scrolled window for summary table swin = gtk.ScrolledWindow(hadjustment=None, vadjustment=None) swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) vbox.pack1(swin) #, resize=True) don't use resize, self.height_inc relies on initial # height of pane being correct for one row # Display summary table at top of page # 3rd parameter passes extra flags, currently includes: # holecards - whether to display card breakdown (True/False) # numhands - min number hands required when displaying all players # gridnum - index for grid data structures flags = [False, self.filters.getNumHands(), 0] self.addGrid(swin, 'playerDetailedStats', flags, playerids ,sitenos, limits, type, seats, groups, dates, games) swin.show() if 'allplayers' in groups and groups['allplayers']: # can't currently do this combination so skip detailed table show_detail = False if show_detail: # Separator vbox2 = gtk.VBox(False, 0) heading = gtk.Label(self.filterText['handhead']) heading.show() vbox2.pack_start(heading, expand=False, padding=3) # Scrolled window for detailed table (display by hand) swin2 = gtk.ScrolledWindow(hadjustment=None, vadjustment=None) swin2.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) swin2.show() vbox2.pack_start(swin2, expand=True, padding=3) vbox.pack2(vbox2) vbox2.show() # Detailed table flags[0] = True flags[2] = 1 self.addGrid(swin2, 'playerDetailedStats', flags, playerids ,sitenos, limits, type, seats, groups, dates, games) if self.height_inc is None: self.height_inc = 0 # need this to check whether scrollbar is visible: while gtk.events_pending(): # see http://faq.pygtk.org/index.py?req=index for more hints (3.7) gtk.main_iteration(False) hs = swin.get_hscrollbar() if hs is not None: #print "hs vis", hs.get_property('visible'), hs.get_property('visible').__class__ if hs.get_property('visible'): self.height_inc = hs.size_request()[1] + swin.style_get_property('scrollbar-spacing') #print "hh set to", self.height_inc self.stats_vbox.set_position(self.top_pane_height + self.height_inc) self.db.rollback() print (_("Stats page displayed in %4.2f seconds") % (time() - startTime))
def update_disc_usage (self): if not self.update: return if self.source.total_duration > self.disc_size: self.__capacity_exceeded.show () else: self.__capacity_exceeded.hide () # Flush events so progressbar redrawing gets done while gtk.events_pending(): gtk.main_iteration(True) if self.source.total_duration > 0: duration = self.__disc_size - self.source.total_duration if duration > 0: dur = _("%s remaining") % self.__hig_duration (duration) else: dur = _("%s overlaping") % self.__hig_duration (abs (duration)) else: dur = _("Empty") self.__usage_label.set_text (dur) e = operations.Event(self) for l in self.listeners: l.on_contents_changed (e)
def setup_ubuntu_cn_mirror(self): window = self.get_toplevel().window if window: window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH)) if UNCONVERT: import ubuntutweak.common.sourcedata reload(ubuntutweak.common.sourcedata) global SOURCES_DATA from ubuntutweak.common.sourcedata import SOURCES_DATA proxy.replace_entry(UBUNTU_CN_STR, PPA_URL) self.update_model() self.emit('sourcechanged') else: iter = self.model.get_iter_first() while iter: while gtk.events_pending(): gtk.main_iteration() url = self.model.get_value(iter, self.COLUMN_URL) if self.has_mirror_ppa(url): new_url = url.replace(PPA_URL, UBUNTU_CN_STR) proxy.replace_entry(url, new_url) self.model.set_value(iter, self.COLUMN_URL, new_url) iter = self.model.iter_next(iter) self.emit('sourcechanged') self.update_ubuntu_cn_model() if window: window.set_cursor(None)
def add(self, target): target = urllib.unquote(target).replace("file://", "") if target.endswith(".m3u"): #load playlist files self.loadm3u(target) elif target.endswith(".pls"): self.loadpls(target) elif os.path.isdir(target): #load directories targs = os.listdir(target) targs.sort() for t in targs: #recurse through directory if not t.startswith("."): #skip dotfiles self.add(target + "/" + t) else: #add target to playlist self.counter, tid = self.counter + 1, self.counter if target.find("://") > -1: name = target else: name = os.path.basename(target) row = [tid, target, name, pango.WEIGHT_BOLD, False] self.view.get_model().append(row) gtk.main_iteration() #allow other events to process return True
def __init__(self, app_obj, image_filename): print "Splash:", image_filename self.app_obj = app_obj # Hook the application's error_dialog() method so that we can # make the splash screen disappear before the dialog box appears. self.real_error_dialog = self.app_obj.error_dialog self.app_obj.error_dialog = pykarta.misc.BoundMethodProxy(self.error_dialog_hook) # Create a white window self.window = gtk.Window(type=gtk.WINDOW_TOPLEVEL) self.window.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse("white")) # Ask the window manager not to decorate it and to put it in the center # of the screen. The way we do this is somewhat redundant because # we want to be sure to be understood. # FIXME: disabled because Ubuntu Unity loses the WM icon! #self.window.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN) # enough under GNOME self.window.set_position(gtk.WIN_POS_CENTER) # needed on Win32 self.window.set_decorated(False) # needed on Win32 self.window.set_keep_above(True) # Load the image and put it in the white window. image = gtk.Image() image.set_from_file(image_filename) self.window.add(image) self.window.show_all() self.window.present() # in case Win32 launcher was minimized while gtk.events_pending(): gtk.main_iteration(False)
def refresh_screen(): """ Refresh the widgets in the screen. Used mainly to update the progress bars during file conversion """ while gtk.events_pending(): gtk.main_iteration()
def show(self): """ Builds the splashscreen and connects the splash window to be destroyed via a timeout callback in L{SplashScreen.DELAY}msec time. The splash can also be destroyed manually by the application """ self.wSplash = gtk.Window(gtk.WINDOW_POPUP) self.wSplash.set_type_hint(gtk.gdk.WINDOW_TYPE_HINT_SPLASHSCREEN) self.wSplash.set_decorated(False) wSplashScreen = gtk.Image() wSplashScreen.set_from_file(os.path.join(conduit.SHARED_DATA_DIR,"conduit-splash.png")) # Make a pretty frame wSplashFrame = gtk.Frame() wSplashFrame.set_shadow_type(gtk.SHADOW_OUT) wSplashFrame.add(wSplashScreen) self.wSplash.add(wSplashFrame) # OK throw up the splashscreen self.wSplash.set_position(gtk.WIN_POS_CENTER) #The splash screen is destroyed automatically (via timeout) #or when the application is finished loading self.destroyed = False self.wSplash.show_all() # ensure it is rendered immediately while gtk.events_pending(): gtk.main_iteration() # The idle timeout handler to destroy the splashscreen gobject.timeout_add(SplashScreen.DELAY,self.destroy)
def progress_timeout(pbobj): if pbobj.activity_check.get_active(): pbobj.pbar.pulse() else: global samplecount global maxsamples if samplecount < parts: data,addr = UDPSock.recvfrom(buffer) samplecount += 1 # Calculate the value of the progress bar using the # value range set in the adjustment object #new_val = pbobj.pbar.get_fraction() + 1.0/1000 new_val = pbobj.pbar.get_fraction() + 1.0/parts #new_val = float(samplecount) / maxsamples # Set the new value if new_val > 1: new_val = 1.0 pbobj.pbar.set_fraction(new_val) while gtk.events_pending(): gtk.main_iteration() return True # As this is a timeout function, return TRUE so that it # continues to get called return False return True
def __init__(self, directory, window="dialog-warning", manageGTK=True, callBack=None): """ Print a small dialog screen @param callBack: method to be called with the directory chosen @type callBack: method or function """ logger.debug("WarningSc.init") self.directory = directory self.window = window self.manageGTK = manageGTK self.quit = True self.callBack = callBack self.guiFiler = None self.gui = gtk.glade.XML(unifiedglade, root=self.window) self.gui.signal_connect('on_dialog_destroy', self.destroy) self.gui.signal_connect('on_Select_clicked', self.filer) self.gui.signal_connect('on_cancel_clicked', self.destroy) self.gui.signal_connect('on_ok_clicked', self.continu) self.gui.signal_connect('on_dirname_editing_done', self.continu) self.gui.get_widget("dirname").set_text(directory) if self.manageGTK: gtk.main() else: while gtk.events_pending(): gtk.main_iteration()
def __init__(self): super(Splash, self).__init__() # These two lines are required here to make sure that unity shows the # correct information in the menu self.set_icon_from_file(W3AF_ICON) self.set_title('w3af - 0wn the Web') vbox = gtk.VBox() self.add(vbox) # content splash = os.path.join(ROOT_PATH, 'core', 'ui', 'gui', 'data', 'splash.png') img = gtk.image_new_from_file(splash) vbox.pack_start(img) self.label = gtk.Label() vbox.pack_start(self.label) # Splash screen doesn't have decoration (at least where supported) # https://github.com/andresriancho/w3af/issues/9084 if not MacOSX.is_current_platform(): self.set_decorated(False) # color and position color = gtk.gdk.color_parse('#f2f2ff') self.modify_bg(gtk.STATE_NORMAL, color) self.set_position(gtk.WIN_POS_CENTER) self.set_size_request(644, 315) # ensure it is rendered immediately self.show_all() while gtk.events_pending(): gtk.main_iteration()
def open_search(self,parent_window): self.titles = [""] self.ids = [""] if self.url.find('%s') > 0: self.url = self.url % self.title self.url = string.replace(self.url, ' ', '%20') else: self.url = string.replace(self.url+self.title, ' ', '%20') try: url = self.url.encode(self.encode) except UnicodeEncodeError: url = self.url.encode('utf-8') self.progress.set_data(parent_window, _("Searching"), _("Wait a moment"), False) retriever = Retriever(url, parent_window, self.progress) retriever.start() while retriever.isAlive(): self.progress.pulse() if self.progress.status: retriever.join() while gtk.events_pending(): gtk.main_iteration() try: if retriever.html: ifile = file(retriever.html[0], 'rb') self.page = ifile.read() # check for gzip compressed pages before decoding to unicode if len(self.page) > 2 and self.page[0:2] == '\037\213': self.page = gutils.decompress(self.page) self.page = self.page.decode(self.encode, 'replace') else: return False except IOError: pass urlcleanup() return True
def update(self, event, no_progress=False, new_total_events=None): """Show text corresponding to an event.""" text = str(event) if new_total_events is not None: self.total_number_of_events = new_total_events self.event_count = 0.0 if not no_progress: self.event_count += 1.0 if self.total_number_of_events == 0: fraction = 1.0 else: fraction = min( [1.0, self.event_count / self.total_number_of_events]) self._stop_pulse() if not no_progress: gobject.idle_add(self.progress_bar.set_fraction, fraction) self._progress_fraction = fraction self.progress_bar.set_text(text) self._progress_message = text gobject.timeout_add(self.TIME_IDLE_BEFORE_PULSE, self._start_pulse, fraction, text) if fraction == 1.0 and not no_progress: gobject.timeout_add(self.TIME_WAIT_FINISH, lambda: self.finish()) while gtk.events_pending(): gtk.main_iteration()
def refresh_handler(self): ''' At every REFRESH interval check the status of the user quota and decide if a warning needs to be displayed. ''' while gtk.events_pending(): gtk.main_iteration(False) quotaInfo = self.getQuota() self.updateLabel(quotaInfo) self.updateProgressBar(quotaInfo) self.updateTip(quotaInfo) if (quotaInfo[1] > 0): used = float(quotaInfo[0]) / 1024 total = float(quotaInfo[1]) / 1024 free = float(quotaInfo[2]) / 1024 percent = int(quotaInfo[3]) # over MAX_WARN%, under MB_WARN MBs, they haven't clicked the checkbox # and the window is not currently being displayed if percent >= MAX_WARN and free <= MAX_WARNMB and self.latch is False: window = self.wTree.get_widget('warning') value = window.get_property('visible') if value is False: window.set_property('visible', True) return True
def close_session(self, do_exit=True): '''close session''' if self.timeout_id: gobject.source_remove(self.timeout_id) self.timeout_id = None if self.session is not None: self.session.quit() self.save_extensions_config() self._save_login_dimensions() if self.session is not None: self.session.save_config() self.session = None self.config.save(self.config_path) if self.conversations: self.conversations.get_parent().hide() self.conversations = None if do_exit: if self.tray_icon is not None: self.tray_icon.set_visible(False) self.window.hide() self.window = None while gtk.events_pending(): gtk.main_iteration(False) sys.exit(0)
def find_table_parameters(self): # This is called by __init__(). Find the poker table window of interest, # given the self.search_string. Then populate self.number, self.title, # self.window, and self.parent (if required). self.number = None self.wnck_table_w = None # Flush GTK event loop before calling wnck.get_* while gtk.events_pending(): gtk.main_iteration(False) for win in root.get_windows(): w_title = win.get_name() if re.search(self.search_string, w_title, re.I): log.info('"%s" matches: "%s"' % (w_title, self.search_string)) title = w_title.replace('"', '') if self.check_bad_words(title): continue # XXX: If we could connect to 'window-closed' here, it # would make things SOOO much easier... Alas, the signal # is not available for individual windows. self.wnck_table_w = win self.number = int(win.get_xid()) self.title = title # XID is a consistent key WNCK_XTABLES.add(self.number) break if self.number is None: log.warning(_("No match in XTables for table '%s'.") % self.search_string) return None
def update_gui(): """ Flush any GTK Events. Used for doing GUI testing. """ import gtk while gtk.events_pending(): gtk.main_iteration(block=False)
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 display_track_tags(self, serial): current_serial = serial try: m = self.youki.get_metadata() if m[mpx.AttributeId.ARTIST] and m[mpx.AttributeId.TITLE]: instance = TrackTagsDataAcquire(m[mpx.AttributeId.ARTIST].get(), m[mpx.AttributeId.TITLE].get()) instance.start() while not instance.is_finished(): while gtk.events_pending(): gtk.main_iteration() tags = instance.get_tags() if current_serial == self.serial: self.tagview.clear() self.tagview.display(False) for t in tags: self.tagview.add_tag(str(t[0]), float(t[1])) else: self.display_track_tags( self.serial ) self.tagview.display(True) except: pass
def report(self,status): _time = time.clock(); _sincelast = _time - self.lasttime if status.getCurrentBlockNum() > self.blocknum: self.blocknum = status.getCurrentBlockNum() self.blockstart = _time if self.lasttime==0 or _sincelast > self.updateinterval: self.lasttime = _time; self.elapsed = _time - self.starttime self.totalelapsed = _time - self.studybegintime self.blocktime = _time - self.blockstart #print "UPDATING!" self.fill_values(status) while gtk.events_pending(): gtk.main_iteration() self.guitime = self.guitime + (time.clock() - _time) if status.isConverged() or status.isDiverged() or status.isInterrupted(): return 1 if self.guiinterrupt: return 2 return 0
def __init__(self, parent, total, text=_("Saved %(count)s of %(total)s.")): gtk.Window.__init__(self) self.count = 0 self.total = total self.text = text if parent: self.set_transient_for(parent) self.set_modal(True) self.set_decorated(False) self.set_resizable(False) self.set_focus_on_map(False) self.add(gtk.Frame()) self.get_child().set_shadow_type(gtk.SHADOW_OUT) vbox = gtk.VBox(spacing=12) vbox.set_border_width(12) self._label = gtk.Label() self._label.set_use_markup(True) self._label.set_markup(self.text % {'count': 0, 'total': self.total}) vbox.pack_start(self._label) self._progress = gtk.ProgressBar() self._progress.set_size_request(300, -1) vbox.pack_start(self._progress) self.get_child().add(vbox) self.set_position(gtk.WIN_POS_CENTER_ON_PARENT) self.show_all() while gtk.events_pending(): gtk.main_iteration()
def abrir_item(self, tv, path, view_column): self.wids['ventana'].window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH)) while gtk.events_pending(): gtk.main_iteration(False) model = tv.get_model() if model[path].parent == None: # Empleado seleccionado idempleado = model[path][-1] empleado = pclases.Empleado.get(idempleado) from formularios import empleados self.wids['ventana'].window.set_cursor(None) ventanaempleado = empleados.Empleados(empleado) # @UnusedVariable else: # Parte seleccionado. # OJO: Para identificar si es parte de producción o de trabajo miro la duración en producción en el model. if model[path][7] != "": # Es de GTX: idparte = model[path][-1] parte = pclases.ParteDeProduccion.get(idparte) from formularios import partes_de_fabricacion_rollos self.wids['ventana'].window.set_cursor(None) ventanaparte = partes_de_fabricacion_rollos.PartesDeFabricacionRollos(parte) # @UnusedVariable elif model[path][8] != "": # Es de fibra idparte = model[path][-1] parte = pclases.ParteDeProduccion.get(idparte) from formularios import partes_de_fabricacion_balas self.wids['ventana'].window.set_cursor(None) ventanaparte = partes_de_fabricacion_balas.PartesDeFabricacionBalas(parte) # @UnusedVariable else: # Debe ser parte de trabajo, no queda otra. idparte = model[path][-1] parte = pclases.ParteDeTrabajo.get(idparte) from formularios import partes_de_trabajo self.wids['ventana'].window.set_cursor(None) ventanaparte = partes_de_trabajo.PartesDeTrabajo(parte) # @UnusedVariable
def fetch_picture(self): if self.image_url: tmp_dest = tempfile.mktemp(prefix='poster_', dir=self.locations['temp']) self.image = tmp_dest.split('poster_', 1)[1] dest = "%s.jpg" % tmp_dest try: self.progress.set_data(self.parent_window, _("Fetching poster"), _("Wait a moment"), False) retriever = Retriever(self.image_url, self.parent_window, self.progress, dest, useurllib2=self.useurllib2) retriever.start() while retriever.isAlive(): self.progress.pulse() if self.progress.status: retriever.join() while gtk.events_pending(): gtk.main_iteration() urlcleanup() except: log.exception('') self.image = "" try: os.remove("%s.jpg" % tmp_dest) except: log.info("Can't remove %s file" % tmp_dest) else: self.image = ""
def __del__(self): self._ventana.destroy() self.__seguir_actualizando = False while gtk.events_pending(): gtk.main_iteration(False) while not gobject.source_remove(self.__tag): pass
def on_btn_apply_clicked(self, widget, data=None): correct = True if len(self.formation_player) == 0: self.error_team.run() correct = False if len(self.rules_computer) == 0 and not self.random_computer: self.error_es_ia.run() correct = False if len(self.formation_computer) == 0 and not self.random_computer: self.error_team_ia.run() correct = False if correct: computer_team = None if self.random_computer: teams = selection.get_installed_teams() computer_team = teams[random.randint(0, len(teams)-1)] else: computer_team = (self.rules_computer, self.formation_computer) self.human_ia_dialog.destroy() while gtk.events_pending(): gtk.main_iteration(False) try: # AQUÍ se lanza el juego de humano contra máquina human_game_handler.init_human_game(self.formation_player, computer_team, self.human_team, self.num_turns, self.dont_save_game) except human_game_handler.FileError as e: self.dlg_bad_file.format_secondary_text(e.msg) self.dlg_bad_file.run() self.quick_game.show()
def __install_button_cb(self, button, data): if self.conf.check_policy('warning-download-update'): device_dialer = tgcm.core.FreeDesktop.DeviceDialer() device_manager = tgcm.core.FreeDesktop.DeviceManager() device = device_manager.get_main_device() if device_dialer.is_modem() and device.is_connected(): tech_mm = device.get_access_technology() if tech_mm in (ACCESS_TECH_GSM, ACCESS_TECH_GSM_COMPACT, \ ACCESS_TECH_GPRS, ACCESS_TECH_EDGE): markup = _("<b>Warning: slow connection</b>") message = _("Your connection seems too slow and the download would take you quite a long time. Are you sure to continue?") resp = question_dialog(message, markup=markup, parent=self.dialog) if resp == gtk.RESPONSE_NO: return self.progress_dialog = tgcm.ui.MSD.MSDProgressWindow(parent=self.dialog) self.progress_dialog.set_show_buttons(False) message = _("Please wait a minute...") self.progress_dialog.show(message, message) entry = self.__get_selected_row(self.updates_treeview) self.news_service.install_async(entry['id'], self.__on_install_callback) if gtk.events_pending(): gtk.main_iteration(False)
def get_open_windows(): gtk.main_iteration() screen = wnck.screen_get_default() screen.force_update() win = screen.get_windows() windows=[] for w in win: if 'NORMAL' in str(w.get_window_type()): if "ducklauncher!!!"==w.get_name(): pass elif w.is_sticky()!=True and "ducklauncher!!"!=w.get_name(): window={} window['id']=w.get_xid() window['title'] =w.get_name() window['app']=w.get_application().get_name() window['icon']=w.get_application().get_icon_name() pix=w.get_icon() pix= pix.scale_simple(128,128,gtk.gdk.INTERP_HYPER) ico_data= pix.get_pixels_array() img = Image.fromarray(ico_data, 'RGBA') home = os.path.expanduser("~")+"/.duck" try: os.stat(home) except: os.mkdir(home)
def run(self): self.oem_config.show() if os.getuid() != 0: title = ('This program must be run with administrative ' 'privileges, and cannot continue without them.') dialog = gtk.MessageDialog(self.oem_config, gtk.DIALOG_MODAL, gtk.MESSAGE_ERROR, gtk.BUTTONS_CLOSE, title) dialog.run() sys.exit(1) self.glade.signal_autoconnect(self) # Some signals need to be connected by hand so that we have the # handler ids. self.username_changed_id = self.username.connect( 'changed', self.on_username_changed) self.auto_login.hide() self.steps.set_current_page(self.steps.page_num(self.step_language)) # TODO cjwatson 2006-07-07: why isn't on_steps_switch_page getting # invoked? self.set_current_page(self.steps.page_num(self.step_language)) while self.current_page is not None: self.backup = False current_name = self.step_name(self.current_page) if current_name == 'step_language': self.dbfilter = language.Language(self) elif current_name == 'step_timezone': self.dbfilter = timezone.Timezone(self) elif current_name == 'step_keyboard': self.dbfilter = console_setup.ConsoleSetup(self) elif current_name == 'step_user': self.dbfilter = user.User(self) else: raise ValueError, "step %s not recognised" % current_name self.allow_change_step(False) self.dbfilter.start(auto_process=True) gtk.main() if self.backup: pass elif current_name == 'step_language': self.translate_widgets() self.steps.next_page() elif current_name == 'step_keyboard': self.info_loop(None) self.steps.next_page() elif current_name == 'step_user': self.allow_change_step(False) self.current_page = None self.apply_changes = True else: self.steps.next_page() while gtk.events_pending(): gtk.main_iteration() # TODO: handle errors if self.apply_changes: dbfilter = language_apply.LanguageApply(self) dbfilter.run_command(auto_process=True) dbfilter = timezone_apply.TimezoneApply(self) dbfilter.run_command(auto_process=True) dbfilter = console_setup_apply.ConsoleSetupApply(self) dbfilter.run_command(auto_process=True) self.oem_config.hide() if self.apply_changes: return 0 else: return 10
class game: def make(self): pygame.init() sound = True try: pygame.mixer.init() except Exception, err: sound = False print 'error with sound', err i = 0 gameDisplay = pygame.display.get_surface() if not (gameDisplay): info = pygame.display.Info() gameDisplay = pygame.display.set_mode( (info.current_w, info.current_h)) # initializing display surface # window name pygame.display.set_caption("Buttons & Scissors") gameicon = pygame.image.load('buts/icon2.png') pygame.display.set_icon(gameicon) disp_width = 800 disp_height = 600 clock = pygame.time.Clock() timer = pygame.time.Clock() background = pygame.image.load( "buts/background.jpg").convert() # background image load background = pygame.transform.scale( background, (disp_width + 100, disp_height + 250)) home = pygame.transform.scale(pygame.image.load("buts/home.png"), (80, 80)) restart = pygame.transform.scale(pygame.image.load("buts/restart.png"), (80, 80)) undo = pygame.transform.scale(pygame.image.load("buts/undo.png"), (80, 80)) hlp = pygame.transform.scale(pygame.image.load("buts/help.png"), (80, 80)) stitch = pygame.transform.scale(pygame.image.load("buts/stitch.png"), (40, 40)) # SOUND FILES LOADED b = welcome() # Welcome Screen Call bvalue = b.make(gameDisplay, sound) crashed = False black = (0, 0, 0) white = (255, 255, 255) horizontal = vertical = rightd = leftd = 0 rightd = leftd = lastx = lasty = 0 buttonslist = [] x = [370 + 280, 435 + 280, 500 + 280, 565 + 280, 630 + 280] y = [235, 300, 365, 430, 495] backup = [] backflag = 0 homeflag = 0 backreset = 0 totaltime = 0 temp = track() flag = 0 helpf = 0 end = 0 Biglist = [] ru = 0 buttonup = 0 moves = 0 lastb = 0 if bvalue == 1: # New Game buttonslist = list(setbuttons().buttonslist) backupbuttonslist = list(buttonslist) totaltime = 0 if bvalue == 0: # Continue with open('score.pkl', 'rb') as input: buttonslist = pickle.load(input) backup = pickle.load(input) backupbuttonslist = pickle.load(input) totaltime = pickle.load(input) moves = pickle.load(input) print moves showline = linetrack(buttonslist[0], buttonslist) if sound: pygame.mixer.Sound("sound/gamestart.ogg").play(0) while not crashed: # MAIN GAME LOOP BEGINS # Gtk events while gtk.events_pending(): gtk.main_iteration() event = pygame.event.poll() totaltime += timer.tick() if event.type == pygame.QUIT: totaltime += timer.tick() with open('score.pkl', 'wb') as output: pickle.dump(buttonslist, output, pickle.HIGHEST_PROTOCOL) pickle.dump(backup, output, pickle.HIGHEST_PROTOCOL) pickle.dump(backupbuttonslist, output, pickle.HIGHEST_PROTOCOL) pickle.dump(totaltime, output, pickle.HIGHEST_PROTOCOL) pickle.dump(moves, output, pickle.HIGHEST_PROTOCOL) crashed = True mos_x, mos_y = pygame.mouse.get_pos() if (not ((mos_x <= 675 + 280) and (mos_x >= 363 + 280) and (mos_y <= 532) and (mos_y >= 225))): temp = track() vertical = horizontal = rightd = leftd = 0 lastx = lasty = 0 gameDisplay.fill(black) gameDisplay.blit(background, (0 - 50 + 280, 0 - 140)) for i in x: # loop to display all stitches on their respactive positions # for j in y: gameDisplay.blit(stitch, (i, j)) if home.get_rect(center=(270 + 280, 255)).collidepoint(mos_x, mos_y): # HOME gameDisplay.blit(pygame.transform.scale(home, (90, 90)), (250 + 280, 235)) if (pygame.mouse.get_pressed())[0] == 1 and homeflag == 0: homeflag = 1 if sound: pygame.mixer.stop() with open('score.pkl', 'wb') as output: pickle.dump(buttonslist, output, pickle.HIGHEST_PROTOCOL) pickle.dump(backup, output, pickle.HIGHEST_PROTOCOL) pickle.dump(backupbuttonslist, output, pickle.HIGHEST_PROTOCOL) pickle.dump(totaltime, output, pickle.HIGHEST_PROTOCOL) pickle.dump(moves, output, pickle.HIGHEST_PROTOCOL) b = welcome() # Welcome Screen Call bvalue = b.make(gameDisplay, sound) if bvalue == 1: # New Game buttonslist = list(setbuttons().buttonslist) backupbuttonslist = list(buttonslist) totaltime = 0 lastb = 0 backup = [] moves = 0 if bvalue == 0: # Continue with open('score.pkl', 'rb') as input: buttonslist = pickle.load(input) backup = pickle.load(input) backupbuttonslist = pickle.load(input) totaltime = pickle.load(input) moves = pickle.load(input) print moves backflag = 0 homeflag = 0 backreset = 0 helpf = 0 temp = track() flag = 0 Biglist = [] lastb = 0 buttonup = 0 showline = linetrack(buttonslist[0], buttonslist) if sound: pygame.mixer.music.load("sound/gamestart.ogg") pygame.mixer.music.play(0) if event.type == pygame.MOUSEBUTTONUP: homeflag = 0 else: gameDisplay.blit(home, (250 + 280, 235)) if undo.get_rect(center=(270 + 280, 335)).collidepoint(mos_x, mos_y): # Undo gameDisplay.blit(pygame.transform.scale(undo, (90, 90)), (250 + 280, 315)) if (pygame.mouse.get_pressed() )[0] == 1 and len(backup) != 0 and backflag == 0: if sound: pygame.mixer.music.load("sound/undo1.ogg") pygame.mixer.music.play(0) for j in backup[len(backup) - 1]: j.flag = 0 j.i = 0 for i in backup[len(backup) - 1]: buttonslist.append(i) backup.remove(backup[len(backup) - 1]) backflag = 1 moves -= 1 flag = 0 if event.type == pygame.MOUSEBUTTONUP: backflag = 0 flag = 0 else: gameDisplay.blit(undo, (250 + 280, 315)) if restart.get_rect(center=(270 + 280, 415)).collidepoint(mos_x, mos_y): # Restart gameDisplay.blit(pygame.transform.scale(restart, (90, 90)), (250 + 280, 395)) if (pygame.mouse.get_pressed())[0] == 1 and backreset == 0: if sound: pygame.mixer.music.load("sound/button.ogg") pygame.mixer.music.play(0) totaltime = 0 backup = [] backflag = 0 temp = track() flag = 0 end = 0 Biglist = [] backreset = 1 moves = 0 lastb = 0 helpf = 0 buttonup = 0 for j in backupbuttonslist: j.flag = 0 j.i = 0 buttonslist = list(backupbuttonslist) if event.type == pygame.MOUSEBUTTONUP: backreset = 0 else: gameDisplay.blit(restart, (250 + 280, 395)) if hlp.get_rect(center=(270 + 280, 495)).collidepoint(mos_x, mos_y): # Help gameDisplay.blit(pygame.transform.scale(hlp, (90, 90)), (250 + 280, 475)) if (pygame.mouse.get_pressed())[0] == 1 and helpf == 0: if sound: pygame.mixer.music.load("sound/button.ogg") pygame.mixer.music.play(0) ru = rule() ru.make(gameDisplay, sound) helpf = 1 if event.type == pygame.MOUSEBUTTONUP: helpf = 0 else: gameDisplay.blit(hlp, (250 + 280, 475)) # BUTTON TRACKING BEGINS...... for t in buttonslist: if t.but.get_rect(center=(t.x_axis + 25, t.y_axis + 25)).collidepoint(mos_x, mos_y): if t.x_axis == lastx and t.y_axis == lasty: break button = t buttoncheck = 1 diff = button.x_axis - button.y_axis total = button.x_axis + button.y_axis if (pygame.mouse.get_pressed())[0] == 1 and buttonup == 0: flag = 1 if (len(temp.coordinatelist) != 0): # SAME COLOR TEST ### if (button.butno == temp.coordinatelist[ len(temp.coordinatelist) - 1].butno): if ((lastx == button.x_axis) or (lasty == button.y_axis) or (lastdiff == diff) or (lasttotal == total)): if (lastdiff == diff): chkf = 0 for chk in buttonslist: if (chk.x_axis - chk.y_axis == diff): if lasty > button.y_axis and lastx > button.x_axis: if (chk.y_axis < lasty and chk.x_axis < lastx ) and (chk.y_axis > button.y_axis and chk.x_axis > button.x_axis): chkf = 1 break if lasty < button.y_axis and lastx < button.x_axis: if (chk.y_axis > lasty and chk.x_axis > lastx ) and (chk.y_axis < button.y_axis and chk.x_axis < button.x_axis): chkf = 1 break elif (lasttotal == total): chkf = 0 for chk in buttonslist: if (chk.x_axis + chk.y_axis == total): if lasty > button.y_axis and lastx < button.x_axis: if (chk.y_axis < lasty and chk.x_axis > lastx ) and (chk.y_axis > button.y_axis and chk.x_axis < button.x_axis): chkf = 1 break if lasty < button.y_axis and lastx > button.x_axis: if (chk.y_axis > lasty and chk.x_axis < lastx ) and (chk.y_axis < button.y_axis and chk.x_axis > button.x_axis): chkf = 1 break elif (lastx == button.x_axis): chkf = 0 for chk in buttonslist: if chk.x_axis == lastx: if lasty > button.y_axis: if (chk.y_axis < lasty and chk.x_axis == lastx ) and (chk.y_axis > button.y_axis and chk.x_axis == lastx): chkf = 1 break if lasty < button.y_axis: if (chk.y_axis > lasty and chk.x_axis == lastx ) and (chk.y_axis < button.y_axis and chk.x_axis == lastx): chkf = 1 break else: chkf = 0 for chk in buttonslist: if chk.y_axis == lasty: if lastx > button.x_axis: if (chk.x_axis < lastx and chk.y_axis == lasty ) and (chk.x_axis > button.x_axis and chk.y_axis == lasty): chkf = 1 break if lastx < button.x_axis: if (chk.x_axis > lastx and chk.y_axis == lasty ) and (chk.x_axis < button.x_axis and chk.y_axis == lasty): chkf = 1 break if (vertical == 0 and horizontal == 0 and rightd == 0 and leftd == 0): if chkf == 0: if lasttotal == total: rightd = 1 temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis elif lastdiff == diff: leftd = 1 temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis elif lastx == button.x_axis: vertical = 1 temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: horizontal = 1 temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 else: if (vertical == 1): if (lastx == button.x_axis): if chkf == 0: temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 elif (horizontal == 1): if (lasty == button.y_axis): if chkf == 0: temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 elif (leftd == 1): if (lastdiff == diff): if chkf == 0: temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 else: if (lasttotal == total): if chkf == 0: temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis else: temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 else: # to nullify the tracking if other buttons are encountered in path temp = track() buttonup = 1 vertical = horizontal = rightd = leftd = 0 lastx = lasty = 0 else: if sound: pygame.mixer.music.load("sound/cbut.ogg") pygame.mixer.music.play(0) temp.insert(button) lastdiff = button.x_axis - button.y_axis lasttotal = button.x_axis + button.y_axis lastx = button.x_axis lasty = button.y_axis showline = linetrack(temp.coordinatelist[0], buttonslist) vertical = horizontal = rightd = leftd = 0 if flag == 1: if (pygame.mouse.get_pressed())[0] == 0: if (len(temp.coordinatelist) != 0): if (t.x_axis == temp.coordinatelist[0].x_axis and t.y_axis == temp.coordinatelist[0].y_axis): temp = track() vertical = horizontal = rightd = leftd = 0 if (len(temp.coordinatelist) == 1): temp = track() vertical = horizontal = rightd = leftd = 0 flag = 0 if (len(temp.coordinatelist) > 1 and len(buttonslist) != 0): for j in temp.coordinatelist: buttonslist.remove(j) lastbackup = list(temp.coordinatelist) backup.append(list(temp.coordinatelist)) temp2 = scissorrun(list(temp.coordinatelist)) Biglist.append(temp2) flag = 0 temp = track() buttonup = 0 lastx = lasty = 0 vertical = horizontal = rightd = leftd = 0 if (len(temp.coordinatelist) != 0): # White Circle Blitting temp.display(gameDisplay) # Button Display List for i in range(len(buttonslist)): # Non Movable Buttons buttonslist[i].display(gameDisplay) if flag == 1: # White line display showline.displayline(gameDisplay) if (len(Biglist) != 0): for j in Biglist: # Movable Buttons if j.sentcoordinatelist[j.length - 1].y_axis + ( 0.2 * (j.sentcoordinatelist[j.length - 1].i**2)) > 620: # checklist=j Biglist.remove(j) moves += 1 if len(buttonslist) == 0 and len(Biglist) == 0: end = 1 continue j.display(gameDisplay) if len(buttonslist) == 0 and end == 1: b = scores() b = b.make(gameDisplay, totaltime, moves, sound) if b == 1: buttonslist = list(setbuttons().buttonslist) backupbuttonslist = list(buttonslist) totaltime = 0 backup = [] backflag = 0 homeflag = 0 backreset = 0 totaltime = 0 temp = track() moves = 0 flag = 0 end = 0 Biglist = [] lastb = 0 helpf = 0 buttonup = 0 showline = linetrack(buttonslist[0], buttonslist) if sound: pygame.mixer.music.load("sound/gamestart.ogg") pygame.mixer.music.play(0) if b == 2: totaltime = 0 backup = [] backflag = 0 helpf = 0 temp = track() flag = 0 end = 0 Biglist = [] lastb = 0 backreset = 1 moves = 0 buttonup = 0 for j in backupbuttonslist: j.flag = 0 j.i = 0 buttonslist = list(backupbuttonslist) if sound: pygame.mixer.music.load("sound/gamestart.ogg") pygame.mixer.music.play(0) pygame.display.update() clock.tick(50) if crashed == True: # Game crash or Close check pygame.quit() sys.exit() # Just a window exception check condition event1 = pygame.event.get() if event1.type == pygame.QUIT: crashed = True if crashed == True: pygame.quit() sys.exit()
def run(self): self.ksHandler = makeVersion() if self.file: self.parser = KickstartParser(self.ksHandler) msg = None try: self.parser.readKickstart(self.file) except (KickstartParseError, KickstartValueError) as e: msg = _("The following error was found while parsing your " "kickstart configuration:\n\n%s" % e) except KickstartError: msg = _( "The kickstart file %s could not be opened.") % self.file if msg: dlg = gtk.MessageDialog(None, 0, gtk.MESSAGE_ERROR, gtk.BUTTONS_OK, msg) dlg.set_title(_("Error Parsing Kickstart Config")) dlg.set_position(gtk.WIN_POS_CENTER_ON_PARENT) dlg.set_modal(True) dlg.run() dlg.destroy() sys.exit(0) self.xml = xml name_tag = (_("Kickstart")) comment_tag = (_("Create a kickstart file")) self.toplevel = xml.get_widget("main_window") self.toplevel.connect("destroy", self.destroy) self.toplevel.set_icon(iconPixbuf) #bring in widgets from glade file self.options_notebook = xml.get_widget("options_notebook") self.install_radiobutton = xml.get_widget("install_radiobutton") self.category_clist = xml.get_widget("category_clist") self.open_menu = xml.get_widget("open_menu") self.preview_menu = xml.get_widget("preview_menu") self.save_menu = xml.get_widget("save_menu") self.quit_menu = xml.get_widget("quit_menu") self.about_menu = xml.get_widget("about_menu") #populate category list self.category_view = xml.get_widget("list_view") self.category_store = gtk.ListStore(gobject.TYPE_STRING) self.category_view.set_model(self.category_store) col = gtk.TreeViewColumn(_("Subsection"), gtk.CellRendererText(), text=0) col.set_sort_column_id(0) self.category_view.append_column(col) self.category_list = [(_("Basic Configuration")), (_("Installation Method")), (_("Boot Loader Options")), (_("Partition Information")), (_("Network Configuration")), (_("Authentication")), (_("Firewall Configuration")), (_("Display Configuration")), (_("Package Selection")), (_("Pre-Installation Script")), (_("Post-Installation Script"))] for item in self.category_list: iter = self.category_store.append() self.category_store.set_value(iter, 0, item) #bring in basic functions self.basic_class = basic.basic(self, xml, self.options_notebook, self.ksHandler) # Now that we've loaded the UI elements for the first active thing in the notebook, # draw it so we can display a progress bar when yum starts doing stuff. self.toplevel.show() while gtk.events_pending(): gtk.main_iteration() self.bootloader_class = bootloader.bootloader(xml, self.options_notebook, self.ksHandler) self.install_class = install.install(self, xml, self.category_store, self.category_view, self.options_notebook, self.ksHandler) self.partition_class = partition.partition(xml, self.ksHandler) self.network_class = network.network(xml, self.ksHandler) self.auth_class = auth.auth(xml, self.ksHandler) self.firewall_class = firewall.Firewall(xml, self.ksHandler) self.X_class = xconfig.xconfig(xml, self.ksHandler) self.progress_window = progressWindow.ProgressWindow(self.toplevel) self.packages_class = packages.Packages(xml, self.ksHandler, self.progress_window) self.scripts_class = scripts.scripts(xml, self.ksHandler) self.open_menu.connect("activate", self.on_activate_open) self.preview_menu.connect("activate", self.on_activate_preview_options) self.save_menu.connect("activate", self.on_activate_save_options) self.quit_menu.connect("activate", gtk.main_quit) self.about_menu.connect("activate", self.on_about_activate) self.category_view.connect("cursor_changed", self.on_list_view_row_activated) self.options_notebook.connect("switch-page", self.on_notebook_changed) #show gui self.applyKickstart() self.toplevel.show() gtk.main()
def progressNotify(self): "A callback to the interface while events are pending" import gtk, pygtk while gtk.events_pending(): gtk.main_iteration(False)
def mySetArrowCursor(): cursor = gtk.gdk.Cursor(gtk.gdk.LEFT_PTR) self.mainWin.window.set_cursor(cursor) while gtk.events_pending(): gtk.main_iteration(False)
def mySetBusyCursor(): cursor = gtk.gdk.Cursor(gtk.gdk.WATCH) self.mainWin.window.set_cursor(cursor) while gtk.events_pending(): gtk.main_iteration(False)
def update(): """Refreshes GTK """ while gtk.events_pending(): gtk.main_iteration(False)
new_x = xp + o w.set_geometry('current', 'x', new_x, yp, wp, hp) if m: w.maximize_horizontally() def on_key_press_event(widget, event): return if __name__ == "__main__": default = wnck.screen_get_default() while gtk.events_pending(): gtk.main_iteration(False) top = [None, None] inactive_display = 0 window_list = default.get_windows_stacked() active_win = None offset = 0 if len(window_list) == 0: pass else: for win in window_list: xp, yp, wp, hp = win.get_geometry() if win.is_most_recently_activated(): if xp < 1920: inactive_display = 1 offset = 1920
class pane3window: def run(self, gameDisplay, info): crashed = False orientation1 = 0 orientation2 = 0 orientation3 = 0 orientation4 = 0 orientation5 = 0 orientation6 = 0 leftmove = 350 midmove = 555 rightmove = 761 limit1 = limit2 = 0 leftman = pygame.image.load("data/images/man.png") rightman = pygame.transform.flip(leftman, True, False) background = pygame.image.load("data/images/3pane.png") lspike = pygame.image.load("data/images/Spike.png") rspike = pygame.transform.flip(lspike, True, False) background = pygame.transform.scale(background, (600, info.current_h)) y_axis1 = 700 y_axis2 = y_axis1 + 370 y_axisa = 750 y_axisb = y_axisa + 370 y_axisx = 761 y_axisy = y_axisx + 370 leftquad = leftman midquad = leftman rightquad = leftman f1 = f2 = f3 = 0 m1 = m2 = m3 = 0 time1 = time2 = 0 font_path = "fonts/arial.ttf" font_size = 50 font1 = pygame.font.Font(font_path, font_size) score = 0 x_axis1 = x_axis2 = 350 x_axisa = x_axisb = 659 x_axisx = x_axisy = 761 speed = 7 flag = 1 black = (0, 0, 0) white = (255, 255, 255) clock = pygame.time.Clock() timer = pygame.time.Clock() sound = True try: pygame.mixer.init() except Exception, err: sound = False print 'error with sound', err jump = pygame.mixer.Sound("data/sound/jump.wav") scoremusic = pygame.mixer.Sound("data/sound/score.wav") collide = pygame.mixer.Sound("data/sound/fall.wav") while not crashed: # Gtk events while gtk.events_pending(): gtk.main_iteration() event = pygame.event.poll() # totaltime+=timer.tick() if event.type == pygame.QUIT: # totaltime+=timer.tick() crashed = True gameDisplay.fill(black) gameDisplay.blit(background, (0 + 350, 0)) # Keypress orientation change if event.type == pygame.KEYDOWN and event.key == 276 and f1 == 0: jump.play(0) f1 = 1 m1 = 1 # start moving if event.type == pygame.KEYDOWN and event.key == 274 and f2 == 0: jump.play(0) f2 = 1 m2 = 1 # start moving if event.type == pygame.KEYDOWN and event.key == 275 and f3 == 0: jump.play(0) f3 = 1 m3 = 1 # start moving # Check for when to stop if leftmove > 484 + 20: # left move leftquad = rightman m1 = f1 = 0 leftmove = 484 + 20 time1 = 0 if leftmove < 350: leftquad = leftman m1 = f1 = 0 leftmove = 350 time1 = 0 if midmove < 555: # mid move midquad = leftman m2 = f2 = 0 midmove = 555 time2 = 0 if midmove > 690 + 20: midquad = rightman m2 = f2 = 0 midmove = 690 + 20 time2 = 0 if rightmove < 761: # right move move rightquad = leftman m3 = f3 = 0 rightmove = 761 time2 = 0 if rightmove > 761 + 156: rightquad = rightman m3 = f3 = 0 rightmove = 761 + 156 time2 = 0 if m1 == 1: if leftquad == leftman: leftmove += 30 if leftquad == rightman: leftmove -= 30 time1 += 1 if m2 == 1: if midquad == leftman: midmove += 30 if midquad == rightman: midmove -= 30 time2 += 1 if m3 == 1: if rightquad == leftman: rightmove += 30 if rightquad == rightman: rightmove -= 30 time2 += 1 #[350,608] [659, 916] # Guy Display if leftquad == leftman or leftquad == rightman: gameDisplay.blit(leftquad, (leftmove, 100)) if midquad == leftman or midquad == rightman: gameDisplay.blit(midquad, (midmove, 100)) if rightquad == leftman or rightquad == rightman: gameDisplay.blit(rightquad, (rightmove, 100)) ######### SPIKE PART########### if orientation1 == 0: # orientation change x_axis1 = 350 gameDisplay.blit(lspike, (x_axis1, y_axis1)) if orientation1 == 1: x_axis1 = 485 gameDisplay.blit(rspike, (x_axis1, y_axis1)) if orientation2 == 0: x_axis2 = 350 gameDisplay.blit(lspike, (x_axis2, y_axis2)) if orientation2 == 1: x_axis2 = 485 gameDisplay.blit(rspike, (x_axis2, y_axis2)) # mid side spikes if orientation3 == 0: x_axisa = 555 gameDisplay.blit(lspike, (x_axisa, y_axisa)) if orientation3 == 1: x_axisa = 691 gameDisplay.blit(rspike, (x_axisa, y_axisa)) if orientation4 == 0: x_axisb = 555 gameDisplay.blit(lspike, (x_axisb, y_axisb)) if orientation4 == 1: x_axisb = 691 gameDisplay.blit(rspike, (x_axisb, y_axisb)) # right side spikes if orientation5 == 0: x_axisx = 761 gameDisplay.blit(lspike, (x_axisx, y_axisx)) if orientation5 == 1: x_axisx = 761 + 136 gameDisplay.blit(rspike, (x_axisx, y_axisx)) if orientation6 == 0: x_axisy = 761 gameDisplay.blit(lspike, (x_axisy, y_axisy)) if orientation6 == 1: x_axisy = 761 + 136 gameDisplay.blit(rspike, (x_axisy, y_axisy)) y_axis1 -= speed y_axis2 -= speed y_axisa -= speed y_axisb -= speed y_axisx -= speed y_axisy -= speed ''' if score==15 or score==45 or score==70: flag=1 if score==15 and flag==1 : flag=0 speed+=0.1 if score==45 and flag==1: flag=0 speed+=0.1 if score==70 and flag==1: flag=0 speed+=0.1 ''' if y_axis1 <= -40 or y_axis2 <= -40 or y_axisa <= -40 or y_axisb <= -40 or \ y_axisx <= -40 or y_axisy <= -40: scoremusic.play(0) score += 1 if (y_axis1 < -40): orientation1 = randint(0, 1) y_axis1 = 700 if (y_axis2 < -40): orientation2 = randint(0, 1) y_axis2 = 700 if (y_axisa < -40): orientation3 = randint(0, 1) y_axisa = 700 if (y_axisb < -40): orientation4 = randint(0, 1) y_axisb = 700 if (y_axisx < -40): orientation5 = randint(0, 1) y_axisx = 700 if (y_axisy < -40): orientation6 = randint(0, 1) y_axisy = 700 scores = font1.render(str(score), 1, (0, 0, 0)) gameDisplay.blit(scores, (200 + 650, 30)) if leftquad.get_rect(center=(leftmove + 5, 100 + 10)).collidepoint(x_axis1 + 8, y_axis1) \ or leftquad.get_rect(center=(leftmove + 5, 100 + 10)).collidepoint(x_axis2 + 8, y_axis2): pygame.mixer.music.load("data/sound/fall.wav") pygame.mixer.music.play(0) # collide.play(0) return score if midquad.get_rect(center=(midmove + 5, 100 + 10)).collidepoint(x_axisa + 8, y_axisa) \ or midquad.get_rect(center=(midmove + 5, 100 + 10)).collidepoint(x_axisb + 8, y_axisb): pygame.mixer.music.load("data/sound/fall.wav") pygame.mixer.music.play(0) # collide.play(0) return score if rightquad.get_rect(center=(rightmove + 5, 100 + 10)).collidepoint(x_axisx + 8, y_axisx) \ or rightquad.get_rect(center=(rightmove + 5, 100 + 10)).collidepoint(x_axisy + 8, y_axisy): pygame.mixer.music.load("data/sound/fall.wav") pygame.mixer.music.play(0) # collide.play(0) return score pygame.display.update() clock.tick(60) if crashed == True: # Game crash or Close check pygame.quit() sys.exit() # Just a window exception check condition event1 = pygame.event.get() if event1.type == pygame.QUIT: crashed = True if crashed == True: pygame.quit() sys.exit()
def renumber_annotations(self, m, at): """Renumber all annotations of a given type. """ d = gtk.Dialog(title=_("Renumbering annotations of type %s") % self.get_title(at), parent=None, flags=gtk.DIALOG_DESTROY_WITH_PARENT, buttons=( gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL, gtk.STOCK_OK, gtk.RESPONSE_OK, )) l = gtk.Label() l.set_markup( _("<b>Renumber all annotations according to their order.</b>\n\n<i>Note that this action cannot be undone.</i>\nReplace the first numeric value of the annotation content with the new annotation number.\nIf no numeric value is found and the annotation is structured, it will insert the number.\nIf no numeric value is found and the annotation is of type text/plain, it will overwrite the annotation content.\nThe offset parameter allows you to renumber from a given annotation." )) l.set_line_wrap(True) l.show() d.vbox.add(l) hb = gtk.HBox() l = gtk.Label(_("Offset")) hb.pack_start(l, expand=False) s = gtk.SpinButton() s.set_range(1, len(at.annotations)) s.set_value(1) s.set_increments(1, 5) hb.add(s) d.vbox.pack_start(hb, expand=False) d.connect('key-press-event', dialog.dialog_keypressed_cb) d.show_all() dialog.center_on_mouse(d) res = d.run() if res == gtk.RESPONSE_OK: re_number = re.compile('(\d+)') re_struct = re.compile('^num=(\d+)$', re.MULTILINE) offset = s.get_value_as_int() - 1 l = at.annotations l.sort(key=lambda a: a.fragment.begin) l = l[offset:] size = float(len(l)) dial = gtk.Dialog( _("Renumbering %d annotations") % size, None, gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT, (gtk.STOCK_CANCEL, gtk.RESPONSE_CANCEL)) prg = gtk.ProgressBar() dial.vbox.pack_start(prg, expand=False) dial.show_all() for i, a in enumerate(l[offset:]): prg.set_text(_("Annotation #%d") % i) prg.set_fraction(i / size) while gtk.events_pending(): gtk.main_iteration() if a.type.mimetype == 'application/x-advene-structured': if re_struct.search(a.content.data): # A 'num' field is present. Update it. data = re_struct.sub("num=%d" % (i + 1), a.content.data) else: # Insert the num field data = ("num=%d\n" % (i + 1)) + a.content.data elif re_number.search(a.content.data): # There is a number. Simply substitute the new one. data = re_number.sub(str(i + 1), a.content.data) elif a.type.mimetype == 'text/plain': # Overwrite the contents data = str(i + 1) else: data = None if data is not None and a.content.data != data: a.content.data = data self.controller.notify('PackageActivate', package=self.controller.package) dial.destroy() d.destroy() return True
def send_data(self, data): for i in range(0, len(data)): ser.write(data[i]) time.sleep(0.1) while gtk.events_pending(): gtk.main_iteration()
def akkumatik_command(string, what): """ Send a Command to the Akkumatik """ def serial_send_command(tname, com_str, retry_count): #{{{ """ Send command and wait for Ack (or not) """ retry_count += 1 if retry_count > (cfg.COMMAND_RETRY): cfg.COMMAND_ABORT = True #skip on further soon to arrive commands return if retry_count == (cfg.COMMAND_RETRY): failed_string = " Failed" failed_color = "#cc6666" else: failed_string = " Resend" failed_color = "#cccccc" try: cfg.SER.write(com_str) except serial.SerialException, err: tmp = "%s" % err tmp += ":" + com_str + ", " + tname print(tmp) cfg.FLOG.write(tmp) gtk_stuff.message_dialog(None, tmp) okk = False i = 0 #Status if len(tname) > 6: tname = tname[:6] label_txt = "[%-5s]: " % (tname) cfg.EVENT_BOX_LSTATUS.modify_bg(gtk.STATE_NORMAL, \ cfg.EVENT_BOX_LSTATUS.get_colormap().alloc_color("#cccccc")) cfg.LABEL_STATUS.show() cfg.LABEL_STATUS.set_text(label_txt) while gtk.events_pending(): gtk.main_iteration() while i < 50: time.sleep(0.08) label_txt += "." cfg.LABEL_STATUS.set_text(label_txt) while gtk.events_pending(): gtk.main_iteration() i += 1 #put on True before sending. - here waiting for False if cfg.COMMAND_WAIT == False: okk = True #Status label_txt += " OK" cfg.EVENT_BOX_LSTATUS.modify_bg(gtk.STATE_NORMAL, \ cfg.EVENT_BOX_LSTATUS.get_colormap().alloc_color("#66cc66")) cfg.LABEL_STATUS.set_text(label_txt) while gtk.events_pending(): gtk.main_iteration() time.sleep(2.0) break if okk == False: #Status cfg.EVENT_BOX_LSTATUS.modify_bg(gtk.STATE_NORMAL, \ cfg.EVENT_BOX_LSTATUS.get_colormap().alloc_color(failed_color)) label_txt += failed_string cfg.LABEL_STATUS.set_text(label_txt) while gtk.events_pending(): gtk.main_iteration() time.sleep(2.0) serial_send_command(tname, com_str, retry_count) cfg.LABEL_STATUS.hide()
def repaintGui(): # Force repaint: ugly, but gui gets repainted so fast that gtk objects don't show it while gtk.events_pending(): gtk.main_iteration(False)
def flush_events(self): gtk.gdk.threads_enter() while gtk.events_pending(): gtk.main_iteration(True) gtk.gdk.flush() gtk.gdk.threads_leave()
def ui_callback(progress): self.view["gen_progress_bar"].set_fraction(progress) while gtk.events_pending(): gtk.main_iteration()
def __wait_connection(self, event, progressbar): while not event.isSet(): progressbar.pulse() event.wait(0.1) while gtk.events_pending(): gtk.main_iteration(False)
def wait(): while gtk.events_pending(): gtk.main_iteration()
def run(self, *args): """Make the deformation.""" self.output.set_text("") if not self.setup_atoms(): return deform_axes = self.get_deformation_axes() if deform_axes is False: return #Nothing to do! # Prepare progress bar if self.radio_relax_on.get_active(): fmax = self.fmax.value mininame = self.minimizers[self.algo.get_active()] self.begin(mode="scale/min", algo=mininame, fmax=fmax, steps=self.steps.value, scalesteps=self.nsteps.value) else: self.begin(mode="scale", scalesteps=self.nsteps.value) try: logger_func = self.gui.simulation['progress'].get_logger_stream except (KeyError, AttributeError): logger = None else: logger = logger_func() # Don't catch errors in the function. # Display status message self.status_label.set_text(_("Running ...")) self.status_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#AA0000')) while gtk.events_pending(): gtk.main_iteration() # Do the scaling scale = self.max_scale.value if self.pull.get_active(): steps = np.linspace(0, scale, self.nsteps.value) else: steps = np.linspace(-scale, scale, self.nsteps.value) steps += self.scale_offset.value undef_cell = self.atoms.get_cell() results = [] #txt = "Strain\t\tEnergy [eV]\n" txt = "" # If we load all configurations, prepare it. if self.radio_results_all.get_active(): self.prepare_store_atoms() stored_atoms = False try: # Now, do the deformation for i, d in enumerate(steps): deformation = np.diag(1.0 + d * deform_axes) self.atoms.set_cell(np.dot(undef_cell, deformation), scale_atoms=True) if self.gui.simulation.has_key('progress'): self.gui.simulation['progress'].set_scale_progress(i) if self.radio_relax_on.get_active(): algo = getattr(ase.optimize, mininame) if mininame == "MDMin": minimizer = algo(self.atoms, logfile=logger, dt=self.mdmin_dt.value) else: minimizer = algo(self.atoms, logfile=logger) minimizer.run(fmax=fmax, steps=self.steps.value) e = self.atoms.get_potential_energy() results.append((d, e)) txt = txt + ("%.5f\t\t%.5f\n" % (d, e)) self.output.set_text(txt) if self.radio_results_all.get_active(): self.store_atoms() stored_atoms = True except AseGuiCancelException: # Update display to reflect cancellation of simulation. self.status_label.set_text(_("Calculation CANCELLED.")) self.status_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#AA4000')) except MemoryError: self.status_label.set_text( _("Out of memory, consider using " "LBFGS instead")) self.status_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#AA4000')) else: # Update display to reflect succesful end of simulation. self.status_label.set_text(_("Calculation completed.")) self.status_label.modify_fg(gtk.STATE_NORMAL, gtk.gdk.color_parse('#007700')) if results: self.do_fit(np.array(results)) if self.radio_results_optimal.get_active(): if self.minimum_ok: deformation = np.diag(1.0 + self.x0 * deform_axes) self.atoms.set_cell(np.dot(undef_cell, deformation), scale_atoms=True) if self.radio_relax_on.get_active(): if self.gui.simulation.has_key('progress'): self.gui.simulation['progress'].set_scale_progress( len(steps)) algo = getattr(ase.optimize, mininame) minimizer = algo(self.atoms, logfile=logger) minimizer.run(fmax=fmax, steps=self.steps.value) # Store the optimal configuration. self.prepare_store_atoms() self.store_atoms() stored_atoms = True else: oops(_("No trustworthy minimum: Old configuration kept.")) self.activate_output() if stored_atoms: self.gui.notify_vulnerable() self.end() # If we store all configurations: Open movie window and energy graph if stored_atoms and self.gui.images.nimages > 1: self.gui.movie() assert not np.isnan(self.gui.images.E[0]) if not self.gui.plot_graphs_newatoms(): expr = 'i, e - E[-1]' self.gui.plot_graphs(expr=expr) # Continuations should use the best image nbest = np.argmin(np.array(results)[:, 1]) self.start_nth_adj.value = nbest
def _flush_interface(): """ Sometimes we need to 'flush' interface, so that the dialog has some time to disaperar before we send a blocking command to the printer """ while gtk.events_pending(): gtk.main_iteration()
def idle_func(self): while gtk.events_pending(): gtk.main_iteration()
def _force_update(self): # This is necessary for the GTK progress bar to be updated properly. # See http://faq.pygtk.org/index.py?req=show&file=faq23.020.htp while gtk.events_pending(): gtk.main_iteration()
def run(self): black = (0, 0, 0) white = (255, 255, 255) clock = pygame.time.Clock() crashed = False # image load land = pygame.image.load("assets/land.png").convert() land1 = pygame.transform.scale(land, (490, 150)) land2 = land1 sky = pygame.image.load("assets/sky.png").convert() sky = pygame.transform.scale(sky, (490, 200)) skyfill = pygame.image.load("assets/skyfill.png").convert() skyfill = pygame.transform.scale(skyfill, (490, 500)) scoreboard = pygame.image.load("assets/scoreboard.png") scoreboard = pygame.transform.scale(scoreboard, (360, 450)) land1x = 350 land2x = 840 replay = pygame.image.load("assets/replay.png") replay = pygame.transform.scale(replay, (150, 90)) rules = pygame.image.load("assets/splash.png") font2 = pygame.font.Font("fonts/Arimo.ttf", 25) flag = 1 birds = bird() button = pygame.image.load("assets/button.png") logo = pygame.image.load("assets/logo.png") logo = pygame.transform.scale(logo, (280, 80)) # GAME LOOP BEGINS !!! while not crashed: # Gtk events while gtk.events_pending(): gtk.main_iteration() for event in pygame.event.get(): # totaltime+=timer.tick() if event.type == pygame.QUIT: crashed = True if event.type == pygame.KEYDOWN and event.key == 273: return # print "help" mos_x, mos_y = pygame.mouse.get_pos() self.gameDisplay.fill(white) self.gameDisplay.blit(skyfill, (350, 0)) self.gameDisplay.blit(sky, (350, 400)) # Platform blit self.gameDisplay.blit(land1, (land1x, 600)) self.gameDisplay.blit(land2, (land2x, 600)) land1x -= 3 land2x -= 3 if (land1x <= -140): land1x = 837 if (land2x <= -140): land2x = 837 # bird display birds.display(self.gameDisplay, flag) self.gameDisplay.blit(rules, (500, 140)) self.gameDisplay.blit(button, (700, 330)) head3 = font2.render(_("Use this button ->"), 1, (white)) self.gameDisplay.blit(head3, (480, 320)) head3 = font2.render(_("to play the game"), 1, (white)) self.gameDisplay.blit(head3, (480, 340)) self.gameDisplay.blit(logo, (455, 30)) # left and right black background patches pygame.draw.rect(self.gameDisplay, black, (0, 0, 350, 768)) pygame.draw.rect(self.gameDisplay, black, (840, 0, 693, 768)) pygame.display.update() clock.tick(60) if crashed: # Game crash or Close check pygame.quit() sys.exit() # Just a window exception check condition event1 = pygame.event.get() if event1.type == pygame.QUIT: crashed = True if crashed: pygame.quit() sys.exit()
def preview_array(self, event): if self.xCEntry.get_text(): columns = int(self.xCEntry.get_text()) else: columns = 0 if self.yCEntry.get_text(): rows = int(self.yCEntry.get_text()) else: rows = 0 if self.xOEntry.get_text(): xOffset = float(self.xOEntry.get_text()) else: xOffset = 0 if self.yOEntry.get_text(): yOffset = float(self.yOEntry.get_text()) else: yOffset = 0 if columns > 0 and rows > 0 and (columns == 1 or (columns > 1 and xOffset <> 0)) and ( rows == 1 or (rows > 1 and yOffset <> 0)): self.fCode = '{}/array_code.ngc'.format(self.tmpDir) if self.shapeMode: fPre = '{}/array_preamble.ngc'.format(self.tmpDir) fPst = '{}/array_postamble.ngc'.format(self.tmpDir) outCod = open(self.fCode, 'w') outPre = open(fPre, 'w') outPst = open(fPst, 'w') inWiz = open(self.fOriginal, 'r') while (1): d = inWiz.readline() if d.startswith('(wizard'): outCod.write(d) break outPre.write(d) while (1): d = inWiz.readline() if d.startswith('(postamble'): outPst.write(d) break outCod.write(d) while (1): d = inWiz.readline() if not d: break outPst.write(d) outCod.close() outPre.close() outPst.close() inWiz.close() self.fNgc = '{}/array.ngc'.format(self.tmpDir) outNgc = open(self.fNgc, 'w') inPre = open(fPre, 'r') for line in inPre: outNgc.write(line) inPre.close() for row in range(rows): for column in range(columns): outNgc.write('\n(row:{} column:{})\n'.format( row + 1, column + 1)) inCod = open(self.fCode, 'r') for line in inCod: raw = line.strip().lower() if raw.startswith('g0') or raw.startswith( 'g1') or raw.startswith( 'g2') or raw.startswith('g3'): a, b = raw.split('x') c, d = b.split('y') if ('i') in d: e, f = d.split('i') f = 'i' + f else: e = d f = '' outNgc.write('{}x{} y{} {}\n'.format( a, float(c) + column * xOffset, float(e) + row * yOffset, f)) else: outNgc.write(line) inCod.close() inPst = open(fPst, 'r') for line in inPst: outNgc.write(line) inPst.close() outNgc.close() self.load_file(self.fNgc) else: self.s.poll() mUnits = self.s.linear_units if self.previewed: md = gtk.MessageDialog(self.W, gtk.DIALOG_DESTROY_WITH_PARENT, gtk.MESSAGE_INFO, gtk.BUTTONS_NONE, 'ARRAY\n\nCalculating.....') md.set_keep_above(True) md.set_position(gtk.WIN_POS_CENTER_ALWAYS) md.set_default_size(200, 100) md.show_all() self.c.program_open(self.fOriginal) watchdog = time.time() + 5 while (1): self.s.poll() if os.path.basename(self.s.file) == os.path.basename( self.fOriginal): n = time.time() + 1 while (1): if time.time() > n: break while gtk.events_pending(): gtk.main_iteration() break if time.time() > watchdog: md.destroy() self.dialog_error('Array file error') return shutil.copyfile(self.s.file, self.fCode) inCod = open(self.fCode, 'r') units = 1 for line in inCod: if 'G21' in line.upper().replace(' ', '') and mUnits != 1: units = 25.4 break if 'G20' in line.upper().replace(' ', '') and mUnits == 1: units = 0.03937 break self.fNgc = '{}/array.ngc'.format(self.tmpDir) outNgc = open(self.fNgc, 'w') xPos = (self.s.g5x_offset[0] - self.s.g92_offset[0]) * units yPos = (self.s.g5x_offset[1] - self.s.g92_offset[1]) * units for row in range(rows): for column in range(columns): outNgc.write('\n(row:{} column:{})\n'.format( row + 1, column + 1)) outNgc.write('G10 L2 P0 X{} Y{}\n'.format( xPos + column * xOffset * units, yPos + row * yOffset * units)) inCod = open(self.fCode, 'r') for line in inCod: a = b = c = '' a = line.upper().replace(' ', '') if 'M2' in a or 'M30' in a: b = a.replace('M2', '') c = b.replace('M30', '') outNgc.write(c) else: outNgc.write(line) inCod.close() outNgc.write('G10 L2 P0 X{} Y{}\n'.format(xPos, yPos)) outNgc.write('M30\n') outNgc.close() self.load_file(self.fNgc) if self.previewed: md.destroy() hal.set_p('plasmac_run.preview-tab', '1') else: msg = '' if columns <= 0: msg += 'Columns are required\n\n' if rows <= 0: msg += 'Rows are required\n\n' if xOffset == 0 and columns > 1: msg += 'Column Offset is required\n\n' if yOffset == 0 and rows > 1: msg += 'Row Offset is required' self.dialog_error(msg) return self.previewed = True self.data_changed = False
def make(self, gameDisplay, totaltime, moves, sound): i = 0 white = (255, 255, 255) disp_width = 900 disp_height = 715 crashed = False clock = pygame.time.Clock() pygame.font.init() mintime = 864000 ex = 0 newb = 0 maxscore = 0 scores = 0 maxi = 0 if os.path.getsize("lasttime.pkl") > 0: with open('lasttime.pkl', 'rb') as input: mintime = pickle.load(input) if os.path.getsize("maxscore.pkl") > 0: with open('maxscore.pkl', 'rb') as input: maxscore = pickle.load(input) if totaltime < mintime: newb = 1 if totaltime < 30000: ex = 1 if totaltime < mintime: with open('lasttime.pkl', 'wb') as output: pickle.dump(totaltime, output, pickle.HIGHEST_PROTOCOL) background = pygame.image.load( "buts/scorescreen/scorescreen.jpg").convert() background = pygame.transform.scale(background, (disp_width, disp_height)) play = pygame.transform.scale( pygame.image.load("buts/scorescreen/play.png"), (80, 80)) restart = pygame.transform.scale( pygame.image.load("buts/scorescreen/restart.png"), (80, 80)) hours = 00 minutes = 00 seconds = 00 totaltime = int(totaltime / 1000) ## seconds total black = (0, 0, 0) t = (100000 / (moves * totaltime)) print t scores = int(t) if scores > maxscore: with open('maxscore.pkl', 'wb') as output: pickle.dump(scores, output, pickle.HIGHEST_PROTOCOL) maxi = 1 if (int(totaltime / 3600) > 0): hours = int(totaltime / 3600) totaltime = int(totaltime % 3600) if (int(totaltime / 60) > 0): minutes = int(totaltime / 60) totaltime = int(totaltime % 60) seconds = int(totaltime) check = 0 font_path = "fonts/comicsans.ttf" font_size = 50 font1 = pygame.font.Font(font_path, font_size) font2 = pygame.font.Font(font_path, 25) checkimg = pygame.transform.scale( pygame.image.load("buts/scorescreen/check.png"), (30, 30)) #Level=font.render("Score:"+str(score), 1,(255,255,255)) Level = font1.render("Level", 1, (255, 255, 161)) completed = font1.render("completed!", 1, (255, 255, 161)) Score = font2.render( "Time: " + str(hours) + ':' + str(minutes) + ':' + str(seconds), 1, (255, 255, 161)) t = 0 scorex = -50 Mintime = font2.render(str(mintime), 1, (255, 255, 161)) Excellent = font2.render("Excellent!", 1, (255, 255, 161)) Newbest = font2.render("New best score!", 1, (255, 255, 161)) scores = font2.render("Score: " + str(scores), 1, (255, 255, 161)) newhighscore = font2.render("New High Score!", 1, (255, 255, 161)) if sound: pygame.mixer.stop() success = pygame.mixer.Sound("sound/levelcomplete.ogg") success.play(0) while not crashed: # Gtk events while gtk.events_pending(): gtk.main_iteration() event = pygame.event.poll() if event.type == pygame.KEYDOWN: #swoosh.play(0) return 1 if event.type == pygame.QUIT: crashed = True mos_x, mos_y = pygame.mouse.get_pos() gameDisplay.fill(black) gameDisplay.blit(background, (0 + 280, 0)) if play.get_rect(center=(280 + 10 + 280 + 10, 400 + 10 + 20 + 50)).collidepoint(mos_x, mos_y): #PLAY gameDisplay.blit(pygame.transform.scale(play, (90, 90)), (280 + 280 + 10, 400 + 20 + 50)) if (pygame.mouse.get_pressed())[0] == 1 and check == 0: return 1 check = 1 if event.type == pygame.MOUSEBUTTONUP: check = 0 else: gameDisplay.blit(play, (280 + 280 + 10, 400 + 20 + 50)) if restart.get_rect(center=(440 + 10 + 280 + 10, 400 + 10 + 20 + 50)).collidepoint(mos_x, mos_y): #restart gameDisplay.blit(pygame.transform.scale(restart, (90, 90)), (440 + 280 + 10, 400 + 20 + 50)) if (pygame.mouse.get_pressed())[0] == 1 and check == 0: return 2 check = 1 if event.type == pygame.MOUSEBUTTONUP: check = 0 else: gameDisplay.blit(restart, (440 + 280 + 10, 400 + 20 + 50)) t += 1 gameDisplay.blit(Level, (340 + 280 + 10, 50)) gameDisplay.blit(completed, (280 + 280 + 10, 100)) ''' gameDisplay.blit(Excellent,(scorex,300)) gameDisplay.blit(Newbest,(scorex,300)) ''' if (scorex + 280 > 0): gameDisplay.blit(Score, (scorex + 280, 230)) gameDisplay.blit(scores, (scorex + 280, 260 + 10)) if ex == 1: gameDisplay.blit(Excellent, (scorex + 5 + 10 + 280, 300 + 30)) gameDisplay.blit(checkimg, (scorex - 40 + 10 + 280, 305 + 30)) if newb == 1: gameDisplay.blit(Newbest, (scorex + 5 + 10 + 280, 380 + 30)) gameDisplay.blit(checkimg, (scorex - 40 + 10 + 280, 385 + 30)) if maxi == 1: gameDisplay.blit(newhighscore, (scorex + 5 + 10 + 280, 340 + 30)) gameDisplay.blit(checkimg, (scorex - 40 + 10 + 280, 345 + 30)) if (scorex + 280 < 320 + 280): scorex += 0.1 * (t**2) pygame.display.update() clock.tick(50) if crashed == True: # Game crash or Close check pygame.quit() sys.exit() event1 = pygame.event.get() if event1.type == pygame.QUIT: crashed = True if crashed == True: pygame.quit() sys.exit()
def execute(self, command, hint=None, cwd=None, extra_env=None): if not command: raise CommandError(_('No command given')) if isinstance(command, (str, unicode)): short_command = command.split()[0] else: short_command = command[0] if vte is None: textbuffer = self.terminal.get_buffer() if isinstance(command, (str, unicode)): self.terminal.get_buffer().insert_with_tags_by_name( textbuffer.get_end_iter(), ' $ ' + command + '\n', 'stdin') else: self.terminal.get_buffer().insert_with_tags_by_name( textbuffer.get_end_iter(), ' $ ' + ' '.join(command) + '\n', 'stdin') kws = { 'close_fds': True, 'shell': isinstance(command, (str, unicode)), 'stdin': subprocess.PIPE, 'stdout': subprocess.PIPE, 'stderr': subprocess.PIPE, } if cwd is not None: kws['cwd'] = cwd if extra_env is not None: kws['env'] = os.environ.copy() kws['env'].update(extra_env) command = self._prepare_execute(command) try: p = subprocess.Popen(command, **kws) except OSError, e: raise CommandError(str(e)) self.child_pid = p.pid p.stdin.close() def make_non_blocking(fd): fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NDELAY) make_non_blocking(p.stdout) make_non_blocking(p.stderr) build_paused = False read_set = [p.stdout, p.stderr] while read_set: # Allow the frontend to get a little time while gtk.events_pending(): gtk.main_iteration() if self.quit: raise ExitRequestedException() rlist, wlist, xlist = select.select(read_set, [], [], 0) if p.stdout in rlist: chunk = p.stdout.read() if chunk == '': p.stdout.close() read_set.remove(p.stdout) textbuffer.insert_with_tags_by_name( textbuffer.get_end_iter(), chunk, 'stdout') if p.stderr in rlist: chunk = p.stderr.read() if chunk == '': p.stderr.close() read_set.remove(p.stderr) textbuffer.insert_with_tags_by_name( textbuffer.get_end_iter(), chunk, 'stderr') if textbuffer.get_line_count() > 200: textbuffer.delete( textbuffer.get_start_iter(), textbuffer.get_iter_at_line_offset( textbuffer.get_line_count() - 200, 0)) mark = textbuffer.get_mark('end') if mark: textbuffer.move_mark(mark, textbuffer.get_end_iter()) else: mark = textbuffer.create_mark('end', textbuffer.get_end_iter(), False) if self.terminal_sclwin.get_vadjustment().upper == \ (self.terminal_sclwin.size_request()[1] + self.terminal_sclwin.get_vadjustment().get_value()): # currently at the bottom of the textview, therefore scroll # automatically self.terminal.scroll_to_mark(mark, 0.05, True, 0.0, 1.0) # See if we should pause the current command if not build_paused and self.is_build_paused(): os.kill(p.pid, signal.SIGSTOP) build_paused = True elif build_paused and not self.is_build_paused(): os.kill(p.pid, signal.SIGCONT) build_paused = False time.sleep(0.05) rc = p.wait() self.child_pid = None
def __init__(self, no_dialog=False): self.settings = EventCore() self.gui_is_active = False # during initialization any dialog (e.g. "Unit change") is not allowed # we set the final value later self.no_dialog = True self._batch_queue = [] self._undo_states = [] self.gui = gtk.Builder() gtk_build_file = get_ui_file_location(GTKBUILD_FILE) if gtk_build_file is None: gtk.main_quit() self.gui.add_from_file(gtk_build_file) if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: gtkrc_file = get_ui_file_location(GTKRC_FILE_WINDOWS) if gtkrc_file: gtk.rc_add_default_file(gtkrc_file) gtk.rc_reparse_all_for_settings(gtk.settings_get_default(), True) self.window = self.gui.get_object("ProjectWindow") self.settings.set("main_window", self.window) # show stock items on buttons # increase the initial width of the window (due to hidden elements) self.window.set_default_size(400, -1) # initialize the RecentManager (TODO: check for Windows) if False and pycam.Utils.get_platform( ) == pycam.Utils.PLATFORM_WINDOWS: # The pyinstaller binary for Windows fails mysteriously when trying # to display the stock item. # Error message: Gtk:ERROR:gtkrecentmanager.c:1942:get_icon_fallback: assertion failed: (retval != NULL) self.recent_manager = None else: try: self.recent_manager = gtk.recent_manager_get_default() except AttributeError: # GTK 2.12.1 seems to have problems with "RecentManager" on # Windows. Sadly this is the version, that is shipped with the # "appunti" GTK packages for Windows (April 2010). # see http://www.daa.com.au/pipermail/pygtk/2009-May/017052.html self.recent_manager = None # file loading self.last_dirname = None self.last_task_settings_uri = None self.last_model_uri = None # define callbacks and accelerator keys for the menu actions for objname, callback, data, accel_key in ( ("LoadTaskSettings", self.load_task_settings_file, None, "<Control>t"), ("SaveTaskSettings", self.save_task_settings_file, lambda: self.last_task_settings_uri, None), ("SaveAsTaskSettings", self.save_task_settings_file, None, None), ("OpenModel", self.load_model_file, None, "<Control>o"), ("Quit", self.destroy, None, "<Control>q"), ("GeneralSettings", self.toggle_preferences_window, None, "<Control>p"), ("UndoButton", self._restore_undo_state, None, "<Control>z"), ("HelpUserManual", self.show_help, "User_Manual", "F1"), ("HelpIntroduction", self.show_help, "Introduction", None), ("HelpSupportedFormats", self.show_help, "SupportedFormats", None), ("HelpModelTransformations", self.show_help, "ModelTransformations", None), ("HelpToolTypes", self.show_help, "ToolTypes", None), ("HelpProcessSettings", self.show_help, "ProcessSettings", None), ("HelpBoundsSettings", self.show_help, "BoundsSettings", None), ("HelpTaskSetup", self.show_help, "TaskSetup", None), ("HelpGCodeExport", self.show_help, "GCodeExport", None), ("HelpTouchOff", self.show_help, "TouchOff", None), ("HelpSimulation", self.show_help, "Simulation", None), ("Help3DView", self.show_help, "3D_View", None), ("HelpServerMode", self.show_help, "ServerMode", None), ("HelpCommandLine", self.show_help, "CommandlineExamples", None), ("HelpHotkeys", self.show_help, "KeyboardShortcuts", None), ("ProjectWebsite", self.show_help, "http://pycam.sourceforge.net", None), ("DevelopmentBlog", self.show_help, "http://fab.senselab.org/pycam", None), ("Forum", self.show_help, "http://sourceforge.net/projects/pycam/forums", None), ("BugTracker", self.show_help, "http://sourceforge.net/tracker/?group_id=237831&atid=1104176", None), ("FeatureRequest", self.show_help, "http://sourceforge.net/tracker/?group_id=237831&atid=1104179", None)): item = self.gui.get_object(objname) action = "activate" if data is None: item.connect(action, callback) else: item.connect(action, callback, data) if accel_key: key, mod = gtk.accelerator_parse(accel_key) accel_path = "<pycam>/%s" % objname item.set_accel_path(accel_path) gtk.accel_map_change_entry(accel_path, key, mod, True) # LinkButton does not work on Windows: https://bugzilla.gnome.org/show_bug.cgi?id=617874 if pycam.Utils.get_platform() == pycam.Utils.PLATFORM_WINDOWS: def open_url(widget, data=None): webbrowser.open(widget.get_uri()) gtk.link_button_set_uri_hook(open_url) # no undo is allowed at the beginning self.gui.get_object("UndoButton").set_sensitive(False) self.settings.register_event("model-change-before", self._store_undo_state) self.settings.register_event( "model-change-after", lambda: self.settings.emit_event("visual-item-updated")) # set the availability of ODE self.enable_ode_control = self.gui.get_object("SettingEnableODE") self.settings.add_item("enable_ode", self.enable_ode_control.get_active, self.enable_ode_control.set_active) self.settings.register_event("parallel-processing-changed", self.update_ode_settings) # configure drag-n-drop for config files and models self.settings.set("configure-drag-drop-func", self.configure_drag_and_drop) self.settings.get("configure-drag-drop-func")(self.window) # other events self.window.connect("destroy", self.destroy) self.window.connect("delete-event", self.destroy) # the settings window self.gui.get_object("CloseSettingsWindow").connect( "clicked", self.toggle_preferences_window, False) self.gui.get_object("ResetPreferencesButton").connect( "clicked", self.reset_preferences) self.preferences_window = self.gui.get_object("GeneralSettingsWindow") self.preferences_window.connect("delete-event", self.toggle_preferences_window, False) self._preferences_window_position = None self._preferences_window_visible = False # "about" window self.about_window = self.gui.get_object("AboutWindow") self.about_window.set_version(VERSION) self.gui.get_object("About").connect("activate", self.toggle_about_window, True) # we assume, that the last child of the window is the "close" button # TODO: fix this ugly hack! self.gui.get_object("AboutWindowButtons").get_children()[-1].connect( "clicked", self.toggle_about_window, False) self.about_window.connect("delete-event", self.toggle_about_window, False) # menu bar uimanager = gtk.UIManager() self.settings.set("gtk-uimanager", uimanager) self._accel_group = uimanager.get_accel_group() # send a "delete" event on "CTRL-w" for every window def handle_window_close(accel_group, window, *args): window.emit("delete-event", gtk.gdk.Event(gtk.gdk.DELETE)) self._accel_group.connect_group(ord('w'), gtk.gdk.CONTROL_MASK, gtk.ACCEL_LOCKED, handle_window_close) self.settings.add_item("gtk-accel-group", lambda: self._accel_group) for obj in self.gui.get_objects(): if isinstance(obj, gtk.Window): obj.add_accel_group(self._accel_group) # preferences tab preferences_book = self.gui.get_object("PreferencesNotebook") def clear_preferences(): for child in preferences_book.get_children(): preferences_book.remove(child) def add_preferences_item(item, name): preferences_book.append_page(item, gtk.Label(name)) self.settings.register_ui_section("preferences", add_preferences_item, clear_preferences) for obj_name, label, priority in (("GeneralSettingsPrefTab", "General", -50), ("ProgramsPrefTab", "Programs", 50)): obj = self.gui.get_object(obj_name) obj.unparent() self.settings.register_ui("preferences", label, obj, priority) # general preferences general_prefs = self.gui.get_object("GeneralPreferencesBox") def clear_general_prefs(): for item in general_prefs.get_children(): general_prefs.remove(item) def add_general_prefs_item(item, name): general_prefs.pack_start(item, expand=False, padding=3) self.settings.register_ui_section("preferences_general", add_general_prefs_item, clear_general_prefs) for obj_name, priority in (("SettingEnableODE", 10), ("TaskSettingsDefaultFileBox", 30)): obj = self.gui.get_object(obj_name) obj.unparent() self.settings.register_ui("preferences_general", None, obj, priority) # set defaults self.cutter = None # add some dummies - to be implemented later ... self.settings.add_item("cutter", lambda: self.cutter) main_tab = self.gui.get_object("MainTabs") def clear_main_tab(): while main_tab.get_n_pages() > 0: main_tab.remove_page(0) def add_main_tab_item(item, name): main_tab.append_page(item, gtk.Label(name)) # TODO: move these to plugins, as well self.settings.register_ui_section("main", add_main_tab_item, clear_main_tab) main_window = self.gui.get_object("WindowBox") def clear_main_window(): main_window.foreach(lambda x: main_window.remove(x)) def add_main_window_item(item, name, **extra_args): # some widgets may want to override the defaults args = {"expand": False, "fill": False} args.update(extra_args) main_window.pack_start(item, **args) main_tab.unparent() self.settings.register_ui_section("main_window", add_main_window_item, clear_main_window) self.settings.register_ui("main_window", "Tabs", main_tab, -20, args_dict={ "expand": True, "fill": True }) # autoload task settings file on startup autoload_enable = self.gui.get_object("AutoLoadTaskFile") autoload_box = self.gui.get_object("StartupTaskFileBox") autoload_source = self.gui.get_object("StartupTaskFile") # TODO: fix the extension filter #for one_filter in get_filters_from_list(FILTER_CONFIG): # autoload_source.add_filter(one_filter) # autoload_source.set_filter(one_filter) def get_autoload_task_file(autoload_source=autoload_source): if autoload_enable.get_active(): return autoload_source.get_filename() else: return "" def set_autoload_task_file(filename): if filename: autoload_enable.set_active(True) autoload_box.show() autoload_source.set_filename(filename) else: autoload_enable.set_active(False) autoload_box.hide() autoload_source.unselect_all() def autoload_enable_switched(widget, box): if not widget.get_active(): set_autoload_task_file(None) else: autoload_box.show() autoload_enable.connect("toggled", autoload_enable_switched, autoload_box) self.settings.add_item("default_task_settings_file", get_autoload_task_file, set_autoload_task_file) def disable_gui(): self.menubar.set_sensitive(False) main_tab.set_sensitive(False) def enable_gui(): self.menubar.set_sensitive(True) main_tab.set_sensitive(True) self.settings.register_event("gui-disable", disable_gui) self.settings.register_event("gui-enable", enable_gui) # configure locations of external programs for auto_control_name, location_control_name, browse_button, key in ( ("ExternalProgramInkscapeAuto", "ExternalProgramInkscapeControl", "ExternalProgramInkscapeBrowse", "inkscape"), ("ExternalProgramPstoeditAuto", "ExternalProgramPstoeditControl", "ExternalProgramPstoeditBrowse", "pstoedit")): self.gui.get_object(auto_control_name).connect( "clicked", self._locate_external_program, key) location_control = self.gui.get_object(location_control_name) self.settings.add_item("external_program_%s" % key, location_control.get_text, location_control.set_text) self.gui.get_object(browse_button).connect( "clicked", self._browse_external_program_location, key) # set the icons (in different sizes) for all windows gtk.window_set_default_icon_list(*get_icons_pixbuffers()) # load menu data gtk_menu_file = get_ui_file_location(GTKMENU_FILE) if gtk_menu_file is None: gtk.main_quit() uimanager.add_ui_from_file(gtk_menu_file) # make the actions defined in the GTKBUILD file available in the menu actiongroup = gtk.ActionGroup("menubar") for action in [ action for action in self.gui.get_objects() if isinstance(action, gtk.Action) ]: actiongroup.add_action(action) # the "pos" parameter is optional since 2.12 - we can remove it later uimanager.insert_action_group(actiongroup, pos=-1) # the "recent files" sub-menu if not self.recent_manager is None: recent_files_menu = gtk.RecentChooserMenu(self.recent_manager) recent_files_menu.set_name("RecentFilesMenu") recent_menu_filter = gtk.RecentFilter() case_converter = pycam.Utils.get_case_insensitive_file_pattern for filter_name, patterns in FILTER_MODEL: if not isinstance(patterns, (list, set, tuple)): patterns = [patterns] # convert it into a mutable list (instead of set/tuple) patterns = list(patterns) for index in range(len(patterns)): patterns[index] = case_converter(patterns[index]) for pattern in patterns: recent_menu_filter.add_pattern(pattern) recent_files_menu.add_filter(recent_menu_filter) recent_files_menu.set_show_numbers(True) # non-local files (without "file://") are not supported. yet recent_files_menu.set_local_only(False) # most recent files to the top recent_files_menu.set_sort_type(gtk.RECENT_SORT_MRU) # show only ten files recent_files_menu.set_limit(10) uimanager.get_widget("/MenuBar/FileMenu/OpenRecentModelMenu")\ .set_submenu(recent_files_menu) recent_files_menu.connect("item-activated", self.load_recent_model_file) else: self.gui.get_object("OpenRecentModel").set_visible(False) # load the menubar and connect functions to its items self.menubar = uimanager.get_widget("/MenuBar") # dict of all merge-ids menu_merges = {} def clear_menu(menu_key): for merge in menu_merges.get(menu_key, []): uimanager.remove_ui(merge) def append_menu_item(menu_key, base_path, widget, name): merge_id = uimanager.new_merge_id() if widget: action_group = widget.props.action_group if not action_group in uimanager.get_action_groups(): uimanager.insert_action_group(action_group, -1) widget_name = widget.get_name() item_type = gtk.UI_MANAGER_MENUITEM else: widget_name = name item_type = gtk.UI_MANAGER_SEPARATOR uimanager.add_ui(merge_id, base_path, name, widget_name, item_type, False) if not menu_key in menu_merges: menu_merges[menu_key] = [] menu_merges[menu_key].append(merge_id) def get_menu_funcs(menu_key, base_path): append_func = lambda widget, name: \ append_menu_item(menu_key, base_path, widget, name) clear_func = lambda: clear_menu(menu_key) return append_func, clear_func for ui_name, base_path in (("view_menu", "/MenuBar/ViewMenu"), ("file_menu", "/MenuBar/FileMenu"), ("edit_menu", "/MenuBar/EditMenu"), ("export_menu", "/MenuBar/FileMenu/ExportMenu")): append_func, clear_func = get_menu_funcs(ui_name, base_path) self.settings.register_ui_section(ui_name, append_func, clear_func) self.settings.register_ui("file_menu", "Quit", self.gui.get_object("Quit"), 100) self.settings.register_ui("file_menu", "QuitSeparator", None, 95) self.settings.register_ui("main_window", "Main", self.menubar, -100) # initialize plugins self.plugin_manager = pycam.Plugins.PluginManager(core=self.settings) self.plugin_manager.import_plugins() # some more initialization self.reset_preferences() # TODO: preferences are not loaded until the new format is stable #self.load_preferences() #self.load_task_settings() self.settings.register_event("notify-file-saved", self.add_to_recent_file_list) self.settings.register_event("notify-file-opened", self.add_to_recent_file_list) # fallback - in case of a failure when opening a model file model = pycam.Importers.TestModel.get_test_model() self.settings.get("models").add_model(model, "Tiny pyramid") # Without this "gkt.main_iteration" loop the task settings file # control would not be updated in time. while gtk.events_pending(): gtk.main_iteration() autoload_task_filename = self.settings.get( "default_task_settings_file") if autoload_task_filename: self.open_task_settings_file(autoload_task_filename) self.update_all_controls() self.no_dialog = no_dialog if not self.no_dialog: # register a logging handler for displaying error messages pycam.Utils.log.add_gtk_gui(self.window, logging.ERROR) self.window.show()
if cwd: kws['directory'] = cwd self.vte_fork_running = True self.vte_child_exit_status = None # In earlier python-vte versions, # - the environment had to be passed as a sequence of strings # ("FOO=1", "BAR=2") (GNOME bug 583078) # - directory keyword could not be set to None (GNOME bug 583129) # The bugs have been fixed, but for compatibility reasons the old # compatibility code is still in place. self.child_pid = self.terminal.fork_command(command=command[0], argv=command, **kws) while self.vte_fork_running: gtk.main_iteration() if self.quit: raise ExitRequestedException() self.child_pid = None if os.WIFEXITED(self.vte_child_exit_status): rc = os.WEXITSTATUS(self.vte_child_exit_status) elif os.WIFSIGNALED(self.vte_child_exit_status): raise CommandError( _('%(command)s died with signal %(rc)s') % { 'command': short_command, 'rc': os.WTERMSIG(self.vte_child_exit_status) }) if rc: raise CommandError( _('%(command)s returned with an error code (%(rc)s)') % {
def load_clicked(self, widget, data=None): if self.cbfilter.get_model()[self.cbfilter.get_active()][0] == ( _("Please select site")): self.progressbar.set_text(_("Please select site")) return stored = None dups = None partial = None errs = None ttime = None # Does the lock acquisition need to be more sophisticated for multiple dirs? # (see comment above about what to do if pipe already open) if self.settings['global_lock'].acquire( wait=False, source="GuiBulkImport" ): # returns false immediately if lock not acquired #try: self.progressbar.set_text(_("Importing")) self.progressbar.pulse() while gtk.events_pending( ): # see http://faq.pygtk.org/index.py?req=index for more hints (3.7) gtk.main_iteration(False) self.timer = gobject.timeout_add(100, self.dopulse) # get the dir to import from the chooser selected = self.chooser.get_filenames() # get the import settings from the gui and save in the importer self.importer.setHandCount(int(self.spin_hands.get_text())) self.importer.setQuiet(self.chk_st_st.get_active()) self.importer.setThreads(int(self.spin_threads.get_text())) self.importer.setHandsInDB(self.n_hands_in_db) cb_model = self.cb_dropindexes.get_model() cb_index = self.cb_dropindexes.get_active() cb_hmodel = self.cb_drophudcache.get_model() cb_hindex = self.cb_drophudcache.get_active() #self.lab_info.set_markup('<span foreground="blue">Importing ...</span>') # uses pango markup! if cb_index: self.importer.setDropIndexes(cb_model[cb_index][0]) else: self.importer.setDropIndexes("auto") if cb_hindex: self.importer.setDropHudCache(cb_hmodel[cb_hindex][0]) else: self.importer.setDropHudCache("auto") sitename = self.cbfilter.get_model()[self.cbfilter.get_active()][0] #self.importer.setFailOnError(self.chk_fail.get_active()) if self.is_archive.get_active(): if sitename == "PokerStars": self.importer.setStarsArchive(True) if sitename == "Full Tilt Poker": self.importer.setFTPArchive(True) for selection in selected: self.importer.addBulkImportImportFileOrDir(selection, site=sitename) self.importer.setCallHud(self.cb_testmode.get_active()) self.importer.bHudTest = self.cb_testmode.get_active() starttime = time() # try: (stored, dups, partial, errs, ttime) = self.importer.runImport() # except: # print "*** EXCEPTION DURING BULKIMPORT!!!" # raise Exceptions.FpdbError # finally: gobject.source_remove(self.timer) ttime = time() - starttime if ttime == 0: ttime = 1 completionMessage = _('Bulk import done: Stored: %d, Duplicates: %d, Partial: %d, Errors: %d, Time: %s seconds, Stored/second: %.0f')\ % (stored, dups, partial, errs, ttime, (stored+0.0) / ttime) print completionMessage log.info(completionMessage) self.importer.clearFileList() if self.n_hands_in_db == 0 and stored > 0: self.cb_dropindexes.set_sensitive(True) self.cb_dropindexes.set_active(0) self.lab_drop.set_sensitive(True) self.cb_drophudcache.set_sensitive(True) self.cb_drophudcache.set_active(0) self.lab_hdrop.set_sensitive(True) self.progressbar.set_text(_("Import Complete")) self.progressbar.set_fraction(0) #except: #err = traceback.extract_tb(sys.exc_info()[2])[-1] #print "*** BulkImport Error: "+err[2]+"("+str(err[1])+"): "+str(sys.exc_info()[1]) #self.settings['global_lock'].release() self.settings['global_lock'].release() else: print _("bulk import aborted - global lock not available")
def gtk_main_tick(): if gtk2compat.USE_GTK3: # FIXME: use something better return while gtk.events_pending(): gtk.main_iteration(False)
def handle_error(self, module, phase, nextphase, error, altphases): summary = _('Error during phase %(phase)s of %(module)s') % { 'phase': phase, 'module': module.name } try: error_message = error.args[0] self.message('%s: %s' % (summary, error_message)) except: error_message = None self.message(summary) if not self.is_active(): self.set_urgency_hint(True) self.notify.notify(summary=summary, body=error_message, icon=gtk.STOCK_DIALOG_ERROR, expire=5) self.error_label.set_markup('<b>%s</b>' % _(summary)) self.error_resolution_model.clear() iter = self.error_resolution_model.append( ('<i>%s</i>' % _('Pick an Action'), '')) self.error_resolution_model.append(('', '')) self.error_resolution_model.append( (_('Rerun phase %s') % phase, phase)) if nextphase: self.error_resolution_model.append( (_('Ignore error and continue to %s') % nextphase, nextphase)) else: self.error_resolution_model.append( (_('Ignore error and continue to next module'), '_done')) self.error_resolution_model.append((_('Give up on module'), 'fail')) for altphase in altphases: try: altphase_label = _( getattr(getattr(module, 'do_' + altphase), 'label')) except AttributeError: altphase_label = altphase self.error_resolution_model.append( (_('Go to phase "%s"') % altphase_label, altphase)) self.error_resolution_model.append(('', '')) self.error_resolution_model.append((_('Open Terminal'), 'shell')) self.error_combo.set_active_iter(iter) self.error_hbox.set_sensitive(True) self.error_hbox.show_all() self.error_resolution = None while True: self.error_resolution = None while gtk.events_pending(): gtk.main_iteration() if self.quit: return 'fail' if not self.error_resolution: continue self.set_urgency_hint(False) if self.error_resolution == 'shell': # set back combobox to "Pick an action" self.error_combo.set_active_iter(iter) if os.fork() == 0: cmd = [ 'gnome-terminal', '--working-directory', module.get_builddir(self) ] os.execvp('gnome-terminal', cmd) sys.exit(0) continue if self.error_resolution == '_done': self.error_resolution = None # keep the error hox visible during all of this module duration self.error_hbox.set_sensitive(False) return self.error_resolution