class TransferList: def __init__(self, frame, type): self.frame = frame self.type = type load_ui_elements(self, os.path.join(frame.gui_dir, "ui", type + "s.ui")) getattr(frame, type + "svbox").add(self.Main) self.widget = widget = getattr(self, type.title() + "List") self.last_ui_update = self.last_save = 0 self.list = [] self.users = {} self.paths = {} # Status list self.statuses = {} self.statuses["Queued"] = _("Queued") self.statuses["Getting status"] = _("Getting status") self.statuses["Establishing connection"] = _("Establishing connection") self.statuses["Transferring"] = _("Transferring") self.statuses["Cannot connect"] = _("Cannot connect") self.statuses["User logged off"] = _("User logged off") self.statuses["Connection closed by peer"] = _( "Connection closed by peer") self.statuses["Aborted"] = _("Aborted") self.statuses["Finished"] = _("Finished") self.statuses["Filtered"] = _("Filtered") self.statuses["File not shared"] = _("File not shared") self.statuses["File not shared."] = _( "File not shared" ) # The official client sends a variant containing a dot self.statuses["Download directory error"] = _( "Download directory error") self.statuses["Local file error"] = _("Local file error") self.statuses["Remote file error"] = _("Remote file error") # String templates self.extension_list_template = _("All %(ext)s") self.files_template = _("%(number)2s files ") self.transfersmodel = Gtk.TreeStore( str, # (0) user str, # (1) path str, # (2) file name str, # (3) status str, # (4) hqueue position GObject.TYPE_UINT64, # (5) percent str, # (6) hsize str, # (7) hspeed str, # (8) htime elapsed str, # (9) time left str, # (10) path str, # (11) status (non-translated) GObject.TYPE_UINT64, # (12) size GObject.TYPE_UINT64, # (13) current bytes GObject.TYPE_UINT64, # (14) speed GObject.TYPE_UINT64, # (15) time elapsed GObject.TYPE_UINT64, # (16) file count GObject.TYPE_UINT64, # (17) queue position GObject.TYPE_PYOBJECT # (18) transfer object ) self.column_numbers = list(range(self.transfersmodel.get_n_columns())) self.cols = cols = initialise_columns( type, widget, ["user", _("User"), 200, "text", None], ["path", _("Path"), 400, "text", None], ["filename", _("Filename"), 400, "text", None], ["status", _("Status"), 140, "text", None], ["queue_position", _("Queue Position"), 50, "number", None], ["percent", _("Percent"), 70, "progress", None], ["size", _("Size"), 170, "number", None], ["speed", _("Speed"), 90, "number", None], ["time_elapsed", _("Time Elapsed"), 140, "number", None], ["time_left", _("Time Left"), 140, "number", None], ) cols["user"].set_sort_column_id(0) cols["path"].set_sort_column_id(1) cols["filename"].set_sort_column_id(2) cols["status"].set_sort_column_id(11) cols["queue_position"].set_sort_column_id(17) cols["percent"].set_sort_column_id(5) cols["size"].set_sort_column_id(12) cols["speed"].set_sort_column_id(14) cols["time_elapsed"].set_sort_column_id(8) cols["time_left"].set_sort_column_id(9) widget.set_model(self.transfersmodel) self.group_dropdown = getattr(frame, "ToggleTree%ss" % self.type.title()) self.expand_button = getattr(frame, "Expand%ss" % self.type.title()) self.group_dropdown.connect("changed", self.on_toggle_tree) self.group_dropdown.set_active( config.sections["transfers"]["group%ss" % self.type]) self.expand_button.connect("toggled", self.on_expand_tree) self.expand_button.set_active( config.sections["transfers"]["%ssexpanded" % self.type]) self.popup_menu_users = PopupMenu(frame) self.popup_menu_clear = PopupMenu(frame) self.popup_menu = PopupMenu(frame) self.popup_menu.setup( ("#" + "selected_files", None), ("", None), ("#" + _("Send to _Player"), self.on_play_files), ("#" + _("_Open Folder"), self.on_open_directory), ("#" + _("File P_roperties"), self.on_file_properties), ("", None), ("#" + _("Copy _File Path"), self.on_copy_file_path), ("#" + _("Copy _URL"), self.on_copy_url), ("#" + _("Copy Folder URL"), self.on_copy_dir_url), ("", None), ("#" + _("_Search"), self.on_file_search), (">" + _("User(s)"), self.popup_menu_users), ("", None), ("#" + _("_Retry"), self.on_retry_transfer), ("#" + _("Abor_t"), self.on_abort_transfer), ("#" + _("_Clear"), self.on_clear_transfer), ("", None), (">" + _("Clear Groups"), self.popup_menu_clear)) self.update_visuals() def init_interface(self, list): self.list = list self.widget.set_sensitive(True) self.update() def rebuild_transfers(self): if self.frame.np.transfers is None: return self.clear() self.update() def save_columns(self): save_columns(self.type, self.widget.get_columns()) def update_visuals(self): for widget in list(self.__dict__.values()): update_widget_visuals(widget, list_font_target="transfersfont") def conn_close(self): self.widget.set_sensitive(False) self.list = [] self.clear() def select_transfers(self): self.selected_transfers = set() self.selected_users = set() model, paths = self.widget.get_selection().get_selected_rows() for path in paths: iterator = model.get_iter(path) self.select_transfer(model, iterator, select_user=True) # If we're in grouping mode, select any transfers under the selected # user or folder self.select_child_transfers(model, model.iter_children(iterator)) def select_child_transfers(self, model, iterator): while iterator is not None: self.select_transfer(model, iterator) self.select_child_transfers(model, model.iter_children(iterator)) iterator = model.iter_next(iterator) def select_transfer(self, model, iterator, select_user=False): user = model.get_value(iterator, 0) transfer = model.get_value(iterator, 18) if isinstance(transfer, Transfer): self.selected_transfers.add(transfer) if select_user: self.selected_users.add(user) def new_transfer_notification(self): self.frame.request_tab_icon(self.tab_label) def on_ban(self, *args): self.select_transfers() for user in self.selected_users: self.frame.np.network_filter.ban_user(user) def on_file_search(self, *args): transfer = next(iter(self.selected_transfers), None) if not transfer: return self.frame.SearchEntry.set_text(transfer.filename.rsplit("\\", 1)[1]) self.frame.change_main_page("search") def translate_status(self, status): try: newstatus = self.statuses[status] except KeyError: newstatus = status return newstatus def update(self, transfer=None, forceupdate=False): if not self.widget.get_sensitive(): """ List is not initialized """ return curtime = time() if (curtime - self.last_save) > 15: """ Save downloads list to file every 15 seconds """ if self.frame.np.transfers is not None: self.frame.np.transfers.save_downloads() self.last_save = curtime finished = (transfer is not None and transfer.status == "Finished") if forceupdate or finished or \ (curtime - self.last_ui_update) > 1: self.frame.update_bandwidth() if not forceupdate and self.frame.current_tab_label != self.tab_label: """ No need to do unnecessary work if transfers are not visible """ return if transfer is not None: self.update_specific(transfer) elif self.list is not None: for transfer in reversed(self.list): self.update_specific(transfer) if forceupdate or finished or \ (curtime - self.last_ui_update) > 1: """ Unless a transfer finishes, use a cooldown to avoid updating too often """ self.update_parent_rows() def update_parent_rows(self, only_remove=False): # Remove empty parent rows for path, pathiter in list(self.paths.items()): if not self.transfersmodel.iter_has_child(pathiter): self.transfersmodel.remove(pathiter) del self.paths[path] elif not only_remove: self.update_parent_row(pathiter) for username, useriter in list(self.users.items()): if isinstance(useriter, Gtk.TreeIter): if not self.transfersmodel.iter_has_child(useriter): self.transfersmodel.remove(useriter) del self.users[username] elif not only_remove: self.update_parent_row(useriter) else: # No grouping if not self.users[username]: del self.users[username] self.frame.update_bandwidth() self.last_ui_update = time() 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 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 retry_transfers(self): for transfer in self.selected_transfers: getattr(self.frame.np.transfers, "retry_" + self.type)(transfer) def abort_transfers(self, clear=False): for transfer in self.selected_transfers: if transfer.status != "Finished": self.frame.np.transfers.abort_transfer(transfer, send_fail_message=True) if not clear: transfer.status = "Aborted" self.update(transfer) if clear: self.remove_specific(transfer) def remove_specific(self, transfer, cleartreeviewonly=False): user = transfer.user if user in self.users and not isinstance(self.users[user], Gtk.TreeIter): # No grouping self.users[user].discard(transfer) if transfer in self.frame.np.transfers.transfer_request_times: del self.frame.np.transfers.transfer_request_times[transfer] if not cleartreeviewonly: self.list.remove(transfer) if transfer.iter is not None: self.transfersmodel.remove(transfer.iter) self.update_parent_rows(only_remove=True) def clear_transfers(self, status): for transfer in self.list.copy(): if transfer.status in status: self.frame.np.transfers.abort_transfer(transfer, send_fail_message=True) self.remove_specific(transfer) def clear(self): self.users.clear() self.paths.clear() self.selected_transfers = set() self.selected_users = set() self.transfersmodel.clear() if self.list is not None: for transfer in self.list: transfer.iter = None def double_click(self, event): self.select_transfers() dc = config.sections["transfers"]["%s_doubleclick" % self.type] if dc == 1: # Send to player self.on_play_files() elif dc == 2: # File manager self.on_open_directory() elif dc == 3: # Search self.on_file_search() elif dc == 4: # Abort self.abort_transfers() elif dc == 5: # Clear self.abort_transfers(clear=True) elif dc == 6: # Retry self.retry_transfers() def populate_popup_menu_users(self): self.popup_menu_users.clear() if not self.selected_users: return for user in self.selected_users: popup = PopupMenu(self.frame) popup.setup_user_menu(user) popup.setup(("", None), ("#" + _("Select User's Transfers"), self.on_select_user_transfers, user)) popup.toggle_user_items() self.popup_menu_users.setup((">" + user, popup)) def expand(self, transfer_path, user_path): if self.expand_button.get_active(): self.widget.expand_to_path(transfer_path) elif user_path and self.tree_users == "folder_grouping": # Group by folder, show user folders in collapsed mode self.widget.expand_to_path(user_path) def on_expand_tree(self, widget): expand_button_icon = getattr(self.frame, "Expand%ssImage" % self.type.title()) expanded = widget.get_active() if expanded: self.widget.expand_all() expand_button_icon.set_from_icon_name("go-up-symbolic", Gtk.IconSize.BUTTON) else: collapse_treeview(self.widget, self.tree_users) expand_button_icon.set_from_icon_name("go-down-symbolic", Gtk.IconSize.BUTTON) config.sections["transfers"]["%ssexpanded" % self.type] = expanded config.write_configuration() def on_toggle_tree(self, widget): active = widget.get_active() config.sections["transfers"]["group%ss" % self.type] = active self.widget.set_show_expanders(active) self.expand_button.set_visible(active) self.tree_users = widget.get_active_id() self.rebuild_transfers() def on_tooltip(self, widget, x, y, keyboard_mode, tooltip): return show_file_path_tooltip(widget, x, y, tooltip, 10) def on_popup_menu(self, *args): self.select_transfers() num_selected_transfers = len(self.selected_transfers) actions = self.popup_menu.get_actions() users = len(self.selected_users) > 0 files = num_selected_transfers > 0 actions[_("User(s)")].set_enabled(users) # Users Menu self.populate_popup_menu_users() if files: act = True else: # Disable options # Send to player, File manager, file properties, Copy File Path, Copy URL, Copy Folder URL, Search filename act = False for i in (_("Send to _Player"), _("_Open Folder"), _("File P_roperties"), _("Copy _File Path"), _("Copy _URL"), _("Copy Folder URL"), _("_Search")): actions[i].set_enabled(act) if not users or not files: # Disable options # Retry, Abort, Clear act = False else: act = True for i in (_("_Retry"), _("Abor_t"), _("_Clear")): actions[i].set_enabled(act) self.popup_menu.set_num_selected_files(num_selected_transfers) self.popup_menu.popup() return True def on_list_clicked(self, widget, event): if triggers_context_menu(event): set_treeview_selected_row(widget, event) return self.on_popup_menu() if event.button == 1 and event.type == Gdk.EventType._2BUTTON_PRESS: self.double_click(event) return True return False def on_select_user_transfers(self, *args): if not self.selected_users: return selected_user = args[-1] sel = self.widget.get_selection() fmodel = self.widget.get_model() sel.unselect_all() iterator = fmodel.get_iter_first() select_user_row_iter(fmodel, sel, 0, selected_user, iterator) self.select_transfers() def on_key_press_event(self, widget, event): keycode = event.hardware_keycode self.select_transfers() if keycode in keyval_to_hardware_keycode(Gdk.KEY_t): self.abort_transfers() elif keycode in keyval_to_hardware_keycode(Gdk.KEY_r): self.retry_transfers() elif event.get_state() & Gdk.ModifierType.CONTROL_MASK and \ keycode in keyval_to_hardware_keycode(Gdk.KEY_c): self.on_copy_file_path() elif keycode in keyval_to_hardware_keycode(Gdk.KEY_Delete): self.abort_transfers(clear=True) else: # No key match, continue event return False widget.stop_emission_by_name("key_press_event") return True 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 on_copy_file_path(self, *args): transfer = next(iter(self.selected_transfers), None) if transfer: self.frame.clipboard.set_text(transfer.filename, -1) def on_copy_url(self, *args): transfer = next(iter(self.selected_transfers), None) if transfer: copy_file_url(transfer.user, transfer.filename, self.frame.clipboard) def on_copy_dir_url(self, *args): transfer = next(iter(self.selected_transfers), None) if transfer: copy_file_url(transfer.user, transfer.filename.rsplit('\\', 1)[0] + '\\', self.frame.clipboard) def on_retry_transfer(self, *args): self.select_transfers() self.retry_transfers() def on_abort_transfer(self, *args): self.select_transfers() self.abort_transfers() def on_clear_transfer(self, *args): self.select_transfers() self.abort_transfers(clear=True) def on_clear_response(self, dialog, response_id, data): dialog.destroy() if response_id == Gtk.ResponseType.OK: self.clear_transfers(["Queued"]) def on_clear_queued(self, *args): self.clear_transfers(["Queued"]) def on_clear_finished(self, *args): self.clear_transfers(["Finished"])
class Search(UserInterface): def __init__(self, searches, text, token, mode, mode_label, showtab): super().__init__("ui/search.ui") self.searches = searches self.frame = searches.frame self.filter_help = UserInterface("ui/popovers/searchfilters.ui") self.text = text self.searchterm_words_include = [] self.searchterm_words_ignore = [] for word in text.lower().split(): if word.startswith('*'): if len(word) > 1: self.searchterm_words_include.append(word[1:]) elif word.startswith('-'): if len(word) > 1: self.searchterm_words_ignore.append(word[1:]) else: self.searchterm_words_include.append(word) self.token = token self.mode = mode self.mode_label = mode_label self.showtab = showtab self.usersiters = {} self.directoryiters = {} self.users = set() self.all_data = [] self.selected_results = [] self.selected_users = [] self.selected_files_count = 0 self.grouping_mode = None self.filters = None self.clearing_filters = False self.active_filter_count = 0 self.num_results_found = 0 self.num_results_visible = 0 self.max_limit = config.sections["searches"]["max_displayed_results"] self.max_limited = False self.operators = { '<': operator.lt, '<=': operator.le, '==': operator.eq, '!=': operator.ne, '>=': operator.ge, '>': operator.gt } # Columns self.treeview_name = "file_search" self.resultsmodel = Gtk.TreeStore( int, # (0) num str, # (1) user str, # (2) flag str, # (3) h_speed str, # (4) h_queue str, # (5) directory str, # (6) filename str, # (7) h_size str, # (8) h_bitrate str, # (9) h_length GObject.TYPE_UINT, # (10) bitrate str, # (11) fullpath str, # (12) country GObject.TYPE_UINT64, # (13) size GObject.TYPE_UINT, # (14) speed GObject.TYPE_UINT64, # (15) queue GObject.TYPE_UINT, # (16) length str # (17) color ) self.column_offsets = {} self.column_numbers = list(range(self.resultsmodel.get_n_columns())) color_col = 17 self.cols = cols = initialise_columns( self.frame, "file_search", self.ResultsList, ["id", _("ID"), 50, "number", color_col], ["user", _("User"), 200, "text", color_col], ["country", _("Country"), 25, "icon", None], ["speed", _("Speed"), 100, "number", color_col], ["in_queue", _("In Queue"), 90, "number", color_col], ["folder", _("Folder"), 400, "text", color_col], ["filename", _("Filename"), 400, "text", color_col], ["size", _("Size"), 100, "number", color_col], ["bitrate", _("Bitrate"), 100, "number", color_col], ["length", _("Length"), 100, "number", color_col]) cols["id"].set_sort_column_id(0) cols["user"].set_sort_column_id(1) cols["country"].set_sort_column_id(12) cols["speed"].set_sort_column_id(14) cols["in_queue"].set_sort_column_id(15) cols["folder"].set_sort_column_id(5) cols["filename"].set_sort_column_id(6) cols["size"].set_sort_column_id(13) cols["bitrate"].set_sort_column_id(10) cols["length"].set_sort_column_id(16) cols["country"].get_widget().hide() self.ResultsList.set_model(self.resultsmodel) for column in self.ResultsList.get_columns(): self.column_offsets[column.get_title()] = 0 column.connect("notify::x-offset", self.on_column_position_changed) self.update_visuals() # Popup menus self.popup_menu_users = PopupMenu(self.frame) self.popup_menu_copy = PopupMenu(self.frame) self.popup_menu_copy.add_items( ("#" + _("Copy _File Path"), self.on_copy_file_path), ("#" + _("Copy _URL"), self.on_copy_url), ("#" + _("Copy Folder U_RL"), self.on_copy_dir_url)) self.popup_menu = PopupMenu(self.frame, self.ResultsList, self.on_popup_menu) self.popup_menu.add_items( ("#" + "selected_files", None), ("", None), ("#" + _("_Download File(s)"), self.on_download_files), ("#" + _("Download File(s) _To…"), self.on_download_files_to), ("#" + _("Download _Folder(s)"), self.on_download_folders), ("#" + _("Download F_older(s) To…"), self.on_download_folders_to), ("", None), ("#" + _("_Browse Folder(s)"), self.on_browse_folder), ("#" + _("F_ile Properties"), self.on_file_properties), ("", None), (">" + _("Copy"), self.popup_menu_copy), (">" + _("User(s)"), self.popup_menu_users)) self.tab_menu = PopupMenu(self.frame) self.tab_menu.add_items( ("#" + _("Copy Search Term"), self.on_copy_search_term), ("", None), ("#" + _("Clear All Results"), self.on_clear), ("#" + _("Close All Tabs…"), self.on_close_all_tabs), ("#" + _("_Close Tab"), self.on_close)) # Key bindings for widget in (self.Main, self.ResultsList): Accelerator("<Primary>f", widget, self.on_show_filter_bar_accelerator) Accelerator("Escape", self.FiltersContainer, self.on_close_filter_bar_accelerator) Accelerator("<Alt>Return", self.ResultsList, self.on_file_properties_accelerator) # Grouping menu = create_grouping_menu( self.frame.MainWindow, config.sections["searches"]["group_searches"], self.on_group) self.ResultGrouping.set_menu_model(menu) self.ExpandButton.set_active( config.sections["searches"]["expand_searches"]) # Filters self.filter_comboboxes = { "filterin": self.FilterIn, "filterout": self.FilterOut, "filtersize": self.FilterSize, "filterbr": self.FilterBitrate, "filtercc": self.FilterCountry, "filtertype": self.FilterType } self.ShowFilters.set_active( config.sections["searches"]["filters_visible"]) self.populate_filters() # Wishlist self.update_wish_button() def set_label(self, label): self.tab_menu.set_parent(label) @staticmethod def on_tooltip(widget, pos_x, pos_y, _keyboard_mode, tooltip): country_tooltip = show_country_tooltip(widget, pos_x, pos_y, tooltip, 12, strip_prefix="") file_path_tooltip = show_file_path_tooltip(widget, pos_x, pos_y, tooltip, 11) if country_tooltip: return country_tooltip if file_path_tooltip: return file_path_tooltip return False def focus_combobox(self, button): # We have the button of a combobox, find the entry parent = button.get_parent() if parent is None: return if isinstance(parent, Gtk.ComboBox): entry = parent.get_child() entry.grab_focus() GLib.idle_add(entry.emit, "activate") return self.focus_combobox(parent) def update_filter_comboboxes(self): for filter_id, widget in self.filter_comboboxes.items(): presets = "" widget.remove_all() if filter_id == "filterbr": presets = ("0", "128", "160", "192", "256", "320") elif filter_id == "filtersize": presets = (">10MiB", "<10MiB", "<5MiB", "<1MiB", ">0") elif filter_id == "filtertype": presets = ("flac|wav|ape|aiff|wv|cue", "mp3|m4a|aac|ogg|opus|wma", "!mp3") for value in presets: widget.append_text(value) for value in config.sections["searches"][filter_id]: if value not in presets: widget.append_text(value) def populate_filters(self): if not config.sections["searches"]["enablefilters"]: return sfilter = config.sections["searches"]["defilter"] num_filters = len(sfilter) if num_filters > 0: self.FilterIn.get_child().set_text(str(sfilter[0])) if num_filters > 1: self.FilterOut.get_child().set_text(str(sfilter[1])) if num_filters > 2: self.FilterSize.get_child().set_text(str(sfilter[2])) if num_filters > 3: self.FilterBitrate.get_child().set_text(str(sfilter[3])) if num_filters > 4: self.FilterFreeSlot.set_active(bool(sfilter[4])) if num_filters > 5: self.FilterCountry.get_child().set_text(str(sfilter[5])) if num_filters > 6: self.FilterType.get_child().set_text(str(sfilter[6])) self.on_refilter() 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_user_results(self, msg, user, country): if user in self.users: return self.users.add(user) if msg.freeulslots: inqueue = 0 h_queue = "" else: inqueue = msg.inqueue or 1 # Ensure value is always >= 1 h_queue = humanize(inqueue) h_speed = "" ulspeed = msg.ulspeed or 0 if ulspeed > 0: h_speed = human_speed(ulspeed) color_id = "search" if msg.freeulslots else "searchq" color = config.sections["ui"][color_id] or None update_ui = self.add_result_list(msg.list, user, country, inqueue, ulspeed, h_speed, h_queue, color) if msg.privatelist: update_ui_private = self.add_result_list(msg.privatelist, user, country, inqueue, ulspeed, h_speed, h_queue, color, private=True) if not update_ui and update_ui_private: update_ui = True 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.text) self.showtab = True self.searches.request_tab_hilite(self.Main) # Update number of results, even if they are all filtered self.update_result_counter() def append(self, row): self.all_data.append(row) if not self.check_filter(row): return False self.add_row_to_model(row) return True def add_row_to_model(self, row): (_counter, user, flag, h_speed, h_queue, directory, _filename, _h_size, _h_bitrate, _h_length, _bitrate, fullpath, country, _size, speed, queue, _length, color) = row expand_user = False expand_folder = False if self.grouping_mode != "ungrouped": # Group by folder or user empty_int = 0 empty_str = "" if user not in self.usersiters: self.usersiters[user] = self.resultsmodel.insert_with_values( None, -1, self.column_numbers, [ empty_int, user, flag, h_speed, h_queue, empty_str, empty_str, empty_str, empty_str, empty_str, empty_int, empty_str, country, empty_int, speed, queue, empty_int, color ]) if self.grouping_mode == "folder_grouping": expand_user = True else: expand_user = self.ExpandButton.get_active() parent = self.usersiters[user] if self.grouping_mode == "folder_grouping": # Group by folder user_directory = user + directory if user_directory not in self.directoryiters: self.directoryiters[ user_directory] = self.resultsmodel.insert_with_values( self.usersiters[user], -1, self.column_numbers, [ empty_int, user, flag, h_speed, h_queue, directory, empty_str, empty_str, empty_str, empty_str, empty_int, fullpath.rsplit('\\', 1)[0] + '\\', country, empty_int, speed, queue, empty_int, color ]) expand_folder = self.ExpandButton.get_active() row = row[:] row[5] = "" # Directory not visible for file row if "group by folder" is enabled parent = self.directoryiters[user_directory] else: parent = None try: """ Note that we use insert_with_values instead of append, as this reduces overhead by bypassing useless row conversion to GObject.Value in PyGObject. """ iterator = self.resultsmodel.insert_with_values( parent, -1, self.column_numbers, row) if expand_user: self.ResultsList.expand_row( self.resultsmodel.get_path(self.usersiters[user]), False) if expand_folder: self.ResultsList.expand_row( self.resultsmodel.get_path( self.directoryiters[user_directory]), False) self.num_results_visible += 1 except Exception as error: types = [] for i in row: types.append(type(i)) log.add("Search row error: %(exception)s %(row)s", { 'exception': error, 'row': row }) iterator = None return iterator def check_digit(self, sfilter, value, factorize=True): used_operator = ">=" if sfilter.startswith((">", "<", "=")): used_operator, sfilter = sfilter[:1] + "=", sfilter[1:] if not sfilter: return True factor = 1 if factorize: base = 1024 # Default to binary for "k", "m", "g" suffixes if sfilter[-1:].lower() == 'b': base = 1000 # Byte suffix detected, prepare to use decimal if necessary sfilter = sfilter[:-1] if sfilter[-1:].lower() == 'i': base = 1024 # Binary requested, stop using decimal sfilter = sfilter[:-1] if sfilter.lower()[-1:] == "g": factor = pow(base, 3) sfilter = sfilter[:-1] elif sfilter.lower()[-1:] == "m": factor = pow(base, 2) sfilter = sfilter[:-1] elif sfilter.lower()[-1:] == "k": factor = base sfilter = sfilter[:-1] if not sfilter: return True try: sfilter = int(sfilter) * factor except ValueError: return True operation = self.operators.get(used_operator) return operation(value, sfilter) @staticmethod def check_country(sfilter, value): if not isinstance(value, str): return False value = value.upper() allowed = False for country_code in sfilter.split("|"): if country_code == value: allowed = True elif country_code.startswith("!") and country_code[1:] != value: allowed = True elif country_code.startswith("!") and country_code[1:] == value: return False return allowed @staticmethod def check_file_type(sfilter, value): if not isinstance(value, str): return False value = value.lower() allowed = False for ext in sfilter.split("|"): exclude_ext = None if ext.startswith("!"): exclude_ext = ext[1:] if not exclude_ext.startswith("."): exclude_ext = "." + exclude_ext elif not ext.startswith("."): ext = "." + ext if not ext.startswith("!") and value.endswith(ext): allowed = True elif ext.startswith("!") and not value.endswith(exclude_ext): allowed = True elif ext.startswith("!") and value.endswith(exclude_ext): return False return allowed def check_filter(self, row): if self.active_filter_count == 0: return True filters = self.filters # "Included text"-filter, check full file path (located at index 11 in row) if filters["filterin"] and not filters["filterin"].search( row[11].lower()): return False # "Excluded text"-filter, check full file path (located at index 11 in row) if filters["filterout"] and filters["filterout"].search( row[11].lower()): return False if filters["filtersize"] and not self.check_digit( filters["filtersize"], row[13].get_uint64()): return False if filters["filterbr"] and not self.check_digit( filters["filterbr"], row[10].get_uint(), False): return False if filters["filterslot"] and row[15].get_uint64() > 0: return False if filters["filtercc"] and not self.check_country( filters["filtercc"], row[12]): return False if filters["filtertype"] and not self.check_file_type( filters["filtertype"], row[11]): return False return True def update_filter_counter(self, count): if count > 0: self.FilterLabel.set_label(_("_Result Filters [%d]") % count) else: self.FilterLabel.set_label(_("_Result Filters")) self.FilterLabel.set_tooltip_text("%d active filter(s)" % count) def update_results_model(self): # Temporarily disable sorting for increased performance sort_column, sort_type = self.resultsmodel.get_sort_column_id() self.resultsmodel.set_default_sort_func(lambda *_args: 0) self.resultsmodel.set_sort_column_id(-1, Gtk.SortType.ASCENDING) self.usersiters.clear() self.directoryiters.clear() self.resultsmodel.clear() self.num_results_visible = 0 for row in self.all_data: if self.check_filter(row): self.add_row_to_model(row) # Update number of results self.update_result_counter() self.update_filter_counter(self.active_filter_count) if sort_column is not None and sort_type is not None: self.resultsmodel.set_sort_column_id(sort_column, sort_type) if self.grouping_mode != "ungrouped": # Group by folder or user if self.ExpandButton.get_active(): self.ResultsList.expand_all() else: collapse_treeview(self.ResultsList, self.grouping_mode) def update_wish_button(self): if self.mode not in ("global", "wishlist"): self.AddWish.hide() return if not self.frame.np.search.is_wish(self.text): self.AddWishIcon.set_property("icon-name", "list-add-symbolic") self.AddWishLabel.set_label(_("Add Wi_sh")) return self.AddWishIcon.set_property("icon-name", "list-remove-symbolic") self.AddWishLabel.set_label(_("Remove Wi_sh")) def on_add_wish(self, *_args): if self.frame.np.search.is_wish(self.text): self.frame.np.search.remove_wish(self.text) else: self.frame.np.search.add_wish(self.text) def add_popup_menu_user(self, popup, user): popup.setup_user_menu(user) popup.add_items(("", None), ("#" + _("Select User's Results"), self.on_select_user_results, user)) popup.update_model() popup.toggle_user_items() def populate_popup_menu_users(self): self.popup_menu_users.clear() if not self.selected_users: return # Multiple users, create submenus for each user if len(self.selected_users) > 1: for user in self.selected_users: popup = PopupMenu(self.frame) self.add_popup_menu_user(popup, user) self.popup_menu_users.add_items((">" + user, popup)) self.popup_menu_users.update_model() return # Single user, add items directly to "User(s)" submenu self.add_popup_menu_user(self.popup_menu_users, self.selected_users[0]) def on_close_filter_bar_accelerator(self, *_args): """ Escape: hide filter bar """ self.ShowFilters.set_active(False) return True def on_show_filter_bar_accelerator(self, *_args): """ Ctrl+F: show filter bar """ self.ShowFilters.set_active(True) self.FilterIn.grab_focus() return True def on_file_properties_accelerator(self, *_args): """ Alt+Return: show file properties dialog """ self.on_file_properties() return True def on_select_user_results(self, *args): if not self.selected_users: return selected_user = args[-1] sel = self.ResultsList.get_selection() fmodel = self.ResultsList.get_model() sel.unselect_all() iterator = fmodel.get_iter_first() select_user_row_iter(fmodel, sel, 1, selected_user, iterator) self.select_results() def select_result(self, model, iterator): user = model.get_value(iterator, 1) if user not in self.selected_users: self.selected_users.append(user) filename = model.get_value(iterator, 6) if not filename: return path = self.resultsmodel.get_path(iterator) if path not in self.selected_results: self.selected_files_count += 1 self.selected_results.append(path) def select_child_results(self, model, iterator): while iterator is not None: self.select_result(model, iterator) self.select_child_results(model, model.iter_children(iterator)) iterator = model.iter_next(iterator) def select_results(self): self.selected_results.clear() self.selected_users.clear() self.selected_files_count = 0 model, paths = self.ResultsList.get_selection().get_selected_rows() for path in paths: iterator = model.get_iter(path) self.select_result(model, iterator) self.select_child_results(model, model.iter_children(iterator)) def update_result_counter(self): if self.max_limited or self.num_results_found > self.num_results_visible: # Append plus symbol "+" if Results are Filtered and/or reached 'Maximum per search' str_plus = "+" # Display total results on the tooltip, but only if we know the exact number of results if self.max_limited: total = "> " + str(self.max_limit) + "+" else: total = self.num_results_found self.CounterButton.set_tooltip_text(_("Total: %s") % total) else: # Hide the tooltip if there are no hidden results str_plus = "" self.CounterButton.set_has_tooltip(False) self.Counter.set_text(str(self.num_results_visible) + str_plus) def update_visuals(self): for widget in list(self.__dict__.values()): update_widget_visuals(widget, list_font_target="searchfont") def on_column_position_changed(self, column, _param): """ Save column position and width to config """ col_title = column.get_title() offset = column.get_x_offset() if self.column_offsets[col_title] == offset: return self.column_offsets[col_title] = offset save_columns(self.treeview_name, self.ResultsList.get_columns()) def on_row_activated(self, treeview, path, _column): self.select_results() iterator = self.resultsmodel.get_iter(path) folder = self.resultsmodel.get_value(iterator, 5) filename = self.resultsmodel.get_value(iterator, 6) if not folder and not filename: # Don't activate user rows return if not filename: self.on_download_folders() else: self.on_download_files() treeview.get_selection().unselect_all() def on_popup_menu(self, menu, _widget): self.select_results() self.populate_popup_menu_users() menu.set_num_selected_files(self.selected_files_count) def on_browse_folder(self, *_args): requested_users = set() requested_folders = set() for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) user = self.resultsmodel.get_value(iterator, 1) folder = self.resultsmodel.get_value(iterator, 11).rsplit( '\\', 1)[0] + '\\' if user not in requested_users and folder not in requested_folders: self.frame.np.userbrowse.browse_user(user, path=folder) requested_users.add(user) requested_folders.add(folder) def on_file_properties(self, *_args): data = [] selected_size = 0 selected_length = 0 for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) virtual_path = self.resultsmodel.get_value(iterator, 11) directory, filename = virtual_path.rsplit('\\', 1) file_size = self.resultsmodel.get_value(iterator, 13) selected_size += file_size selected_length += self.resultsmodel.get_value(iterator, 16) country_code = self.resultsmodel.get_value(iterator, 12) country = "%s (%s)" % (self.frame.np.geoip.country_code_to_name( country_code), country_code) data.append({ "user": self.resultsmodel.get_value(iterator, 1), "fn": virtual_path, "filename": filename, "directory": directory, "size": file_size, "speed": self.resultsmodel.get_value(iterator, 14), "queue_position": self.resultsmodel.get_value(iterator, 15), "bitrate": self.resultsmodel.get_value(iterator, 8), "length": self.resultsmodel.get_value(iterator, 9), "country": country }) if data: FileProperties(self.frame, data, selected_size, selected_length).show() def on_download_files(self, *_args, prefix=""): for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) user = self.resultsmodel.get_value(iterator, 1) filepath = self.resultsmodel.get_value(iterator, 11) size = self.resultsmodel.get_value(iterator, 13) bitrate = self.resultsmodel.get_value(iterator, 8) length = self.resultsmodel.get_value(iterator, 9) self.frame.np.transfers.get_file(user, filepath, prefix, size=size, bitrate=bitrate, length=length) def on_download_files_to_selected(self, selected, _data): self.on_download_files(prefix=selected) def on_download_files_to(self, *_args): choose_dir(parent=self.frame.MainWindow, title=_("Select Destination Folder for File(s)"), callback=self.on_download_files_to_selected, initialdir=config.sections["transfers"]["downloaddir"], multichoice=False) def on_download_folders(self, *_args, download_location=""): if download_location: """ Custom download location specified, remember it when peer sends a folder contents reply """ requested_folders = self.frame.np.transfers.requested_folders else: requested_folders = defaultdict(dict) for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) user = self.resultsmodel.get_value(iterator, 1) folder = self.resultsmodel.get_value(iterator, 11).rsplit('\\', 1)[0] if folder in requested_folders[user]: """ Ensure we don't send folder content requests for a folder more than once, e.g. when several selected resuls belong to the same folder. """ continue requested_folders[user][folder] = download_location visible_files = [] for row in self.all_data: # Find the wanted directory if folder != row[11].rsplit('\\', 1)[0]: continue destination = self.frame.np.transfers.get_folder_destination( user, folder) (_counter, user, _flag, _h_speed, _h_queue, _directory, _filename, _h_size, h_bitrate, h_length, _bitrate, fullpath, _country, size, _speed, _queue, _length, _color) = row visible_files.append((user, fullpath, destination, size.get_uint64(), h_bitrate, h_length)) self.frame.np.search.request_folder_download( user, folder, visible_files) def on_download_folders_to_selected(self, selected, _data): self.on_download_folders(download_location=selected) def on_download_folders_to(self, *_args): choose_dir(parent=self.frame.MainWindow, title=_("Select Destination Folder"), callback=self.on_download_folders_to_selected, initialdir=config.sections["transfers"]["downloaddir"], multichoice=False) def on_copy_file_path(self, *_args): for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) filepath = self.resultsmodel.get_value(iterator, 11) copy_text(filepath) return def on_copy_url(self, *_args): for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) user = self.resultsmodel.get_value(iterator, 1) filepath = self.resultsmodel.get_value(iterator, 11) url = self.frame.np.userbrowse.get_soulseek_url(user, filepath) copy_text(url) return def on_copy_dir_url(self, *_args): for path in self.selected_results: iterator = self.resultsmodel.get_iter(path) user = self.resultsmodel.get_value(iterator, 1) filepath = self.resultsmodel.get_value(iterator, 11) url = self.frame.np.userbrowse.get_soulseek_url( user, filepath.rsplit('\\', 1)[0] + '\\') copy_text(url) return def on_counter_button(self, *_args): if self.num_results_found > self.num_results_visible: self.on_clear_filters() else: self.frame.on_settings(page='Searches') def on_group(self, action, state): mode = state.get_string() active = mode != "ungrouped" config.sections["searches"]["group_searches"] = mode self.cols["id"].set_visible(not active) self.ResultsList.set_show_expanders(active) self.ExpandButton.set_visible(active) self.grouping_mode = mode self.update_results_model() action.set_state(state) def on_toggle_expand_all(self, *_args): active = self.ExpandButton.get_active() if active: self.ResultsList.expand_all() self.expand.set_property("icon-name", "go-up-symbolic") else: collapse_treeview(self.ResultsList, self.grouping_mode) self.expand.set_property("icon-name", "go-down-symbolic") config.sections["searches"]["expand_searches"] = active def on_toggle_filters(self, widget): visible = widget.get_active() self.FiltersContainer.set_reveal_child(visible) config.sections["searches"]["filters_visible"] = visible if visible: self.FilterIn.grab_focus() return self.ResultsList.grab_focus() def on_copy_search_term(self, *_args): copy_text(self.text) @staticmethod def push_history(filter_id, value): if not value: return history = config.sections["searches"].get(filter_id) if history is None: return if value in history: history.remove(value) elif len(history) >= 5: del history[-1] history.insert(0, value) config.write_configuration() def on_refilter(self, *_args): if self.clearing_filters: return filter_in = self.FilterIn.get_active_text().strip().lower() filter_out = self.FilterOut.get_active_text().strip().lower() if filter_in: try: filter_in = re.compile(filter_in) except sre_constants.error: filter_in = None if filter_out: try: filter_out = re.compile(filter_out) except sre_constants.error: filter_out = None filters = { "filterin": filter_in, "filterout": filter_out, "filtersize": self.FilterSize.get_active_text().strip(), "filterbr": self.FilterBitrate.get_active_text().strip(), "filterslot": self.FilterFreeSlot.get_active(), "filtercc": self.FilterCountry.get_active_text().strip().upper(), "filtertype": self.FilterType.get_active_text().strip().lower() } if self.filters == filters: # Filters have not changed, no need to refilter return self.active_filter_count = 0 # Set red background if invalid regex pattern is detected if filter_in is None: set_widget_fg_bg_css(self.FilterIn.get_child(), bg_color="#e04f5e", fg_color="white") else: update_widget_visuals(self.FilterIn.get_child()) if filter_out is None: set_widget_fg_bg_css(self.FilterOut.get_child(), bg_color="#e04f5e", fg_color="white") else: update_widget_visuals(self.FilterOut.get_child()) # Add filters to history for filter_id, value in filters.items(): try: value = value.pattern except AttributeError: pass if not value: continue self.push_history(filter_id, value) self.active_filter_count += 1 # Apply the new filters self.filters = filters self.update_filter_comboboxes() self.update_results_model() def on_filter_entry_changed(self, widget): if not widget.get_text(): self.on_refilter() def on_clear_filters(self, *_args): self.clearing_filters = True for widget in self.filter_comboboxes.values(): widget.get_child().set_text("") self.FilterFreeSlot.set_active(False) if self.ShowFilters.get_active(): self.FilterIn.get_child().grab_focus() else: self.ResultsList.grab_focus() self.clearing_filters = False self.on_refilter() def on_clear(self, *_args): self.all_data = [] self.usersiters.clear() self.directoryiters.clear() self.resultsmodel.clear() self.num_results_found = 0 self.num_results_visible = 0 self.max_limited = False self.max_limit = config.sections["searches"]["max_displayed_results"] # Allow parsing search result messages again self.frame.np.search.add_allowed_token(self.token) # Update number of results widget self.update_result_counter() def on_close(self, *_args): del self.searches.pages[self.token] self.frame.np.search.remove_search(self.token) self.searches.remove_page(self.Main) def on_close_all_tabs(self, *_args): self.searches.remove_all_pages()
class Search: def __init__(self, searches, text, id, mode, remember, showtab): self.searches = searches self.frame = searches.frame # Build the window load_ui_elements(self, os.path.join(self.frame.gui_dir, "ui", "search.ui")) self.text = text self.searchterm_words_include = [ p for p in text.lower().split() if not p.startswith('-') ] self.searchterm_words_ignore = [ p[1:] for p in text.lower().split() if p.startswith('-') and len(p) > 1 ] self.id = id self.mode = mode self.remember = remember self.showtab = showtab self.usersiters = {} self.directoryiters = {} self.users = set() self.all_data = [] self.filters = None self.clearing_filters = False self.resultslimit = 2000 self.numvisibleresults = 0 self.active_filter_count = 0 self.operators = { '<': operator.lt, '<=': operator.le, '==': operator.eq, '!=': operator.ne, '>=': operator.ge, '>': operator.gt } if mode not in ("global", "wishlist"): self.RememberCheckButton.hide() self.RememberCheckButton.set_active(remember) """ Columns """ self.resultsmodel = Gtk.TreeStore( GObject.TYPE_UINT64, # (0) num str, # (1) user GObject.TYPE_OBJECT, # (2) flag str, # (3) immediatedl str, # (4) h_speed str, # (5) h_queue str, # (6) directory str, # (7) filename str, # (8) h_size str, # (9) h_bitrate str, # (10) h_length GObject.TYPE_UINT64, # (11) bitrate str, # (12) fullpath str, # (13) country GObject.TYPE_UINT64, # (14) size GObject.TYPE_UINT64, # (15) speed GObject.TYPE_UINT64, # (16) queue GObject.TYPE_UINT64, # (17) length str # (18) color ) self.column_numbers = list(range(self.resultsmodel.get_n_columns())) color_col = 18 self.cols = cols = initialise_columns( "file_search", self.ResultsList, ["id", _("ID"), 50, "text", color_col], ["user", _("User"), 200, "text", color_col], ["country", _("Country"), 25, "pixbuf", None], [ "immediate_download", _("Immediate Download"), 50, "center", color_col ], ["speed", _("Speed"), 90, "number", color_col], ["in_queue", _("In Queue"), 90, "center", color_col], ["folder", _("Folder"), 400, "text", color_col], ["filename", _("Filename"), 400, "text", color_col], ["size", _("Size"), 100, "number", color_col], ["bitrate", _("Bitrate"), 100, "number", color_col], ["length", _("Length"), 100, "number", color_col]) cols["id"].set_sort_column_id(0) cols["user"].set_sort_column_id(1) cols["country"].set_sort_column_id(13) cols["immediate_download"].set_sort_column_id(3) cols["speed"].set_sort_column_id(15) cols["in_queue"].set_sort_column_id(16) cols["folder"].set_sort_column_id(6) cols["filename"].set_sort_column_id(7) cols["size"].set_sort_column_id(14) cols["bitrate"].set_sort_column_id(11) cols["length"].set_sort_column_id(17) cols["country"].get_widget().hide() self.ResultsList.set_model(self.resultsmodel) self.update_visuals() """ Filters """ self.ShowFilters.set_active( config.sections["searches"]["filters_visible"]) self.populate_filters() """ Popup """ self.popup_menu_users = PopupMenu(self.frame) self.popup_menu = PopupMenu(self.frame) self.popup_menu.setup( ("#" + "selected_files", None), ("", None), ("#" + _("_Download File(s)"), self.on_download_files), ("#" + _("Download File(s) _To..."), self.on_download_files_to), ("#" + _("Download _Folder(s)"), self.on_download_folders), ("#" + _("Download F_older(s) To..."), self.on_download_folders_to), ("#" + _("_Browse Folder"), self.on_browse_folder), ("#" + _("File _Properties"), self.on_file_properties), ("", None), ("#" + _("Copy _File Path"), self.on_copy_file_path), ("#" + _("Copy _URL"), self.on_copy_url), ("#" + _("Copy Folder U_RL"), self.on_copy_dir_url), ("", None), (">" + _("User(s)"), self.popup_menu_users)) self.tab_menu = PopupMenu(self.frame) self.tab_menu.setup( ("#" + _("Copy Search Term"), self.on_copy_search_term), ("", None), ("#" + _("Clear All Results"), self.on_clear), ("#" + _("Close All Tabs"), self.on_close_all_tabs), ("#" + _("_Close Tab"), self.on_close)) """ Grouping """ self.ResultGrouping.set_active( config.sections["searches"]["group_searches"]) self.ExpandButton.set_active( config.sections["searches"]["expand_searches"]) def on_tooltip(self, widget, x, y, keyboard_mode, tooltip): country_tooltip = show_country_tooltip(widget, x, y, tooltip, 13, strip_prefix="") file_path_tooltip = show_file_path_tooltip(widget, x, y, tooltip, 12) if country_tooltip: return country_tooltip elif file_path_tooltip: return file_path_tooltip def populate_filters(self, set_default_filters=True): for combobox in (self.FilterIn, self.FilterOut, self.FilterType, self.FilterSize, self.FilterBitrate, self.FilterCountry): combobox.remove_all() if set_default_filters and config.sections["searches"]["enablefilters"]: sfilter = config.sections["searches"]["defilter"] self.FilterInEntry.set_text(str(sfilter[0])) self.FilterOutEntry.set_text(str(sfilter[1])) self.FilterSizeEntry.set_text(str(sfilter[2])) self.FilterBitrateEntry.set_text(str(sfilter[3])) self.FilterFreeSlot.set_active(sfilter[4]) if len(sfilter) > 5: self.FilterCountryEntry.set_text(str(sfilter[5])) if len(sfilter) > 6: self.FilterTypeEntry.set_text(str(sfilter[6])) self.on_refilter(None) for i in ['0', '128', '160', '192', '256', '320']: self.FilterBitrate.append_text(i) for i in [">10MiB", "<10MiB", "<5MiB", "<1MiB", ">0"]: self.FilterSize.append_text(i) for i in [ 'flac|wav|ape|aiff|wv|cue', 'mp3|m4a|aac|ogg|opus|wma', '!mp3' ]: self.FilterType.append_text(i) for i in config.sections["searches"]["filterin"]: self.add_combo(self.FilterIn, i, True) for i in config.sections["searches"]["filterout"]: self.add_combo(self.FilterOut, i, True) for i in config.sections["searches"]["filtersize"]: self.add_combo(self.FilterSize, i, True) for i in config.sections["searches"]["filterbr"]: self.add_combo(self.FilterBitrate, i, True) for i in config.sections["searches"]["filtercc"]: self.add_combo(self.FilterCountry, i, True) for i in config.sections["searches"]["filtertype"]: self.add_combo(self.FilterType, i, True) def focus_combobox(self, button): # We have the button of a combobox, find the entry parent = button.get_parent() if parent is None: return if isinstance(parent, Gtk.ComboBox): entry = parent.get_child() entry.grab_focus() GLib.idle_add(entry.emit, "activate") return self.focus_combobox(parent) def add_combo(self, combobox, text, list=False): text = str(text).strip() if not text: return False model = combobox.get_model() iterator = model.get_iter_first() match = False while iterator is not None: value = model.get_value(iterator, 0) if value.strip() == text: match = True iterator = model.iter_next(iterator) if not match: if list: combobox.append_text(text) else: combobox.prepend_text(text) 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) def append(self, row): self.all_data.append(row) if self.numvisibleresults >= config.sections["searches"][ "max_displayed_results"]: return False if not self.check_filter(row): return False iterator = self.add_row_to_model(row) if self.ResultGrouping.get_active_id() != "ungrouped": # Group by folder or user if self.ExpandButton.get_active(): path = None if iterator is not None: path = self.resultsmodel.get_path(iterator) if path is not None: self.ResultsList.expand_to_path(path) else: collapse_treeview(self.ResultsList, self.ResultGrouping.get_active_id()) return True def add_row_to_model(self, row): counter, user, flag, immediatedl, h_speed, h_queue, directory, filename, h_size, h_bitrate, h_length, bitrate, fullpath, country, size, speed, queue, length, color = row if self.ResultGrouping.get_active_id() != "ungrouped": # Group by folder or user empty_int = 0 empty_str = "" if user not in self.usersiters: self.usersiters[user] = self.resultsmodel.insert_with_values( None, -1, self.column_numbers, [ empty_int, user, flag, immediatedl, h_speed, h_queue, empty_str, empty_str, empty_str, empty_str, empty_str, empty_int, empty_str, country, empty_int, speed, queue, empty_int, color ]) parent = self.usersiters[user] if self.ResultGrouping.get_active_id() == "folder_grouping": # Group by folder if directory not in self.directoryiters: self.directoryiters[ directory] = self.resultsmodel.insert_with_values( self.usersiters[user], -1, self.column_numbers, [ empty_int, user, flag, immediatedl, h_speed, h_queue, directory, empty_str, empty_str, empty_str, empty_str, empty_int, fullpath.rsplit('\\', 1)[0] + '\\', country, empty_int, speed, queue, empty_int, color ]) row = row[:] row[6] = "" # Directory not visible for file row if "group by folder" is enabled parent = self.directoryiters[directory] else: parent = None try: """ Note that we use insert_with_values instead of append, as this reduces overhead by bypassing useless row conversion to GObject.Value in PyGObject. """ iterator = self.resultsmodel.insert_with_values( parent, -1, self.column_numbers, row) self.numvisibleresults += 1 except Exception as e: types = [] for i in row: types.append(type(i)) log.add_warning(_("Search row error: %(exception)s %(row)s"), { 'exception': e, 'row': row }) iterator = None return iterator def check_digit(self, sfilter, value, factorize=True): op = ">=" if sfilter[:1] in (">", "<", "="): op, sfilter = sfilter[:1] + "=", sfilter[1:] if not sfilter: return True factor = 1 if factorize: base = 1024 # Default to binary for "k", "m", "g" suffixes if sfilter[-1:].lower() == 'b': base = 1000 # Byte suffix detected, prepare to use decimal if necessary sfilter = sfilter[:-1] if sfilter[-1:].lower() == 'i': base = 1024 # Binary requested, stop using decimal sfilter = sfilter[:-1] if sfilter.lower()[-1:] == "g": factor = pow(base, 3) sfilter = sfilter[:-1] elif sfilter.lower()[-1:] == "m": factor = pow(base, 2) sfilter = sfilter[:-1] elif sfilter.lower()[-1:] == "k": factor = base sfilter = sfilter[:-1] if not sfilter: return True try: sfilter = int(sfilter) * factor except ValueError: return True operation = self.operators.get(op) return operation(value, sfilter) def check_country(self, sfilter, value): if not isinstance(value, str): return False value = value.upper() allowed = False for cc in sfilter.split("|"): if cc == value: allowed = True elif cc.startswith("!") and cc[1:] != value: allowed = True elif cc.startswith("!") and cc[1:] == value: return False return allowed def check_file_type(self, sfilter, value): if not isinstance(value, str): return False value = value.lower() allowed = False for ext in sfilter.split("|"): exclude_ext = None if ext.startswith("!"): exclude_ext = ext[1:] if not exclude_ext.startswith("."): exclude_ext = "." + exclude_ext elif not ext.startswith("."): ext = "." + ext if not ext.startswith("!") and value.endswith(ext): allowed = True elif ext.startswith("!") and not value.endswith(exclude_ext): allowed = True elif ext.startswith("!") and value.endswith(exclude_ext): return False return allowed def check_filter(self, row): filters = self.filters if self.active_filter_count == 0: return True # "Included text"-filter, check full file path (located at index 12 in row) if filters["include"] and not filters["include"].search( row[12].lower()): return False # "Excluded text"-filter, check full file path (located at index 12 in row) if filters["exclude"] and filters["exclude"].search(row[12].lower()): return False if filters["size"] and not self.check_digit(filters["size"], row[14].get_uint64()): return False if filters["bitrate"] and not self.check_digit( filters["bitrate"], row[11].get_uint64(), False): return False if filters["freeslot"] and row[3] != "Y": return False if filters["country"] and not self.check_country( filters["country"], row[13]): return False if filters["type"] and not self.check_file_type( filters["type"], row[12]): return False return True def set_filters(self, enable, f_in, f_out, size, bitrate, freeslot, country, f_type): self.filters = { "include": None, "exclude": None, "size": None, "bitrate": None, "freeslot": freeslot, "country": None, "type": None } self.active_filter_count = 0 if f_in: try: f_in = re.compile(f_in.lower()) self.filters["include"] = f_in except sre_constants.error: set_widget_fg_bg_css(self.FilterInEntry, "red", "white") else: set_widget_fg_bg_css(self.FilterInEntry) self.active_filter_count += 1 if f_out: try: f_out = re.compile(f_out.lower()) self.filters["exclude"] = f_out except sre_constants.error: set_widget_fg_bg_css(self.FilterOutEntry, "red", "white") else: set_widget_fg_bg_css(self.FilterOutEntry) self.active_filter_count += 1 if size: self.filters["size"] = size self.active_filter_count += 1 if bitrate: self.filters["bitrate"] = bitrate self.active_filter_count += 1 if country: self.filters["country"] = country.upper() self.active_filter_count += 1 if f_type: self.filters["type"] = f_type.lower() self.active_filter_count += 1 if freeslot: self.active_filter_count += 1 self.usersiters.clear() self.directoryiters.clear() self.resultsmodel.clear() self.numvisibleresults = 0 for row in self.all_data: if self.numvisibleresults >= config.sections["searches"][ "max_displayed_results"]: break if self.check_filter(row): self.add_row_to_model(row) # Update number of visible results self.update_result_counter() self.update_filter_counter(self.active_filter_count) def populate_popup_menu_users(self): self.popup_menu_users.clear() if not self.selected_users: return for user in self.selected_users: popup = PopupMenu(self.frame) popup.setup_user_menu(user) popup.setup(("", None), ("#" + _("Select User's Transfers"), self.on_select_user_results, user)) popup.toggle_user_items() self.popup_menu_users.setup((">" + user, popup)) def on_select_user_results(self, *args): if not self.selected_users: return selected_user = args[-1] sel = self.ResultsList.get_selection() fmodel = self.ResultsList.get_model() sel.unselect_all() iterator = fmodel.get_iter_first() select_user_row_iter(fmodel, sel, 1, selected_user, iterator) self.select_results() def select_results(self): self.selected_results = [] self.selected_users = [] self.selected_files_count = 0 model, paths = self.ResultsList.get_selection().get_selected_rows() for path in paths: iterator = model.get_iter(path) user = model.get_value(iterator, 1) if user is None: continue if user not in self.selected_users: self.selected_users.append(user) filepath = model.get_value(iterator, 12) if not filepath: # Result is not a file or directory, don't add it continue bitrate = model.get_value(iterator, 9) length = model.get_value(iterator, 10) size = model.get_value(iterator, 14) self.selected_results.append( (user, filepath, size, bitrate, length)) filename = model.get_value(iterator, 7) if filename: self.selected_files_count += 1 def update_result_counter(self): self.Counter.set_text(str(self.numvisibleresults)) def update_visuals(self): for widget in list(self.__dict__.values()): update_widget_visuals(widget, list_font_target="searchfont") def save_columns(self): save_columns("file_search", self.ResultsList.get_columns()) def on_list_clicked(self, widget, event): if triggers_context_menu(event): set_treeview_selected_row(widget, event) return self.on_popup_menu() pathinfo = widget.get_path_at_pos(event.x, event.y) if pathinfo is None: widget.get_selection().unselect_all() elif event.button == 1 and event.type == Gdk.EventType._2BUTTON_PRESS: self.select_results() self.on_download_files() self.ResultsList.get_selection().unselect_all() return True return False def on_key_press_event(self, widget, event): self.select_results() if event.get_state() & Gdk.ModifierType.CONTROL_MASK and \ event.hardware_keycode in keyval_to_hardware_keycode(Gdk.KEY_c): self.on_copy_file_path() else: # No key match, continue event return False widget.stop_emission_by_name("key_press_event") return True def on_popup_menu(self, *args): self.select_results() actions = self.popup_menu.get_actions() users = len(self.selected_users) > 0 files = len(self.selected_results) > 0 for i in (_("_Download File(s)"), _("Download File(s) _To..."), _("File _Properties"), _("Copy _URL")): actions[i].set_enabled(False) for i in (_("Download _Folder(s)"), _("Download F_older(s) To..."), _("_Browse Folder"), _("Copy _File Path"), _("Copy Folder U_RL")): actions[i].set_enabled(files) actions[_("User(s)")].set_enabled(users) self.populate_popup_menu_users() for result in self.selected_results: if not result[1].endswith('\\'): # At least one selected result is a file, activate file-related items for i in (_("_Download File(s)"), _("Download File(s) _To..."), _("File _Properties"), _("Copy _URL")): actions[i].set_enabled(True) break self.popup_menu.set_num_selected_files(self.selected_files_count) self.popup_menu.popup() return True def on_browse_folder(self, *args): requested_folders = set() for file in self.selected_results: user = file[0] folder = file[1].rsplit('\\', 1)[0] if folder not in requested_folders: self.frame.browse_user(user, folder) requested_folders.add(folder) def on_file_properties(self, *args): if not self.frame.np.transfers: return data = [] model, paths = self.ResultsList.get_selection().get_selected_rows() for path in paths: iterator = model.get_iter(path) filename = model.get_value(iterator, 7) # We only want to see the metadata of files, not directories if not filename: continue num = model.get_value(iterator, 0) user = model.get_value(iterator, 1) immediate = model.get_value(iterator, 3) speed = model.get_value(iterator, 4) queue = model.get_value(iterator, 5) size = model.get_value(iterator, 8) bitratestr = model.get_value(iterator, 9) length = model.get_value(iterator, 10) fn = model.get_value(iterator, 12) directory = fn.rsplit('\\', 1)[0] cc = model.get_value(iterator, 13) country = "%s / %s" % (cc, code2name(cc)) data.append({ "user": user, "fn": fn, "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 on_download_files(self, *args, prefix=""): if not self.frame.np.transfers: return for file in self.selected_results: # Make sure the selected result is not a directory if not file[1].endswith('\\'): self.frame.np.transfers.get_file(file[0], file[1], prefix, size=file[2], bitrate=file[3], length=file[4], checkduplicate=True) def on_download_files_to_selected(self, selected, data): self.on_download_files(prefix=selected) def on_download_files_to(self, *args): choose_dir(parent=self.frame.MainWindow, callback=self.on_download_files_to_selected, initialdir=config.sections["transfers"]["downloaddir"], multichoice=False) def on_download_folders(self, *args, download_location=""): if not self.frame.np.transfers: return if download_location: """ Custom download location specified, remember it when peer sends a folder contents reply """ requested_folders = self.frame.np.transfers.requested_folders else: requested_folders = defaultdict(dict) for i in self.selected_results: user = i[0] folder = i[1].rsplit('\\', 1)[0] if folder in requested_folders[user]: """ Ensure we don't send folder content requests for a folder more than once, e.g. when several selected resuls belong to the same folder. """ continue requested_folders[user][folder] = download_location # First queue the visible search results files = [] for row in self.all_data: # Find the wanted directory if folder != row[12].rsplit('\\', 1)[0]: continue destination = self.frame.np.transfers.get_folder_destination( user, folder) counter, user, flag, immediatedl, h_speed, h_queue, directory, filename, h_size, h_bitrate, h_length, bitrate, fullpath, country, size, speed, queue, length, color = row files.append((user, fullpath, destination, size.get_uint64(), bitrate.get_uint64(), length.get_uint64())) if config.sections["transfers"]["reverseorder"]: files.sort(key=lambda x: x[1], reverse=True) for file in files: user, fullpath, destination, size, bitrate, length = file self.frame.np.transfers.get_file(user, fullpath, destination, size=size, bitrate=bitrate, length=length, checkduplicate=True) # Ask for the rest of the files in the folder self.frame.np.send_message_to_peer( user, slskmessages.FolderContentsRequest(None, folder)) def on_download_folders_to_selected(self, selected, data): self.on_download_folders(download_location=selected) def on_download_folders_to(self, *args): choose_dir(parent=self.frame.MainWindow, callback=self.on_download_folders_to_selected, initialdir=config.sections["transfers"]["downloaddir"], multichoice=False) def on_copy_file_path(self, *args): if self.selected_results: user, path = self.selected_results[0][:2] self.frame.clipboard.set_text(path, -1) def on_copy_url(self, *args): if self.selected_results: user, path = self.selected_results[0][:2] copy_file_url(user, path, self.frame.clipboard) def on_copy_dir_url(self, *args): if self.selected_results: user, path = self.selected_results[0][:2] copy_file_url(user, path.rsplit('\\', 1)[0] + '\\', self.frame.clipboard) def on_group(self, widget): self.on_refilter(widget) active = widget.get_active() self.ResultsList.set_show_expanders(active) config.sections["searches"]["group_searches"] = active self.cols["id"].set_visible(not active) self.ExpandButton.set_visible(active) def on_toggle_expand_all(self, widget): active = self.ExpandButton.get_active() if active: self.ResultsList.expand_all() self.expand.set_from_icon_name("go-up-symbolic", Gtk.IconSize.BUTTON) else: collapse_treeview(self.ResultsList, self.ResultGrouping.get_active_id()) self.expand.set_from_icon_name("go-down-symbolic", Gtk.IconSize.BUTTON) config.sections["searches"]["expand_searches"] = active def on_toggle_filters(self, widget): visible = widget.get_active() self.FiltersContainer.set_visible(visible) config.sections["searches"]["filters_visible"] = visible def on_copy_search_term(self, *args): self.frame.clipboard.set_text(self.text, -1) def on_toggle_remember(self, widget): self.remember = widget.get_active() search = self.searches.searches[self.id] if not self.remember: self.searches.wish_list.remove_wish(search["term"]) else: self.searches.wish_list.add_wish(search["term"]) def push_history(self, widget, title): text = widget.get_active_text() if not text.strip(): return None text = text.strip() history = config.sections["searches"][title] if text in history: history.remove(text) elif len(history) >= 5: del history[-1] history.insert(0, text) config.write_configuration() self.add_combo(widget, text) widget.get_child().set_text(text) return text def on_refilter(self, *args): if self.clearing_filters: return f_in = self.push_history(self.FilterIn, "filterin") f_out = self.push_history(self.FilterOut, "filterout") f_size = self.push_history(self.FilterSize, "filtersize") f_br = self.push_history(self.FilterBitrate, "filterbr") f_free = self.FilterFreeSlot.get_active() f_country = self.push_history(self.FilterCountry, "filtercc") f_type = self.push_history(self.FilterType, "filtertype") self.ResultsList.set_model(None) self.set_filters(1, f_in, f_out, f_size, f_br, f_free, f_country, f_type) self.ResultsList.set_model(self.resultsmodel) if self.ResultGrouping.get_active_id() != "ungrouped": # Group by folder or user if self.ExpandButton.get_active(): self.ResultsList.expand_all() else: collapse_treeview(self.ResultsList, self.ResultGrouping.get_active_id()) def on_clear_filters(self, *args): self.clearing_filters = True self.FilterInEntry.set_text("") self.FilterOutEntry.set_text("") self.FilterSizeEntry.set_text("") self.FilterBitrateEntry.set_text("") self.FilterCountryEntry.set_text("") self.FilterTypeEntry.set_text("") self.FilterFreeSlot.set_active(False) self.clearing_filters = False self.FilterInEntry.grab_focus() self.on_refilter() def on_about_filters(self, *args): if not hasattr(self, "AboutSearchFiltersPopover"): load_ui_elements( self, os.path.join(self.frame.gui_dir, "ui", "popovers", "searchfilters.ui")) self.AboutSearchFiltersPopover.set_relative_to(self.ShowChatHelp) try: self.AboutSearchFiltersPopover.popup() except AttributeError: # GTK <3.22 support self.AboutSearchFiltersPopover.set_transitions_enabled(True) self.AboutSearchFiltersPopover.show() def update_filter_counter(self, count): if count > 0: self.FilterLabel.set_text(_("Result Filters") + " *") else: self.FilterLabel.set_text(_("Result Filters")) self.FilterLabel.set_tooltip_text("%d active filter(s)" % count) def on_clear(self, *args): self.all_data = [] self.usersiters.clear() self.directoryiters.clear() self.resultsmodel.clear() self.numvisibleresults = 0 # Update number of visible results self.update_result_counter() def on_close(self, *args): self.searches.remove_tab(self) def on_close_all_tabs(self, *args): self.searches.remove_all_pages()
class IconNotebook: """ This class implements a pseudo Gtk.Notebook On top of what a Gtk.Notebook provides: - You can have icons on the notebook tab. - You can choose the label orientation (angle). """ def __init__(self, images, angle=0, tabclosers=False, show_hilite_image=True, reorderable=True, show_status_image=False, notebookraw=None): # We store the real Gtk.Notebook object self.notebook = notebookraw self.notebook.set_show_border(False) self.tabclosers = tabclosers self.reorderable = reorderable self.images = images self._show_hilite_image = show_hilite_image self._show_status_image = show_status_image self.notebook.connect("key-press-event", self.on_key_press_event) self.notebook.connect("switch-page", self.on_switch_page) self.unread_button = Gtk.Button.new_from_icon_name( "emblem-important-symbolic", Gtk.IconSize.BUTTON) self.unread_button.set_relief(Gtk.ReliefStyle.NONE) self.unread_button.set_tooltip_text(_("Unread Tabs")) self.unread_button.set_halign(Gtk.Align.CENTER) self.unread_button.set_valign(Gtk.Align.CENTER) self.unread_button.connect("clicked", self.on_unread_notifications_menu) context = self.unread_button.get_style_context() context.add_class("circular") self.notebook.set_action_widget(self.unread_button, Gtk.PackType.END) self.popup_menu_unread = PopupMenu(window=self.notebook.get_toplevel()) self.unread_pages = [] self.angle = angle def get_labels(self, page): tab_label = self.notebook.get_tab_label(page) menu_label = self.notebook.get_menu_label(page) return tab_label, menu_label def set_reorderable(self, reorderable): self.reorderable = reorderable for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) self.notebook.set_tab_reorderable(page, self.reorderable) def set_tab_closers(self, closers): self.tabclosers = closers for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.set_onclose(self.tabclosers) def show_hilite_images(self, show_image=True): self._show_hilite_image = show_image for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.show_hilite_image(self._show_hilite_image) def show_status_images(self, show_image=True): self._show_status_image = show_image def set_tab_angle(self, angle): if angle == self.angle: return self.angle = angle for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.set_angle(angle) def set_tab_pos(self, pos): self.notebook.set_tab_pos(pos) def append_page(self, page, label, onclose=None, angle=0, fulltext=None, status=None): self.set_tab_angle(angle) closebutton = self.tabclosers label_tab = ImageLabel(label, onclose, closebutton=closebutton, angle=angle, show_hilite_image=self._show_hilite_image, status_image=self.images["offline"], show_status_image=self._show_status_image) if fulltext is None: fulltext = label # menu for all tabs label_tab_menu = ImageLabel(label) label_tab.connect('button_press_event', self.on_tab_click, page) label_tab.connect('popup_menu', self.on_tab_popup, page) label_tab.connect('touch_event', self.on_tab_click, page) label_tab.show() Gtk.Notebook.append_page_menu(self.notebook, page, label_tab, label_tab_menu) if status: self.set_user_status(page, label, status) else: label_tab.set_tooltip_text(fulltext) self.notebook.set_tab_reorderable(page, self.reorderable) self.notebook.set_show_tabs(True) def remove_page(self, page): Gtk.Notebook.remove_page(self.notebook, self.page_num(page)) if self.notebook.get_n_pages() == 0: self.notebook.set_show_tabs(False) def remove_all_pages_response(self, dialog, response_id, data): dialog.destroy() if response_id == Gtk.ResponseType.OK: for page in self.notebook.get_children(): tab_label, menu_label = self.get_labels(page) tab_label.onclose(dialog) def remove_all_pages(self): option_dialog(parent=self.notebook.get_toplevel(), title=_('Close All Tabs?'), message=_('Are you sure you wish to close all tabs?'), callback=self.remove_all_pages_response) def get_page_owner(self, page, items): n = self.page_num(page) page = self.get_nth_page(n) return next(owner for owner, tab in items.items() if tab.Main is page) def on_tab_popup(self, widget, page): # Dummy implementation pass def on_tab_click(self, widget, event, page): if triggers_context_menu(event): return self.on_tab_popup(widget, page) elif event.button == 2: # Middle click tab_label, menu_label = self.get_labels(page) tab_label.onclose(widget) return True return False def set_status_image(self, page, status): tab_label, menu_label = self.get_labels(page) if status == 1: image_name = "away" elif status == 2: image_name = "online" else: image_name = "offline" image = self.images[image_name] tab_label.set_status_image(image) menu_label.set_status_image(image) def set_user_status(self, page, user, status): if status == 1: status_text = _("Away") elif status == 2: status_text = _("Online") else: status_text = _("Offline") if not config.sections["ui"]["tab_status_icons"]: self.set_text(page, "%s (%s)" % (user[:15], status_text)) else: self.set_text(page, user) self.set_status_image(page, status) # Set a tab tooltip containing the user's status and name tab_label, menu_label = self.get_labels(page) tab_label.set_tooltip_text("%s (%s)" % (user, status_text)) def set_hilite_image(self, page, status): tab_label, menu_label = self.get_labels(page) image = None if status > 0: image = self.images[("hilite3", "hilite")[status - 1]] if status == 1 and tab_label.get_hilite_image( ) == self.images["hilite"]: # Chat mentions have priority over normal notifications return tab_label.set_hilite_image(image) menu_label.set_hilite_image(image) # Determine if button for unread notifications should be shown if image: if page not in self.unread_pages: self.unread_pages.append(page) self.unread_button.show() return if page in self.unread_pages: self.unread_pages.remove(page) if not self.unread_pages: self.unread_button.hide() def set_text(self, page, label): tab_label, menu_label = self.get_labels(page) tab_label.set_text(label) menu_label.set_text(label) def set_text_colors(self, status): for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) self.set_text_color(page, status) def set_text_color(self, page, status): tab_label, menu_label = self.get_labels(page) tab_label.set_text_color(status) def request_hilite(self, page): current = self.get_nth_page(self.get_current_page()) if current == page: return self.set_hilite_image(page, status=2) self.set_text_color(page, status=2) def request_changed(self, page): current = self.get_nth_page(self.get_current_page()) if current == page: return self.set_hilite_image(page, status=1) self.set_text_color(page, status=1) def get_current_page(self): return self.notebook.get_current_page() def set_current_page(self, page_num): return self.notebook.set_current_page(page_num) def set_unread_page(self, action, state, page_num): self.notebook.set_current_page(page_num) def get_nth_page(self, page_num): return self.notebook.get_nth_page(page_num) def page_num(self, page): return self.notebook.page_num(page) def popup_enable(self): self.notebook.popup_enable() def popup_disable(self): self.notebook.popup_disable() def show(self): self.notebook.show() def on_key_press_event(self, widget, event): keycode = event.hardware_keycode if event.get_state() & Gdk.ModifierType.CONTROL_MASK: if keycode in keyval_to_hardware_keycode(Gdk.KEY_w) or \ keycode in keyval_to_hardware_keycode(Gdk.KEY_F4): # Ctrl+W and Ctrl+F4: close current tab page = self.get_nth_page(self.get_current_page()) tab_label, menu_label = self.get_labels(page) tab_label.onclose(widget) return True return False def on_switch_page(self, notebook, new_page, page_num): # Hide widgets on previous page for a performance boost current_page = self.get_nth_page(self.get_current_page()) for child in current_page.get_children(): child.hide() for child in new_page.get_children(): child.show() # Dismiss tab notification self.set_hilite_image(new_page, status=0) self.set_text_color(new_page, status=0) def on_unread_notifications_menu(self, widget): self.popup_menu_unread.clear() for page in self.unread_pages: tab_label, menu_label = self.get_labels(page) self.popup_menu_unread.setup( ("#" + tab_label.get_text(), self.set_unread_page, self.page_num(page))) self.popup_menu_unread.popup()
class IconNotebook: """ This class implements a pseudo Gtk.Notebook On top of what a Gtk.Notebook provides: - Icons on the notebook tab - Dropdown menu for unread tabs - A few shortcuts """ def __init__(self, images, tabclosers=False, show_hilite_image=True, show_status_image=False, notebookraw=None): # We store the real Gtk.Notebook object self.notebook = notebookraw self.notebook.set_show_border(False) self.tabclosers = tabclosers self.images = images self._show_hilite_image = show_hilite_image self._show_status_image = show_status_image self.key_controller = connect_key_press_event(self.notebook, self.on_key_press_event) self.notebook.connect("switch-page", self.on_switch_page) self.unread_button = Gtk.MenuButton.new() if Gtk.get_major_version() == 4: self.window = self.notebook.get_root() self.unread_button.set_icon_name("emblem-important-symbolic") self.unread_button.set_has_frame(False) else: self.window = self.notebook.get_toplevel() self.popup_enable() self.unread_button.set_image( Gtk.Image.new_from_icon_name("emblem-important-symbolic", Gtk.IconSize.BUTTON)) self.unread_button.set_relief(Gtk.ReliefStyle.NONE) self.unread_button.set_tooltip_text(_("Unread Tabs")) self.unread_button.set_halign(Gtk.Align.CENTER) self.unread_button.set_valign(Gtk.Align.CENTER) context = self.unread_button.get_style_context() context.add_class("circular") self.notebook.set_action_widget(self.unread_button, Gtk.PackType.END) self.popup_menu_unread = PopupMenu(widget=self.unread_button, connect_events=False) self.unread_button.set_menu_model(self.popup_menu_unread) self.unread_pages = [] self.notebook.hide() def get_labels(self, page): tab_label = self.notebook.get_tab_label(page) menu_label = self.notebook.get_menu_label(page) return tab_label, menu_label def get_tab_label_inner(self, page): if Gtk.get_major_version() == 4: return self.notebook.get_tab_label(page).get_first_child() else: return self.notebook.get_tab_label(page).get_children()[0] def set_tab_closers(self, closers): self.tabclosers = closers for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.set_onclose(self.tabclosers) def show_hilite_images(self, show_image=True): self._show_hilite_image = show_image for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.show_hilite_image(self._show_hilite_image) def show_status_images(self, show_image=True): self._show_status_image = show_image def set_tab_pos(self, pos): self.notebook.set_tab_pos(pos) def update_unread_pages_menu(self): self.popup_menu_unread.clear() for page in self.unread_pages: tab_label, menu_label = self.get_labels(page) self.popup_menu_unread.setup( ("#" + tab_label.get_text(), self.set_unread_page, self.page_num(page))) def append_unread_page(self, page): if page in self.unread_pages: return self.unread_pages.append(page) self.update_unread_pages_menu() self.unread_button.show() def remove_unread_page(self, page): if page in self.unread_pages: self.unread_pages.remove(page) self.update_unread_pages_menu() if not self.unread_pages: self.unread_button.hide() def append_page(self, page, label, onclose=None, fulltext=None, status=None): closebutton = self.tabclosers label_tab = ImageLabel(label, onclose, closebutton=closebutton, show_hilite_image=self._show_hilite_image, status_image=self.images["offline"], show_status_image=self._show_status_image) label_tab.show() if fulltext is None: fulltext = label # menu for all tabs label_tab_menu = ImageLabel(label) if Gtk.get_major_version() == 4: label_tab.gesture_click = Gtk.GestureClick() label_tab.add_controller(label_tab.gesture_click) else: label_tab.gesture_click = Gtk.GestureMultiPress.new(label_tab) label_tab.gesture_click.set_button(Gdk.BUTTON_MIDDLE) label_tab.gesture_click.connect("pressed", label_tab.onclose, page) Gtk.Notebook.append_page_menu(self.notebook, page, label_tab, label_tab_menu) if status: self.set_user_status(page, label, status) else: label_tab.set_tooltip_text(fulltext) self.notebook.set_tab_reorderable(page, True) self.notebook.show() def remove_page(self, page): Gtk.Notebook.remove_page(self.notebook, self.page_num(page)) self.remove_unread_page(page) if self.notebook.get_n_pages() == 0: self.notebook.hide() def remove_all_pages_response(self, dialog, response_id, data): dialog.destroy() if response_id == Gtk.ResponseType.OK: for i in reversed(range(self.notebook.get_n_pages())): page = self.notebook.get_nth_page(i) tab_label, menu_label = self.get_labels(page) tab_label.onclose(dialog) def remove_all_pages(self): option_dialog(parent=self.window, title=_('Close All Tabs?'), message=_('Are you sure you wish to close all tabs?'), callback=self.remove_all_pages_response) def get_page_owner(self, page, items): n = self.page_num(page) page = self.get_nth_page(n) return next(owner for owner, tab in items.items() if tab.Main is page) def on_tab_popup(self, widget, page): # Dummy implementation pass def set_status_image(self, page, status): tab_label, menu_label = self.get_labels(page) if status == 1: image_name = "away" elif status == 2: image_name = "online" else: image_name = "offline" image = self.images[image_name] tab_label.set_status_image(image) menu_label.set_status_image(image) def set_user_status(self, page, user, status): if status == 1: status_text = _("Away") elif status == 2: status_text = _("Online") else: status_text = _("Offline") if not config.sections["ui"]["tab_status_icons"]: self.set_text(page, "%s (%s)" % (user[:15], status_text)) else: self.set_text(page, user) self.set_status_image(page, status) # Set a tab tooltip containing the user's status and name tab_label, menu_label = self.get_labels(page) tab_label.set_tooltip_text("%s (%s)" % (user, status_text)) def set_hilite_image(self, page, status): tab_label, menu_label = self.get_labels(page) image = None if status > 0: image = self.images[("hilite3", "hilite")[status - 1]] if status == 1 and tab_label.get_hilite_image( ) == self.images["hilite"]: # Chat mentions have priority over normal notifications return tab_label.set_hilite_image(image) menu_label.set_hilite_image(image) # Determine if button for unread notifications should be shown if image: self.append_unread_page(page) return self.remove_unread_page(page) def set_text(self, page, label): tab_label, menu_label = self.get_labels(page) tab_label.set_text(label) menu_label.set_text(label) def set_text_colors(self, status): for i in range(self.notebook.get_n_pages()): page = self.notebook.get_nth_page(i) self.set_text_color(page, status) def set_text_color(self, page, status): tab_label, menu_label = self.get_labels(page) tab_label.set_text_color(status) def request_hilite(self, page): current = self.get_nth_page(self.get_current_page()) if current == page: return self.set_hilite_image(page, status=2) self.set_text_color(page, status=2) def request_changed(self, page): current = self.get_nth_page(self.get_current_page()) if current == page: return self.set_hilite_image(page, status=1) self.set_text_color(page, status=1) def get_current_page(self): return self.notebook.get_current_page() def set_current_page(self, page_num): return self.notebook.set_current_page(page_num) def set_unread_page(self, action, state, page_num): self.notebook.set_current_page(page_num) def get_nth_page(self, page_num): return self.notebook.get_nth_page(page_num) def page_num(self, page): return self.notebook.page_num(page) def popup_enable(self): self.notebook.popup_enable() def popup_disable(self): self.notebook.popup_disable() def show(self): self.notebook.show() def on_key_press_event(self, *args): keyval, keycode, state = get_key_press_event_args(*args) keycodes_w, mods = parse_accelerator("<Primary>w") keycodes_f4, mods = parse_accelerator("<Primary>F4") if state & mods and (keycode in keycodes_w or keycode in keycodes_f4): # Ctrl+W and Ctrl+F4: close current tab page = self.get_nth_page(self.get_current_page()) tab_label, menu_label = self.get_labels(page) tab_label.onclose(None) return True return False def on_switch_page(self, notebook, new_page, page_num): # Hide widgets on previous page for a performance boost current_page = self.get_nth_page(self.get_current_page()) for child in current_page.get_children(): child.hide() for child in new_page.get_children(): child.show() # Dismiss tab notification self.set_hilite_image(new_page, status=0) self.set_text_color(new_page, status=0)
class TransferList(UserInterface): def __init__(self, frame, transfer_type): super().__init__("ui/" + transfer_type + "s.ui") getattr(frame, transfer_type + "s_content").add(self.Main) self.frame = frame self.type = transfer_type self.page_id = transfer_type + "s" self.user_counter = getattr(frame, "%sUsers" % transfer_type.title()) self.file_counter = getattr(frame, "%sFiles" % transfer_type.title()) grouping_button = getattr(frame, "ToggleTree%ss" % transfer_type.title()) if Gtk.get_major_version() == 4: self.ClearTransfers.set_has_frame(False) Accelerator("t", self.Transfers, self.on_abort_transfers_accelerator) Accelerator("r", self.Transfers, self.on_retry_transfers_accelerator) Accelerator("Delete", self.Transfers, self.on_clear_transfers_accelerator) Accelerator("<Alt>Return", self.Transfers, self.on_file_properties_accelerator) self.last_ui_update = 0 self.transfer_list = [] self.users = {} self.paths = {} self.selected_users = [] self.selected_transfers = [] self.tree_users = None # Status list self.statuses = { "Queued": _("Queued"), "Queued (prioritized)": _("Queued (prioritized)"), "Queued (privileged)": _("Queued (privileged)"), "Getting status": _("Getting status"), "Transferring": _("Transferring"), "Cannot connect": _("Cannot connect"), "Pending shutdown.": _("Pending shutdown"), "User logged off": _("User logged off"), "Disallowed extension": _("Disallowed extension" ), # Sent by Soulseek NS for filtered extensions "Aborted": _("Aborted"), "Cancelled": _("Cancelled"), "Paused": _("Paused"), "Finished": _("Finished"), "Filtered": _("Filtered"), "Banned": _("Banned"), "Blocked country": _("Blocked country"), "Too many files": _("Too many files"), "Too many megabytes": _("Too many megabytes"), "File not shared": _("File not shared"), "File not shared.": _("File not shared"), # Newer variant containing a dot "Download folder error": _("Download folder error"), "Local file error": _("Local file error"), "Remote file error": _("Remote file error") } self.deprioritized_statuses = ("", "Paused", "Aborted", "Finished", "Filtered") self.transfersmodel = Gtk.TreeStore( str, # (0) user str, # (1) path str, # (2) file name str, # (3) translated status str, # (4) hqueue position int, # (5) percent str, # (6) hsize str, # (7) hspeed str, # (8) htime elapsed str, # (9) htime left GObject.TYPE_UINT64, # (10) size GObject.TYPE_UINT64, # (11) current bytes GObject.TYPE_UINT64, # (12) speed GObject.TYPE_UINT, # (13) queue position int, # (14) time elapsed int, # (15) time left GObject.TYPE_PYOBJECT # (16) transfer object ) self.column_numbers = list(range(self.transfersmodel.get_n_columns())) self.cols = cols = initialise_columns( frame, transfer_type, self.Transfers, ["user", _("User"), 200, "text", None], ["path", self.path_label, 400, "text", None], ["filename", _("Filename"), 400, "text", None], ["status", _("Status"), 140, "text", None], ["queue_position", _("Queue"), 75, "number", None], ["percent", _("Percent"), 70, "progress", None], ["size", _("Size"), 170, "number", None], ["speed", _("Speed"), 90, "number", None], ["time_elapsed", _("Time Elapsed"), 140, "number", None], ["time_left", _("Time Left"), 140, "number", None], ) cols["user"].set_sort_column_id(0) cols["path"].set_sort_column_id(1) cols["filename"].set_sort_column_id(2) cols["status"].set_sort_column_id(3) cols["queue_position"].set_sort_column_id(13) cols["percent"].set_sort_column_id(5) cols["size"].set_sort_column_id(10) cols["speed"].set_sort_column_id(12) cols["time_elapsed"].set_sort_column_id(14) cols["time_left"].set_sort_column_id(15) self.Transfers.set_model(self.transfersmodel) self.status_page = getattr(frame, "%ss_status_page" % transfer_type) self.expand_button = getattr(frame, "Expand%ss" % transfer_type.title()) state = GLib.Variant( "s", verify_grouping_mode(config.sections["transfers"]["group%ss" % transfer_type])) action = Gio.SimpleAction(name="%sgrouping" % transfer_type, parameter_type=GLib.VariantType("s"), state=state) action.connect("change-state", self.on_toggle_tree) frame.MainWindow.add_action(action) action.change_state(state) menu = create_grouping_menu( frame.MainWindow, config.sections["transfers"]["group%ss" % transfer_type], self.on_toggle_tree) grouping_button.set_menu_model(menu) self.expand_button.connect("toggled", self.on_expand_tree) self.expand_button.set_active( config.sections["transfers"]["%ssexpanded" % transfer_type]) self.popup_menu_users = PopupMenu(frame) self.popup_menu_clear = PopupMenu(frame) self.ClearTransfers.set_menu_model(self.popup_menu_clear.model) self.popup_menu_copy = PopupMenu(frame) self.popup_menu_copy.add_items( ("#" + _("Copy _File Path"), self.on_copy_file_path), ("#" + _("Copy _URL"), self.on_copy_url), ("#" + _("Copy Folder U_RL"), self.on_copy_dir_url)) self.popup_menu = PopupMenu(frame, self.Transfers, self.on_popup_menu) self.popup_menu.add_items( ("#" + "selected_files", None), ("", None), ("#" + _("Send to _Player"), self.on_play_files), ("#" + _("_Open in File Manager"), self.on_open_file_manager), ("#" + _("F_ile Properties"), self.on_file_properties), ("", None), ("#" + _("_Search"), self.on_file_search), ("#" + _("_Browse Folder(s)"), self.on_browse_folder), ("", None), ("#" + self.retry_label, self.on_retry_transfer), ("#" + self.abort_label, self.on_abort_transfer), ("#" + _("_Clear"), self.on_clear_transfer), ("", None), (">" + _("Clear Groups"), self.popup_menu_clear), (">" + _("Copy"), self.popup_menu_copy), (">" + _("User(s)"), self.popup_menu_users)) self.update_visuals() def init_transfers(self, transfer_list): self.transfer_list = transfer_list self.update(forceupdate=True) def server_login(self): pass def server_disconnect(self): pass def rebuild_transfers(self): self.clear() self.update() def save_columns(self): save_columns(self.type, self.Transfers.get_columns()) def update_visuals(self): for widget in list(self.__dict__.values()): update_widget_visuals(widget, list_font_target="transfersfont") def select_transfers(self): self.selected_transfers.clear() self.selected_users.clear() model, paths = self.Transfers.get_selection().get_selected_rows() for path in paths: iterator = model.get_iter(path) self.select_transfer(model, iterator, select_user=True) # If we're in grouping mode, select any transfers under the selected # user or folder self.select_child_transfers(model, model.iter_children(iterator)) def select_child_transfers(self, model, iterator): while iterator is not None: self.select_transfer(model, iterator) self.select_child_transfers(model, model.iter_children(iterator)) iterator = model.iter_next(iterator) def select_transfer(self, model, iterator, select_user=False): transfer = model.get_value(iterator, 16) if transfer.filename is not None and transfer not in self.selected_transfers: self.selected_transfers.append(transfer) if select_user and transfer.user not in self.selected_users: self.selected_users.append(transfer.user) def new_transfer_notification(self, finished=False): if self.frame.current_page_id != self.page_id: self.frame.request_tab_hilite(self.page_id, mentioned=finished) def on_ban(self, *_args): self.select_transfers() for user in self.selected_users: self.frame.np.network_filter.ban_user(user) def on_file_search(self, *_args): transfer = next(iter(self.selected_transfers), None) if not transfer: return self.frame.SearchEntry.set_text(transfer.filename.rsplit("\\", 1)[1]) self.frame.change_main_page("search") def translate_status(self, status): translated_status = self.statuses.get(status) if translated_status: return translated_status return status def update_num_users_files(self): self.user_counter.set_text(str(len(self.users))) self.file_counter.set_text(str(len(self.transfer_list))) def update(self, transfer=None, forceupdate=False, update_parent=True): if not forceupdate and self.frame.current_page_id != self.page_id: # No need to do unnecessary work if transfers are not visible return if transfer is not None: self.update_specific(transfer) elif self.transfer_list: for transfer_i in reversed(self.transfer_list): self.update_specific(transfer_i) if update_parent: self.update_parent_rows(transfer) def update_parent_rows(self, transfer=None): if self.tree_users != "ungrouped": if transfer is not None: username = transfer.user path = transfer.path if self.type == "download" else transfer.filename.rsplit( '\\', 1)[0] user_path = username + path user_path_iter = self.paths.get(user_path) user_iter = self.users.get(username) if user_path_iter: self.update_parent_row(user_path_iter, user_path, folder=True) if user_iter: self.update_parent_row(user_iter, username) else: for user_path, user_path_iter in list(self.paths.items()): self.update_parent_row(user_path_iter, user_path, folder=True) for username, user_iter in list(self.users.items()): self.update_parent_row(user_iter, username) # Show tab description if necessary self.status_page.set_visible(not self.transfer_list) self.Main.set_visible(self.transfer_list) @staticmethod def get_hqueue_position(queue_position): return str(queue_position) if queue_position > 0 else "" @staticmethod def get_hsize(current_byte_offset, size): return "%s / %s" % (human_size(current_byte_offset), human_size(size)) @staticmethod def get_hspeed(speed): return human_speed(speed) if speed > 0 else "" @staticmethod def get_helapsed(elapsed): return human_length(elapsed) if elapsed >= 1 else "" @staticmethod def get_hleft(left): return human_length(left) if left >= 1 else "" @staticmethod def get_percent(current_byte_offset, size): return min(((100 * int(current_byte_offset)) / int(size)), 100) if size > 0 else 100 @staticmethod def get_size(size): try: size = int(size) if size < 0 or size > maxsize: size = 0 except TypeError: size = 0 return 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): current_byte_offset = transfer.current_byte_offset or 0 queue_position = transfer.queue_position or 0 modifier = transfer.modifier status = transfer.status or "" if modifier and status == "Queued": # Priority status status = status + " (%s)" % modifier size = self.get_size(transfer.size) speed = transfer.speed or 0 hspeed = self.get_hspeed(speed) elapsed = transfer.time_elapsed or 0 helapsed = self.get_helapsed(elapsed) left = transfer.time_left or 0 initer = transfer.iterator # Modify old transfer if initer is not None: translated_status = self.translate_status(status) if self.transfersmodel.get_value(initer, 3) != translated_status: self.transfersmodel.set_value(initer, 3, translated_status) if self.transfersmodel.get_value(initer, 7) != hspeed: self.transfersmodel.set_value(initer, 7, hspeed) self.transfersmodel.set_value( initer, 12, GObject.Value(GObject.TYPE_UINT64, speed)) if self.transfersmodel.get_value(initer, 8) != helapsed: self.transfersmodel.set_value(initer, 8, helapsed) self.transfersmodel.set_value(initer, 9, self.get_hleft(left)) self.transfersmodel.set_value(initer, 14, elapsed) self.transfersmodel.set_value(initer, 15, left) if self.transfersmodel.get_value(initer, 11) != current_byte_offset: percent = self.get_percent(current_byte_offset, size) self.transfersmodel.set_value(initer, 5, percent) self.transfersmodel.set_value( initer, 6, self.get_hsize(current_byte_offset, size)) self.transfersmodel.set_value( initer, 11, GObject.Value(GObject.TYPE_UINT64, current_byte_offset)) elif self.transfersmodel.get_value(initer, 10) != size: self.transfersmodel.set_value( initer, 6, self.get_hsize(current_byte_offset, size)) self.transfersmodel.set_value( initer, 10, GObject.Value(GObject.TYPE_UINT64, size)) if self.transfersmodel.get_value(initer, 13) != queue_position: self.transfersmodel.set_value( initer, 4, self.get_hqueue_position(queue_position)) self.transfersmodel.set_value( initer, 13, GObject.Value(GObject.TYPE_UINT, queue_position)) return expand_user = False expand_folder = False filename = transfer.filename user = transfer.user shortfn = filename.split("\\")[-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_int, empty_int, empty_int, empty_int, empty_int, empty_int, Transfer(user=user) ]) if self.tree_users == "folder_grouping": expand_user = True else: expand_user = self.expand_button.get_active() 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 """ full_path = path = transfer.path if self.type == "download" else transfer.filename.rsplit( '\\', 1)[0] user_path = user + path if config.sections["ui"]["reverse_file_paths"]: path = self.path_separator.join( reversed(path.split(self.path_separator))) if user_path not in self.paths: self.paths[ user_path] = self.transfersmodel.insert_with_values( self.users[user], -1, self.column_numbers, [ user, path, empty_str, empty_str, empty_str, empty_int, empty_str, empty_str, empty_str, empty_str, empty_int, empty_int, empty_int, empty_int, empty_int, empty_int, Transfer(user=user, path=full_path) ]) expand_folder = self.expand_button.get_active() 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 = transfer.path if self.type == "download" else transfer.filename.rsplit( '\\', 1)[0] if config.sections["ui"]["reverse_file_paths"]: path = self.path_separator.join( reversed(path.split(self.path_separator))) iterator = self.transfersmodel.insert_with_values( parent, -1, self.column_numbers, (user, path, shortfn, self.translate_status(status), self.get_hqueue_position(queue_position), self.get_percent(current_byte_offset, size), self.get_hsize(current_byte_offset, size), hspeed, helapsed, self.get_hleft(left), GObject.Value(GObject.TYPE_UINT64, size), GObject.Value(GObject.TYPE_UINT64, current_byte_offset), GObject.Value(GObject.TYPE_UINT64, speed), GObject.Value(GObject.TYPE_UINT, queue_position), elapsed, left, transfer)) transfer.iterator = iterator self.update_num_users_files() if expand_user: self.Transfers.expand_row( self.transfersmodel.get_path(self.users[user]), False) if expand_folder: self.Transfers.expand_row( self.transfersmodel.get_path(self.paths[user_path]), False) def retry_transfers(self): for transfer in self.selected_transfers: getattr(self.frame.np.transfers, "retry_" + self.type)(transfer) def abort_transfers(self, clear=False): for transfer in self.selected_transfers: if transfer.status != "Finished": self.frame.np.transfers.abort_transfer(transfer, send_fail_message=True) if not clear: transfer.status = self.aborted_status self.update(transfer) if clear: self.remove_specific(transfer, update_parent=False) self.update_parent_rows() self.update_num_users_files() def remove_specific(self, transfer, cleartreeviewonly=False, update_parent=True): user = transfer.user if self.tree_users == "ungrouped" and user in self.users: # No grouping self.users[user].discard(transfer) if not self.users[user]: del self.users[user] if transfer in self.frame.np.transfers.transfer_request_times: del self.frame.np.transfers.transfer_request_times[transfer] if not cleartreeviewonly: self.transfer_list.remove(transfer) if transfer.iterator is not None: self.transfersmodel.remove(transfer.iterator) if update_parent: self.update_parent_rows(transfer) self.update_num_users_files() def clear_transfers(self, status): for transfer in self.transfer_list.copy(): if transfer.status in status: self.frame.np.transfers.abort_transfer(transfer, send_fail_message=True) self.remove_specific(transfer) def clear(self): self.users.clear() self.paths.clear() self.selected_transfers.clear() self.selected_users.clear() self.transfersmodel.clear() for transfer in self.transfer_list: transfer.iterator = None def add_popup_menu_user(self, popup, user): popup.setup_user_menu(user) popup.add_items(("", None), ("#" + _("Select User's Transfers"), self.on_select_user_transfers, user)) popup.update_model() popup.toggle_user_items() def populate_popup_menu_users(self): self.popup_menu_users.clear() if not self.selected_users: return # Multiple users, create submenus for each user if len(self.selected_users) > 1: for user in self.selected_users: popup = PopupMenu(self.frame) self.add_popup_menu_user(popup, user) self.popup_menu_users.add_items((">" + user, popup)) self.popup_menu_users.update_model() return # Single user, add items directly to "User(s)" submenu user = next(iter(self.selected_users), None) self.add_popup_menu_user(self.popup_menu_users, user) def on_expand_tree(self, widget): expand_button_icon = getattr(self.frame, "Expand%ssImage" % self.type.title()) expanded = widget.get_active() if expanded: icon_name = "go-up-symbolic" self.Transfers.expand_all() else: icon_name = "go-down-symbolic" collapse_treeview(self.Transfers, self.tree_users) expand_button_icon.set_property("icon-name", icon_name) config.sections["transfers"]["%ssexpanded" % self.type] = expanded config.write_configuration() def on_toggle_tree(self, action, state): mode = state.get_string() active = mode != "ungrouped" config.sections["transfers"]["group%ss" % self.type] = mode self.Transfers.set_show_expanders(active) self.expand_button.set_visible(active) self.tree_users = mode if self.transfer_list: self.rebuild_transfers() action.set_state(state) @staticmethod def on_tooltip(widget, pos_x, pos_y, _keyboard_mode, tooltip): return show_file_path_tooltip(widget, pos_x, pos_y, tooltip, 16, transfer=True) def on_popup_menu(self, menu, _widget): self.select_transfers() num_selected_transfers = len(self.selected_transfers) menu.set_num_selected_files(num_selected_transfers) self.populate_popup_menu_users() def on_row_activated(self, _treeview, _path, _column): self.select_transfers() action = config.sections["transfers"]["%s_doubleclick" % self.type] if action == 1: # Send to Player self.on_play_files() elif action == 2: # Open in File Manager self.on_open_file_manager() elif action == 3: # Search self.on_file_search() elif action == 4: # Pause / Abort self.abort_transfers() elif action == 5: # Clear self.abort_transfers(clear=True) elif action == 6: # Resume / Retry self.retry_transfers() elif action == 7: # Browse Folder self.on_browse_folder() def on_select_user_transfers(self, *args): if not self.selected_users: return selected_user = args[-1] sel = self.Transfers.get_selection() fmodel = self.Transfers.get_model() sel.unselect_all() iterator = fmodel.get_iter_first() select_user_row_iter(fmodel, sel, 0, selected_user, iterator) self.select_transfers() def on_abort_transfers_accelerator(self, *_args): """ T: abort transfer """ self.select_transfers() self.abort_transfers() return True def on_retry_transfers_accelerator(self, *_args): """ R: retry transfers """ self.select_transfers() self.retry_transfers() return True def on_clear_transfers_accelerator(self, *_args): """ Delete: clear transfers """ self.select_transfers() self.abort_transfers(clear=True) return True def on_file_properties_accelerator(self, *_args): """ Alt+Return: show file properties dialog """ self.select_transfers() self.on_file_properties() return True def on_file_properties(self, *_args): data = [] selected_size = 0 for transfer in self.selected_transfers: fullname = transfer.filename filename = fullname.split("\\")[-1] directory = fullname.rsplit("\\", 1)[0] file_size = transfer.size selected_size += file_size data.append({ "user": transfer.user, "fn": fullname, "filename": filename, "directory": directory, "path": transfer.path, "queue_position": transfer.queue_position, "speed": transfer.speed, "size": file_size, "bitrate": transfer.bitrate, "length": transfer.length }) if data: FileProperties(self.frame, data, total_size=selected_size, download_button=False).show() def on_copy_file_path(self, *_args): transfer = next(iter(self.selected_transfers), None) if transfer: copy_text(transfer.filename) def on_retry_transfer(self, *_args): self.select_transfers() self.retry_transfers() def on_abort_transfer(self, *_args): self.select_transfers() self.abort_transfers() def on_clear_transfer(self, *_args): self.select_transfers() self.abort_transfers(clear=True) def on_clear_response(self, dialog, response_id, data): dialog.destroy() if response_id == 2: if data == "queued": self.clear_transfers(["Queued"]) elif data == "all": self.clear() def on_clear_queued(self, *_args): self.clear_transfers(["Queued"]) def on_clear_finished(self, *_args): self.clear_transfers(["Finished"])