def fetch_opml(url): try: outline = opml.parse(url) except IOError: print_d("Failed opening OPML %s" % url) return [] GObject.idle_add(lambda: update_feeds([x.xmlUrl for x in outline]))
def set_blinking(self, blinking): self.blinking = blinking if blinking and self.tick_id == 0: GObject.idle_add(self._blink_idle) elif self.tick_id > 0: self.stop_blinking = True
def find_books(self, search_text): if _NEW_TOOLBAR_SUPPORT: self.enable_button(False) else: self._books_toolbar.enable_button(False) self.clear_downloaded_bytes() textbuffer = self.textview.get_buffer() textbuffer.set_text(_('Performing lookup, please wait') + '...') self.book_selected = False self.ls.clear() search_tuple = search_text.lower().split() if len(search_tuple) == 0: self._alert(_('Error'), _('You must enter at least one search word.')) if _NEW_TOOLBAR_SUPPORT: self.search_entry.grab_focus() else: self._books_toolbar.search_entry.grab_focus() return FL = urllib.quote('fl[]') SORT = urllib.quote('sort[]') self.search_url = 'http://www.archive.org/advancedsearch.php?q=' + \ urllib.quote('(title:(' + search_text.lower() + ') OR creator:(' + search_text.lower() +')) AND format:(DJVU)') self.search_url += '&' + FL + '=creator&' + FL + '=description&' + FL + '=format&' + FL + '=identifier&' \ + FL + '=language' self.search_url += '&' + FL + '=publisher&' + FL + '=subject&' + FL + '=title&' + FL + '=volume' self.search_url += '&' + SORT + '=title&' + SORT + '&' + SORT + '=&rows=500&save=yes&fmt=csv&xmlsearch=Search' GObject.idle_add(self.download_csv, self.search_url)
def buffer_icons(self): def buffer_icons(): #~ print "Buffering icons ..." #t0 = GObject.get_current_time() if self.current_matches is None: return False db = self.db.xapiandb for m in self.current_matches: doc = db.get_document(m.docid) # calling get_icon is enough to cache the icon self.get_icon(doc) while Gtk.events_pending(): Gtk.main_iteration() #~ import sys #~ t_lapsed = round(GObject.get_current_time() - t0, 3) #~ print "Appstore buffered icons in %s seconds" % t_lapsed #from softwarecenter.utils import get_nice_size #~ cache_size = get_nice_size(sys.getsizeof(_app_icon_cache)) #~ print "Number of icons in cache: %s consuming: %sb" % ( #~ len(_app_icon_cache), cache_size) return False # remove from sources on completion if self.current_matches is not None: GObject.idle_add(buffer_icons)
def on_realized(self, widget, data=None): if self.blinking and self.tick_id == 0: GObject.idle_add(self._blink_idle) trackers.con_tracker_get().disconnect(self, "realize", self.on_realized)
def __init__(self, window): Gtk.Dialog.__init__(self, _('Edit archive'), window, Gtk.DialogFlags.MODAL, (Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL)) self.kill = False # Dialog is killed. self.file_handler = window.file_handler self._window = window self._save_button = self.add_button(Gtk.STOCK_SAVE_AS, Gtk.ResponseType.OK) # There is no stock response for "import", but by using # RESPONSE_HELP we automatically get the button placed at the left. self._import_button = self.add_button(_('Import'), Gtk.ResponseType.HELP) self._import_button.set_image(Gtk.Image.new_from_stock(Gtk.STOCK_ADD, Gtk.IconSize.BUTTON)) self.set_border_width(4) self.resize(min(Gdk.Screen.get_default().get_width() - 50, 750), min(Gdk.Screen.get_default().get_height() - 50, 600)) self.connect('response', self._response) self._image_area = _ImageArea(self) self._other_area = _OtherArea(self) notebook = Gtk.Notebook() notebook.set_border_width(6) notebook.append_page(self._image_area, Gtk.Label(label=_('Images'))) notebook.append_page(self._other_area, Gtk.Label(label=_('Other files'))) self.vbox.pack_start(notebook, True, True, 0) self.show_all() GObject.idle_add(self._load_original_files)
def checkFiles( self ): for monitored in self.monitoredFiles: if monitored.hasChanged(): if monitored.args: GObject.idle_add( monitored.callback, monitored.args ) else: GObject.idle_add( monitored.callback )
def __init__(self): #self.radio = tea5767() self.player = player() self.load = False self.defaullt = "/data/media/Music" self.config = configparser.ConfigParser() self.config.read('config.ini') interface = gtk.Builder() interface.add_from_file('./interface/interface.glade') self.volume = interface.get_object("volume") self.progression = interface.get_object("progression") self.music = interface.get_object("music") self.artiste = interface.get_object("artiste") self.cover = interface.get_object("pochette") self.mode = interface.get_object("mode") self.freq = interface.get_object("scale1") self.deroul = interface.get_object("liststore1") self.folder = interface.get_object("filechooserbutton1") self.tab = interface.get_object('notebook1') self.on_notebook1_switch_page(self.tab, None,self.tab.get_current_page()) self.fullScreen = interface.get_object("main") interface.connect_signals(self) gobject.idle_add(self.test) if True:#(self.config["player"]["last"] != self.defaullt) time.sleep(2) self.player.new_folder(self.defaullt) self.config["player"]["last"] = self.defaullt with open("./config.ini", 'w') as configfile: # save self.config.write(configfile)
def __init__(self): GObject.GObject.__init__(self) self.connected = False # check is ONECONF_NET_CONNECTED is in the environment variables # if so force the network status to be connected or disconnected if "ONECONF_NET_CONNECTED" in os.environ: if os.environ["ONECONF_NET_CONNECTED"].lower() == 'true': GObject.idle_add(self._on_connection_state_changed, self.NM_STATE_CONNECTED_LOCAL) LOG.warn('forced netstate into connected mode...') else: GObject.idle_add(self._on_connection_state_changed, self.NM_STATE_DISCONNECTED) LOG.warn('forced netstate into disconnected mode...') return try: bus = dbus.SystemBus() nm = bus.get_object('org.freedesktop.NetworkManager', '/org/freedesktop/NetworkManager') nm.connect_to_signal("StateChanged", self._on_connection_state_changed) network_state = nm.state(dbus_interface='org.freedesktop.NetworkManager') self._on_connection_state_changed(network_state) except Exception as e: LOG.warn("failed to init network state watcher '%s'" % e) self._on_connection_state_changed(self.NM_STATE_UNKNOWN)
def fullscreen(self): """ Makes the window fullscreen. """ if not self.is_fullscreen: GObject.idle_add(self.main.set_resizable, True) GObject.idle_add(self.main.fullscreen) self.is_fullscreen = True
def unfullscreen(self): """ Unfullscreens the window """ if self.is_fullscreen: GObject.idle_add(self.main.set_resizable, False) GObject.idle_add(self.main.unfullscreen) self.is_fullscreen = False
def on_changed(self, *args): text = self.get_text().strip()[:self.get_max_length()] new_pos = 0 new_text = '' for c in text: if c in '0123456789-+': print('C:',c,new_text) if new_pos != 0 and c in ('-','+'): continue new_text += c new_pos += 1 if new_text: cur_pos = self.get_position() if new_pos - cur_pos > 2: new_pos = cur_pos self.handler_block_by_func(self.on_changed) print('new-text:',new_text) if len(new_text) > 1 or not new_text[0] in ('-','+'): if int(new_text) > self._max: new_text = str(self._max) if len(new_text) > 1 or not new_text[0] in ('-','+'): if int(new_text) < self._min: new_text = str(self._min) self.set_text(new_text) self.handler_unblock_by_func(self.on_changed) GObject.idle_add(self.set_position, new_pos) else: self.set_text(new_text) self.stop_emission("changed")
def on_changed(self, *args): text = self.get_text().strip()[:self.get_max_length()] new_pos = 0 new_text = '' for c in text: if c in '0123456789:+-': if new_pos in (2,5): if c != ':': new_text += ':' + c new_pos += 1 else: new_text += c else: if new_pos == 8: if c in ('-','+'): new_text += c else: if c != ':': new_text += c new_pos += 1 if new_text: cur_pos = self.get_position() if new_pos - cur_pos > 2: new_pos = cur_pos self.handler_block_by_func(self.on_changed) self.set_text(new_text) self.handler_unblock_by_func(self.on_changed) GObject.idle_add(self.set_position, new_pos) else: self.set_text(new_text) self.stop_emission("changed")
def __init__(self, handle): super(PhysicsActivity, self).__init__(handle) self.metadata['mime_type'] = 'application/x-physics-activity' self.add_events(Gdk.EventMask.ALL_EVENTS_MASK | Gdk.EventMask.VISIBILITY_NOTIFY_MASK) self.connect('visibility-notify-event', self._focus_event) self.connect('window-state-event', self._window_event) self.game_canvas = sugargame.canvas.PygameCanvas(self) self.game = physics.main(self) self.preview = None self._sample_window = None self._fixed = Gtk.Fixed() self._fixed.put(self.game_canvas, 0, 0) w = Gdk.Screen.width() h = Gdk.Screen.height() - 2 * GRID_CELL_SIZE self.game_canvas.set_size_request(w, h) self._constructors = {} self.build_toolbar() self.set_canvas(self._fixed) Gdk.Screen.get_default().connect('size-changed', self.__configure_cb) logging.debug(os.path.join( activity.get_activity_root(), 'data', 'data')) self.game_canvas.run_pygame(self.game.run) GObject.idle_add(self._setup_sharing) self.show_all()
def update_progress(self, fail=False, done=False, pulse=False, total=0,current=0,message=""): if(pulse): Gdk.threads_enter() self.label.set_label(message) Gdk.threads_leave() self.do_progress_pulse(message) return if(done): # cool, finished :D self.should_pulse = False self.done = done Gdk.threads_enter() self.progress.set_fraction(1) self.label.set_label(message) GObject.idle_add(self.go_quit) Gdk.threads_leave() return self.should_pulse = False _total = float(total) _current = float(current) pct = float(_current/_total) szPct = int(pct) # thread block Gdk.threads_enter() self.progress.set_fraction(pct) self.label.set_label(message) Gdk.threads_leave()
def start_ponder(self, pondermove, movelist, cmove): startpos = gv.gshogi.get_startpos() # if not startpos must be sfen if startpos != "startpos": startpos = "sfen " + startpos ml = "" for move in movelist: ml = ml + move + " " # if ml == "": # print "error empty movelist in ponder in usi.py" # return ml = ml.strip() ml = ml + " " + cmove + " " + pondermove ml = ml.strip() # create the position string with the ponder move added b = "position " + startpos + " moves " + ml + "\n" # Send the board position to the engine self.command(b) pondercmd = "go ponder" + self.gocmnd[2:] self.command(pondercmd + "\n") # clear the engine output window ready for next move GObject.idle_add( self.engine_output.clear, self.side, self.get_running_engine().strip()) return
def _save_selected_subtitle (self): cursor = Gdk.Cursor.new (Gdk.CursorType.WATCH) self._dialog.get_window ().set_cursor (cursor) model, rows = self._tree_view.get_selection ().get_selected_rows () if rows: subtitle_iter = model.get_iter (rows[0]) subtitle_id = model.get_value (subtitle_iter, 3) subtitle_format = model.get_value (subtitle_iter, 1) bpath = self._cache_subtitles_dir() directory = Gio.file_new_for_path (bpath) try: directory.make_directory_with_parents (None); except: pass thread = DownloadThread (self._model, subtitle_id) thread.start () GObject.idle_add (self._save_subtitles, thread, subtitle_format) self._progress.set_text (_(u'Downloading the subtitles…')) GObject.timeout_add (350, self._progress_bar_increment, thread) else: #warn user! pass
def on_tab_switch(self, notebook, page, page_num, data=None): """Do the real work for a tab switch""" tabs_last_active_term = data['tabs_last_active_term'] if tabs_last_active_term: term = self.terminator.find_terminal_by_uuid(tabs_last_active_term.urn) GObject.idle_add(term.ensure_visible_and_focussed) return True
def read_stdout(self): while True: try: e = ("<-" + self.side + "(" + self.get_running_engine().strip() + "):") self.p.stdout.flush() line = self.p.stdout.readline() if line == "": if gv.verbose: print e + "eof reached" if gv.verbose: print e + "stderr:", self.p.stderr.read() break line = line.strip() if gv.verbose or gv.verbose_usi: print e + line GObject.idle_add(self.engine_debug.add_to_log, e+line) if line.startswith("info"): GObject.idle_add( self.engine_output.add_to_log, self.side, self.get_running_engine().strip(), line) self.op.append(line) except Exception, e: # line = e + "error" print "subprocess error in usi.py read_stdout:", e
def wait_idle(self): with self.condition: def notify(): with self.condition: self.condition.notify() GObject.idle_add(notify) self.condition.wait()
def isRedundant(self, path): if not self.symlinks.get_active() or not os.path.islink(path) or not os.path.isdir(path): return False else: if os.path.realpath(path) in self.dirs: GObject.idle_add(self.setStatusText, "Skipping " + path + " - direcotry already searched") return True
def updateText(self, selection, filesize): if selection: self.window.set_icon(selection[0]) self.text = htmlentitydecode(selection[1]) + "\n" + selection[2] + "\n" if selection[3]: self.text += "Length: " + selection[3] + "\n" if selection[4]: self.text += "This is a " + selection[4] + " file.\n" if filesize: self.text += "File size: " + filesize + "\n" if selection[5]: self.text += "Comment:\n" + selection[5] + "\n" if selection[6]: self.text += "Released:\n" + selection[6] + "\n" if selection[7]: self.text += "Modified:\n" + selection[7] + "\n" if selection[8]: self.text += "This links to:\n" + selection[8] + "\n\n" if selection[9]: self.text += "This file is at:\n" +selection[9] + "\n\n" if selection[10]: self.text += "Price:\n" + selection[10] + "\n\n" if selection[11]: self.text += "id:" + selection[11] GObject.idle_add(self.settext, self.text);
def update(self): # update liststore self.liststore.clear() self.liststore.append(("0.", _("Start Pos"), " ")) mvstr = engine.getmovelist() if mvstr != "": mlst = mvstr.split(",") moveno = 1 for m in mlst: (capture, ispromoted, move) = m.split(";") if move.find("*") == -1: m1 = move[0:3] m2 = move[3:] move = m1 + capture + m2 if ispromoted == "+": move = "+" + move comment = self.comments.get_comment(moveno) if comment != "": cind = "..." else: cind = " " e = str(moveno) + ".", move, cind self.liststore.append(e) moveno += 1 GObject.idle_add(self.scroll_to_end)
def clicked(self, key): ''' This function is called in response to a menu_item click. Fire away. ''' x = self.services[key] GObject.idle_add(self.emit, "connect", (x.name, x.address, x.port, x))
def start(self): """Starts the Clutter main event loop and sets our kernel startup routine. """ # Register our function to initiate the kernel and start Clutter GObject.idle_add(self._wire_kernel) Clutter.init([]) Clutter.main()
def __key_press_event(self, widget, event): """ Tabulador Inteligente. """ if event.keyval == 65421: buffer = self.get_buffer() textmark = buffer.get_insert() textiter = buffer.get_iter_at_mark(textmark) id = textiter.get_line() line_iter = buffer.get_iter_at_line(id) chars = line_iter.get_chars_in_line() if chars > 3: ### Ultimo caracter. start_iter = buffer.get_iter_at_line_offset(id, chars-2) end_iter = buffer.get_iter_at_line_offset(id, chars-1) texto = buffer.get_text(start_iter, end_iter, True) if texto == ":": ### Tola la linea. line_end_iter = buffer.get_iter_at_line_offset(id, chars-1) texto = buffer.get_text(line_iter, line_end_iter, True) tabs = 0 if texto.startswith(self.tab): tabs = len(texto.split(self.tab))-1 GObject.idle_add(self.__forzar_identacion, tabs+1)
def list_periodic_refresher(): while True: # Trying to update the GTK GUI from a thread causes # a segmentation fault - this is the proper way to do it if self.in_list_mode: GObject.idle_add(self.refresh_list) sleep(15)
def _button_release_cb(win, event, sw): if sw.press == None: return True for i in range (0,4): if sw.press == sw.buttons_off[i].spr: sw.buttons_on[i].draw_sprite(1500) GObject.idle_add(__play_sound_cb, sw.sound_files[i], sw.sound) GObject.timeout_add(500,sw.buttons_on[i].spr.hide) if sw.playpushed is False: sw.press = None return if sw.seq[sw.counter] == i: # correct reponse sw.counter += 1 if sw.counter == sw.level*2: GObject.timeout_add(1000, _dance, sw, [i], 10, 0) sw.counter = 0 sw.level += 1 sw.activity.level_label.set_text( "%s %d" % (_("Level"),sw.level)) if sw.level*2 < len(sw.seq): GObject.timeout_add(3000, play_the_game, sw) else: # game over GObject.timeout_add(2000, _flash, sw, 7, True) sw.playpushed = False sw.level = 1 sw.seq = gen_seq(30) sw.activity.level_label.set_text( "%s %d" % (_("Level"),sw.level)) else: # incorrect response _all_gone(sw) GObject.timeout_add(1000, _all_off, sw) sw.counter = 0 sw.press = None
def start_profiling_cb(self, action): if getattr(self, 'profiler_active', False): self.profiler_active = False return def doit(): import cProfile profile = cProfile.Profile() self.profiler_active = True logger.info('--- GUI Profiling starts ---') while self.profiler_active: profile.runcall(Gtk.main_iteration_do, False) if not Gtk.events_pending(): time.sleep(0.050) # ugly trick to remove "user does nothing" from profile logger.info('--- GUI Profiling ends ---') profile.dump_stats('profile_fromgui.pstats') logger.debug('profile written to mypaint_profile.pstats') if os.path.exists("profile_fromgui.png"): os.unlink("profile_fromgui.png") os.system('gprof2dot.py -f pstats profile_fromgui.pstats | dot -Tpng -o profile_fromgui.png') if os.path.exists("profile_fromgui.png"): os.system('xdg-open profile_fromgui.png &') GObject.idle_add(doit)
def deferred_set_rough_geometry_hints(self): # no parameters are used in set_rough_geometry_hints, so we can # use the set_rough_geometry_hints if self.pending_set_rough_geometry_hint == True: return self.pending_set_rough_geometry_hint = True GObject.idle_add(self.do_deferred_set_rough_geometry_hints)
def update_object(): if event.obj: GObject.idle_add(self.hosts_sidebar.update_object, event.obj) host_count, service_count, vuln_count = self.update_counts() GObject.idle_add(self.statusbar.update_ws_info, host_count, service_count, vuln_count)
def _merge_cache_info(self, cache_installed, collect_type): self._resolve_id_for_collection(collect_type) collect_install = cache_installed[collect_type] collect_online = self.cache_object[collect_type] cache_folder = self.get_cache_folder(collect_type) used_thumbs = [] for pkg_id in collect_install: if not pkg_id in collect_online: collect_online[pkg_id] = collect_install[pkg_id] else: data_install = collect_install[pkg_id] data_online = collect_online[pkg_id] for key in data_install: if not key in data_online: data_online[key] = data_install[key] data_online["hide-configuration"] = data_install[ "hide-configuration"] data_online["settings-type"] = data_install["settings-type"] data_online["ext-setting-app"] = data_install[ "ext-setting-app"] data_online["schema-file"] = data_install["schema-file"] data_online["installed-folder"] = data_install[ "installed-folder"] data_online["install-edited"] = data_install["install-edited"] data_online["max-instances"] = data_install["max-instances"] if data_install["icon"]: data_online["icon"] = data_install["icon"] for pkg_id in collect_online: data_online = collect_online[pkg_id] try: data_online["score"] = int(data_online["score"]) except Exception: data_online["score"] = 0 try: data_online["max-instances"] = int( data_online["max-instances"]) except Exception: data_online["max-instances"] = 1 try: data_online["spices-show"] = "'%s/%ss/view/%s'" % ( URL_SPICES_HOME, collect_type, data_online["spices-id"]) except KeyError: data_online["spices-show"] = "" except ValueError: data_online["spices-show"] = "" self._fix_last_edited(data_online) data_online["uuid"] = str(pkg_id) icon_path = "" if data_online["icon-filename"]: icon_basename = data_online["icon-filename"] used_thumbs.append(icon_basename) icon_path = os.path.join(cache_folder, icon_basename) if not pkg_id in collect_install: if icon_path: data_online["icon"] = icon_path data_online["settings-type"] = SETTING_TYPE_NONE data_online["ext-setting-app"] = "" data_online["schema-file"] = "" data_online["installed-folder"] = "" data_online["collection"] = collect_type data_online["install-edited"] = -1 data_online["max-instances"] = 1 data_online["installed-type"] = 0 else: can_update = data_online[ "install-edited"] != -1 and data_online[ "install-edited"] < data_online["last-edited"] if can_update: data_online["installed-type"] = 2 else: data_online["installed-type"] = 1 if not data_online["icon"]: data_online["icon"] = "cs-%ss" % (collect_type) if data_online["install-edited"] > 0: data_online["install-ver"] = datetime.datetime.fromtimestamp( data_online["install-edited"]).strftime( "%Y-%m-%d\n%H:%M:%S") else: data_online["install-ver"] = "" if data_online["last-edited"] > 0: data_online["last-ver"] = datetime.datetime.fromtimestamp( data_online["last-edited"]).strftime("%Y-%m-%d\n%H:%M:%S") else: data_online["last-ver"] = "" GObject.idle_add(self._cleanup_obsolete_thumbs, used_thumbs, cache_folder)
def get_regcode_thread(window): safe_id = get_safe_id() if get_regcode(safe_id): GObject.idle_add(update_window, window)
def _calculate_apt_changes(task): global _apt_cache_lock apt_cache = get_apt_cache() with _apt_cache_lock: apt_cache.clear() print("MintInstall: Calculating changes required for APT package: %s" % task.pkginfo.name) pkginfo = task.pkginfo aptpkg = apt_cache[pkginfo.name] try: if aptpkg.is_installed: aptpkg.mark_delete(True, True) else: aptpkg.mark_install() except: if aptpkg.name not in BROKEN_PACKAGES: BROKEN_PACKAGES.append(aptpkg.name) changes = apt_cache.get_changes() for pkg in changes: if pkg.marked_install: task.to_install.append(pkg.name) elif pkg.marked_upgrade: task.to_update.append(pkg.name) elif pkg.marked_delete: task.to_remove.append(pkg.name) task.download_size = apt_cache.required_download space = apt_cache.required_space if space < 0: task.freed_size = space * -1 task.install_size = 0 else: task.freed_size = 0 task.install_size = space for pkg_name in task.to_remove: if _is_critical_package(apt_cache[pkg_name]): print("MintInstall: apt - cannot remove critical package: %s" % pkg_name) task.info_ready_status = task.STATUS_FORBIDDEN if aptpkg.name in BROKEN_PACKAGES: print( "MintInstall: apt- cannot execute task, package is broken: %s" % aptpkg.name) task.info_ready_status = task.STATUS_BROKEN print("For install:", task.to_install) print("For removal:", task.to_remove) print("For upgrade:", task.to_update) if task.info_ready_status not in (task.STATUS_FORBIDDEN, task.STATUS_BROKEN): task.info_ready_status = task.STATUS_OK task.execute = execute_transaction GObject.idle_add(task.info_ready_callback, task)
def runthread(): # Called in other thread returned = getimage.savefromPIL( getimage.getimage_2(self.listbundle), "bundle-mosaic.png") # Add GObject.idle_add(finished, returned)
def emit(self, *args): GObject.idle_add(GObject.GObject.emit, self, *args)
def halt(self): if getattr(self, 'pipeline', False): self.pipeline.set_state(Gst.State.NULL) del self.pipeline _log.info('Quitting MainLoop gracefully...') GObject.idle_add(self._loop.quit)
def lost_connection_to_server_event(): GObject.idle_add(self.lost_db_connection, event.problem, self.handle_connection_lost, self.force_change_couch_url) GObject.idle_add(self.reload_workspaces_no_connection)
def normal_error_event(): GObject.idle_add(self.show_normal_error, event.text)
def workspace_not_accessible_event(): GObject.idle_add(self.handle_no_active_workspace)
def new_notification_event(): self.notificationsModel.prepend([str(event)]) GObject.idle_add(self.statusbar.inc_notif_button_label) host_count, service_count, vuln_count = self.update_counts() GObject.idle_add(self.statusbar.update_ws_info, host_count, service_count, vuln_count)
def important_error_event(): GObject.idle_add(self.show_important_error, event)
def new_log_event(): GObject.idle_add(self.console_log.customEvent, event.text)
def workspace_changed_event(): self.serverIO.active_workspace = event.workspace.name host_count, service_count, vuln_count = self.update_counts() total_host_amount = self.serverIO.get_hosts_number() first_host_page = self.serverIO.get_hosts(page='1', page_size='20', sort='vulns', sort_dir='desc') total_host_amount = self.serverIO.get_workspace_numbers()[0] GObject.idle_add(self.statusbar.set_workspace_label, event.workspace.name) GObject.idle_add( self.hosts_sidebar.reset_model_after_workspace_changed, first_host_page, total_host_amount) GObject.idle_add(self.statusbar.update_ws_info, host_count, service_count, vuln_count) GObject.idle_add(self.statusbar.set_default_conflict_label) GObject.idle_add(self.statusbar.set_default_conflict_label) GObject.idle_add(self.select_active_workspace)
def exit_faraday(self, button=None, parent=None): """A simple exit which will ask for confirmation.""" if not self.window.do_delete_event(parent): if parent is not None: GObject.idle_add(parent.destroy) GObject.idle_add(self.window.destroy)
def new_conflict_event(): GObject.idle_add(self.statusbar.update_conflict_button_label, event.nconflicts)
def lost_db_connection(self, explanatory_message=None, handle_connection_lost=None, connect_to_a_different_couch=None): """Creates a simple dialog with an error message to inform the user some kind of problem has happened and the connection was lost. Returns whether the login dialog should be shown or not """ # NOTE: if we start faraday without CouchDB, both the signal coming # from CouchDB manager AND our test in do_activate will try # to raise the dialog. This avoids more than one dialog to be raised. if self.lost_connection_dialog_raised: return False def do_nothing_on_key_stroke(event, key): """Do nothing except return True""" return True self.lost_connection_dialog_raised = True if explanatory_message and isinstance(explanatory_message, basestring): explanation = "\n The specific error was: " + explanatory_message else: explanation = "" dialog = Gtk.MessageDialog( self.window, 0, Gtk.MessageType.ERROR, Gtk.ButtonsType.NONE, "The client can't connect to Faraday Server. " "You can try to reconnect to the last URL " "you set up, change it or exit Faraday " "until you fix the problem. \n" "For more information about Faraday Server " "please refer to the Faraday Github Wiki. \n " + explanation) dialog.set_deletable(False) dialog.set_modal(True) dialog.connect("key_press_event", do_nothing_on_key_stroke) retry_button = dialog.add_button("Retry connection?", 42) retry_button.connect("clicked", handle_connection_lost, dialog) change_couch_url = dialog.add_button("Change server IP?", 43) change_couch_url.connect("clicked", connect_to_a_different_couch, dialog) cancel_button = dialog.add_button("Exit Faraday", 0) cancel_button.connect("clicked", self.on_quit) if hasattr(self, 'force_new_workspace_dialog'): # The dialog to create a new workspace is open. Lets close it new_workspace_dialog = getattr(self, 'force_new_workspace_dialog') new_workspace_dialog.destroy() setattr(self, 'force_new_workspace_dialog', None) response = dialog.run() if response == Gtk.ResponseType.DELETE_EVENT: GObject.idle_add(self.exit_faraday_without_confirm) elif response in [0, 42, 43]: return False return True
def delete_notifications(self): """Clear the notifications model of all info, also send a signal to get the notification label to 0 on the main window's button """ self.notificationsModel.clear() GObject.idle_add(self.statusbar.set_default_notif_label)
def _keypress_cb(self, area, event): ''' Keypress ''' # Games 4, 5, and 6 use the keyboard print 'keypress event' if self.level not in [4, 5, 6]: return True k = Gdk.keyval_name(event.keyval) u = Gdk.keyval_to_unicode(event.keyval) if self._waiting_for_enter: if k == 'Return': self._waiting_for_enter = False self._panel.hide() self._counter += 1 self._correct = 0 GObject.timeout_add(1000, self.new_game, False) return if k in NOISE_KEYS or k in WHITE_SPACE: return True if self.level == 6 and self._waiting_for_delete: if k in ['BackSpace', 'Delete']: self._waiting_for_delete = False self._sticky_cards[self._correct].set_label_color('white') self._sticky_cards[self._correct].set_label(MSGS[ self._counter][self._sticky_cards[self._correct].type]) self._panel.hide() self._panel.set_label_color('black') return if k[0:5] == 'dead_': self._dead_key = k[5:] return if self.level == 6: n = len(MSGS[self._counter]) else: n = self._counter + 1 if self.level == 6: i = self._correct if self._dead_key is not None: k = DEAD_DICTS[DEAD_KEYS.index(self._dead_key)][k] self._dead_key = None elif k in PUNCTUATION: k = PUNCTUATION[k] elif k in SPECIAL: k = SPECIAL[k] elif len(k) > 1: return True if self._sticky_cards[i].labels[0] == k: self._sticky_cards[i].set_label_color('blue') self._sticky_cards[i].set_label(k) self._correct += 1 else: self._sticky_cards[i].set_label_color('red') self._sticky_cards[i].set_label(k) self._panel.set_label_color('red') self._panel.set_label(ALERTS[1]) self._panel.set_layer(PANEL_LAYER) self._waiting_for_delete = True play_audio_from_file( self, os.path.join(self._path, 'sounds', 'glass.ogg')) else: for i in range(n): if self._sticky_cards[i].labels[0] == k: self._sticky_cards[i].set_label('') self._sticky_cards[i].hide() break # Test for end condition if self.level == 6 and \ self._correct == len(MSGS[self._counter]) - \ MSGS[self._counter].count(' '): c = 0 for i in range(len(MSGS[self._counter])): if MSGS[self._counter][i] == ' ': continue elif MSGS[self._counter][i] != self._sticky_cards[c].labels[0]: return True c += 1 self._panel.set_label(ALERTS[0]) self._panel.set_layer(PANEL_LAYER) self._waiting_for_enter = True GObject.idle_add(play_audio_from_file, self, os.path.join(self._path, 'sounds', 'drip.ogg')) return else: for i in range(n): if len(self._sticky_cards[i].labels[0]) > 0: return True self._counter += 1 self._correct = 0 GObject.timeout_add(1000, self.new_game, False)
def exit(*args, **kwargs): logger.info( "Exit because there are no workspaces found, and user is not admin" ) GObject.idle_add(self.window.destroy) GObject.idle_add(self.on_quit)
def _do_start_service(self): # Network manager self.network_manager = g15network.NetworkManager(self) # Global plugins self.session_active = True self.global_plugins = g15pluginmanager.G15Plugins(None, self, network_manager=self.network_manager) self.global_plugins.start() for listener in self.service_listeners: listener.service_starting_up() # UINPUT try: g15uinput.open_devices() except OSError as e: logger.debug("Error opening uinput devices", exc_info=e) if e.errno == 13 or e.errno == 2: raise Exception( "Failed to open uinput devices. Do you have the uinput module loaded (try modprobe uinput), " "and are the permissions of /dev/uinput correct? " "If you have just installed Gnome15 for the first time, you may need to simply reboot.") else: raise self.session_bus = dbus.SessionBus() self.system_bus = dbus.SystemBus() # Create a screen for each device self.conf_client.add_dir("/apps/gnome15", gconf.ClientPreloadType.PRELOAD_NONE) logger.info("Looking for devices") if len(self.devices) == 0: if g15devices.have_udev and not self.exit_on_no_devices: logger.error("No devices found yet, waiting for some to appear") else: logger.error("No devices found. Gnome15 will now exit") self.shutdown() return else: # Create the default profile for all devices for device in self.devices: g15profile.create_default(device) # If there is a single device, it is enabled by default if len(self.devices) == 1: self.conf_client.set_bool("/apps/gnome15/%s/enabled" % self.devices[0].uid, True) errors = 0 for device in self.devices: val = self.conf_client.get("/apps/gnome15/%s/enabled" % device.uid) h = self.conf_client.notify_add("/apps/gnome15/%s/enabled" % device.uid, self._device_enabled_configuration_changed, device) self.device_notify_handles[device.uid] = h if (val is None and device.model_id != "virtual") or (val is not None and val.get_bool()): screen = self._add_screen(device) if not screen: errors += 1 if len(self.devices) == errors: logger.error("All screens failed to load. Shutting down") self.shutdown() return if len(self.screens) == 0: logger.warning("No screens found yet. Will stay running waiting for one to be enabled.") # Load hidden configuration and monitor for changes self._load_hidden_configuration() self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/scroll_delay", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/scroll_amount", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/animated_menus", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/animation_delay", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/key_hold_duration", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/use_x_test", self._hidden_configuration_changed)) self.notify_handles.append( self.conf_client.notify_add("/apps/gnome15/disable_svg_glow", self._hidden_configuration_changed)) # Monitor active application gobject.idle_add(self._configure_window_monitoring) # Activate global plugins self.global_plugins.activate() # Start each screen's plugin manager th = [] for screen in self.screens: t = StartThread(screen) if self.start_in_threads: t.start() else: t.run() th.append(t) if len(self.screens) == 1: if th[0].error is not None: raise th[0].error if self.start_in_threads: for t in th: t.join() self.starting_up = False for listener in self.service_listeners: listener.service_started_up() self.started = True gobject.idle_add(self._monitor_session) # Watch for devices changing g15devices.device_added_listeners.append(self._device_added) g15devices.device_removed_listeners.append(self._device_removed)
def create_layout(self, layout): """Apply layout configuration""" def child_compare(a, b): order_a = children[a]['order'] order_b = children[b]['order'] if (order_a == order_b): return 0 if (order_a < order_b): return -1 if (order_a > order_b): return 1 if not layout.has_key('children'): err('layout specifies no children: %s' % layout) return children = layout['children'] if len(children) <= 1: #Notebooks should have two or more children err('incorrect number of children for Notebook: %s' % layout) return num = 0 keys = children.keys() keys.sort(child_compare) for child_key in keys: child = children[child_key] dbg('Making a child of type: %s' % child['type']) if child['type'] == 'Terminal': pass elif child['type'] == 'VPaned': page = self.get_nth_page(num) self.split_axis(page, True) elif child['type'] == 'HPaned': page = self.get_nth_page(num) self.split_axis(page, False) num = num + 1 num = 0 for child_key in keys: page = self.get_nth_page(num) if not page: # This page does not yet exist, so make it self.newtab(children[child_key]) page = self.get_nth_page(num) if layout.has_key('labels'): labeltext = layout['labels'][num] if labeltext and labeltext != "None": label = self.get_tab_label(page) label.set_custom_label(labeltext) page.create_layout(children[child_key]) if layout.get('last_active_term', None): self.last_active_term[page] = make_uuid( layout['last_active_term'][num]) num = num + 1 if layout.has_key('active_page'): # Need to do it later, or layout changes result GObject.idle_add(self.set_current_page, int(layout['active_page'])) else: self.set_current_page(0)
def unreveal(self): if self.disabled: return GObject.idle_add(self.set_reveal_child, False)
def quit(self): """Exit the UI event loop.""" GObject.idle_add(Gtk.main_quit)
def on_edit_button_clicked(self, button): # The day's text is already in the editor. self.change_mode(preview=False) # Select (not only highlight) previously selected text by giving focus # to the day editor. GObject.idle_add(self.day_text_field.day_text_view.grab_focus)
def my_fn(*args, **kwargs): GObject.idle_add(fn, *args, **kwargs)
def importButton_clicked_cb(self, widget): """Callback executed when the user wants to import messages""" if self.currentProject is None: self.log.error("No project is open") return # retrieve symbol name symbolName = self._view.nameOfCreatedSymbolEntry.get_text() if symbolName is None or len(symbolName) < 1: self.displayErrorMessage(_("Specify the name of new symbol")) return found = False for symbol in self.currentProject.getVocabulary().getSymbols(): if symbol.getName() == symbolName: found = True break if found: self.displayErrorMessage( _("The provided symbol name already exists.")) return # Should we consider meta datas of excluded messages if self._view.removeDuplicatedMessagesCheckButton.get_active( ) and self._view.keepPropertiesOfDuplicatedMessagesCheckButton.get_active( ): # Retrieve the 'excluded' messages and retrieve their properties for message in self.excludedMessages: # search for an included message to register properties eq_message = None for importedMessage in self.importedMessages: if importedMessage.getStringData( ) == message.getStringData(): eq_message = importedMessage break if eq_message is not None: for property in message.getProperties(): eq_message.addExtraProperty(property) # We create a session with each message session = Session(str(uuid.uuid4()), "Session 1", "") for message in self.importedMessages: session.addMessage(message) # We register the session in the vocabulary of the project self.currentProject.getVocabulary().addSession(session) # We register each message in the vocabulary of the project for message in self.importedMessages: self.currentProject.getVocabulary().addMessage(message) message.setSession(session) # We create a default symbol dedicated for this symbol = Symbol(str(uuid.uuid4()), symbolName, self.currentProject) for message in self.importedMessages: symbol.addMessage(message) # We register the symbol in the vocabulary of the project self.currentProject.getVocabulary().addSymbol(symbol) # Add the environmental dependencies to the project # if fetchEnv: # project.getConfiguration().setVocabularyInferenceParameter(ProjectConfiguration.VOCABULARY_ENVIRONMENTAL_DEPENDENCIES, # self.envDeps.getEnvData()) # Computes current date date = datetime.now() description = "No description (yet not implemented)" # We also save the session and the messages in the workspace trace = ImportedTrace(str(uuid.uuid4()), date, self.importType, description, self.currentProject.getName()) trace.addSession(session) for message in self.importedMessages: trace.addMessage(message) self.currentWorkspace.addImportedTrace(trace) # Now we save the workspace self.currentWorkspace.saveConfigFile() self._view.destroy() if self.finish_cb is not None: GObject.idle_add(self.finish_cb)
def reveal(self): if self.disabled: return GObject.idle_add(self._reveal_idle_callback)
def clicked(self, service_name, address, port): """ This function is called in response to a menu_item click. Fire away. """ GObject.idle_add(self.emit, "connect", (service_name, address, port))
def destroy(self): import gc GObject.idle_add(lambda: gc.collect())