def _remove_scan_cb(self, widget): model, selection = self.scan_result.scan_result_notebook.scans_list.scans_list.get_selection().get_selected_rows() selected_refs = [] for path in selection: # Kill running scans and remove finished scans from the inventory. entry = model.get_value(model.get_iter(path), 0) if entry.running: self.cancel_scan(entry.command) try: # Remove it from the inventory if present. self.inventory.remove_scan(entry.parsed) except ValueError: pass # Create TreeRowReferences because those persist while we change the # model. selected_refs.append(gtk.TreeRowReference(model, path)) # Delete the entries from the ScansListStore. for ref in selected_refs: model.remove(model.get_iter(ref.get_path())) self.update_ui()
def initTreeModel(): """ Populate the TreeModel with data """ for folder in TLFolders: #Contains *all* folders # Handle Top level Folders with no folder children first if (folder.childState == False and folder.parentState == False): row = [folder, folder] parentIter = folderModel.append(None, row) path = folderModel.get_path(parentIter) treeRowRef = gtk.TreeRowReference(folderModel, path) folder.treeRowRef = treeRowRef children = folder.getPackages() for child in children: #Add children files to treeview row = [child, child] childIter = folderModel.append(parentIter, row) path = folderModel.get_path(childIter) treeRowRef = gtk.TreeRowReference(folderModel, path) child.treeRowRef = treeRowRef else: # Folders have folder children (an unknown amount unfortunately) (Recursive) #Add the parent folder to the treeview row = [folder, folder] if folder.parentState == False: #Top level parentIter = folderModel.append(None, row) path = folderModel.get_path(parentIter) treeRowRef = gtk.TreeRowReference(folderModel, path) folder.treeRowRef = treeRowRef # We will need this later to pack the children # in the treeview else: #child folder # We gotta find the stupid things parent row parent = folder.parent path = parent.treeRowRef.get_path() grandIter = folderModel.get_iter(path) parentIter = folderModel.append(grandIter, row) path = folderModel.get_path(parentIter) treeRowRef = gtk.TreeRowReference(folderModel, path) folder.treeRowRef = treeRowRef for subfile in folder.getPackages(): row = [subfile, subfile] FileIter = folderModel.append(parentIter, row) path = folderModel.get_path(FileIter) treeRowRef = gtk.TreeRowReference(folderModel, path) subfile.treeRowRef = treeRowRef # Top Level Files only for pfile in TLFiles: row = [pfile, pfile] parentIter = folderModel.append(None, row) path = folderModel.get_path(parentIter) treeRowRef = gtk.TreeRowReference(folderModel, path) pfile.treeRowRef = treeRowRef
def add_file(self, widget): self.statusbar.pop(1) (filestore, filerows) = self.fileview.get_selection().get_selected_rows() (colstore, colrows) = self.colview.get_selection().get_selected_rows() colpaths = list() for row in colrows: if len(row) == 1: colpaths.append(row) else: parent = (row[0], ) if not parent in colpaths: colpaths.append(parent) targetcols = list() for path in colpaths: gtkrow = gtk.TreeRowReference(colstore, path) targetcols.append((path, self.get_path_value(colstore, gtkrow)[0])) if len(targetcols) == 0: self.status("Select a target collection to add") filehashes = self.get_hashes(filestore, filerows) for filename, filehash in filehashes: for colpath, colname in targetcols: colname = unicode(colname) if colname in self.db: try: asin = self.kindle.files[filehash].asin if not self.db.in_collection(colname, asin): colstore.append(colstore[colpath].iter, [filename, filehash, asin]) self.db.add_asin(colname, self.kindle.files[filehash].asin, self.kindle.files[filehash].type) except TypeError: if not self.db.in_collection(colname, filehash): colstore.append(colstore[colpath].iter, [filename, filehash, ""]) self.db.add_filehash(colname, filehash) else: self.status("No such collection:" + colname)
def OnButtonPressed(self, widget): if self.initphase: return name = gtk.Buildable.get_name(widget) if name == "checkmyport": OpenUri('='.join([ 'http://tools.slsknet.org/porttest.php?port', str(self.frame.np.waitport) ]) ) if name == "addshare": selected = ChooseDir( self.window.get_toplevel(), title=_("Nicotine+") + ": " + _("Add a shared directory") ) if selected: for directory in selected: virtual = input_box( self.frame, title=_("Virtual name"), message=_("Enter virtual name for '%(dir)s':") % {'dir': directory} ) if virtual == '': pass else: self.addshareddir((virtual, directory)) if name == "removeshares": model, paths = self.kids['shareddirectoriestree'].get_selection().get_selected_rows() refs = [gtk.TreeRowReference(model, x) for x in paths] for i in refs: self.sharelist.remove(self.sharelist.get_iter(i.get_path())) self.resetcompleteness()
def monitor_power_levels(self, device): def update(row_ref, cinfo, address): if not row_ref.valid(): dprint("stopping monitor (row does not exist)") cinfo.deinit() self.monitored_devices.remove(props["Address"]) return False if not self.props.model: self.monitored_devices.remove(props["Address"]) return False iter = self.props.model.get_iter(row_ref.get_path()) device = self.get(iter, "device")["device"] if not device.Valid or not device.Connected: dprint("stopping monitor (not connected)") cinfo.deinit() self.level_setup_event(row_ref, device, None) self.monitored_devices.remove(props["Address"]) return False else: self.level_setup_event(row_ref, device, cinfo) return True props = device.GetProperties() if "Connected" in props and props["Connected"] and props["Address"] not in self.monitored_devices: dprint("starting monitor") iter = self.find_device(device) hci = os.path.basename(self.Adapter.GetObjectPath()) try: cinfo = conn_info(props["Address"], hci) except: dprint("Failed to get power levels") else: r = gtk.TreeRowReference(self.props.model, self.props.model.get_path(iter)) self.level_setup_event(r, device, cinfo) gobject.timeout_add(1000, update, r, cinfo, props["Address"]) self.monitored_devices.append(props["Address"])
def on_device_property_changed(self, key, value, path, *args, **kwargs): dprint("list: device_prop_ch", key, value, path, args, kwargs) iter = self.find_device_by_path(path) if iter != None: dev = self.get(iter, "device")["device"] self.row_update_event(iter, key, value) self.emit("device-property-changed", dev, iter, (key, value)) if key == "Connected": if value: self.monitor_power_levels(dev) else: r = gtk.TreeRowReference(self.props.model, self.props.model.get_path(iter)) self.level_setup_event(r, dev, None) elif key == "Paired": if value and dev.Temp: dev.Temp = False
def set_user_tags(self, usertaginfo): """ sets the user defined tags usertaginfo is a list with each element a sublist containing: [tree_path,type,tag_name,display_text,icon_path] NB: model contains [tag_name,pixbuf,display_text,check_state,icon_path] """ self.user_tags = {} path = self.model.get_iter((0, )) self.model.remove(path) self.model.insert( None, 0, (0, 'favorites', None, '<b>Categorized</b>', False, '')) for row in usertaginfo: path = tuple(row[0]) parent = self.model.get_iter(path[0:len(path) - 1]) self.model.append(parent, [row[1], row[2], None, row[3], False, row[4]]) self.user_tags[row[2]] = gtk.TreeRowReference(self.model, path) self.load_user_bitmaps(usertaginfo)
def set_current_page(self, path, vivificate=False): '''Select a page in the treeview @param path: a notebook L{Path} object for the page @param vivificate: when C{True} the path is created temporarily when it did not yet exist @returns: a gtk TreePath (tuple of intergers) or C{None} ''' #~ print '!! SELECT', path model = self.get_model() if model is None: return None # index not yet initialized ... treepath = model.get_treepath(path) if not treepath: if vivificate: # path does not exist, but we can create it path = model.index.touch(path) treepath = model.get_treepath(path) assert treepath, 'BUG: failed to touch placeholder' else: return None rowreference = gtk.TreeRowReference(model, treepath) # make reference before cleanup - path may change if self._cleanup and self._cleanup.valid(): mytreepath = self._cleanup.get_path() if mytreepath != treepath: indexpath = model.get_indexpath(model.get_iter(mytreepath)) #~ print '!! CLEANUP', indexpath model.index.cleanup(indexpath) treepath = model.get_treepath(path) self._cleanup = rowreference model.set_current_page(path) # highlight in model return treepath
def _select_index(self, idx, hasctrl, hasshift): path = (idx,) if not (hasctrl or hasshift): self._treeview.get_selection().unselect_all() if hasshift: self._shift_extend(path) else: self._shift_start = None if not hasctrl: self._treeview.get_selection().select_path(path) self._treeview.scroll_to_cell(path, None, True, 0.5, 0) self._remove_cursor() if hasctrl or hasshift: self._cursor = gtk.TreeRowReference(self._store, path) piter = self._store.get_iter(path) self._store.row_changed(path, piter)
def on_ok(liststore, list_of_paths): # delete rows from db that match log_line_id list_of_rowrefs = [] for path in list_of_paths: # make them treerowrefs (it's needed) list_of_rowrefs.append(gtk.TreeRowReference(liststore, path)) for rowref in list_of_rowrefs: path = rowref.get_path() if path is None: continue log_line_id = liststore[path][0] del liststore[path] # remove from UI # remove from db self.cur.execute( ''' DELETE FROM logs WHERE log_line_id = ? ''', (log_line_id, )) self.con.commit() self.AT_LEAST_ONE_DELETION_DONE = True
def _update_cmd_row(self, model_rr, cmd_deps, to_reparent): path = model_rr.get_path() model_iter = self.get_iter(path) cmd = self.iter_to_command(model_iter) cpu_str = "%.2f" % (cmd.cpu_usage * 100) mem_usage = int(cmd.mem_rss_bytes / 1024) self.set(model_iter, COL_CMDS_TV_EXEC, cmd.exec_str, COL_CMDS_TV_COMMAND_ID, cmd.command_id, COL_CMDS_TV_STATUS_ACTUAL, cmd.status(), COL_CMDS_TV_DEPUTY, cmd_deps[cmd].deputy_id, COL_CMDS_TV_CPU_USAGE, cpu_str, COL_CMDS_TV_MEM_RSS, mem_usage, COL_CMDS_TV_AUTO_RESPAWN, cmd.auto_respawn) # get a row reference to the model since # adding a group may invalidate the iterators model_rr = gtk.TreeRowReference(self, path) # check that the command is in the correct group in the # treemodel correct_grr = self._find_or_make_group_row_reference(cmd.group) correct_parent_iter = None correct_parent_path = None actual_parent_path = None if correct_grr and correct_grr.get_path() is not None: correct_parent_iter = self.get_iter(correct_grr.get_path()) actual_parent_iter = self.iter_parent( self.get_iter(model_rr.get_path()) ) # use the model_rr in case model_iter was invalidated if correct_parent_iter: correct_parent_path = self.get_path(correct_parent_iter) if actual_parent_iter: actual_parent_path = self.get_path(actual_parent_iter) if correct_parent_path != actual_parent_path: # schedule the command to be moved to_reparent.append((model_rr, correct_grr))
def reset_view(self): """ Expire all the children in the model, collapse everything, reexpand the rows to the previous state where possible and update the infobox. """ logger.debug('SearchView::reset_view') model, paths = self.results_view.get_selection().get_selected_rows() ref = None try: # try to get the reference to the selected object, if the # object has been deleted then we won't try to reselect it later ref = gtk.TreeRowReference(model, paths[0]) except: pass self.session.expire_all() # the invalidate_str_cache() method are specific to Species # and Accession right now....it's a bit of a hack since there's # no real interface that the method complies to...but it does # fix our string caching issues def invalidate_cache(model, path, treeiter, data=None): obj = model[path][0] if hasattr(obj, 'invalidate_str_cache'): obj.invalidate_str_cache() model.foreach(invalidate_cache) expanded_rows = self.get_expanded_rows() self.results_view.collapse_all() # expand_to_all_refs will invalidate the ref so get the path first if not ref: return path = None if ref.valid(): path = ref.get_path() self.expand_to_all_refs(expanded_rows) self.results_view.set_cursor(path)
def on_jids_listview_selection_changed(self, widget, data=None): liststore, list_of_paths = self.jids_listview.get_selection()\ .get_selected_rows() paths_len = len(list_of_paths) if paths_len == 0: # nothing is selected return self.logs_liststore.clear() # clear the store self.welcome_vbox.hide() self.search_results_scrolledwindow.hide() self.logs_scrolledwindow.show() list_of_rowrefs = [] for path in list_of_paths: # make them treerowrefs (it's needed) list_of_rowrefs.append(gtk.TreeRowReference(liststore, path)) for rowref in list_of_rowrefs: # FILL THE STORE, for all rows selected path = rowref.get_path() if path is None: continue jid = liststore[path][0] # jid self._fill_logs_listview(jid)
def on_all_timezones_added(self): continents = self.map.world.continents (sys_ctnt_index, sys_ctry_index, sys_tz_index) = self.get_current_tz() if sys_ctnt_index == -1 or sys_ctry_index == -1 or sys_tz_index == -1: sys_ctnt_index = 0 sys_ctry_index = 0 sys_tz_index = 0 tree_iter = self.ctnt_store.append() self.ctnt_store.set(tree_iter, 0, None, 1, Timezone.SELECT_LABEL) for continent in continents: text = continent.name tree_iter = self.ctnt_store.append() self.ctnt_store.set(tree_iter, 0, continent, 1, _(text)) path = self.ctnt_store.get_path(tree_iter) continent.ref = gtk.TreeRowReference(self.ctnt_store, path) self.ctnt_combo.set_active(sys_ctnt_index + 1) self.ctry_combo.set_active(sys_ctry_index + 1) self.tz_combo.set_active(sys_tz_index + 1)
def editrider(self, ref=None, first=None, last=None, club=None, cat=None, refid=None, ucicode=None, note=None, bib=None): """Create or update the rider with supplied parameters.""" i = None if ref is None: if bib is None: bib = self.nextriderno() ## ERROR: num not ever defined? i = self.model.append( [bib, u'', u'', u'', u'', u'', u'', u'', u'']) ref = gtk.TreeRowReference(self.model, self.model.get_path(i)) if ref.valid(): i = self.model.get_iter(ref.get_path()) if first is not None: self.model.set_value(i, COL_FIRST, first) if last is not None: self.model.set_value(i, COL_LAST, last) if club is not None: self.model.set_value(i, COL_CLUB, club) if cat is not None: self.model.set_value(i, COL_CAT, cat) if refid is not None: self.model.set_value(i, COL_REFID, refid) if ucicode is not None: self.model.set_value(i, COL_UCICODE, ucicode) if note is not None: self.model.set_value(i, COL_NOTE, note) return ref
def __cur_selection(self): selection = self.treeview.get_selection() model, bookmark_paths = selection.get_selected_rows() # Convert the paths to gtk.TreeRowReference objects, because we # might modify the model while this generator is running bookmark_refs = [ gtk.TreeRowReference(model, p) for p in bookmark_paths ] for reference in bookmark_refs: bookmark_iter = model.get_iter(reference.get_path()) item_iter = model.iter_parent(bookmark_iter) # bookmark_iter is actually an item_iter if item_iter is None: item_iter = bookmark_iter item_id = model.get_value(item_iter, 0) bookmark_id, bookmark_iter = None, None else: bookmark_id = model.get_value(bookmark_iter, 0) item_id = model.get_value(item_iter, 0) yield model, bookmark_id, bookmark_iter, item_id, item_iter
def get_hashes(self, filestore, filerows): filehashes = list() for row in filerows: gtkrow = gtk.TreeRowReference(filestore, row) filerow = self.get_path_value(filestore, gtkrow) if filerow[1] == "": piter = filestore.get_iter(gtkrow.get_path()) citer = filestore.iter_children(piter) if citer: subrow = filestore.get_path(citer) subhashes = self.get_hashes(filestore, [subrow]) for subhash in subhashes: filehashes.append(subhash) niter = filestore.iter_next(citer) while niter: nextrow = filestore.get_path(niter) subhashes = self.get_hashes(filestore, [nextrow]) for subhash in subhashes: filehashes.append(subhash) niter = filestore.iter_next(niter) else: filehashes.append((filerow[0], filerow[1])) return filehashes
def on_button_remove_snippet_clicked(self, button): override, remove, system = self.selected_snippets_state() if not (override ^ remove) or system: return paths = self.selected_snippets(include_languages=False, as_path=True) if override: action = self.remove_snippet_revert else: action = self.remove_snippet_delete # Remove selection self.tree_view.get_selection().unselect_all() # Create tree row references references = [] for path in paths: references.append(gtk.TreeRowReference(self.model, path)) # Remove/revert snippets select = None for reference in references: path = reference.get_path() piter = self.model.get_iter(path) res = action(path, piter) if res: select = res if select: self.select_iter(select) self.selection_changed()
def remove_clicked_cb(self, button): """ Remove the selected players from the test tree. """ test_view = self.__builder.get_object("test_view") test_sel = test_view.get_selection() model, paths = test_sel.get_selected_rows() rows = [] for path in paths: iter = model.get_iter(path) if not model.iter_has_child(iter): # Delete player configurations, not test lines parent = model.iter_parent(iter) path = model.get_path(parent) row = gtk.TreeRowReference(model, path) rows.append(row) for row in rows: if row.valid(): path = row.get_path() iter = model.get_iter(path) model.remove(iter)
def on_drag_drop(self, to_tree, drag_context, x, y, selection): # ff - from_filter self.copy = drag_context.action to_filter_model = to_tree.get_model() to_model = to_filter_model.get_model() if to_tree.get_dest_row_at_pos(x, y): to_filter_path, to_filter_pos = to_tree.get_dest_row_at_pos(x, y) to_filter_iter = to_filter_model.get_iter(to_filter_path) to_iter = to_filter_model.convert_iter_to_child_iter( to_filter_iter) else: to_filter_path = None to_filter_pos = None to_filter_iter = None to_iter = None from_tree = drag_context.get_source_widget() if not from_tree: return None ff_model, ff_paths = from_tree.get_selection().get_selected_rows() new_iter = None self.row_to_remove = [] ff_row_refs = [ gtk.TreeRowReference(ff_model, ff_path) for ff_path in ff_paths ] """to tree is NavigationTreeControl""" is_copy_move = False if isinstance(self, self.controls.tree.__class__): if from_tree is not to_tree: return if sys.version_info < (2, 6): return dest_folder = self.get_dest_folder(to_filter_model, to_filter_iter, to_filter_path) rows = [to_model[ff_path] for ff_path in ff_paths] files = [ row[self.path[0]] for row in rows if os.path.dirname(row[self.path[0]]) != dest_folder ] if (to_filter_pos and ((to_filter_pos == gtk.TREE_VIEW_DROP_INTO_OR_BEFORE) or (to_filter_pos == gtk.TREE_VIEW_DROP_INTO_OR_AFTER)) and os.path.isfile( to_filter_model[to_filter_path][self.path[0]])): to_filter_pos = gtk.TREE_VIEW_DROP_AFTER if files and copy_move_files_dialog(files, dest_folder, self.copy): is_copy_move = True text = _( "Copying:") if self.copy == gtk.gdk.ACTION_COPY else _( "Replacing:") #@UndefinedVariable self.pr_window = CopyProgressWindow(_("Progress"), files, 300, 100) self.pr_window.label_from.set_text(text) self.pr_window.label_to.set_text( _("To: ") + dest_folder + "\n") for ff_path, ff_row_ref, file in zip(ff_paths, ff_row_refs, files): new_path = self.replace_inside_navig_tree( file, dest_folder) if not new_path: continue self.one_row_replacing(ff_row_ref, ff_path, ff_model, from_tree, to_model, to_tree, to_iter, to_filter_pos, to_filter_path, new_iter, new_path, is_copy_move) self.remove_replaced(ff_model) self.pr_window.destroy() self.save_beans_from_tree() return for ff_row_ref in ff_row_refs: self.one_row_replacing(ff_row_ref, ff_path, ff_model, from_tree, to_model, to_tree, to_iter, to_filter_pos, to_filter_path, new_iter) if from_tree == to_tree: self.remove_replaced(ff_model) self.row_to_remove = [] self.rebuild_tree(to_tree)
def _check_for_lonely_groups(model, path, model_iter, user_data): is_group = self._is_group_row(model_iter) if is_group and not model.iter_has_child(model_iter): groups_to_remove.append(gtk.TreeRowReference(model, path))
def OnButtonPressed(self, widget): if self.initphase: return name = gtk.Buildable.get_name(widget) if name == "checkmyport": OpenUri('='.join([ 'http://tools.slsknet.org/porttest.php?port', str(self.frame.np.waitport) ]) ) if name == "addshare": selected = ChooseDir( self.window.get_toplevel(), title=_("Nicotine+") + ": " + _("Add a shared directory") ) if selected: for directory in selected: virtual = input_box( self.frame, title=_("Virtual name"), message=_("Enter virtual name for '%(dir)s':") % {'dir': directory} ) # If the virtual name is empty if virtual == '' or virtual is None: popupWarning( self.window, _("Warning"), _("The chosen virtual name is empty"), self.frame.images["n"] ) pass else: # We get the current defined shares from the treeview model, paths = self.kids['shareddirectoriestree'].get_selection().get_selected_rows() iter = model.get_iter_first() while iter is not None: # We reject the share if the virtual share name is already used if virtual == model.get_value(iter, 0): popupWarning( self.window, _("Warning"), _("The chosen virtual name already exist"), self.frame.images["n"] ) return # We also reject the share if the directory is already used elif directory == model.get_value(iter, 6): popupWarning( self.window, _("Warning"), _("The chosen directory is already shared"), self.frame.images["n"] ) return else: iter = model.iter_next(iter) # The share is unique: we can add it self.addshareddir((virtual, directory)) if name == "removeshares": model, paths = self.kids['shareddirectoriestree'].get_selection().get_selected_rows() refs = [gtk.TreeRowReference(model, x) for x in paths] for i in refs: self.sharelist.remove(self.sharelist.get_iter(i.get_path())) self.resetcompleteness()
def __init__(self): self.shownCompatibilityWarning = False self.vncserver = None self.vncviewer = None self.scrWidth = 100 self.scrHeight = 75 self.showRealNames = False self.currentScreenshots = dict() self.current_macs = subprocess.Popen([ 'sh', '-c', """ip -oneline -family inet link show | sed -n '/.*ether[[:space:]]*\\([[:xdigit:]:]*\).*/{s//\\1/;y/abcdef-/ABCDEF:/;p;}' echo $LTSP_CLIENT_MAC""" ], stdout=subprocess.PIPE ).communicate()[0].split() self.uid = os.getuid() if 'thumbnails_width' in config.user: self.scrWidth = config.user['thumbnails_width'] self.offline = gtk.gdk.pixbuf_new_from_file('images/offline.svg') self.thin = gtk.gdk.pixbuf_new_from_file('images/thin.svg') self.fat = gtk.gdk.pixbuf_new_from_file('images/fat.svg') self.standalone = gtk.gdk.pixbuf_new_from_file('images/standalone.svg') self.imagetypes = { 'thin': self.thin, 'fat': self.fat, 'standalone': self.standalone, 'offline': self.offline } self.wTree = gtk.Builder() self.wTree.add_from_file('epoptes.ui') self.get = lambda obj: self.wTree.get_object(obj) # Connect glade handlers with the callback functions self.wTree.connect_signals(self) # Hide the remote assistance menuitem if epoptes-client is not installed if not os.path.isfile('/usr/share/epoptes-client/remote-assistance'): self.get('mi_remote_assistance').set_property('visible', False) self.get('remote_assistance_separator').set_property( 'visible', False) self.groups_menu = self.get('mAddToGroup') self.add_to_group_menu = self.get('miAddToGroup') self.gstore = gtk.ListStore(str, object, bool) self.gtree = self.get("groups_tree") self.gtree.set_model(self.gstore) self.gtree.get_selection().connect("changed", self.on_group_selection_changed) self.mainwin = self.get('mainwindow') self.cstore = gtk.ListStore(str, gtk.gdk.Pixbuf, object, str) self.cview = self.get('clientsview') self.cView_order = (1, 0) self.set_cView(*self.cView_order) self.cview.set_model(self.cstore) self.cview.set_pixbuf_column(C_PIXBUF) self.cview.set_text_column(C_LABEL) self.cstore.set_sort_column_id(C_LABEL, gtk.SORT_ASCENDING) self.on_clients_selection_changed() self.cview.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, [("add", gtk.TARGET_SAME_APP, 0)], gtk.gdk.ACTION_COPY) self.gtree.enable_model_drag_dest([("add", gtk.TARGET_SAME_APP, 0)], gtk.gdk.ACTION_COPY) self.default_group = structs.Group('<b>' + _('Detected clients') + '</b>') default_iter = self.gstore.append( [self.default_group.name, self.default_group, False]) self.default_group.ref = gtk.TreeRowReference( self.gstore, self.gstore.get_path(default_iter)) self.gtree.get_selection().select_path( self.default_group.ref.get_path()) self.get('iconsSizeAdjustment').set_value(self.scrWidth) self.reload_imagetypes() saved_clients, groups = config.read_groups( os.path.expanduser('~/.config/epoptes/groups.json')) if len(groups) > 0: self.add_to_group_menu.set_sensitive(True) for grp in groups: self.gstore.append([grp.name, grp, True]) mitem = gtk.MenuItem(grp.name) mitem.show() mitem.connect('activate', self.on_add_to_group_clicked, grp) self.groups_menu.append(mitem) self.fillIconView(self.getSelectedGroup()[1]) if config.settings.has_option('GUI', 'selected_group'): path = config.settings.getint('GUI', 'selected_group') self.gtree.get_selection().select_path(path) if config.settings.has_option('GUI', 'label'): try: self.get(config.settings.get('GUI', 'label')).set_active(True) except: pass if config.settings.has_option('GUI', 'showRealNames'): self.get('mcShowRealNames').set_active( config.settings.getboolean('GUI', 'showRealNames')) self.mainwin.set_sensitive(False)
def on_update(self): #dont bother if we are not visible: if not GTKUtils.is_visible(self.container): return #track which rows still exist: updateObjects = set() appList = self.bbApp.applications.values() + [ self.bbApp, self.bbApp.torApp ] #update each app: for app in appList: #make sure a row exists for it if not hasattr(app, "treeRow") or not app.treeRow: #insert into the model iter = self.mdl.append(None, (app.name, "", "", "", "", "", "", 1, "white", "black", True)) #set treeRow so we can more easily update in the future app.treeRow = gtk.TreeRowReference( self.mdl, self.mdl.get_string_from_iter(iter)) #update each circ: for app in appList: for circuit in app.circuits: self.objects.add(circuit) #if circuit.treeView is not set, this must be a new circuit if not hasattr(circuit, "treeRow") or not circuit.treeRow: #insert into the model iter = self.mdl.append( self.mdl[circuit.app.treeRow.get_path()].iter, (str(circuit.id), circuit.status, "path", "0", "", "0 sec", "0", 1, "white", "black", True)) #set circuit.treeRow so we can more easily update in the future circuit.treeRow = gtk.TreeRowReference( self.mdl, self.mdl.get_string_from_iter(iter)) #update the information in the row updateObjects.add(circuit) self.update_object(circuit, "circuit") #update each stream: for app in appList: for stream in app.streams.values(): self.objects.add(stream) #if stream.circuit.treeRow is not set, this must be a new circuit if not stream.treeRow: #this might happen if the stream is new and hasnt been assigned a circuit yet if not stream.circuit: return #this should never happen. if not stream.circuit.treeRow: log_msg( "%s has a circuit %s with no treeRow?" % (stream.id, stream.circuit.id), 0) return #get the row of the circuit iter = self.mdl[stream.circuit.treeRow.get_path()].iter #insert the stream as a child of the circuit iter = self.mdl.append( iter, (str(stream.id), stream.status, stream.targetHost, "0", "", "0 sec", "0", 0, "white", "black", True)) #set stream.treeRow for easy updating later stream.treeRow = gtk.TreeRowReference( self.mdl, self.mdl.get_string_from_iter(iter)) else: #check that we are under the RIGHT circuit (in case of being reattached): parent = None shouldUpdate = False #do we have a circuit? if stream.circuit: #is that circuit in the GUI yet? if stream.circuit.treeRow: parent = self.mdl[ stream.circuit.treeRow.get_path()].iter iter = self.mdl[stream.treeRow.get_path()].iter iter = self.mdl.iter_parent(iter) #do we have a parent row? if iter: #check if it is the RIGHT parent row or not id = int(self.mdl.get_value(iter, 0)) if id != stream.circuit.id: shouldUpdate = True else: shouldUpdate = True else: log_msg( "Stream " + str(stream.id) + " has Circuit " + str(stream.circuit.id) + " with no treeRow?", 0) else: #can justput at the end of the list, top level: shouldUpdate = True #remove old row and insert new row if necessary: if shouldUpdate: oldIter = self.mdl[stream.treeRow.get_path()].iter n_columns = self.mdl.get_n_columns() values = self.mdl.get(oldIter, *range(n_columns)) self.mdl.remove(oldIter) newIter = self.mdl.append(parent, values) stream.treeRow = gtk.TreeRowReference( self.mdl, self.mdl.get_string_from_iter(newIter)) #update the information in the row self.update_object(stream, "stream") updateObjects.add(stream) #remove any of our rows that were NOT updated: toRemove = [] for obj in self.objects: if obj not in updateObjects: toRemove.append(obj) for obj in toRemove: self.remove_object(obj) self.objects.remove(obj)
def build(self): #I need this to make the window less ugly/more beautilful padding = gtk.Alignment(xscale=1, yscale=1) padding.set_padding(padding_top=20, padding_bottom=20, padding_right=30, padding_left=30) self.add(padding) vbox = gtk.VBox(homogeneous=False, spacing=20) padding.add(vbox) toolbar = gtk.Toolbar() toolbar.set_style(gtk.TOOLBAR_ICONS) #Icons only toolbar.set_tooltips(True) vbox.pack_start(toolbar, expand=False, padding=5) #Add notecard toolitem add_icon = gtk.Image() add_icon.set_from_stock(stock_id=gtk.STOCK_ADD, size=gtk.ICON_SIZE_DIALOG) toolbar.append_item(text="", tooltip_text="Add notecard", tooltip_private_text="", icon=add_icon, callback=self.on_add_clicked) #Delete notecard toolitem delete_icon = gtk.Image() delete_icon.set_from_stock(stock_id=gtk.STOCK_REMOVE, size=gtk.ICON_SIZE_DIALOG) toolbar.append_item(text="", tooltip_text="Delete notecard(s)", tooltip_private_text="", icon=delete_icon, callback=self.on_delete_clicked) #Scrollable window is needed before the treeview scrolled_window = gtk.ScrolledWindow() scrolled_window.set_policy( hscrollbar_policy=gtk.POLICY_AUTOMATIC, vscrollbar_policy=gtk.POLICY_AUTOMATIC ) #Automatically decide if we need scrollbars vbox.pack_start(scrolled_window, expand=True, fill=True, padding=5) #The list store self.liststore = gtk.ListStore(int, str, str) #id, back, front self.liststore.set_default_sort_func( None) #Apparently, it becomes slow otherwise self.rows = { } #We can fetch rows by ids later, if we store them now of course count = 0 for notecard in self.master.notecards.get_all_notecards(): self.liststore.append(notecard) #We need to keep references later for removing, editing, etc _id = notecard[0] row_reference = gtk.TreeRowReference(self.liststore, count) self.rows[_id] = row_reference count += 1 #The treeview treeview = gtk.TreeView(model=self.liststore) treeview.set_enable_search(True) #Make it searchable treeview.set_headers_clickable(True) #So users can sort by header treeview.set_reorderable(True) #Make sure they can reorder scrolled_window.add(treeview) treeview.connect("row-activated", self.on_row_clicked) #When a row is double clicked #Tree selection self.selection = treeview.get_selection() self.selection.set_mode( gtk.SELECTION_MULTIPLE) #Make multiple items selectable #We need the renderers text_renderer = gtk.CellRendererText() text_renderer.set_property( "wrap-width", 600 ) #For some reason, it raises an error here(it doesn't want an integer value) but still works fine text_renderer.set_padding(5, 0) #Columns front_column = gtk.TreeViewColumn( "Front", text_renderer, text=1 ) #text=1 means fetch from second row(which is front row) of the ListStore # header, CellRenderer, column reference front_column.set_sort_column_id(1) #Sort with the values of front back_column = gtk.TreeViewColumn("Back", text_renderer, text=2) back_column.set_sort_column_id(2) treeview.append_column(front_column) treeview.append_column(back_column)
def iv_dnd_received_data(self, iconview, context, x, y, selection_data, target_id, etime): """Handles received data by drag and drop in iconview""" model = iconview.get_model() data = selection_data.data if data: data = data.split('\n;\n') drop_info = iconview.get_dest_item_at_pos(x, y) iter_to = None if drop_info: path, position = drop_info ref_to = gtk.TreeRowReference(model,path) else: position = gtk.ICON_VIEW_DROP_RIGHT if len(model) > 0: #find the iterator of the last row row = model[-1] path = row.path ref_to = gtk.TreeRowReference(model,path) if ref_to: before = (position == gtk.ICON_VIEW_DROP_LEFT or position == gtk.ICON_VIEW_DROP_ABOVE) #if target_id == self.MODEL_ROW_INTERN: if selection_data.target == 'MODEL_ROW_INTERN': if before: data.sort(key=int) else: data.sort(key=int,reverse=True) ref_from_list = [gtk.TreeRowReference(model,path) for path in data] for ref_from in ref_from_list: path = ref_to.get_path() iter_to = model.get_iter(path) path = ref_from.get_path() iter_from = model.get_iter(path) row = model[iter_from] if before: model.insert_before(iter_to, row) else: model.insert_after(iter_to, row) if context.action == gtk.gdk.ACTION_MOVE: for ref_from in ref_from_list: path = ref_from.get_path() iter_from = model.get_iter(path) model.remove(iter_from) #elif target_id == self.MODEL_ROW_EXTERN: elif selection_data.target == 'MODEL_ROW_EXTERN': if not before: data.reverse() while data: tmp = data.pop(0).split('\n') filename = tmp[0] npage, angle = [int(k) for k in tmp[1:3]] crop = [float(side) for side in tmp[3:7]] if self.add_pdf_pages(filename, npage, npage, angle, crop): if len(model) > 0: path = ref_to.get_path() iter_to = model.get_iter(path) row = model[-1] #the last row path = row.path iter_from = model.get_iter(path) if before: model.move_before(iter_from, iter_to) else: model.move_after(iter_from, iter_to) if context.action == gtk.gdk.ACTION_MOVE: context.finish(True, True, etime)
def on_update(self): if not GTKUtils.is_visible(self.container): return if not self.download.started: return #now add the actual data: stats = self.download.startStats(True) peers = stats['spew'] peersUpdated = set() if not peers: return for peerInfo in peers: #format all data for this peer def format_bool(val): if val is True: return '1' if val is False: return '0' return str(val) peerId = peerInfo['id'] peerClient = peerInfo['client'] peerIp = peerInfo['ip'] upRate = float(peerInfo['uprate']) downRate = float(peerInfo['downrate']) totalUp = int(peerInfo['utotal']) totalDown = int(peerInfo['dtotal']) chokedUp = format_bool(peerInfo['uchoked']) chokedDown = format_bool(peerInfo['dchoked']) snubbed = format_bool(peerInfo['snubbed']) interestedUp = format_bool(peerInfo['uinterested']) interestedDown = format_bool(peerInfo['dinterested']) speed = float(peerInfo['speed']) requests = str(peerInfo['pendingRequests']) circId = str(peerInfo['circId']) completed = float(peerInfo['completed']) allValues = [peerIp, upRate, downRate, totalUp, totalDown, chokedUp, chokedDown, snubbed, interestedUp, interestedDown, speed, requests, circId, completed, peerClient, peerId] #do we have a row already for this peer? if peerId in self.peerRows: #then just update the row peerIter = self.liststore[self.peerRows[peerId].get_path()].iter valuesArg = [] for columnTuple, value in zip(self.COLUMNS, allValues): idx = self.attrIdx[columnTuple[0]] valuesArg.append(idx) valuesArg.append(value) self.liststore.set(peerIter, *valuesArg) else: #otherwise have to make a new one peerIter = self.liststore.append(allValues) self.peerRows[peerId] = gtk.TreeRowReference(self.liststore, self.liststore.get_string_from_iter(peerIter)) peersUpdated.add(peerId) toRemove = set() for peerId, row in self.peerRows.iteritems(): if peerId not in peersUpdated: toRemove.add(peerId) for row in toRemove: del self.peerRows[row]
def _build_type_tree(model): ''' Build a gtk.treemodel from a dictionary of objects. Branch rows in the treemodel will be the set of types taken from the dictionary's object's attribute that is conceptually (to the user) a type (having string values from a small set). Leaf rows in the treemodel will be keys from the dictionary (which usually are the same as the ID or name attr of objects in the dictionary.) Also, the object's attribute can be a list of types (categories). That is, we build the same tree structure for viewtype: Type and viewtype: Category. For viewtype Category, a thing can appear in more than one row of the treeview. ''' model.treemodel.clear() # tree structure: one level: type names, second level: leaves, names of objects having that type # for example, a tree whose leaves are PDB procedure names and whose branches are procedure types. # EG, as an image of the displayed treeview, where ^ is an icon that collapses the branch # treeview: typedict: [db[].thing.name, .ztype]: viewspec: # ^Integer (1: Integer) foo, 1 ("Type and Name", "ztype", "Type", typedict) # foo (2: Char) bar, 1 # bar zed, 2 # ^Char # zed # # ^Integer (1: Integer) foo, Integer,Char ("Type and Name", "ztype", "Category", typedict) # foo (2: Char) bar, Integer # bar zed, Char # ^Char # foo *appears in two types # zed db = model.viewspec.db type_to_row = {} SEP = string.maketrans(',', ' ') # add parent rows to treemodel, remembering the tree path. # treerowreferences are persistent, treeiters and treepaths are not, so convert back and forth # do parents first, then children, so can raise exceptions for missing parents. for parent in model.viewspec.typedict.keys(): # for each unique value of the type # Parent means parent row in the treemodel. # Translate to friendly displayed string, different from type strings in the db displayedtype = model.viewspec.typedict[parent] piter = model.treemodel.append(None, [displayedtype, ""]) # second, hidden column empty row = gtk.TreeRowReference(model.treemodel, model.treemodel.get_path(piter)) type_to_row[parent] = row # add child rows to treemodel, looking up parent tree path for name, thing in db.iteritems(): # EG key is name, value is an object with an attribute that is a type. if not model.viewspec.filterdict[name]: # is filtered out by search string? continue # Get the value of the thing's attribute. The value is 'of the type'. # The name of the attribute is given in the viewspec for the model. value = eval("thing." + model.viewspec.attrname) # !!! Value can be a list of type names (a category) if model.viewspec.type == "Category": # For now, categories cannot be encoded, must be str # list words in commma OR whitespace delimited string # First translate commas to whitespace, then split on any whitespace valuelist = value.translate(SEP).split() if len(valuelist) < 1: valuelist = ["NA"] # the type of an empty category # Note that it is better to insure the db has no empty category values, substitue "NA" at load time for avalue in valuelist: try: parentrow = type_to_row[avalue] piter = model.treemodel.get_iter(parentrow.get_path()) model.treemodel.append(piter, [name, name]) # second use is as ID of procedure except KeyError: print "Key error: type not found in viewspec.typedict: ", avalue else: # viewtype is Type. try: parentrow = type_to_row[value] piter = model.treemodel.get_iter(parentrow.get_path()) model.treemodel.append(piter, [name, name]) # second use is as ID of procedure except KeyError: print "Key error: type not found in viewspec.typedict" ''' OLD
def on_button_press(self, w, e): if is_middle_click(e): """to avoid unselect all selected items""" self.stop_emission('button-press-event') if is_left_click(e): # on left click expand selected folders return if is_double_left_click(e): # on middle click play selected beans self.add_to_tab() return if is_rigth_click(e): # on right click, show pop-up menu menu = Popup() menu.add_item(_("Append to playlist"), gtk.STOCK_ADD, lambda: self.add_to_tab(True), None) menu.add_item(_("Open in new playlist"), gtk.STOCK_MEDIA_PLAY, self.add_to_tab, None) menu.add_separator() menu.add_item(_("Add folder here"), gtk.STOCK_OPEN, self.add_folder, None) menu.add_separator() if FC().tabs_mode == "Multi": menu.add_item(_("Add folder in new tab"), gtk.STOCK_OPEN, lambda: self.add_folder(True), None) menu.add_item( _("Clear"), gtk.STOCK_CLEAR, lambda: self.controls.tabhelper.clear_tree(self.scroll), None) menu.add_item( _("Update"), gtk.STOCK_REFRESH, lambda: self.controls.tabhelper .on_update_music_tree(self.scroll), None) f_model, f_t_paths = self.get_selection().get_selected_rows() if f_t_paths: model = f_model.get_model() t_paths = [ f_model.convert_child_path_to_path(f_t_path) for f_t_path in f_t_paths ] row = model[t_paths[0]] paths = [model[t_path][self.path[0]] for t_path in t_paths] row_refs = [ gtk.TreeRowReference(model, t_path) for t_path in t_paths ] menu.add_separator() menu.add_item(_("Open in file manager"), None, open_in_filemanager, self.get_selected_bean().path) menu.add_item(_("Create folder"), None, self.create_folder, (model, f_t_paths[0], row)) menu.add_item(_("Rename file (folder)"), None, self.rename_files, (row, self.path[0], self.text[0])) menu.add_item( _("Delete file(s) / folder(s)"), None, self.delete_files, (row_refs, paths, self.get_iter_from_row_reference)) menu.show(e)
def on_drag_drop(self, to_tree, drag_context, x, y, selection): # ff - from_filter self.copy = drag_context.action to_filter_model = to_tree.get_model() to_model = to_filter_model.get_model() if to_tree.get_dest_row_at_pos(x, y): to_filter_path, to_filter_pos = to_tree.get_dest_row_at_pos(x, y) to_filter_iter = to_filter_model.get_iter(to_filter_path) to_iter = to_filter_model.convert_iter_to_child_iter( to_filter_iter) else: to_filter_path = None to_filter_pos = None to_filter_iter = None to_iter = None from_tree = drag_context.get_source_widget() if not from_tree: return None ff_model, ff_paths = from_tree.get_selection().get_selected_rows() if "PlaylistTreeControl" in str(to_tree) and to_tree != from_tree: self.controls.search_progress.start() self.spinner = True def task(to_iter): all_rows = [] for ff_path in ff_paths: ff_iter = ff_model.get_iter(ff_path) beans = self.get_all_beans_by_parent(ff_model, ff_iter) all_rows += self.fill_beans_and_get_rows( beans, self.simple_content_filter) self.spinner = False for i, row in enumerate(all_rows): pos = gtk.TREE_VIEW_DROP_AFTER if i else to_filter_pos if row[self.path[0]] and get_file_extension( row[self.path[0]]) in [".m3u", ".m3u8"]: self.add_m3u(ff_model, ff_iter, to_tree, to_model, to_iter, pos) continue to_iter = self.to_add_drag_item(to_tree, to_model, to_iter, pos, None, row=row) self.controls.search_progress.stop() self.update_tracknumber() t = threading.Thread(target=task, args=(to_iter, )) t.start() """trick to show spinner before end of handling""" while t.isAlive(): time.sleep(0.1) while gtk.events_pending(): if self.spinner: #self.controls.search_progress.get_property('active'): gtk.main_iteration() else: break # otherwise endless cycle''' return new_iter = None self.row_to_remove = [] ff_row_refs = [ gtk.TreeRowReference(ff_model, ff_path) for ff_path in ff_paths ] """to tree is NavigationTreeControl""" is_copy_move = False if isinstance(self, self.controls.tree.__class__): if from_tree is not to_tree: return if sys.version_info < (2, 6): return dest_folder = self.get_dest_folder(to_filter_model, to_filter_iter, to_filter_path) rows = [to_model[ff_path] for ff_path in ff_paths] files = [ row[self.path[0]] for row in rows if os.path.dirname(row[self.path[0]]) != dest_folder ] if to_filter_pos: if os.path.isfile( to_filter_model[to_filter_path][self.path[0]]): if to_filter_pos != gtk.TREE_VIEW_DROP_BEFORE: to_filter_pos = gtk.TREE_VIEW_DROP_AFTER elif to_filter_pos in (gtk.TREE_VIEW_DROP_BEFORE, gtk.TREE_VIEW_DROP_AFTER): info_dialog( _("Attention!!!"), _("When you release the mouse button the mouse" + " pointer must be over the folder exactly." + " Please retry!")) return if files and copy_move_files_dialog(files, dest_folder, self.copy): is_copy_move = True text = _( "Copying:") if self.copy == gtk.gdk.ACTION_COPY else _( "Replacing:") #@UndefinedVariable self.pr_window = CopyProgressWindow(_("Progress"), files, 300, 100) self.pr_window.label_from.set_text(text) self.pr_window.label_to.set_text( _("To: ") + dest_folder + "\n") for ff_path, ff_row_ref, file in zip(ff_paths, ff_row_refs, files): new_path = self.replace_inside_navig_tree( file, dest_folder) if not new_path: continue self.one_row_replacing(ff_row_ref, ff_path, ff_model, from_tree, to_tree, to_model, to_iter, to_filter_pos, to_filter_path, new_iter, new_path, is_copy_move) self.remove_replaced(ff_model) self.pr_window.destroy() self.save_beans_from_tree() return for ff_row_ref in ff_row_refs: new_iter = self.one_row_replacing(ff_row_ref, ff_path, ff_model, from_tree, to_tree, to_model, to_iter, to_filter_pos, to_filter_path, new_iter) if from_tree == to_tree: self.remove_replaced(ff_model) self.row_to_remove = [] self.rebuild_tree(to_tree)