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)
