def update_stat_value(self, stat_id, session_value):
total_value = config.sections["statistics"][stat_id]
if stat_id == "downloaded_size" or stat_id == "uploaded_size":
session_value = human_size(session_value)
total_value = human_size(total_value)
else:
session_value = str(session_value)
total_value = str(total_value)
getattr(self, stat_id + "_session").set_text(session_value)
getattr(self, stat_id + "_total").set_text(total_value)
def make_new_model(self, shares, private_shares=None):
self.clear_model()
private_size = num_private_folders = 0
# Generate the directory tree and select first directory
size, num_folders = self.create_folder_tree(shares)
if private_shares:
shares = shares + private_shares
private_size, num_private_folders = self.create_folder_tree(
private_shares, private=True)
# Sort files
for _folder, files in shares:
files.sort()
self.shares = dict(shares)
self.AmountShared.set_text(human_size(size + private_size))
self.NumDirectories.set_text(str(num_folders + num_private_folders))
if self.ExpandButton.get_active():
self.FolderTreeView.expand_all()
else:
self.FolderTreeView.collapse_all()
iterator = self.dir_store.get_iter_first()
if iterator:
path = self.dir_store.get_path(iterator)
self.FolderTreeView.set_cursor(path)
self.set_finished()
def set_directory(self, directory):
# Temporarily disable sorting for improved performance
self.file_store.set_default_sort_func(lambda *args: 0)
self.file_store.set_sort_column_id(-1, Gtk.SortType.ASCENDING)
self.selected_folder = directory
self.file_store.clear()
self.files.clear()
found_dir = False
for d, f in self.shares:
if d == directory:
found_dir = True
files = f
break
if not found_dir:
return
for file in files:
# Filename, HSize, Bitrate, HLength, Size, Length, RawFilename
try:
size = int(file[2])
except ValueError:
size = 0
f = [file[1], human_size(size)]
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, file[4])
f += [
h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, int(size)),
GObject.Value(GObject.TYPE_UINT64, bitrate),
GObject.Value(GObject.TYPE_UINT64, length)
]
try:
self.files[f[0]] = self.file_store.insert_with_valuesv(
-1, self.file_column_numbers, f)
except Exception as msg:
log.add(
_("Error while attempting to display folder '%(folder)s', reported error: %(error)s"
), {
'folder': directory,
'error': msg
})
self.file_store.set_sort_column_id(0, Gtk.SortType.ASCENDING)
def set_directory(self, directory):
self.selected_folder = directory
self.file_store.clear()
self.files.clear()
found_dir = False
for d, f in self.shares:
if d == directory:
found_dir = True
files = f
break
if not found_dir:
return
for file in files:
# Filename, HSize, Bitrate, HLength, Size, Length, RawFilename
try:
size = int(file[2])
# Some clients send incorrect file sizes
if size < 0 or size > maxsize:
size = 0
except ValueError:
size = 0
f = [file[1], human_size(size)]
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, file[4])
f += [
h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, int(size)),
GObject.Value(GObject.TYPE_UINT64, bitrate),
GObject.Value(GObject.TYPE_UINT64, length)
]
try:
self.files[f[0]] = self.file_store.insert_with_valuesv(
-1, self.file_column_numbers, f)
except Exception as msg:
log.add(
_("Error while attempting to display folder '%(folder)s', reported error: %(error)s"
), {
'folder': directory,
'error': msg
})
def update_title(self):
index = self.current_index + 1
total_files = len(self.properties)
total_size = str(human_size(self.total_size))
if self.total_length:
self.dialog.set_title(_("File Properties (%(num)i of %(total)i / %(size)s / %(length)s)") % {
'num': index, 'total': total_files, 'size': total_size,
'length': str(human_length(self.total_length))
})
return
self.dialog.set_title(_("File Properties (%(num)i of %(total)i / %(size)s)") % {
'num': index, 'total': total_files, 'size': total_size})
def on_file_properties(self, *args):
if not self.frame.np.transfers:
return
data = []
model, paths = self.widget.get_selection().get_selected_rows()
for path in paths:
iterator = model.get_iter(path)
transfer = model.get_value(iterator, 18)
if not isinstance(transfer, Transfer):
continue
user = model.get_value(iterator, 0)
filename = model.get_value(iterator, 2)
fullname = model.get_value(iterator, 10)
size = speed = length = queue = immediate = num = country = bitratestr = ""
size = str(human_size(transfer.size))
if transfer.speed:
speed = str(human_speed(transfer.speed))
bitratestr = str(transfer.bitrate)
length = str(transfer.length)
directory = fullname.rsplit("\\", 1)[0]
data.append({
"user": user,
"fn": fullname,
"position": num,
"filename": filename,
"directory": directory,
"size": size,
"speed": speed,
"queue": queue,
"immediate": immediate,
"bitrate": bitratestr,
"length": length,
"country": country
})
if paths:
FileProperties(self.frame, data).show()
def set_directory(self, iter_user_data):
directory = self.dir_user_data.get(iter_user_data)
if directory is None or self.selected_folder == directory:
return
self.selected_folder = directory
self.file_store.clear()
self.file_iters.clear()
files = self.shares.get(directory)
if not files:
return
# Temporarily disable sorting for increased performance
sort_column, sort_type = self.file_store.get_sort_column_id()
self.file_store.set_default_sort_func(lambda *_args: 0)
self.file_store.set_sort_column_id(-1, Gtk.SortType.ASCENDING)
selected_folder_size = 0
for file in files:
# Filename, HSize, Bitrate, HLength, Size, Length
filename = file[1]
size = file[2]
selected_folder_size += size
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, file[4])
file_row = [
filename,
human_size(size), h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT64, bitrate),
GObject.Value(GObject.TYPE_UINT64, length)
]
self.file_iters[filename] = self.file_store.insert_with_valuesv(
-1, self.file_column_numbers, file_row)
self.selected_folder_size = selected_folder_size
if sort_column is not None and sort_type is not None:
self.file_store.set_sort_column_id(sort_column, sort_type)
def make_new_model(self, shares, private_shares=None):
# Temporarily disable sorting for improved performance
self.dir_store.set_default_sort_func(lambda *args: 0)
self.dir_store.set_sort_column_id(-1, Gtk.SortType.ASCENDING)
self.shares = shares
private_size = num_private_folders = 0
self.query = None
self.selected_folder = None
self.selected_files.clear()
self.directories.clear()
self.files.clear()
self.dir_store.clear()
self.file_store.clear()
self.search_list.clear()
# Generate the directory tree and select first directory
size, num_folders = self.create_folder_tree(shares)
if config.sections["ui"]["private_shares"] and private_shares:
self.shares = shares + private_shares
private_size, num_private_folders = self.create_folder_tree(
private_shares, private=True)
self.AmountShared.set_text(human_size(size + private_size))
self.NumDirectories.set_text(str(num_folders + num_private_folders))
if self.ExpandButton.get_active():
self.FolderTreeView.expand_all()
else:
self.FolderTreeView.collapse_all()
self.dir_store.set_sort_column_id(0, Gtk.SortType.ASCENDING)
iterator = self.dir_store.get_iter_first()
sel = self.FolderTreeView.get_selection()
sel.unselect_all()
if iterator:
path = self.dir_store.get_path(iterator)
sel.select_path(path)
self.set_finished()
def update_current_file(self):
""" Updates the UI with properties for the selected file """
properties = self.properties[self.current_index]
self.navigation_buttons.set_visible(len(self.properties) > 1)
self.filename_value.set_text(str(properties["filename"]))
self.folder_value.set_text(str(properties["directory"]))
self.filesize_value.set_text("%s (%s B)" % (human_size(properties["size"]), humanize(properties["size"])))
self.username_value.set_text(str(properties["user"]))
path = properties.get("path") or ""
bitrate = properties.get("bitrate") or ""
length = properties.get("length") or ""
queue_position = properties.get("queue_position") or 0
speed = properties.get("speed") or 0
country = properties.get("country") or ""
self.path_value.set_text(str(path))
self.path.set_visible(bool(path))
self.bitrate_value.set_text(str(bitrate))
self.bitrate.set_visible(bool(bitrate))
self.length_value.set_text(str(length))
self.length.set_visible(bool(length))
self.queue_value.set_text(str(humanize(queue_position)))
self.queue.set_visible(bool(queue_position))
self.speed_value.set_text(str(human_speed(speed)))
self.speed.set_visible(bool(speed))
self.country_value.set_text(str(country))
self.country.set_visible(bool(country))
self.update_title()
def on_file_properties(self, *args):
data = []
for transfer in self.selected_transfers:
user = transfer.user
fullname = transfer.filename
filename = fullname.split("\\")[-1]
size = speed = length = queue = immediate = num = country = bitratestr = ""
size = str(human_size(transfer.size))
if transfer.speed:
speed = str(human_speed(transfer.speed))
bitratestr = str(transfer.bitrate)
length = str(transfer.length)
directory = fullname.rsplit("\\", 1)[0]
data.append({
"user": user,
"fn": fullname,
"position": num,
"filename": filename,
"directory": directory,
"size": size,
"speed": speed,
"queue": queue,
"immediate": immediate,
"bitrate": bitratestr,
"length": length,
"country": country
})
if data:
FileProperties(self.frame, data).show()
def make_new_model(self, list):
self.shares = list
self.selected_folder = None
self.selected_files.clear()
self.directories.clear()
self.files.clear()
self.dir_store.clear()
self.file_store.clear()
# Compute the number of shared dirs and total size
self.totalsize = 0
for dir, files in self.shares:
for filedata in files:
if filedata[2] < maxsize:
self.totalsize += filedata[2]
self.AmountShared.set_text(human_size(self.totalsize))
self.NumDirectories.set_text(str(len(self.shares)))
# Generate the directory tree and select first directory
currentdir = self.browse_get_dirs()
sel = self.FolderTreeView.get_selection()
sel.unselect_all()
if currentdir in self.directories:
path = self.dir_store.get_path(self.directories[currentdir])
if path is not None:
sel.select_path(path)
if self.ExpandButton.get_active():
self.FolderTreeView.expand_all()
else:
self.FolderTreeView.collapse_all()
self.set_finished()
def get_hsize(current_byte_offset, size):
return "%s / %s" % (human_size(current_byte_offset), human_size(size))
def update_parent_row(self, initer, key, folder=False):
speed = 0.0
totalsize = current_bytes = 0
elapsed = 0
left = 0
salientstatus = ""
iterator = self.transfersmodel.iter_children(initer)
if iterator is None:
# Remove parent row if no children are present anymore
dictionary = self.paths if folder else self.users
self.transfersmodel.remove(initer)
del dictionary[key]
return
while iterator is not None:
transfer = self.transfersmodel.get_value(iterator, 16)
status = transfer.status
if status == "Transferring" or salientstatus in self.deprioritized_statuses:
salientstatus = status
if status == "Filtered":
# We don't want to count filtered files when calculating the progress
iterator = self.transfersmodel.iter_next(iterator)
continue
elapsed += transfer.time_elapsed or 0
left += transfer.time_left or 0
totalsize += self.get_size(transfer.size)
current_bytes += transfer.current_byte_offset or 0
speed += transfer.speed or 0
iterator = self.transfersmodel.iter_next(iterator)
transfer = self.transfersmodel.get_value(initer, 16)
if transfer.status != salientstatus:
self.transfersmodel.set_value(initer, 3,
self.translate_status(salientstatus))
transfer.status = salientstatus
if transfer.speed != speed:
self.transfersmodel.set_value(initer, 7, self.get_hspeed(speed))
self.transfersmodel.set_value(
initer, 12, GObject.Value(GObject.TYPE_UINT64, speed))
transfer.speed = speed
if transfer.time_elapsed != elapsed:
self.transfersmodel.set_value(initer, 8,
self.get_helapsed(elapsed))
self.transfersmodel.set_value(initer, 9, self.get_hleft(left))
self.transfersmodel.set_value(initer, 14, elapsed)
self.transfersmodel.set_value(initer, 15, left)
transfer.time_elapsed = elapsed
transfer.time_left = left
if transfer.current_byte_offset != current_bytes:
self.transfersmodel.set_value(
initer, 5, self.get_percent(current_bytes, totalsize))
self.transfersmodel.set_value(
initer, 6,
"%s / %s" % (human_size(current_bytes), human_size(totalsize)))
self.transfersmodel.set_value(
initer, 11, GObject.Value(GObject.TYPE_UINT64, current_bytes))
transfer.current_byte_offset = current_bytes
if transfer.size != totalsize:
self.transfersmodel.set_value(
initer, 6,
"%s / %s" % (human_size(current_bytes), human_size(totalsize)))
self.transfersmodel.set_value(
initer, 10, GObject.Value(GObject.TYPE_UINT64, totalsize))
transfer.size = totalsize
def update_specific(self, transfer=None):
currentbytes = transfer.currentbytes
place = transfer.place or 0
hplace = ""
if place > 0:
hplace = str(place)
hspeed = helapsed = ""
if currentbytes is None:
currentbytes = 0
status = transfer.status or ""
hstatus = self.translate_status(status)
try:
size = int(transfer.size)
if size < 0 or size > maxsize:
size = 0
except TypeError:
size = 0
hsize = "%s / %s" % (human_size(currentbytes), human_size(size))
if transfer.modifier:
hsize += " (%s)" % transfer.modifier
speed = transfer.speed or 0
elapsed = transfer.timeelapsed or 0
left = transfer.timeleft or ""
if speed > 0:
speed = float(speed)
hspeed = human_speed(speed)
if elapsed > 0:
helapsed = self.frame.np.transfers.get_time(elapsed)
try:
icurrentbytes = int(currentbytes)
percent = min(((100 * icurrentbytes) / int(size)), 100)
except Exception:
icurrentbytes = 0
percent = 100
# Modify old transfer
if transfer.iter is not None:
initer = transfer.iter
self.transfersmodel.set_value(initer, 3, hstatus)
self.transfersmodel.set_value(initer, 4, hplace)
self.transfersmodel.set_value(
initer, 5, GObject.Value(GObject.TYPE_UINT64, percent))
self.transfersmodel.set_value(initer, 6, hsize)
self.transfersmodel.set_value(initer, 7, hspeed)
self.transfersmodel.set_value(initer, 8, helapsed)
self.transfersmodel.set_value(initer, 9, left)
self.transfersmodel.set_value(initer, 11, status)
self.transfersmodel.set_value(
initer, 12, GObject.Value(GObject.TYPE_UINT64, size))
self.transfersmodel.set_value(
initer, 13, GObject.Value(GObject.TYPE_UINT64, currentbytes))
self.transfersmodel.set_value(
initer, 14, GObject.Value(GObject.TYPE_UINT64, speed))
self.transfersmodel.set_value(
initer, 15, GObject.Value(GObject.TYPE_UINT64, elapsed))
self.transfersmodel.set_value(
initer, 17, GObject.Value(GObject.TYPE_UINT64, place))
else:
fn = transfer.filename
user = transfer.user
shortfn = fn.split("\\")[-1]
filecount = 1
if self.tree_users != "ungrouped":
# Group by folder or user
empty_int = 0
empty_str = ""
if user not in self.users:
# Create Parent if it doesn't exist
# ProgressRender not visible (last column sets 4th column)
self.users[user] = self.transfersmodel.insert_with_values(
None, -1, self.column_numbers, [
user, empty_str, empty_str, empty_str, empty_str,
empty_int, empty_str, empty_str, empty_str,
empty_str, empty_str, empty_str, empty_int,
empty_int, empty_int, empty_int, filecount,
empty_int, lambda: None
])
parent = self.users[user]
if self.tree_users == "folder_grouping":
# Group by folder
""" Paths can be empty if files are downloaded individually, make sure we
don't add files to the wrong user in the TreeView """
path = transfer.path
user_path = user + path
reverse_path = '/'.join(reversed(path.split('/')))
if user_path not in self.paths:
self.paths[
user_path] = self.transfersmodel.insert_with_values(
self.users[user], -1, self.column_numbers, [
user, reverse_path, empty_str, empty_str,
empty_str, empty_int, empty_str, empty_str,
empty_str, empty_str, empty_str, empty_str,
empty_int, empty_int, empty_int, empty_int,
filecount, empty_int, lambda: None
])
parent = self.paths[user_path]
else:
# No grouping
# We use this list to get the total number of users
self.users.setdefault(user, set()).add(transfer)
parent = None
# Add a new transfer
if self.tree_users == "folder_grouping":
# Group by folder, path not visible
path = ""
else:
path = '/'.join(reversed(transfer.path.split('/')))
iterator = self.transfersmodel.insert_with_values(
parent, -1, self.column_numbers,
(user, path, shortfn, hstatus, hplace,
GObject.Value(GObject.TYPE_UINT64,
percent), hsize, hspeed, helapsed, left, fn,
status, GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT64, icurrentbytes),
GObject.Value(GObject.TYPE_UINT64, speed),
GObject.Value(GObject.TYPE_UINT64, elapsed),
GObject.Value(GObject.TYPE_UINT64, filecount),
GObject.Value(GObject.TYPE_UINT64, place), transfer))
transfer.iter = iterator
# Expand path
if parent is not None:
transfer_path = self.transfersmodel.get_path(iterator)
if self.tree_users == "folder_grouping":
# Group by folder, we need the user path to expand it
user_path = self.transfersmodel.get_path(self.users[user])
else:
user_path = None
self.expand(transfer_path, user_path)
def update_parent_row(self, initer):
speed = 0.0
percent = totalsize = position = 0
hspeed = helapsed = left = ""
elapsed = 0
filecount = 0
salientstatus = ""
extensions = {}
iterator = self.transfersmodel.iter_children(initer)
while iterator is not None:
status = self.transfersmodel.get_value(iterator, 11)
if salientstatus in (
'', "Finished",
"Filtered"): # we prefer anything over ''/finished
salientstatus = status
filename = self.transfersmodel.get_value(iterator, 2)
parts = filename.rsplit('.', 1)
if len(parts) == 2:
ext = parts[1]
try:
extensions[ext.lower()] += 1
except KeyError:
extensions[ext.lower()] = 1
filecount += self.transfersmodel.get_value(iterator, 16)
if status == "Filtered":
# We don't want to count filtered files when calculating the progress
iterator = self.transfersmodel.iter_next(iterator)
continue
elapsed += self.transfersmodel.get_value(iterator, 15)
totalsize += self.transfersmodel.get_value(iterator, 12)
position += self.transfersmodel.get_value(iterator, 13)
if status == "Transferring":
speed += float(self.transfersmodel.get_value(iterator, 14))
left = self.transfersmodel.get_value(iterator, 9)
if status in ("Transferring", "Banned", "Getting address",
"Establishing connection"):
salientstatus = status
iterator = self.transfersmodel.iter_next(iterator)
if totalsize > 0:
percent = min(((100 * position) / totalsize), 100)
else:
percent = 100
if speed > 0:
hspeed = human_speed(speed)
left = self.frame.np.transfers.get_time(
(totalsize - position) / speed)
if elapsed > 0:
helapsed = self.frame.np.transfers.get_time(elapsed)
if not extensions:
extensions = ""
elif len(extensions) == 1:
extensions = " (" + self.extension_list_template % {
'ext': next(iter(extensions))
} + ")"
else:
extensions = " (" + ", ".join(
(str(count) + " " + ext
for (ext, count) in extensions.items())) + ")"
self.transfersmodel.set_value(
initer, 2,
self.files_template % {'number': filecount} + extensions)
self.transfersmodel.set_value(initer, 3,
self.translate_status(salientstatus))
self.transfersmodel.set_value(
initer, 5, GObject.Value(GObject.TYPE_UINT64, percent))
self.transfersmodel.set_value(
initer, 6,
"%s / %s" % (human_size(position), human_size(totalsize)))
self.transfersmodel.set_value(initer, 7, hspeed)
self.transfersmodel.set_value(initer, 8, helapsed)
self.transfersmodel.set_value(initer, 9, left)
self.transfersmodel.set_value(initer, 11, salientstatus)
self.transfersmodel.set_value(
initer, 12, GObject.Value(GObject.TYPE_UINT64, totalsize))
self.transfersmodel.set_value(
initer, 13, GObject.Value(GObject.TYPE_UINT64, position))
self.transfersmodel.set_value(
initer, 14, GObject.Value(GObject.TYPE_UINT64, speed))
self.transfersmodel.set_value(
initer, 15, GObject.Value(GObject.TYPE_UINT64, elapsed))
self.transfersmodel.set_value(
initer, 16, GObject.Value(GObject.TYPE_UINT64, filecount))
def add_result_list(self,
result_list,
user,
country,
inqueue,
ulspeed,
h_speed,
h_queue,
color,
private=False):
""" Adds a list of search results to the treeview. Lists can either contain publicly or
privately shared files. """
update_ui = False
for result in result_list:
if self.num_results_found >= self.max_limit:
self.max_limited = True
break
fullpath = result[1]
fullpath_lower = fullpath.lower()
if any(word in fullpath_lower
for word in self.searchterm_words_ignore):
# Filter out results with filtered words (e.g. nicotine -music)
log.add_debug((
"Filtered out excluded search result %(filepath)s from user %(user)s for "
"search term \"%(query)s\""), {
"filepath": fullpath,
"user": user,
"query": self.text
})
continue
if not any(word in fullpath_lower
for word in self.searchterm_words_include):
# Certain users may send us wrong results, filter out such ones
log.add_search(
_("Filtered out incorrect search result %(filepath)s from user %(user)s for "
"search query \"%(query)s\""), {
"filepath": fullpath,
"user": user,
"query": self.text
})
continue
self.num_results_found += 1
fullpath_split = fullpath.split('\\')
if config.sections["ui"]["reverse_file_paths"]:
# Reverse file path, file name is the first item. next() retrieves the name and removes
# it from the iterator.
fullpath_split = reversed(fullpath_split)
name = next(fullpath_split)
else:
# Regular file path, file name is the last item. Retrieve it and remove it from the list.
name = fullpath_split.pop()
# Join the resulting items into a folder path
directory = '\\'.join(fullpath_split)
size = result[2]
h_size = human_size(size)
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, result[4])
if private:
name = _("[PRIVATE] %s") % name
is_result_visible = self.append([
self.num_results_found, user,
get_flag_icon_name(country), h_speed, h_queue, directory, name,
h_size, h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT, bitrate), fullpath, country,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT, ulspeed),
GObject.Value(GObject.TYPE_UINT64, inqueue),
GObject.Value(GObject.TYPE_UINT, length),
GObject.Value(GObject.TYPE_STRING, color)
])
if is_result_visible:
update_ui = True
return update_ui
def add_result_list(self,
result_list,
counter,
user,
country,
inqueue,
ulspeed,
h_speed,
imdl,
h_queue,
color,
private=False):
""" Adds a list of search results to the treeview. Lists can either contain publicly or
privately shared files. """
update_ui = False
max_results = config.sections["searches"]["max_displayed_results"]
for result in result_list:
if counter > max_results:
break
fullpath = result[1]
fullpath_lower = fullpath.lower()
if any(word in fullpath_lower
for word in self.searchterm_words_ignore):
""" Filter out results with filtered words (e.g. nicotine -music) """
log.add_search(
_("Filtered out excluded search result " + fullpath +
" from user " + user))
continue
if not any(word in fullpath_lower
for word in self.searchterm_words_include):
""" Some users may send us wrong results, filter out such ones """
log.add_search(
_("Filtered out inexact or incorrect search result " +
fullpath + " from user " + user))
continue
fullpath_split = fullpath.split('\\')
if config.sections["ui"]["reverse_file_paths"]:
# Reverse file path, file name is the first item. next() retrieves the name and removes
# it from the iterator.
fullpath_split = reversed(fullpath_split)
name = next(fullpath_split)
else:
# Regular file path, file name is the last item. Retrieve it and remove it from the list.
name = fullpath_split.pop()
# Join the resulting items into a folder path
directory = '\\'.join(fullpath_split)
size = result[2]
h_size = human_size(size)
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, result[4])
if private:
name = "[PRIVATE FILE] " + name
is_result_visible = self.append([
GObject.Value(GObject.TYPE_UINT64, counter), user,
GObject.Value(GObject.TYPE_OBJECT,
self.frame.get_flag_image(country)), imdl,
h_speed, h_queue, directory, name, h_size, h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, bitrate), fullpath, country,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT64, ulspeed),
GObject.Value(GObject.TYPE_UINT64, inqueue),
GObject.Value(GObject.TYPE_UINT64, length),
GObject.Value(GObject.TYPE_STRING, color)
])
if is_result_visible:
update_ui = True
counter += 1
return update_ui, counter
def add_user_results(self, msg, user, country):
if user in self.users:
return
self.users.add(user)
counter = len(self.all_data) + 1
inqueue = msg.inqueue
ulspeed = msg.ulspeed
h_speed = human_speed(ulspeed)
if msg.freeulslots:
imdl = "Y"
inqueue = 0
else:
imdl = "N"
color_id = (imdl == "Y" and "search" or "searchq")
color = config.sections["ui"][color_id] or None
h_queue = humanize(inqueue)
update_ui = False
maxstoredresults = config.sections["searches"]["max_stored_results"]
for result in msg.list:
if counter > maxstoredresults:
break
fullpath = result[1]
fullpath_lower = fullpath.lower()
if any(word in fullpath_lower
for word in self.searchterm_words_ignore):
""" Filter out results with filtered words (e.g. nicotine -music) """
log.add_search(
_("Filtered out excluded search result " + fullpath +
" from user " + user))
continue
if not any(word in fullpath_lower
for word in self.searchterm_words_include):
""" Some users may send us wrong results, filter out such ones """
log.add_search(
_("Filtered out inexact or incorrect search result " +
fullpath + " from user " + user))
continue
fullpath_split = reversed(fullpath.split('\\'))
name = next(fullpath_split)
directory = '\\'.join(fullpath_split)
size = result[2]
h_size = human_size(size)
h_bitrate, bitrate, h_length, length = get_result_bitrate_length(
size, result[4])
is_result_visible = self.append([
GObject.Value(GObject.TYPE_UINT64, counter), user,
GObject.Value(GObject.TYPE_OBJECT,
self.frame.get_flag_image(country)), imdl,
h_speed, h_queue, directory, name, h_size, h_bitrate, h_length,
GObject.Value(GObject.TYPE_UINT64, bitrate), fullpath, country,
GObject.Value(GObject.TYPE_UINT64, size),
GObject.Value(GObject.TYPE_UINT64, ulspeed),
GObject.Value(GObject.TYPE_UINT64, inqueue),
GObject.Value(GObject.TYPE_UINT64, length),
GObject.Value(GObject.TYPE_STRING, color)
])
if is_result_visible:
update_ui = True
counter += 1
if update_ui:
# If this search wasn't initiated by us (e.g. wishlist), and the results aren't spoofed, show tab
if not self.showtab:
self.searches.show_tab(self, self.id, self.text, self.mode)
self.showtab = True
# Update number of results
self.update_result_counter()
# Update tab notification
self.frame.searches.request_changed(self.Main)
self.frame.request_tab_icon(self.frame.SearchTabLabel)