def __init__(self, library, main): super(SearchBar, self).__init__(library, main) self.set_spacing(6) self._filter = None self._library = library self.commands = {"query": self.__query} completion = LibraryTagCompletion(library.librarian) self.accelerators = Gtk.AccelGroup() show_limit = config.getboolean("browsers", "search_limit") sbb = LimitSearchBarBox(completion=completion, accel_group=self.accelerators, show_limit=show_limit) sbb.connect('query-changed', self.__text_parse) sbb.connect('focus-out', self.__focus) self._sb_box = sbb prefs = PreferencesButton(sbb) sbb.pack_start(prefs, False, True, 0) align = (Alignment(sbb, left=6, right=6, top=6) if main else Alignment(sbb)) self.pack_start(align, False, True, 0) self.connect('destroy', self.__destroy) self.show_all()
def __init__(self, library, main, limit=True): super(SearchBar, self).__init__(library, main) self.set_spacing(6) completion = LibraryTagCompletion(library.librarian) self.accelerators = gtk.AccelGroup() if limit: self._search_bar = LimitSearchBar(completion=completion, accel_group=self.accelerators) else: self._search_bar = SearchBarBox(completion=completion, accel_group=self.accelerators) self._search_bar.connect('query-changed', self.__text_parse) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() self._search_bar.connect('focus-out', focus) self.connect('destroy', self.__destroy) if main: align = Alignment(self._search_bar, left=3, right=3, top=3) else: align = Alignment(self._search_bar) align.show() self.pack_start(align, expand=False) self.show()
def __init__(self, library, main): super(PanedBrowser, self).__init__() self._register_instance() self.__main = main self._filter = None self._library = library self.commands = {"query": self.__query} self.set_spacing(6) completion = LibraryTagCompletion(library.librarian) self.accelerators = Gtk.AccelGroup() sbb = SearchBarBox(completion=completion, accel_group=self.accelerators) sbb.connect('query-changed', self.__text_parse) sbb.connect('focus-out', self.__focus) self._sb_box = sbb align = (Alignment(sbb, left=6, right=6, top=6) if main else Alignment(sbb)) self.pack_start(align, False, True, 0) keyval, mod = Gtk.accelerator_parse("<control>Home") s = self.accelerators.connect(keyval, mod, 0, self.__select_all) self.connect_object('destroy', self.accelerators.disconnect_key, keyval, mod) select = Gtk.Button(_("Select _All"), use_underline=True) s = select.connect('clicked', self.__select_all) self.connect_object('destroy', select.disconnect, s) sbb.pack_start(select, False, True, 0) prefs = PreferencesButton(self) sbb.pack_start(prefs, False, True, 0) for s in [ library.connect('changed', self.__changed), library.connect('added', self.__added), library.connect('removed', self.__removed) ]: self.connect_object('destroy', library.disconnect, s) self.connect('destroy', self.__destroy) # contains the panes and the song list self.main_box = RPaned() self.pack_start(self.main_box, True, True, 0) self.refresh_panes() for child in self.get_children(): child.show_all()
def __init__(self, parent, player, library): super(TopBar, self).__init__() # play controls control_item = Gtk.ToolItem() self.insert(control_item, 0) t = PlayControls(player, library.librarian) self.volume = t.volume control_item.add(t) self.insert(Gtk.SeparatorToolItem(), 1) info_item = Gtk.ToolItem() self.insert(info_item, 2) info_item.set_expand(True) box = Gtk.Box(spacing=6) info_item.add(box) qltk.add_css(self, "GtkToolbar {padding: 3px;}") # song text text = SongInfo(library.librarian, player) box.pack_start(Alignment(text, border=3), True, True, 0) # cover image self.image = CoverImage(resize=True) gobject_weak(player.connect, 'song-started', self.__new_song, parent=self) gobject_weak(parent.connect, 'artwork-changed', self.__song_art_changed, library, parent=self) # CoverImage doesn't behave in a Alignment, so wrap it coverbox = Gtk.Box() coverbox.pack_start(self.image, True, True, 0) box.pack_start(Alignment(coverbox, border=2), False, True, 0) for child in self.get_children(): child.show_all() context = self.get_style_context() context.add_class("primary-toolbar")
def __init__(self, paths): super(FileListExpander, self).__init__(label=_("Files:")) self.set_resize_toplevel(True) paths = [fsdecode(unexpand(p)) for p in paths] lab = Gtk.Label(label="\n".join(paths)) lab.set_alignment(0.0, 0.0) lab.set_selectable(True) win = Gtk.ScrolledWindow() win.add_with_viewport(Alignment(lab, border=6)) win.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) win.set_shadow_type(Gtk.ShadowType.ETCHED_OUT) win.set_size_request(-1, 100) self.add(win) win.show_all()
def __init__(self, library, main): super(AudioFeeds, self).__init__(spacing=6) self.__view = view = AllTreeView() self.__render = render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) col = Gtk.TreeViewColumn("Audio Feeds", render) col.set_cell_data_func(render, AudioFeeds.cell_data) view.append_column(col) view.set_model(self.__feeds) view.set_rules_hint(True) view.set_headers_visible(False) swin = ScrolledWindow() swin.set_shadow_type(Gtk.ShadowType.IN) swin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) swin.add(view) self.pack_start(swin, True, True, 0) new = Button(_("_New"), Gtk.STOCK_ADD, Gtk.IconSize.MENU) new.connect('clicked', self.__new_feed) view.get_selection().connect('changed', self.__changed) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) view.connect('popup-menu', self.__popup_menu) targets = [ ("text/uri-list", 0, DND_URI_LIST), ("text/x-moz-url", 0, DND_MOZ_URL) ] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) view.connect('drag-data-received', self.__drag_data_received) view.connect('drag-motion', self.__drag_motion) view.connect('drag-leave', self.__drag_leave) self.connect_object('destroy', self.__save, view) self.pack_start(Alignment(new, left=3, bottom=3), False, True, 0) for child in self.get_children(): child.show_all()
def __init__(self, library, player, headless=False): super(QuodLibetWindow, self).__init__(dialog=False) self.last_dir = const.HOME self.__destroyed = False self.__update_title(player) self.set_default_size(550, 450) main_box = Gtk.VBox() self.add(main_box) # create main menubar, load/restore accelerator groups self.__library = library ui = self.__create_menu(player, library) accel_group = ui.get_accel_group() self.add_accel_group(accel_group) def scroll_and_jump(*args): self.__jump_to_current(True, True) keyval, mod = Gtk.accelerator_parse("<control><shift>J") accel_group.connect(keyval, mod, 0, scroll_and_jump) # dbus app menu AppMenu(self, ui.get_action_groups()[0]) # custom accel map accel_fn = os.path.join(const.USERDIR, "accels") Gtk.AccelMap.load(accel_fn) # save right away so we fill the file with example comments of all # accels Gtk.AccelMap.save(accel_fn) menubar = ui.get_widget("/Menu") # Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79 # toplevel menu items show an empty 16x16 image. While we don't # need image items there UIManager creates them by default. # Work around by removing the empty GtkImages for child in menubar.get_children(): if isinstance(child, Gtk.ImageMenuItem): child.set_image(None) main_box.pack_start(menubar, False, True, 0) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.songlist.connect("key-press-event", self.__songlist_key_press) self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) main_box.pack_start(top_bar, False, True, 0) self.top_bar = top_bar self.__browserbox = Alignment(bottom=3) main_box.pack_start(self.__browserbox, True, True, 0) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start( Alignment(statusbox, border=3, top=-3, right=3), False, True, 0) self.songpane = ConfigRVPaned("memory", "queue_position", 0.75) self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") def songpane_button_press_cb(pane, event): """If we start to drag the pane handle while the queue expander is unexpanded, expand it and move the handle to the bottom, so we can 'drag' the queue out """ if event.window != pane.get_handle_window(): return False if not self.qexpander.get_expanded(): self.qexpander.set_expanded(True) pane.set_relative(1.0) return False self.songpane.connect("button-press-event", songpane_button_press_cb) self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('draw', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) try: orders = [] for e in config.getstringlist('memory', 'sortby', []): orders.append((e[1:], int(e[0]))) except ValueError: pass else: self.songlist.set_sort_orders(orders) self.browser = None self.ui = ui main_box.show_all() # set at least the playlist. the song should be restored # after the browser emits the song list player.setup(self.playlist, None, 0) self.__first_browser_set = True restore_browser = not headless try: self.select_browser( self, config.get("memory", "browser"), library, player, restore_browser) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise self.showhide_playlist(ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.info.connect("changed", self.__set_time) lib = library.librarian connect_destroy(lib, 'changed', self.__song_changed, player) self._playback_error_dialog = None player_sigs = [ ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: connect_destroy(player, *sig) # make sure we redraw all error indicators before opening # a dialog (blocking the main loop), so connect after default handlers connect_after_destroy(player, 'error', self.__player_error) # connect after to let SongTracker update stats connect_after_destroy(player, "song-ended", self.__song_ended) targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)] targets = [Gtk.TargetEntry.new(*t) for t in targets] self.drag_dest_set( Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) self.connect('drag-data-received', self.__drag_data_received) if not headless: GLib.idle_add(self.__configure_scan_dirs, library) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect("key-press-event", self.__key_pressed, player) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet")
class QuodLibetWindow(Window, PersistentWindowMixin): def __init__(self, library, player, headless=False): super(QuodLibetWindow, self).__init__(dialog=False) self.last_dir = const.HOME self.__destroyed = False self.__update_title(player) self.set_default_size(550, 450) main_box = Gtk.VBox() self.add(main_box) # create main menubar, load/restore accelerator groups self.__library = library ui = self.__create_menu(player, library) accel_group = ui.get_accel_group() self.add_accel_group(accel_group) def scroll_and_jump(*args): self.__jump_to_current(True, True) keyval, mod = Gtk.accelerator_parse("<control><shift>J") accel_group.connect(keyval, mod, 0, scroll_and_jump) # dbus app menu AppMenu(self, ui.get_action_groups()[0]) # custom accel map accel_fn = os.path.join(const.USERDIR, "accels") Gtk.AccelMap.load(accel_fn) # save right away so we fill the file with example comments of all # accels Gtk.AccelMap.save(accel_fn) menubar = ui.get_widget("/Menu") # Since https://git.gnome.org/browse/gtk+/commit/?id=b44df22895c79 # toplevel menu items show an empty 16x16 image. While we don't # need image items there UIManager creates them by default. # Work around by removing the empty GtkImages for child in menubar.get_children(): if isinstance(child, Gtk.ImageMenuItem): child.set_image(None) main_box.pack_start(menubar, False, True, 0) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.songlist.connect("key-press-event", self.__songlist_key_press) self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) main_box.pack_start(top_bar, False, True, 0) self.top_bar = top_bar self.__browserbox = Alignment(bottom=3) main_box.pack_start(self.__browserbox, True, True, 0) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start( Alignment(statusbox, border=3, top=-3, right=3), False, True, 0) self.songpane = ConfigRVPaned("memory", "queue_position", 0.75) self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") def songpane_button_press_cb(pane, event): """If we start to drag the pane handle while the queue expander is unexpanded, expand it and move the handle to the bottom, so we can 'drag' the queue out """ if event.window != pane.get_handle_window(): return False if not self.qexpander.get_expanded(): self.qexpander.set_expanded(True) pane.set_relative(1.0) return False self.songpane.connect("button-press-event", songpane_button_press_cb) self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('draw', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) try: orders = [] for e in config.getstringlist('memory', 'sortby', []): orders.append((e[1:], int(e[0]))) except ValueError: pass else: self.songlist.set_sort_orders(orders) self.browser = None self.ui = ui main_box.show_all() # set at least the playlist. the song should be restored # after the browser emits the song list player.setup(self.playlist, None, 0) self.__first_browser_set = True restore_browser = not headless try: self.select_browser( self, config.get("memory", "browser"), library, player, restore_browser) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise self.showhide_playlist(ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.info.connect("changed", self.__set_time) lib = library.librarian connect_destroy(lib, 'changed', self.__song_changed, player) self._playback_error_dialog = None player_sigs = [ ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: connect_destroy(player, *sig) # make sure we redraw all error indicators before opening # a dialog (blocking the main loop), so connect after default handlers connect_after_destroy(player, 'error', self.__player_error) # connect after to let SongTracker update stats connect_after_destroy(player, "song-ended", self.__song_ended) targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)] targets = [Gtk.TargetEntry.new(*t) for t in targets] self.drag_dest_set( Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) self.connect('drag-data-received', self.__drag_data_received) if not headless: GLib.idle_add(self.__configure_scan_dirs, library) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect("key-press-event", self.__key_pressed, player) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet") def set_as_osx_window(self, osx_app): assert osx_app menu = self.ui.get_widget("/Menu") menu.hide() osx_app.set_menu_bar(menu) # Reparent some items to the "Application" menu item = self.ui.get_widget('/Menu/Help/About') osx_app.insert_app_menu_item(item, 0) osx_app.insert_app_menu_item(Gtk.SeparatorMenuItem(), 1) item = self.ui.get_widget('/Menu/Music/Preferences') osx_app.insert_app_menu_item(item, 2) quit_item = self.ui.get_widget('/Menu/Music/Quit') quit_item.hide() def get_osx_is_persistent(self): return True def __player_error(self, player, song, player_error): # it's modal, but mmkeys etc. can still trigger new ones if self._playback_error_dialog: self._playback_error_dialog.destroy() dialog = PlaybackErrorDialog(self, player_error) self._playback_error_dialog = dialog dialog.run() self._playback_error_dialog = None def __configure_scan_dirs(self, library): """Get user to configure scan dirs, if none is set up""" if not get_scan_dirs() and not len(library) and \ quodlibet.is_first_session("quodlibet"): print_d("Couldn't find any scan dirs") resp = ConfirmLibDirSetup(self).run() if resp == ConfirmLibDirSetup.RESPONSE_SETUP: prefs = PreferencesWindow(self) prefs.set_page("library") prefs.show() def __add_bookmark(self, librarian, player): if player.song: position = player.get_position() // 1000 bookmarks = player.song.bookmarks new_mark = (position, _("Bookmark Name")) if new_mark not in bookmarks: bookmarks.append(new_mark) player.song.bookmarks = bookmarks def __edit_bookmarks(self, librarian, player): if player.song: window = EditBookmarks(self, librarian, player) window.show() def __key_pressed(self, widget, event, player): if not player.song: return def seek_relative(seconds): current = player.get_position() current += seconds * 1000 current = min(player.song("~#length") * 1000 - 1, current) current = max(0, current) player.seek(current) if qltk.is_accel(event, "<alt>Right"): seek_relative(10) return True elif qltk.is_accel(event, "<alt>Left"): seek_relative(-10) return True def __destroy(self, *args): self.playlist.destroy() # The tray icon plugin tries to unhide QL because it gets disabled # on Ql exit. The window should stay hidden after destroy. self.show = lambda: None self.present = self.show def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime): assert tid == DND_URI_LIST uris = sel.get_uris() dirs = [] error = False for uri in uris: try: uri = URI(uri) except ValueError: continue if uri.is_filename: loc = os.path.normpath(uri.filename) if os.path.isdir(loc): dirs.append(loc) else: loc = os.path.realpath(loc) if loc not in self.__library: self.__library.add_filename(loc) elif app.player.can_play_uri(uri): if uri not in self.__library: self.__library.add([RemoteFile(uri)]) else: error = True break Gtk.drag_finish(ctx, not error, False, etime) if error: ErrorMessage( self, _("Unable to add songs"), _("%s uses an unsupported protocol.") % util.bold(uri)).run() else: if dirs: copool.add( self.__library.scan, dirs, cofuncid="library", funcid="library") def __songlist_key_press(self, songlist, event): return self.browser.key_pressed(event) def __songlist_drag_data_recv(self, view, *args): if self.browser.can_reorder: songs = view.get_songs() self.browser.reordered(songs) self.songlist.clear_sort() def __show_or(self, widget, prop): ssv = self.song_scroller.get_property('visible') qxv = self.qexpander.get_property('visible') self.songpane.set_property('visible', ssv or qxv) if not ssv: self.qexpander.set_expanded(True) self.__expand_or(widget, prop) def __expand_or(self, widget, prop): if self.qexpander.get_property('expanded'): self.songpane.set_property("position", self.__handle_position) def __moved_pane_handle(self, widget, prop): if self.qexpander.get_property('expanded'): self.__handle_position = self.songpane.get_property("position") def __qex_size_allocate(self, event, param=None): if not self.qexpander.get_property('expanded'): p_max = self.songpane.get_property("max-position") p_cur = self.songpane.get_property("position") if p_max != p_cur: self.songpane.set_property("position", p_max) def __create_menu(self, player, library): ag = Gtk.ActionGroup.new('QuodLibetWindowActions') actions = [ ('Music', None, _("_Music")), ('AddFolders', Gtk.STOCK_ADD, _(u'_Add a Folder…'), "<control>O", None, self.open_chooser), ('AddFiles', Gtk.STOCK_ADD, _(u'_Add a File…'), None, None, self.open_chooser), ('AddLocation', Gtk.STOCK_ADD, _(u'_Add a Location…'), None, None, self.open_location), ('BrowseLibrary', Gtk.STOCK_FIND, _('Open _Browser'), ""), ("Preferences", Gtk.STOCK_PREFERENCES, None, None, None, self.__preferences), ("Plugins", Gtk.STOCK_EXECUTE, _("_Plugins"), None, None, self.__plugins), ("Quit", Gtk.STOCK_QUIT, None, None, None, lambda *x: self.destroy()), ("Control", None, _("_Control")), ("EditTags", Gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None, self.__current_song_prop), ("Information", Gtk.STOCK_INFO, None, None, None, self.__current_song_info), ("Jump", Gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"), "<control>J", None, self.__jump_to_current), ("View", None, _("_View")), ("Help", None, _("_Help")), ] actions.append(("Previous", Gtk.STOCK_MEDIA_PREVIOUS, None, "<control>comma", None, self.__previous_song)) actions.append(("PlayPause", Gtk.STOCK_MEDIA_PLAY, None, "<control>space", None, self.__play_pause)) actions.append(("Next", Gtk.STOCK_MEDIA_NEXT, None, "<control>period", None, self.__next_song)) ag.add_actions(actions) act = Gtk.ToggleAction.new("StopAfter", _("Stop After This Song"), None, "") ag.add_action_with_accel(act, "<shift>space") # access point for the tray icon self.stop_after = act act = Gtk.Action.new( "AddBookmark", _("Add Bookmark"), None, Gtk.STOCK_ADD) connect_obj(act, 'activate', self.__add_bookmark, library.librarian, player) ag.add_action_with_accel(act, "<ctrl>D") act = Gtk.Action.new("EditBookmarks", _(u"Edit Bookmarks…"), None, "") connect_obj(act, 'activate', self.__edit_bookmarks, library.librarian, player) ag.add_action_with_accel(act, "<ctrl>B") act = Gtk.Action.new("About", None, None, Gtk.STOCK_ABOUT) connect_obj(act, 'activate', self.__show_about, player) ag.add_action_with_accel(act, None) act = Gtk.Action.new( "OnlineHelp", _("Online Help"), None, Gtk.STOCK_HELP) def website_handler(*args): util.website(const.ONLINE_HELP) act.connect('activate', website_handler) ag.add_action_with_accel(act, "F1") act = Gtk.Action.new("SearchHelp", _("Search Help"), None, "") def search_help_handler(*args): util.website(const.SEARCH_HELP) act.connect('activate', search_help_handler) ag.add_action_with_accel(act, None) act = Gtk.Action.new( "RefreshLibrary", _("Re_fresh Library"), None, Gtk.STOCK_REFRESH) act.connect('activate', self.__rebuild, False) ag.add_action_with_accel(act, None) ag.add_toggle_actions([ ("SongList", None, _("Song _List"), None, None, self.showhide_playlist, config.getboolean("memory", "songlist"))]) ag.add_toggle_actions([ ("Queue", None, _("_Queue"), None, None, self.showhide_playqueue, config.getboolean("memory", "queue"))]) view_actions = [] for i, Kind in enumerate(browsers.browsers): action = "View" + Kind.__name__ label = Kind.accelerated_name view_actions.append((action, None, label, None, None, i)) current = browsers.index(config.get("memory", "browser")) def action_callback(view_action, current): self.select_browser(view_action, current, library, player) ag.add_radio_actions( view_actions, current, action_callback, None) for Kind in browsers.browsers: if not Kind.in_menu: continue action = "Browser" + Kind.__name__ label = Kind.accelerated_name act = Gtk.Action.new(action, label, None, None) def browser_activate(action, Kind): LibraryBrowser.open(Kind, library, player) act.connect('activate', browser_activate, Kind) ag.add_action_with_accel(act, None) ui = Gtk.UIManager() ui.insert_action_group(ag, -1) ui.add_ui_from_string( MAIN_MENU % {"browsers": browsers.BrowseLibrary()}) self._filter_menu = FilterMenu(library, player, ui) menustr = MENU % { "views": browsers.ViewBrowser(), } ui.add_ui_from_string(menustr) # Cute. So. UIManager lets you attach tooltips, but when they're # for menu items, they just get ignored. So here I get to actually # attach them. ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text( _("Check for changes in your library")) return ui def __show_about(self, player): about = AboutQuodLibet(self, player) about.run() about.destroy() def select_browser(self, activator, current, library, player, restore=False): if isinstance(current, Gtk.RadioAction): current = current.get_current_value() Browser = browsers.get(current) config.set("memory", "browser", Browser.__name__) if self.browser: container = self.browser.__container self.browser.unpack(container, self.songpane) if self.browser.accelerators: self.remove_accel_group(self.browser.accelerators) container.destroy() self.browser.destroy() self.browser = Browser(library) self.browser.connect('songs-selected', self.__browser_cb, library, player) self.browser.connect('songs-activated', self.__browser_activate) if restore: self.browser.restore() self.browser.activate() self.browser.finalize(restore) if self.browser.can_reorder: self.songlist.enable_drop() elif self.browser.dropped: self.songlist.enable_drop(False) else: self.songlist.disable_drop() if self.browser.accelerators: self.add_accel_group(self.browser.accelerators) container = self.browser.__container = self.browser.pack(self.songpane) player.replaygain_profiles[1] = self.browser.replaygain_profiles player.volume = player.volume self.__browserbox.add(container) container.show() self._filter_menu.set_browser(self.browser) self.__hide_headers() self.__refresh_size() def __update_paused(self, player, paused): menu = self.ui.get_widget("/Menu/Control/PlayPause") if paused: key = Gtk.STOCK_MEDIA_PLAY else: key = Gtk.STOCK_MEDIA_PAUSE text = Gtk.stock_lookup(key).label menu.get_image().set_from_stock(key, Gtk.IconSize.MENU) menu.set_label(text) menu.set_use_underline(True) def __song_ended(self, player, song, stopped): # check if the song should be removed base on the # active filter of the current browser active_filter = self.browser.active_filter if song and active_filter and not active_filter(song): iter_ = self.songlist.model.find(song) if iter_: self.songlist.remove_iters([iter_]) if self.stop_after.get_active(): player.paused = True self.stop_after.set_active(False) def __song_changed(self, library, songs, player): if player.info in songs: self.__update_title(player) def __update_title(self, player): song = player.info title = "Quod Libet" if song: title = song.comma("~title~version~~people") + " - " + title self.set_title(title) def __song_started(self, player, song): self.__update_title(player) for wid in ["Jump", "Next", "EditTags", "Information", "EditBookmarks", "AddBookmark", "StopAfter"]: self.ui.get_widget( '/Menu/Control/' + wid).set_sensitive(bool(song)) # don't jump on stream changes (player.info != player.song) if song and player.song is song and not self.songlist._activated and \ config.getboolean("settings", "jump") and self.songlist.sourced: self.__jump_to_current(False) def __refresh_size(self): ssv = self.song_scroller.get_property('visible') qex = self.qexpander.get_property('visible') if ssv or qex: return # Handle more later if needed.. if not isinstance(self.browser, Gtk.Box): return # If a child expands the browser will take the new space for child in self.browser.get_children(): if self.browser.query_child_packing(child)[0]: break else: # no expanding child, make the window smaller instead width, height = self.get_size() height = self.size_request().height self.resize(width, height) def showhide_playlist(self, toggle): self.song_scroller.set_property('visible', toggle.get_active()) self.__refresh_size() def showhide_playqueue(self, toggle): self.qexpander.set_property('visible', toggle.get_active()) self.__refresh_size() def __play_pause(self, *args): if app.player.song is None: app.player.reset() else: app.player.paused ^= True def __jump_to_current(self, explicit, force_scroll=False): """Select/scroll to the current playing song in the playlist. If it can't be found tell the browser to properly fill the playlist with an appropriate selection containing the song. explicit means that the jump request comes from the user and not from an event like song-started. force_scroll will ask the browser to refill the playlist in any case. """ def idle_jump_to(song, select): ok = self.songlist.jump_to_song(song, select=select) if ok: self.songlist.grab_focus() return False song = app.player.song # We are not playing a song if song is None: return if not force_scroll: ok = self.songlist.jump_to_song(song, select=explicit) else: assert explicit ok = False if ok: self.songlist.grab_focus() elif explicit: # if we can't find it and the user requested it, try harder self.browser.scroll(song) # We need to wait until the browser has finished # scrolling/filling and the songlist is ready. # Not perfect, but works for now. GLib.idle_add( idle_jump_to, song, explicit, priority=GLib.PRIORITY_LOW) def __next_song(self, *args): app.player.next() def __previous_song(self, *args): app.player.previous() def __rebuild(self, activator, force): scan_library(self.__library, force) # Set up the preferences window. def __preferences(self, activator): window = PreferencesWindow(self) window.show() def __plugins(self, activator): window = PluginWindow(self) window.show() def open_location(self, action): name = GetStringDialog(self, _("Add a Location"), _("Enter the location of an audio file:"), okbutton=Gtk.STOCK_ADD).run() if name: if not util.uri_is_valid(name): ErrorMessage( self, _("Unable to add location"), _("%s is not a valid location.") % ( util.bold(util.escape(name)))).run() elif not app.player.can_play_uri(name): ErrorMessage( self, _("Unable to add location"), _("%s uses an unsupported protocol.") % ( util.bold(util.escape(name)))).run() else: if name not in self.__library: self.__library.add([RemoteFile(name)]) def open_chooser(self, action): last_dir = self.last_dir if not os.path.exists(last_dir): last_dir = const.HOME class MusicFolderChooser(FolderChooser): def __init__(self, parent, init_dir): super(MusicFolderChooser, self).__init__( parent, _("Add Music"), init_dir) cb = Gtk.CheckButton(_("Watch this folder for new songs")) # enable if no folders are being watched cb.set_active(not get_scan_dirs()) cb.show() self.set_extra_widget(cb) def run(self): fns = super(MusicFolderChooser, self).run() cb = self.get_extra_widget() return fns, cb.get_active() class MusicFileChooser(FileChooser): def __init__(self, parent, init_dir): super(MusicFileChooser, self).__init__( parent, _("Add Music"), formats.filter, init_dir) if action.get_name() == "AddFolders": dialog = MusicFolderChooser(self, last_dir) fns, do_watch = dialog.run() dialog.destroy() if fns: fns = map(glib2fsnative, fns) # scan them self.last_dir = fns[0] copool.add(self.__library.scan, fns, funcid="library") # add them as library scan directory if do_watch: dirs = get_scan_dirs() for fn in fns: if fn not in dirs: dirs.append(fn) set_scan_dirs(dirs) else: dialog = MusicFileChooser(self, last_dir) fns = dialog.run() dialog.destroy() if fns: fns = map(glib2fsnative, fns) self.last_dir = os.path.dirname(fns[0]) for filename in map(os.path.realpath, fns): self.__library.add_filename(filename) def __songs_popup_menu(self, songlist): path, col = songlist.get_cursor() header = col.header_name menu = self.songlist.Menu(header, self.browser, self.__library) if menu is not None: return self.songlist.popup_menu(menu, 0, Gtk.get_current_event_time()) def __current_song_prop(self, *args): song = app.player.song if song: librarian = self.__library.librarian window = SongProperties(librarian, [song], parent=self) window.show() def __current_song_info(self, *args): song = app.player.song if song: librarian = self.__library.librarian window = Information(librarian, [song], self) window.show() def __browser_activate(self, browser): app.player.reset() def __browser_cb(self, browser, songs, sorted, library, player): if browser.background: bg = background_filter() if bg: songs = filter(bg, songs) self.songlist.set_songs(songs, sorted) # After the first time the browser activates, which should always # happen if we start up and restore, restore the playing song. # Because the browser has send us songs we can be sure it has # registered all its libraries. if self.__first_browser_set: self.__first_browser_set = False song = library.librarian.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek", 0) config.set("memory", "seek", 0) if song is not None: player.setup(self.playlist, song, seek_pos) def __hide_headers(self, activator=None): for column in self.songlist.get_columns(): if self.browser.headers is None: column.set_visible(True) else: for tag in util.tagsplit(column.header_name): if tag in self.browser.headers: column.set_visible(True) break else: column.set_visible(False) def __cols_changed(self, songlist): headers = [col.header_name for col in songlist.get_columns()] try: headers.remove('~current') except ValueError: pass if len(headers) == len(get_columns()): # Not an addition or removal (handled separately) set_columns(headers) SongList.headers = headers def __make_query(self, query): if self.browser.can_filter_text(): self.browser.filter_text(query.encode('utf-8')) self.browser.activate() def __set_time(self, info, songs): i = len(songs) length = sum(song.get("~#length", 0) for song in songs) t = self.browser.statusbar(i) % { 'count': i, 'time': util.format_time_long(length)} self.statusbar.set_default_text(t)
def __init__(self, library, main): super(CollectionBrowser, self).__init__(spacing=6) self._register_instance() if self.__model is None: self._init_model(library) sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) self.view = view = CollectionView() view.set_headers_visible(False) model_sort = CollectionSortModel(model=self.__model) model_filter = CollectionFilterModel(child_model=model_sort) self.__filter = None self.__bg_filter = background_filter() model_filter.set_visible_func(self.__parse_query) view.set_model(model_filter) def sort(model, i1, i2, data): t1, t2 = model[i1][0], model[i2][0] if t1 is None or t2 is None: # FIXME: why? return 0 # FIXME: order this deterministically if t1 is MultiNode or t1 is UnknownNode or \ t2 is MultiNode or t2 is UnknownNode: return -cmp(t1, t2) if not isinstance(t1, Album): return cmp(util.human_sort_key(t1), util.human_sort_key(t2)) a1, a2 = t1, t2 return (cmp(a1.peoplesort and a1.peoplesort[0], a2.peoplesort and a2.peoplesort[0]) or cmp(a1.date or "ZZZZ", a2.date or "ZZZZ") or cmp( (a1.sort, a1.key), (a2.sort, a2.key))) model_sort.set_sort_func(0, sort) model_sort.set_sort_column_id(0, Gtk.SortType.ASCENDING) column = Gtk.TreeViewColumn("albums") def cell_data(column, cell, model, iter_, data): markup = model.get_markup(self.__model.tags, iter_) cell.markup = markup cell.set_property('markup', markup) def get_scaled_cover(album): # XXX: Cache this somewhere else cover = None if not hasattr(album, "_scaled_cover"): scale_factor = get_scale_factor(self) album.scan_cover(scale_factor=scale_factor) if album.cover: s = 25 * scale_factor cover = scale(album.cover, (s, s)) album._scaled_cover = cover else: cover = album._scaled_cover return cover def cell_data_pb(column, cell, model, iter_, data): album = model.get_album(iter_) if album is None: cell.set_property('stock_id', Gtk.STOCK_DIRECTORY) else: cover = get_scaled_cover(album) if cover: pbosf = get_pbosf_for_pixbuf(self, cover) prop_name = pbosf_get_property_name(pbosf) cell.set_property(prop_name, pbosf) else: cell.set_property('stock_id', Gtk.STOCK_CDROM) imgrender = Gtk.CellRendererPixbuf() render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) column.pack_start(imgrender, False) column.pack_start(render, True) column.set_cell_data_func(render, cell_data) column.set_cell_data_func(imgrender, cell_data_pb) view.append_column(column) sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.add(view) hbox = Gtk.HBox(spacing=6) prefs = Gtk.Button() prefs.add(SymbolicIconImage("emblem-system", Gtk.IconSize.MENU)) prefs.connect('clicked', lambda *x: Preferences(self)) search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) hbox.pack_start(search, True, True, 0) hbox.pack_start(prefs, False, True, 0) if main: self.pack_start(Alignment(hbox, left=6, top=6), False, True, 0) else: self.pack_start(hbox, False, True, 0) self.pack_start(sw, True, True, 0) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) self.__sig = view.get_selection().connect('changed', self.__selection_changed) view.connect('row-activated', self.__play, main) view.connect_object('popup-menu', self.__popup, view, library) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) view.connect("drag-data-get", self.__drag_data_get) self.connect("destroy", self.__destroy) self.show_all()
def __init__(self, library, dir=None): super(ExFalsoWindow, self).__init__() self.set_title("Ex Falso") self.set_default_size(750, 475) self.enable_window_tracking("exfalso") self.__library = library hp = ConfigRHPaned("memory", "exfalso_paned_position", 1.0) hp.set_border_width(0) hp.set_position(250) hp.show() self.add(hp) vb = Gtk.VBox() bbox = Gtk.HBox(spacing=6) about = Gtk.Button() about.add( Gtk.Image.new_from_stock(Gtk.STOCK_ABOUT, Gtk.IconSize.BUTTON)) about.connect_object('clicked', self.__show_about, self) bbox.pack_start(about, False, True, 0) prefs = Gtk.Button() prefs.add( Gtk.Image.new_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.BUTTON)) def prefs_cb(button): window = PreferencesWindow(self) window.show() prefs.connect('clicked', prefs_cb) bbox.pack_start(prefs, False, True, 0) plugins = qltk.Button(_("_Plugins"), Gtk.STOCK_EXECUTE) def plugin_window_cb(button): window = PluginWindow(self) window.show() plugins.connect('clicked', plugin_window_cb) bbox.pack_start(plugins, False, True, 0) l = Gtk.Label() l.set_alignment(1.0, 0.5) l.set_ellipsize(Pango.EllipsizeMode.END) bbox.pack_start(l, True, True, 0) fs = MainFileSelector() vb.pack_start(fs, True, True, 0) vb.pack_start(Alignment(bbox, border=6), False, True, 0) vb.show_all() hp.pack1(vb, resize=True, shrink=False) nb = qltk.Notebook() nb.show() for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]: page = Page(self, self.__library) page.show() nb.append_page(page) align = Alignment(nb, top=3) align.show() hp.pack2(align, resize=True, shrink=False) fs.connect('changed', self.__changed, l) if dir: fs.go_to(dir) s = self.__library.connect('changed', lambda *x: fs.rescan()) self.connect_object('destroy', self.__library.disconnect, s) self.__save = None self.connect_object('changed', self.set_pending, None) for c in fs.get_children(): c.get_child().connect('button-press-event', self.__pre_selection_changed, fs, nb) c.get_child().connect('focus', self.__pre_selection_changed, fs, nb) fs.get_children()[1].get_child().connect('popup-menu', self.__popup_menu, fs) self.emit('changed', []) self.get_child().show() self.__ag = Gtk.AccelGroup() key, mod = Gtk.accelerator_parse("<control>Q") self.__ag.connect(key, mod, 0, lambda *x: self.destroy()) self.add_accel_group(self.__ag)
def __init__(self, library, main): super(AlbumList, self).__init__(spacing=6) self._register_instance() if self.__model is None: self._init_model(library) sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.set_headers_visible(False) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) render = Gtk.CellRendererPixbuf() self.__cover_column = column = Gtk.TreeViewColumn("covers", render) column.set_visible(config.getboolean("browsers", "album_covers")) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) column.set_fixed_width(Album.COVER_SIZE + 12) render.set_property('height', Album.COVER_SIZE + 8) def cell_data_pb(column, cell, model, iter_, no_cover): album = model.get_album(iter_) if album is None: pixbuf = None elif album.cover: pixbuf = album.cover else: pixbuf = no_cover if self.__last_render_pb == pixbuf: return self.__last_render_pb = pixbuf cell.set_property('pixbuf', pixbuf) column.set_cell_data_func(render, cell_data_pb, self.__no_cover) view.append_column(column) render = Gtk.CellRendererText() column = Gtk.TreeViewColumn("albums", render) column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) render.set_property('ellipsize', Pango.EllipsizeMode.END) def cell_data(column, cell, model, iter_, data): album = model.get_album(iter_) if album is None: text = "<b>%s</b>" % _("All Albums") text += "\n" + ngettext("%d album", "%d albums", len(model) - 1) % (len(model) - 1) markup = text else: markup = AlbumList._pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) column.set_cell_data_func(render, cell_data) view.append_column(column) view.get_selection().set_mode(Gtk.SelectionMode.MULTIPLE) view.set_rules_hint(True) view.set_search_equal_func(self.__search_func, None) view.set_search_column(0) view.set_model(model_filter) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.add(view) if main: gobject_weak(view.connect, 'row-activated', self.__play_selection) self.__sig = gobject_weak( view.get_selection().connect, 'changed', util.DeferredSignal(self.__update_songs), parent=view) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, 1), ("text/uri-list", 0, 2)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_source_set( Gdk.ModifierType.BUTTON1_MASK, targets, Gdk.DragAction.COPY) gobject_weak(view.connect, "drag-data-get", self.__drag_data_get) gobject_weak(view.connect_object, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) gobject_weak(search.connect, 'query-changed', self.__update_filter) gobject_weak(search.connect_object, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) if main: self.pack_start(Alignment(search, left=6, top=6), False, True, 0) else: self.pack_start(search, False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.__cover_column) self.connect('key-press-event', self.__key_pressed, library.librarian) self.show_all()
def __init__(self, parent=None): if self.is_not_unique(): return super(PluginWindow, self).__init__() self.set_title(_("Plugins") + " - Quod Libet") self.set_border_width(12) self.set_default_size(655, 404) self.set_transient_for(parent) paned = Gtk.Paned() vbox = Gtk.VBox(spacing=6) sw = Gtk.ScrolledWindow() sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.ALWAYS) model = ObjectStore() filter_model = ObjectModelFilter(child_model=model) tv = PluginListView() tv.set_model(filter_model) tv.set_rules_hint(True) tv.connect("plugin-toggled", self.__plugin_toggled) fb = Gtk.HBox(spacing=6) filter_combo = PluginFilterCombo() filter_combo.connect("changed", lambda s: filter_model.refilter()) fb.pack_start(filter_combo, False, True, 0) filter_entry = ClearEntry() filter_entry.connect("changed", lambda s: filter_model.refilter()) filter_entry.enable_clear_button() fb.pack_start(filter_entry, True, True, 0) sw.add(tv) sw.set_shadow_type(Gtk.ShadowType.IN) sw.set_size_request(200, -1) bbox = Gtk.HBox(homogeneous=True, spacing=12) errors = qltk.Button(_("Show _Errors"), Gtk.STOCK_DIALOG_WARNING) errors.set_focus_on_click(False) errors.connect('clicked', self.__show_errors) bbox.pack_start(errors, True, True, 0) pref_box = PluginPreferencesContainer() if const.DEBUG: refresh = Gtk.Button(stock=Gtk.STOCK_REFRESH) refresh.set_focus_on_click(False) refresh.connect('clicked', self.__refresh, tv, pref_box, errors, filter_combo) bbox.pack_start(refresh, True, True, 0) vbox.pack_start(fb, False, True, 0) vbox.pack_start(sw, True, True, 0) vbox.pack_start(bbox, False, True, 0) paned.pack1(vbox, True, False) close = Gtk.Button(stock=Gtk.STOCK_CLOSE) close.connect('clicked', lambda *x: self.destroy()) bb_align = Gtk.Alignment.new(0, 1, 1, 0) bb = Gtk.HButtonBox() bb.set_layout(Gtk.ButtonBoxStyle.END) bb.pack_start(close, True, True, 0) bb_align.add(bb) selection = tv.get_selection() selection.connect('changed', self.__selection_changed, pref_box) selection.emit('changed') right_box = Gtk.VBox(spacing=12) right_box.pack_start(pref_box, True, True, 0) right_box.pack_start(bb_align, True, True, 0) paned.pack2(Alignment(right_box, left=6), True, False) paned.set_position(250) self.add(paned) self.__refill(tv, pref_box, errors, filter_combo) self.connect('destroy', self.__destroy) filter_model.set_visible_func(self.__filter, (filter_entry, filter_combo)) self.get_child().show_all() filter_entry.grab_focus() restore_id = config.get("memory", "plugin_selection") tv.select_by_plugin_id(restore_id)
def __init__(self, library, player): super(QuodLibetWindow, self).__init__() self.last_dir = const.HOME self.__update_title(player) self.set_default_size(550, 450) main_box = gtk.VBox() self.add(main_box) # create test instance of the MPD backend self._mpd = quodmpd.QuodMpd() # create main menubar, load/restore accelerator groups self.__library = library self.__create_menu(player, library) self.add_accel_group(self.ui.get_accel_group()) accel_fn = os.path.join(const.USERDIR, "accels") gtk.accel_map_load(accel_fn) accelgroup = gtk.accel_groups_from_object(self)[0] accelgroup.connect('accel-changed', lambda *args: gtk.accel_map_save(accel_fn)) main_box.pack_start(self.ui.get_widget("/Menu"), expand=False) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.add_accel_group(self.songlist.accelerators) self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( self.ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( self.ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) top_align = Alignment(top_bar, border=3, bottom=-3) main_box.pack_start(top_align, expand=False) self.__browserbox = Alignment(top=3, bottom=3) main_box.pack_start(self.__browserbox) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start(Alignment(statusbox, border=3, top=-3), expand=False) self.songpane = gtk.VPaned() self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('size-allocate', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) sort = config.get('memory', 'sortby') self.songlist.set_sort_by(None, sort[1:], order=int(sort[0])) self.browser = None main_box.show_all() try: self.select_browser( self, config.get("memory", "browser"), library, player, True) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise # set at least the playlist before the mainloop starts.. player.setup(self.playlist, None, 0) def delayed_song_set(): song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek") config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos) gobject.idle_add(delayed_song_set) self.showhide_playlist(self.ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(self.ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.get_selection().connect( 'changed', util.DeferredSignal(self.__set_time)) lib = library.librarian gobject_weak(lib.connect, 'removed', self.__set_time, parent=self) gobject_weak(lib.connect, 'added', self.__set_time, parent=self) gobject_weak(lib.connect_object, 'changed', self.__song_changed, player, parent=self) player_sigs = [ ('song-ended', self.__song_ended), ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: gobject_weak(player.connect, *sig, **{"parent": self}) targets = [("text/uri-list", 0, 1)] self.drag_dest_set( gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_DEFAULT) self.connect_object('drag-motion', QuodLibetWindow.__drag_motion, self) self.connect_object('drag-leave', QuodLibetWindow.__drag_leave, self) self.connect_object( 'drag-data-received', QuodLibetWindow.__drag_data_received, self) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect_object("key-press-event", self.__key_pressed, player) self.connect("delete-event", self.__save_browser) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet")
def __init__(self, library, player, headless=False): super(QuodLibetWindow, self).__init__(dialog=False) self.last_dir = const.HOME self.__update_title(player) self.set_default_size(550, 450) main_box = Gtk.VBox() self.add(main_box) # create main menubar, load/restore accelerator groups self.__library = library ui = self.__create_menu(player, library) accel_group = ui.get_accel_group() self.add_accel_group(accel_group) # dbus app menu AppMenu(self, ui.get_action_groups()[0]) accel_fn = os.path.join(const.USERDIR, "accels") Gtk.AccelMap.load(accel_fn) def accel_save_cb(*args): Gtk.AccelMap.save(accel_fn) accel_group.connect_object('accel-changed', accel_save_cb, None) main_box.pack_start(ui.get_widget("/Menu"), False, True, 0) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) main_box.pack_start(top_bar, False, True, 0) self.top_bar = top_bar self.__browserbox = Alignment(bottom=3) main_box.pack_start(self.__browserbox, True, True, 0) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start( Alignment(statusbox, border=3, top=-3, right=3), False, True, 0) self.songpane = ConfigRVPaned("memory", "queue_position", 0.75) self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") def songpane_button_press_cb(pane, event): """If we start to drag the pane handle while the queue expander is unexpanded, expand it and move the handle to the bottom, so we can 'drag' the queue out """ if event.window != pane.get_handle_window(): return False if not self.qexpander.get_expanded(): self.qexpander.set_expanded(True) pane.set_relative(1.0) return False self.songpane.connect("button-press-event", songpane_button_press_cb) self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('draw', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) try: orders = [] for e in config.getstringlist('memory', 'sortby', []): orders.append((e[1:], int(e[0]))) except ValueError: pass else: self.songlist.set_sort_orders(orders) self.browser = None self.ui = ui main_box.show_all() try: self.select_browser( self, config.get("memory", "browser"), library, player, True) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise # set at least the playlist before the mainloop starts.. player.setup(self.playlist, None, 0) def delayed_song_set(): self.__delayed_setup = None song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek", 0) config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos) self.__delayed_setup = GLib.idle_add(delayed_song_set) self.showhide_playlist(ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.info.connect("changed", self.__set_time) lib = library.librarian gobject_weak(lib.connect_object, 'changed', self.__song_changed, player, parent=self) self._playback_error_dialog = None player_sigs = [ ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: gobject_weak(player.connect, *sig, **{"parent": self}) # make sure we redraw all error indicators before opening # a dialog (blocking the main loop), so connect after default handlers gobject_weak(player.connect_after, 'error', self.__player_error, **{"parent": self}) # connect after to let SongTracker update stats player_sigs.append( gobject_weak(player.connect_after, "song-ended", self.__song_ended, parent=self)) targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)] targets = [Gtk.TargetEntry.new(*t) for t in targets] self.drag_dest_set( Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) self.connect('drag-data-received', self.__drag_data_received) if not headless: GLib.idle_add(self.__configure_scan_dirs, library) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect_object("key-press-event", self.__key_pressed, player) self.connect("delete-event", self.__save_browser) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet")
def set_slider_widget(self, widget): self._box.pack_start(Alignment(widget, left=3, right=3), False, True, 0)
def __init__(self, library, dir=None): super(ExFalsoWindow, self).__init__(dialog=False) self.set_title("Ex Falso") self.set_default_size(750, 475) self.enable_window_tracking("exfalso") self.__library = library hp = ConfigRHPaned("memory", "exfalso_paned_position", 1.0) hp.set_border_width(0) hp.set_position(250) hp.show() self.add(hp) vb = Gtk.VBox() bbox = Gtk.HBox(spacing=6) about = Gtk.Button() about.add(Gtk.Image.new_from_stock( Gtk.STOCK_ABOUT, Gtk.IconSize.BUTTON)) connect_obj(about, 'clicked', self.__show_about, self) bbox.pack_start(about, False, True, 0) prefs = Gtk.Button() prefs.add(Gtk.Image.new_from_stock( Gtk.STOCK_PREFERENCES, Gtk.IconSize.BUTTON)) def prefs_cb(button): window = PreferencesWindow(self) window.show() prefs.connect('clicked', prefs_cb) bbox.pack_start(prefs, False, True, 0) plugins = qltk.Button(_("_Plugins"), Gtk.STOCK_EXECUTE) def plugin_window_cb(button): window = PluginWindow(self) window.show() plugins.connect('clicked', plugin_window_cb) bbox.pack_start(plugins, False, True, 0) l = Gtk.Label() l.set_alignment(1.0, 0.5) l.set_ellipsize(Pango.EllipsizeMode.END) bbox.pack_start(l, True, True, 0) fs = MainFileSelector() vb.pack_start(fs, True, True, 0) vb.pack_start(Alignment(bbox, border=6), False, True, 0) vb.show_all() hp.pack1(vb, resize=True, shrink=False) nb = qltk.Notebook() nb.props.scrollable = True nb.show() for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]: page = Page(self, self.__library) page.show() nb.append_page(page) align = Alignment(nb, top=3) align.show() hp.pack2(align, resize=True, shrink=False) fs.connect('changed', self.__changed, l) if dir: fs.go_to(dir) connect_destroy(self.__library, 'changed', self.__library_changed, fs) self.__save = None connect_obj(self, 'changed', self.set_pending, None) for c in fs.get_children(): c.get_child().connect('button-press-event', self.__pre_selection_changed, fs, nb) c.get_child().connect('focus', self.__pre_selection_changed, fs, nb) fs.get_children()[1].get_child().connect('popup-menu', self.__popup_menu, fs) self.emit('changed', []) self.get_child().show() self.__ag = Gtk.AccelGroup() key, mod = Gtk.accelerator_parse("<control>Q") self.__ag.connect(key, mod, 0, lambda *x: self.destroy()) self.add_accel_group(self.__ag)
def __init__(self, library): super(InternetRadio, self).__init__(spacing=12) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) search.connect('query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_(u"_New Station…"), Gtk.STOCK_ADD) new_item.connect('activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Gtk.STOCK_REFRESH) update_item.connect('activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton( SymbolicIconImage("emblem-system", Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() search.connect('focus-out', focus) # treeview scrolled_window = ScrolledWindow() scrolled_window.show() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.show() view.set_headers_visible(False) scrolled_window.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append(row=[self.TYPE_ALL, Gtk.STOCK_DIRECTORY, "__all", _("All Stations")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) #Translators: Favorite radio stations model.append(row=[self.TYPE_FAV, Gtk.STOCK_DIRECTORY, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Gtk.STOCK_FIND, k, text]) model.append(row=[self.TYPE_NOCAT, Gtk.STOCK_DIRECTORY, "nocat", _("No Category")]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "stock_id", self.STOCK) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = connect_destroy(selection, 'changed', util.DeferredSignal(lambda x: self.activate())) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) self._searchbox = Alignment(box, left=0, right=6, top=6) self._searchbox.show_all() def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() pane = qltk.ConfigRHPaned("browsers", "internetradio_pos", 0.4) pane.show() pane.pack1(scrolled_window, resize=False, shrink=False) songbox = Gtk.VBox(spacing=6) songbox.pack_start(self._searchbox, False, True, 0) self._songpane_container = Gtk.VBox() self._songpane_container.show() songbox.pack_start(self._songpane_container, True, True, 0) songbox.pack_start(self.qbar, False, True, 0) songbox.show() pane.pack2(songbox, resize=True, shrink=False) self.pack_start(pane, True, True, 0) self.show()
class InternetRadio(Gtk.VBox, Browser, util.InstanceTracker): __gsignals__ = Browser.__gsignals__ __stations = None __fav_stations = None __librarian = None __filter = None name = _("Internet Radio") accelerated_name = _("_Internet Radio") priority = 16 headers = "title artist ~people grouping genre website ~format " \ "channel-mode".split() TYPE, STOCK, KEY, NAME = range(4) TYPE_FILTER, TYPE_ALL, TYPE_FAV, TYPE_SEP, TYPE_NOCAT = range(5) STAR = ["artist", "title", "website", "genre", "comment"] @classmethod def _init(klass, library): klass.__librarian = library.librarian klass.__stations = SongLibrary("iradio-remote") klass.__stations.load(STATIONS_ALL) klass.__fav_stations = SongLibrary("iradio") klass.__fav_stations.load(STATIONS_FAV) klass.filters = GenreFilter() @classmethod def _destroy(klass): if klass.__stations.dirty: klass.__stations.save() klass.__stations.destroy() klass.__stations = None if klass.__fav_stations.dirty: klass.__fav_stations.save() klass.__fav_stations.destroy() klass.__fav_stations = None klass.__librarian = None klass.filters = None def __inhibit(self): self.view.get_selection().handler_block(self.__changed_sig) def __uninhibit(self): self.view.get_selection().handler_unblock(self.__changed_sig) def __destroy(self, *args): if not self.instances(): self._destroy() def __init__(self, library): super(InternetRadio, self).__init__(spacing=12) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) search.connect('query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_(u"_New Station…"), Gtk.STOCK_ADD) new_item.connect('activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Gtk.STOCK_REFRESH) update_item.connect('activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton( SymbolicIconImage("emblem-system", Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() search.connect('focus-out', focus) # treeview scrolled_window = ScrolledWindow() scrolled_window.show() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.show() view.set_headers_visible(False) scrolled_window.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append(row=[self.TYPE_ALL, Gtk.STOCK_DIRECTORY, "__all", _("All Stations")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) #Translators: Favorite radio stations model.append(row=[self.TYPE_FAV, Gtk.STOCK_DIRECTORY, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Gtk.STOCK_FIND, k, text]) model.append(row=[self.TYPE_NOCAT, Gtk.STOCK_DIRECTORY, "nocat", _("No Category")]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "stock_id", self.STOCK) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = connect_destroy(selection, 'changed', util.DeferredSignal(lambda x: self.activate())) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) self._searchbox = Alignment(box, left=0, right=6, top=6) self._searchbox.show_all() def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() pane = qltk.ConfigRHPaned("browsers", "internetradio_pos", 0.4) pane.show() pane.pack1(scrolled_window, resize=False, shrink=False) songbox = Gtk.VBox(spacing=6) songbox.pack_start(self._searchbox, False, True, 0) self._songpane_container = Gtk.VBox() self._songpane_container.show() songbox.pack_start(self._songpane_container, True, True, 0) songbox.pack_start(self.qbar, False, True, 0) songbox.show() pane.pack2(songbox, resize=True, shrink=False) self.pack_start(pane, True, True, 0) self.show() def _is_library_empty(self): return not len(self.__stations) and not len(self.__fav_stations) def pack(self, songpane): container = Gtk.VBox() container.add(self) self._songpane_container.add(songpane) return container def unpack(self, container, songpane): self._songpane_container.remove(songpane) container.remove(self) def __update(self, *args): self.qbar.hide() copool.add(download_taglist, self.__update_done, cofuncid="radio-load", funcid="radio-load") def __update_done(self, stations): if not stations: print_w("Loading remote station list failed.") return # filter stations based on quality, listenercount def filter_stations(station): peak = station.get("~#listenerpeak", 0) if peak < 10: return False aac = "AAC" in station("~format") bitrate = station("~#bitrate", 50) if (aac and bitrate < 40) or (not aac and bitrate < 60): return False return True stations = filter(filter_stations, stations) # group them based on the title groups = {} for s in stations: key = s("~title~artist") groups.setdefault(key, []).append(s) # keep at most 2 URLs for each group stations = [] for key, sub in groups.iteritems(): sub.sort(key=lambda s: s.get("~#listenerpeak", 0), reverse=True) stations.extend(sub[:2]) # only keep the ones in at least one category all_ = [self.filters.query(k) for k in self.filters.keys()] assert all_ anycat_filter = reduce(lambda x, y: x | y, all_) stations = filter(anycat_filter.search, stations) # remove listenerpeak for s in stations: s.pop("~#listenerpeak", None) # update the libraries stations = dict(((s.key, s) for s in stations)) # don't add ones that are in the fav list for fav in self.__fav_stations.iterkeys(): stations.pop(fav, None) # separate o, n = set(self.__stations.iterkeys()), set(stations) to_add, to_change, to_remove = n - o, o & n, o - n del o, n # migrate stats to_change = [stations.pop(k) for k in to_change] for new in to_change: old = self.__stations[new.key] # clear everything except stats AudioFile.reload(old) # add new metadata except stats for k in (x for x in new.iterkeys() if x not in MIGRATE): old[k] = new[k] to_add = [stations.pop(k) for k in to_add] to_remove = [self.__stations[k] for k in to_remove] self.__stations.remove(to_remove) self.__stations.changed(to_change) self.__stations.add(to_add) def __filter_changed(self, bar, text, restore=False): self.__filter = Query(text, self.STAR) if not restore: self.activate() def __get_selected_libraries(self): """Returns the libraries to search in depending on the filter selection""" selection = self.view.get_selection() model, rows = selection.get_selected_rows() types = [model[row][self.TYPE] for row in rows] libs = [self.__fav_stations] if types != [self.TYPE_FAV]: libs.append(self.__stations) return libs def __get_selection_filter(self): """Retuns a filter object for the current selection or None if nothing should be filtered""" selection = self.view.get_selection() model, rows = selection.get_selected_rows() filter_ = None for row in rows: type_ = model[row][self.TYPE] if type_ == self.TYPE_FILTER: key = model[row][self.KEY] current_filter = self.filters.query(key) if current_filter: if filter_: filter_ |= current_filter else: filter_ = current_filter elif type_ == self.TYPE_NOCAT: # if notcat is selected, combine all filters, negate and merge all_ = [self.filters.query(k) for k in self.filters.keys()] nocat_filter = all_ and -reduce(lambda x, y: x | y, all_) if nocat_filter: if filter_: filter_ |= nocat_filter else: filter_ = nocat_filter elif type_ == self.TYPE_ALL: filter_ = None break return filter_ def __add_fav(self, songs): songs = [s for s in songs if s in self.__stations] type(self).__librarian.move( songs, self.__stations, self.__fav_stations) def __remove_fav(self, songs): songs = [s for s in songs if s in self.__fav_stations] type(self).__librarian.move( songs, self.__fav_stations, self.__stations) def __add(self, button): parent = qltk.get_top_parent(self) uri = (AddNewStation(parent).run(clipboard=True) or "").strip() if uri != "": self.__add_station(uri) def __add_station(self, uri): irfs = add_station(uri) if not irfs: qltk.ErrorMessage( None, _("No stations found"), _("No Internet radio stations were found at %s.") % util.escape(uri)).run() return irfs = filter(lambda station: station not in self.__fav_stations, irfs) if not irfs: qltk.WarningMessage( None, _("Unable to add station"), _("All stations listed are already in your library.")).run() if irfs: self.__fav_stations.add(irfs) def Menu(self, songs, library, items): in_fav = False in_all = False for song in songs: if song in self.__fav_stations: in_fav = True elif song in self.__stations: in_all = True if in_fav and in_all: break iradio_items = [] button = MenuItem(_("Add to Favorites"), Gtk.STOCK_ADD) button.set_sensitive(in_all) connect_obj(button, 'activate', self.__add_fav, songs) iradio_items.append(button) button = MenuItem(_("Remove from Favorites"), Gtk.STOCK_REMOVE) button.set_sensitive(in_fav) connect_obj(button, 'activate', self.__remove_fav, songs) iradio_items.append(button) items.append(iradio_items) menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True, queue=False, devices=False, items=items) return menu def restore(self): text = config.get("browsers", "query_text").decode("utf-8") self.__searchbar.set_text(text) if Query.is_parsable(text): self.__filter_changed(self.__searchbar, text, restore=True) keys = config.get("browsers", "radio").splitlines() def select_func(row): return row[self.TYPE] != self.TYPE_SEP and row[self.KEY] in keys self.__inhibit() view = self.view if not view.select_by_func(select_func): for row in view.get_model(): if row[self.TYPE] == self.TYPE_FAV: view.set_cursor(row.path) break self.__uninhibit() def __get_filter(self): filter_ = self.__get_selection_filter() text_filter = self.__filter or Query("") if filter_: filter_ &= text_filter else: filter_ = text_filter return filter_ def can_filter_text(self): return True def filter_text(self, text): self.__searchbar.set_text(text) if Query.is_parsable(text): self.__filter_changed(self.__searchbar, text) self.activate() def activate(self): filter_ = self.__get_filter() libs = self.__get_selected_libraries() songs = filter_.filter(itertools.chain(*libs)) self.songs_selected(songs) def active_filter(self, song): for lib in self.__get_selected_libraries(): if song in lib: break else: return False filter_ = self.__get_filter() if filter_: return filter_.search(song) return True def save(self): text = self.__searchbar.get_text().encode("utf-8") config.set("browsers", "query_text", text) selection = self.view.get_selection() model, rows = selection.get_selected_rows() names = filter(None, [model[row][self.KEY] for row in rows]) config.set("browsers", "radio", "\n".join(names)) def scroll(self, song): # nothing we care about if song not in self.__stations and song not in self.__fav_stations: return path = None for row in self.view.get_model(): if row[self.TYPE] == self.TYPE_FILTER: if self.filters.query(row[self.KEY]).search(song): path = row.path break else: # in case nothing matches, select all path = (0,) self.view.set_cursor(path) self.view.scroll_to_cell(path, use_align=True, row_align=0.5) def statusbar(self, i): return ngettext("%(count)d station", "%(count)d stations", i)
def __init__(self, library, main): super(PlaylistsBrowser, self).__init__(spacing=6) self.__main = main self.__view = view = RCMHintedTreeView() self.__view.set_enable_search(True) self.__view.set_search_column(0) self.__view.set_search_equal_func( lambda model, col, key, iter, data: not model[iter][col].name. lower().startswith(key.lower()), None) self.__render = render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) render.connect('editing-started', self.__start_editing) render.connect('edited', self.__edited) col = Gtk.TreeViewColumn("Playlists", render) col.set_cell_data_func(render, PlaylistsBrowser.cell_data) view.append_column(col) view.set_model(self.__lists) view.set_rules_hint(True) view.set_headers_visible(False) swin = ScrolledWindow() swin.set_shadow_type(Gtk.ShadowType.IN) swin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) swin.add(view) self.pack_start(swin, True, True, 0) newpl = qltk.Button(_("_New"), Gtk.STOCK_NEW, Gtk.IconSize.MENU) newpl.connect('clicked', self.__new_playlist) importpl = qltk.Button(_("_Import"), Gtk.STOCK_ADD, Gtk.IconSize.MENU) importpl.connect('clicked', self.__import, library) hb = Gtk.HBox(spacing=6) hb.set_homogeneous(True) hb.pack_start(newpl, True, True, 0) hb.pack_start(importpl, True, True, 0) self.pack_start(Alignment(hb, left=3, bottom=3), False, True, 0) view.connect('popup-menu', self.__popup_menu, library) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, DND_QL), ("text/uri-list", 0, DND_URI_LIST), ("text/x-moz-url", 0, DND_MOZ_URL)] targets = [Gtk.TargetEntry.new(*t) for t in targets] view.drag_dest_set(Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) view.drag_source_set(Gdk.ModifierType.BUTTON1_MASK, targets[:2], Gdk.DragAction.COPY) view.connect('drag-data-received', self.__drag_data_received, library) view.connect('drag-data-get', self.__drag_data_get) view.connect('drag-motion', self.__drag_motion) view.connect('drag-leave', self.__drag_leave) if main: view.connect('row-activated', lambda *x: self.emit("activated")) else: render.set_property('editable', True) view.get_selection().connect('changed', self.activate) s = view.get_model().connect('row-changed', self.__check_current) self.connect_object('destroy', view.get_model().disconnect, s) self.connect('key-press-event', self.__key_pressed) for child in self.get_children(): child.show_all()
class QuodLibetWindow(Window, PersistentWindowMixin): SIG_PYOBJECT = (GObject.SignalFlags.RUN_LAST, None, (object,)) __gsignals__ = { 'artwork-changed': SIG_PYOBJECT, } def __init__(self, library, player, headless=False): super(QuodLibetWindow, self).__init__(dialog=False) self.last_dir = const.HOME self.__update_title(player) self.set_default_size(550, 450) main_box = Gtk.VBox() self.add(main_box) # create main menubar, load/restore accelerator groups self.__library = library ui = self.__create_menu(player, library) accel_group = ui.get_accel_group() self.add_accel_group(accel_group) # dbus app menu AppMenu(self, ui.get_action_groups()[0]) accel_fn = os.path.join(const.USERDIR, "accels") Gtk.AccelMap.load(accel_fn) def accel_save_cb(*args): Gtk.AccelMap.save(accel_fn) accel_group.connect_object('accel-changed', accel_save_cb, None) main_box.pack_start(ui.get_widget("/Menu"), False, True, 0) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) main_box.pack_start(top_bar, False, True, 0) self.top_bar = top_bar self.__browserbox = Alignment(bottom=3) main_box.pack_start(self.__browserbox, True, True, 0) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start( Alignment(statusbox, border=3, top=-3, right=3), False, True, 0) self.songpane = ConfigRVPaned("memory", "queue_position", 0.75) self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") def songpane_button_press_cb(pane, event): """If we start to drag the pane handle while the queue expander is unexpanded, expand it and move the handle to the bottom, so we can 'drag' the queue out """ if event.window != pane.get_handle_window(): return False if not self.qexpander.get_expanded(): self.qexpander.set_expanded(True) pane.set_relative(1.0) return False self.songpane.connect("button-press-event", songpane_button_press_cb) self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('draw', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) try: orders = [] for e in config.getstringlist('memory', 'sortby', []): orders.append((e[1:], int(e[0]))) except ValueError: pass else: self.songlist.set_sort_orders(orders) self.browser = None self.ui = ui main_box.show_all() try: self.select_browser( self, config.get("memory", "browser"), library, player, True) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise # set at least the playlist before the mainloop starts.. player.setup(self.playlist, None, 0) def delayed_song_set(): self.__delayed_setup = None song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek", 0) config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos) self.__delayed_setup = GLib.idle_add(delayed_song_set) self.showhide_playlist(ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.info.connect("changed", self.__set_time) lib = library.librarian gobject_weak(lib.connect_object, 'changed', self.__song_changed, player, parent=self) self._playback_error_dialog = None player_sigs = [ ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: gobject_weak(player.connect, *sig, **{"parent": self}) # make sure we redraw all error indicators before opening # a dialog (blocking the main loop), so connect after default handlers gobject_weak(player.connect_after, 'error', self.__player_error, **{"parent": self}) # connect after to let SongTracker update stats player_sigs.append( gobject_weak(player.connect_after, "song-ended", self.__song_ended, parent=self)) targets = [("text/uri-list", Gtk.TargetFlags.OTHER_APP, DND_URI_LIST)] targets = [Gtk.TargetEntry.new(*t) for t in targets] self.drag_dest_set( Gtk.DestDefaults.ALL, targets, Gdk.DragAction.COPY) self.connect('drag-data-received', self.__drag_data_received) if not headless: GLib.idle_add(self.__configure_scan_dirs, library) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect_object("key-press-event", self.__key_pressed, player) self.connect("delete-event", self.__save_browser) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet") def __player_error(self, player, song, player_error): # it's modal, but mmkeys etc. can still trigger new ones if self._playback_error_dialog: self._playback_error_dialog.destroy() dialog = PlaybackErrorDialog(self, player_error) self._playback_error_dialog = dialog dialog.run() self._playback_error_dialog = None def __configure_scan_dirs(self, library): """Get user to configure scan dirs, if none is set up""" if not get_scan_dirs() and not len(library) and \ quodlibet.is_first_session("quodlibet"): print_d("Couldn't find any scan dirs") if qltk.ConfirmAction(self, _("Set up library directories?"), _("You don't have any music library set up. " "Would you like to do that now?")).run(): prefs = PreferencesWindow(self) prefs.set_page("library") prefs.show() def __add_bookmark(self, librarian, player): if player.song: position = player.get_position() // 1000 bookmarks = player.song.bookmarks new_mark = (position, _("Bookmark Name")) if new_mark not in bookmarks: bookmarks.append(new_mark) player.song.bookmarks = bookmarks def __edit_bookmarks(self, librarian, player): if player.song: window = EditBookmarks(self, librarian, player) window.show() def __key_pressed(self, player, event): if not player.song: return def seek_relative(seconds): current = player.get_position() current += seconds * 1000 current = min(player.song("~#length") * 1000 - 1, current) current = max(0, current) player.seek(current) if qltk.is_accel(event, "<alt>Right"): seek_relative(10) return True elif qltk.is_accel(event, "<alt>Left"): seek_relative(-10) return True def __destroy(self, *args): if self.__delayed_setup: GLib.source_remove(self.__delayed_setup) # The tray icon plugin tries to unhide QL because it gets disabled # on Ql exit. The window should stay hidden after destroy. self.show = lambda: None self.present = self.show def __drag_data_received(self, widget, ctx, x, y, sel, tid, etime): assert tid == DND_URI_LIST uris = sel.get_uris() dirs = [] error = False for uri in uris: try: uri = URI(uri) except ValueError: continue if uri.is_filename: loc = os.path.normpath(uri.filename) if os.path.isdir(loc): dirs.append(loc) else: loc = os.path.realpath(loc) if loc not in self.__library: self.__library.add_filename(loc) elif app.player.can_play_uri(uri): if uri not in self.__library: self.__library.add([RemoteFile(uri)]) else: error = True break Gtk.drag_finish(ctx, not error, False, etime) if error: ErrorMessage( self, _("Unable to add songs"), _("<b>%s</b> uses an unsupported protocol.") % uri).run() else: if dirs: copool.add( self.__library.scan, dirs, cofuncid="library", funcid="library") def __songlist_drag_data_recv(self, view, *args): if callable(self.browser.reordered): self.browser.reordered(view) self.songlist.clear_sort() def __save_browser(self, *args): print_d("Saving active browser state") try: self.browser.save() except NotImplementedError: pass def destroy(self, *args): self.__save_browser() super(QuodLibetWindow, self).destroy() def __show_or(self, widget, prop): ssv = self.song_scroller.get_property('visible') qxv = self.qexpander.get_property('visible') self.songpane.set_property('visible', ssv or qxv) if not ssv: self.qexpander.set_expanded(True) self.__expand_or(widget, prop) def __expand_or(self, widget, prop): if self.qexpander.get_property('expanded'): self.songpane.set_property("position", self.__handle_position) def __moved_pane_handle(self, widget, prop): if self.qexpander.get_property('expanded'): self.__handle_position = self.songpane.get_property("position") def __qex_size_allocate(self, event, param=None): if not self.qexpander.get_property('expanded'): p_max = self.songpane.get_property("max-position") p_cur = self.songpane.get_property("position") if p_max != p_cur: self.songpane.set_property("position", p_max) def __create_menu(self, player, library): ag = Gtk.ActionGroup.new('QuodLibetWindowActions') def logging_cb(*args): window = LoggingWindow(self) window.show() actions = [ ('Music', None, _("_Music")), ('AddFolders', Gtk.STOCK_ADD, _('_Add a Folder...'), "<control>O", None, self.open_chooser), ('AddFiles', Gtk.STOCK_ADD, _('_Add a File...'), None, None, self.open_chooser), ('AddLocation', Gtk.STOCK_ADD, _('_Add a Location...'), None, None, self.open_location), ('BrowseLibrary', Gtk.STOCK_FIND, _('Open _Browser'), ""), ("Preferences", Gtk.STOCK_PREFERENCES, None, None, None, self.__preferences), ("Plugins", Gtk.STOCK_EXECUTE, _("_Plugins"), None, None, self.__plugins), ("Quit", Gtk.STOCK_QUIT, None, None, None, self.destroy), ('Filters', None, _("_Filters")), ("PlayedRecently", Gtk.STOCK_FIND, _("Recently _Played"), "", None, self.__filter_menu_actions), ("AddedRecently", Gtk.STOCK_FIND, _("Recently _Added"), "", None, self.__filter_menu_actions), ("TopRated", Gtk.STOCK_FIND, _("_Top 40"), "", None, self.__filter_menu_actions), ("All", Gtk.STOCK_FIND, _("All _Songs"), "", None, self.__filter_menu_actions), ("Control", None, _("_Control")), ("EditTags", Gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None, self.__current_song_prop), ("Information", Gtk.STOCK_INFO, None, None, None, self.__current_song_info), ("Jump", Gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"), "<control>J", None, self.__jump_to_current), ("View", None, _("_View")), ("Help", None, _("_Help")), ("OutputLog", Gtk.STOCK_EDIT, _("_Output Log"), None, None, logging_cb), ] actions.append(("Previous", Gtk.STOCK_MEDIA_PREVIOUS, None, "<control>comma", None, self.__previous_song)) actions.append(("PlayPause", Gtk.STOCK_MEDIA_PLAY, None, "<control>space", None, self.__play_pause)) actions.append(("Next", Gtk.STOCK_MEDIA_NEXT, None, "<control>period", None, self.__next_song)) ag.add_actions(actions) act = Gtk.ToggleAction.new("StopAfter", _("Stop After This Song"), None, "") ag.add_action_with_accel(act, "<shift>space") # access point for the tray icon self.stop_after = act act = Gtk.Action.new( "AddBookmark", _("Add Bookmark"), None, Gtk.STOCK_ADD) act.connect_object('activate', self.__add_bookmark, library.librarian, player) ag.add_action_with_accel(act, "<ctrl>D") act = Gtk.Action.new("EditBookmarks", _(u"Edit Bookmarks…"), None, "") act.connect_object('activate', self.__edit_bookmarks, library.librarian, player) ag.add_action_with_accel(act, "<ctrl>B") act = Gtk.Action.new("About", None, None, Gtk.STOCK_ABOUT) act.connect_object('activate', self.__show_about, player) ag.add_action_with_accel(act, None) act = Gtk.Action.new( "OnlineHelp", _("Online Help"), None, Gtk.STOCK_HELP) act.connect_object('activate', util.website, const.ONLINE_HELP) ag.add_action_with_accel(act, "F1") act = Gtk.Action.new("SearchHelp", _("Search Help"), None, "") act.connect_object('activate', util.website, const.SEARCH_HELP) ag.add_action_with_accel(act, None) act = Gtk.Action.new( "RefreshLibrary", _("Re_fresh Library"), None, Gtk.STOCK_REFRESH) act.connect('activate', self.__rebuild, False) ag.add_action_with_accel(act, None) for tag_, lab in [ ("genre", _("Filter on _Genre")), ("artist", _("Filter on _Artist")), ("album", _("Filter on Al_bum"))]: act = Gtk.Action.new( "Filter%s" % util.capitalize(tag_), lab, None, Gtk.STOCK_INDEX) act.connect_object('activate', self.__filter_on, tag_, None, player) ag.add_action_with_accel(act, None) for (tag_, accel, label) in [ ("genre", "G", _("Random _Genre")), ("artist", "T", _("Random _Artist")), ("album", "M", _("Random Al_bum"))]: act = Gtk.Action.new("Random%s" % util.capitalize(tag_), label, None, Gtk.STOCK_DIALOG_QUESTION) act.connect('activate', self.__random, tag_) ag.add_action_with_accel(act, "<control>" + accel) ag.add_toggle_actions([ ("SongList", None, _("Song _List"), None, None, self.showhide_playlist, config.getboolean("memory", "songlist"))]) ag.add_toggle_actions([ ("Queue", None, _("_Queue"), None, None, self.showhide_playqueue, config.getboolean("memory", "queue"))]) view_actions = [] for i, Kind in enumerate(browsers.browsers): action = "View" + Kind.__name__ label = Kind.accelerated_name view_actions.append((action, None, label, None, None, i)) current = browsers.index(config.get("memory", "browser")) def action_callback(view_action, current): self.select_browser(view_action, current, library, player) ag.add_radio_actions( view_actions, current, action_callback, None) for Kind in browsers.browsers: if not Kind.in_menu: continue action = "Browser" + Kind.__name__ label = Kind.accelerated_name act = Gtk.Action.new(action, label, None, None) act.connect_object('activate', LibraryBrowser.open, Kind, library) ag.add_action_with_accel(act, None) debug_menu = "" if const.DEBUG: debug_menu = ( "<separator/>" "<menuitem action='OutputLog' always-show-image='true'/>") ui = Gtk.UIManager() ui.insert_action_group(ag, -1) menustr = const.MENU % {"browsers": browsers.BrowseLibrary(), "views": browsers.ViewBrowser(), "debug": debug_menu} ui.add_ui_from_string(menustr) # Cute. So. UIManager lets you attach tooltips, but when they're # for menu items, they just get ignored. So here I get to actually # attach them. ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text( _("Check for changes in your library")) ui.get_widget("/Menu/Filters/TopRated").set_tooltip_text( _("The 40 songs you've played most (more than 40 may " "be chosen if there are ties)")) return ui def __show_about(self, player): about = AboutQuodLibet(self, player) about.run() about.destroy() def __browser_configure(self, paned, event, browser): if paned.get_property('position-set'): key = "%s_pos" % browser.__class__.__name__ config.set("browsers", key, str(paned.get_relative())) def select_browser(self, activator, current, library, player, restore=False): if isinstance(current, Gtk.RadioAction): current = current.get_current_value() Browser = browsers.get(current) config.set("memory", "browser", Browser.__name__) if self.browser: container = self.browser.__container self.browser.unpack(container, self.songpane) if self.browser.accelerators: self.remove_accel_group(self.browser.accelerators) container.destroy() self.browser.destroy() self.browser = Browser(library, True) self.browser.connect('songs-selected', self.__browser_cb) self.browser.connect('activated', self.__browser_activate) if restore: self.browser.restore() self.browser.activate() self.browser.finalize(restore) if self.browser.reordered: self.songlist.enable_drop() elif self.browser.dropped: self.songlist.enable_drop(False) else: self.songlist.disable_drop() if self.browser.accelerators: self.add_accel_group(self.browser.accelerators) container = self.browser.__container = self.browser.pack(self.songpane) # find a paned and save the position paned = None for widget in qltk.find_widgets(container, RPaned): if widget is not self.songpane: paned = widget break if paned: try: key = "%s_pos" % self.browser.__class__.__name__ val = config.getfloat("browsers", key) # Use a minimum restore size val = max(val, 0.1) except: val = 0.4 paned.connect( 'notify::position', self.__browser_configure, self.browser) paned.set_relative(val) player.replaygain_profiles[1] = self.browser.replaygain_profiles player.volume = player.volume self.__browserbox.add(container) container.show() self.__hide_menus() self.__hide_headers() self.__refresh_size() def __update_paused(self, player, paused): menu = self.ui.get_widget("/Menu/Control/PlayPause") if paused: key = Gtk.STOCK_MEDIA_PLAY else: key = Gtk.STOCK_MEDIA_PAUSE text = Gtk.stock_lookup(key).label menu.get_image().set_from_stock(key, Gtk.IconSize.MENU) menu.set_label(text) menu.set_use_underline(True) def __song_ended(self, player, song, stopped): # check if the song should be removed base on the # active filter of the current browser active_filter = self.browser.active_filter if song and active_filter and not active_filter(song): iter_ = self.songlist.model.find(song) if iter_: self.songlist.remove_iters([iter_]) if self.stop_after.get_active(): player.paused = True self.stop_after.set_active(False) def __song_changed(self, player, songs): if player.info in songs: self.__update_title(player) def __update_title(self, player): song = player.info title = "Quod Libet" if song: title = song.comma("~title~version~~people") + " - " + title self.set_title(title) def __song_started(self, player, song): self.__update_title(player) for wid in ["Jump", "Next", "EditTags", "Information", "EditBookmarks", "AddBookmark", "StopAfter"]: self.ui.get_widget( '/Menu/Control/' + wid).set_sensitive(bool(song)) for wid in ["FilterAlbum", "FilterArtist", "FilterGenre"]: self.ui.get_widget( '/Menu/Filters/' + wid).set_sensitive(bool(song)) if song: for h in ['genre', 'artist', 'album']: self.ui.get_widget( "/Menu/Filters/Filter%s" % h.capitalize()).set_sensitive( h in song) # don't jump on stream changes (player.info != player.song) if song and player.song is song and not self.songlist._activated and \ config.getboolean("settings", "jump"): self.__jump_to_current(False) def __refresh_size(self): ssv = self.song_scroller.get_property('visible') qex = self.qexpander.get_property('visible') if ssv or qex: return # Handle more later if needed.. if not isinstance(self.browser, Gtk.Box): return # If a child expands the browser will take the new space for child in self.browser.get_children(): if self.browser.query_child_packing(child)[0]: break else: # no expanding child, make the window smaller instead width, height = self.get_size() height = self.size_request().height self.resize(width, height) def showhide_playlist(self, toggle): self.song_scroller.set_property('visible', toggle.get_active()) self.__refresh_size() def showhide_playqueue(self, toggle): self.qexpander.set_property('visible', toggle.get_active()) self.__refresh_size() def __play_pause(self, *args): if app.player.song is None: app.player.reset() else: app.player.paused ^= True def __jump_to_current(self, explicit): """Select/scroll to the current playing song in the playlist. If it can't be found tell the browser to properly fill the playlist with an appropriate selection containing the song. explicit means that the jump request comes from the user and not from an event like song-started. """ def idle_jump_to(song, select): ok = self.songlist.jump_to_song(song, select=select) if ok: self.songlist.grab_focus() return False song = app.player.song # We are not playing a song if song is None: return ok = self.songlist.jump_to_song(song, select=explicit) if ok: self.songlist.grab_focus() elif explicit: # if we can't find it and the user requested it, try harder self.browser.scroll(song) # We need to wait until the browser has finished # scrolling/filling and the songlist is ready. # Not perfect, but works for now. GLib.idle_add( idle_jump_to, song, explicit, priority=GLib.PRIORITY_LOW) def __next_song(self, *args): app.player.next() def __previous_song(self, *args): app.player.previous() def __random(self, item, key): self.browser.filter_random(key) def __filter_menu_actions(self, menuitem): name = menuitem.get_name() if name == "PlayedRecently": self.__make_query("#(lastplayed < 7 days ago)") elif name == "AddedRecently": self.__make_query("#(added < 7 days ago)") elif name == "TopRated": bg = background_filter() songs = (bg and filter(bg, self.__library)) or self.__library songs = [song.get("~#playcount", 0) for song in songs] if len(songs) == 0: return songs.sort() if len(songs) < 40: self.__make_query("#(playcount > %d)" % (songs[0] - 1)) else: self.__make_query("#(playcount > %d)" % (songs[-40] - 1)) elif name == "All": self.browser.unfilter() def __rebuild(self, activator, force): scan_library(self.__library, force) # Set up the preferences window. def __preferences(self, activator): window = PreferencesWindow(self) window.show() def __plugins(self, activator): window = PluginWindow(self) window.show() def open_location(self, action): name = GetStringDialog(self, _("Add a Location"), _("Enter the location of an audio file:"), okbutton=Gtk.STOCK_ADD).run() if name: if not util.uri_is_valid(name): ErrorMessage( self, _("Unable to add location"), _("<b>%s</b> is not a valid location.") % ( util.escape(name))).run() elif not app.player.can_play_uri(name): ErrorMessage( self, _("Unable to add location"), _("<b>%s</b> uses an unsupported protocol.") % ( util.escape(name))).run() else: if name not in self.__library: self.__library.add([RemoteFile(name)]) def open_chooser(self, action): last_dir = self.last_dir if not os.path.exists(last_dir): last_dir = const.HOME class MusicFolderChooser(FolderChooser): def __init__(self, parent, init_dir): super(MusicFolderChooser, self).__init__( parent, _("Add Music"), init_dir) cb = Gtk.CheckButton(_("Watch this folder for new songs")) # enable if no folders are being watched cb.set_active(not get_scan_dirs()) cb.show() self.set_extra_widget(cb) def run(self): fns = super(MusicFolderChooser, self).run() cb = self.get_extra_widget() return fns, cb.get_active() class MusicFileChooser(FileChooser): def __init__(self, parent, init_dir): super(MusicFileChooser, self).__init__( parent, _("Add Music"), formats.filter, init_dir) if action.get_name() == "AddFolders": dialog = MusicFolderChooser(self, last_dir) fns, do_watch = dialog.run() dialog.destroy() if fns: fns = map(glib2fsnative, fns) # scan them self.last_dir = fns[0] copool.add(self.__library.scan, fns, funcid="library") # add them as library scan directory if do_watch: dirs = get_scan_dirs() for fn in fns: if fn not in dirs: dirs.append(fn) set_scan_dirs(dirs) else: dialog = MusicFileChooser(self, last_dir) fns = dialog.run() dialog.destroy() if fns: fns = map(glib2fsnative, fns) self.last_dir = os.path.dirname(fns[0]) for filename in map(os.path.realpath, fns): self.__library.add_filename(filename) def __songs_popup_menu(self, songlist): path, col = songlist.get_cursor() header = col.header_name menu = self.songlist.Menu(header, self.browser, self.__library) if menu is not None: return self.songlist.popup_menu(menu, 0, Gtk.get_current_event_time()) def __current_song_prop(self, *args): song = app.player.song if song: librarian = self.__library.librarian window = SongProperties(librarian, [song], parent=self) window.show() def __current_song_info(self, *args): song = app.player.song if song: librarian = self.__library.librarian window = Information(librarian, [song], self) window.show() def __hide_menus(self): menus = {'genre': ["/Menu/Filters/FilterGenre", "/Menu/Filters/RandomGenre"], 'artist': ["/Menu/Filters/FilterArtist", "/Menu/Filters/RandomArtist"], 'album': ["/Menu/Filters/FilterAlbum", "/Menu/Filters/RandomAlbum"], None: ["/Menu/Filters/PlayedRecently", "/Menu/Filters/AddedRecently", "/Menu/Filters/TopRated", "/Menu/Filters/All"]} for key, widgets in menus.items(): c = self.browser.can_filter(key) for widget in widgets: self.ui.get_widget(widget).set_property('visible', c) def __browser_activate(self, browser): model = self.songlist.get_model() model.reset() if app.player.go_to(model.get_iter_first(), True): app.player.paused = False def __browser_cb(self, browser, songs, sorted): if browser.background: bg = background_filter() if bg: songs = filter(bg, songs) self.songlist.set_songs(songs, sorted) def __filter_on(self, header, songs, player): browser = self.browser if not browser: return # Fall back to the playing song if songs is None: if player.song: songs = [player.song] else: return browser.filter_on(songs, header) def __hide_headers(self, activator=None): for column in self.songlist.get_columns(): if self.browser.headers is None: column.set_visible(True) else: for tag in util.tagsplit(column.header_name): if tag in self.browser.headers: column.set_visible(True) break else: column.set_visible(False) def __cols_changed(self, songlist): headers = [col.header_name for col in songlist.get_columns()] try: headers.remove('~current') except ValueError: pass if len(headers) == len(get_columns()): # Not an addition or removal (handled separately) set_columns(headers) SongList.headers = headers def __make_query(self, query): if self.browser.can_filter_text(): self.browser.filter_text(query.encode('utf-8')) self.browser.activate() def __set_time(self, info, songs): i = len(songs) length = sum(song.get("~#length", 0) for song in songs) t = self.browser.statusbar(i) % { 'count': i, 'time': util.format_time_long(length)} self.statusbar.set_default_text(t)
def __init__(self, library, dir=None): super(ExFalsoWindow, self).__init__() self.set_title("Ex Falso") self.set_default_size(650, 475) self.enable_window_tracking("exfalso") self.__library = library hp = gtk.HPaned() hp.set_border_width(0) hp.set_position(250) hp.show() self.add(hp) vb = gtk.VBox() bbox = gtk.HBox(spacing=6) about = gtk.Button() about.add(gtk.image_new_from_stock( gtk.STOCK_ABOUT, gtk.ICON_SIZE_BUTTON)) about.connect_object('clicked', self.__show_about, self) bbox.pack_start(about, expand=False) prefs = gtk.Button() prefs.add(gtk.image_new_from_stock( gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_BUTTON)) prefs.connect_object('clicked', PreferencesWindow, self) bbox.pack_start(prefs, expand=False) plugins = qltk.Button(_("_Plugins"), gtk.STOCK_EXECUTE) plugins.connect_object('clicked', PluginWindow, self) bbox.pack_start(plugins, expand=False) l = gtk.Label() l.set_alignment(1.0, 0.5) l.set_ellipsize(pango.ELLIPSIZE_END) bbox.pack_start(l) fs = FileSelector(dir) vb.pack_start(fs) vb.pack_start(Alignment(bbox, border=6), expand=False) vb.show_all() hp.pack1(vb, resize=True, shrink=False) nb = qltk.Notebook() nb.show() for Page in [EditTags, TagsFromPath, RenameFiles, TrackNumbers]: nb.append_page(Page(self, self.__library)) align = Alignment(nb, top=3) align.show() hp.pack2(align, resize=True, shrink=False) fs.connect('changed', self.__changed, l) s = self.__library.connect_object('changed', FileSelector.rescan, fs) self.connect_object('destroy', self.__library.disconnect, s) self.__save = None self.connect_object('changed', self.set_pending, None) for c in fs.get_children(): c.child.connect('button-press-event', self.__pre_selection_changed, fs, nb) c.child.connect('focus', self.__pre_selection_changed, fs, nb) fs.get_children()[1].child.connect('popup-menu', self.__popup_menu, fs) self.emit('changed', []) self.child.show() self.__ag = gtk.AccelGroup() key, mod = gtk.accelerator_parse("<control>Q") self.__ag.connect_group(key, mod, 0, lambda *x: self.destroy()) self.add_accel_group(self.__ag)
class QuodLibetWindow(gtk.Window, PersistentWindowMixin): SIG_PYOBJECT = (gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, (object,)) __gsignals__ = { 'artwork-changed': SIG_PYOBJECT, } def __init__(self, library, player): super(QuodLibetWindow, self).__init__() self.last_dir = const.HOME self.__update_title(player) self.set_default_size(550, 450) main_box = gtk.VBox() self.add(main_box) # create test instance of the MPD backend self._mpd = quodmpd.QuodMpd() # create main menubar, load/restore accelerator groups self.__library = library self.__create_menu(player, library) self.add_accel_group(self.ui.get_accel_group()) accel_fn = os.path.join(const.USERDIR, "accels") gtk.accel_map_load(accel_fn) accelgroup = gtk.accel_groups_from_object(self)[0] accelgroup.connect('accel-changed', lambda *args: gtk.accel_map_save(accel_fn)) main_box.pack_start(self.ui.get_widget("/Menu"), expand=False) # get the playlist up before other stuff self.songlist = MainSongList(library, player) self.songlist.show_all() self.add_accel_group(self.songlist.accelerators) self.songlist.connect_after( 'drag-data-received', self.__songlist_drag_data_recv) self.song_scroller = SongListScroller( self.ui.get_widget("/Menu/View/SongList")) self.song_scroller.add(self.songlist) self.qexpander = QueueExpander( self.ui.get_widget("/Menu/View/Queue"), library, player) self.playlist = PlaylistMux( player, self.qexpander.model, self.songlist.model) top_bar = TopBar(self, player, library) top_align = Alignment(top_bar, border=3, bottom=-3) main_box.pack_start(top_align, expand=False) self.__browserbox = Alignment(top=3, bottom=3) main_box.pack_start(self.__browserbox) statusbox = StatusBarBox(self.songlist.model, player) self.order = statusbox.order self.repeat = statusbox.repeat self.statusbar = statusbox.statusbar main_box.pack_start(Alignment(statusbox, border=3, top=-3), expand=False) self.songpane = gtk.VPaned() self.songpane.pack1(self.song_scroller, resize=True, shrink=False) self.songpane.pack2(self.qexpander, resize=True, shrink=False) self.__handle_position = self.songpane.get_property("position") self.song_scroller.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::visible', self.__show_or) self.qexpander.connect('notify::expanded', self.__expand_or) self.qexpander.connect('size-allocate', self.__qex_size_allocate) self.songpane.connect('notify', self.__moved_pane_handle) sort = config.get('memory', 'sortby') self.songlist.set_sort_by(None, sort[1:], order=int(sort[0])) self.browser = None main_box.show_all() try: self.select_browser( self, config.get("memory", "browser"), library, player, True) except: config.set("memory", "browser", browsers.name(0)) config.save(const.CONFIG) raise # set at least the playlist before the mainloop starts.. player.setup(self.playlist, None, 0) def delayed_song_set(): song = library.get(config.get("memory", "song")) seek_pos = config.getint("memory", "seek") config.set("memory", "seek", 0) player.setup(self.playlist, song, seek_pos) gobject.idle_add(delayed_song_set) self.showhide_playlist(self.ui.get_widget("/Menu/View/SongList")) self.showhide_playqueue(self.ui.get_widget("/Menu/View/Queue")) self.songlist.connect('popup-menu', self.__songs_popup_menu) self.songlist.connect('columns-changed', self.__cols_changed) self.songlist.connect('columns-changed', self.__hide_headers) self.songlist.get_selection().connect( 'changed', util.DeferredSignal(self.__set_time)) lib = library.librarian gobject_weak(lib.connect, 'removed', self.__set_time, parent=self) gobject_weak(lib.connect, 'added', self.__set_time, parent=self) gobject_weak(lib.connect_object, 'changed', self.__song_changed, player, parent=self) player_sigs = [ ('song-ended', self.__song_ended), ('song-started', self.__song_started), ('paused', self.__update_paused, True), ('unpaused', self.__update_paused, False), ] for sig in player_sigs: gobject_weak(player.connect, *sig, **{"parent": self}) targets = [("text/uri-list", 0, 1)] self.drag_dest_set( gtk.DEST_DEFAULT_ALL, targets, gtk.gdk.ACTION_DEFAULT) self.connect_object('drag-motion', QuodLibetWindow.__drag_motion, self) self.connect_object('drag-leave', QuodLibetWindow.__drag_leave, self) self.connect_object( 'drag-data-received', QuodLibetWindow.__drag_data_received, self) if config.getboolean('library', 'refresh_on_start'): self.__rebuild(None, False) self.connect_object("key-press-event", self.__key_pressed, player) self.connect("delete-event", self.__save_browser) self.connect("destroy", self.__destroy) self.enable_window_tracking("quodlibet") def __key_pressed(self, player, event): if not player.song: return def seek_relative(seconds): current = player.get_position() current += seconds * 1000 current = min(player.song("~#length") * 1000 -1, current) current = max(0, current) player.seek(current) if qltk.is_accel(event, "<alt>Right"): seek_relative(10) return True elif qltk.is_accel(event, "<alt>Left"): seek_relative(-10) return True def __destroy(self, *args): # The tray icon plugin tries to unhide QL because it gets disabled # on Ql exit. The window should stay hidden after destroy. self.show = lambda: None self.present = self.show def __drag_motion(self, ctx, x, y, time): # Don't accept drops from QL itself, since it offers text/uri-list. if ctx.get_source_widget() is None: self.drag_highlight() return True else: return False def __drag_leave(self, ctx, time): self.drag_unhighlight() def __drag_data_received(self, ctx, x, y, sel, tid, etime): if tid == 1: uris = sel.get_uris() if tid == 2: uri = sel.data.decode('utf16', 'replace').split('\n')[0] uris = [uri.encode('ascii', 'replace')] dirs = [] error = False for uri in uris: try: uri = URI(uri) except ValueError: continue if uri.is_filename: loc = os.path.normpath(uri.filename) if os.path.isdir(loc): dirs.append(loc) else: loc = os.path.realpath(loc) if loc not in self.__library: self.__library.add_filename(loc) elif player.can_play_uri(uri): if uri not in self.__library: self.__library.add([RemoteFile(uri)]) else: error = True break ctx.finish(not error, False, etime) if error: ErrorMessage( self, _("Unable to add songs"), _("<b>%s</b> uses an unsupported protocol.") % uri).run() else: if dirs: copool.add( self.__library.scan, dirs, self.__status.bar.progress, cofuncid="library", funcid="library") def __songlist_drag_data_recv(self, view, *args): if callable(self.browser.reordered): self.browser.reordered(view) self.songlist.set_sort_by(None, refresh=False) def __save_browser(self, *args): print_d("Saving active browser state") try: self.browser.save() except NotImplementedError: pass def destroy(self, *args): self.__save_browser() super(QuodLibetWindow, self).destroy() def __show_or(self, widget, prop): ssv = self.song_scroller.get_property('visible') qxv = self.qexpander.get_property('visible') self.songpane.set_property('visible', ssv or qxv) if not ssv: self.qexpander.set_expanded(True) self.__expand_or(widget, prop) def __expand_or(self, widget, prop): if self.qexpander.get_property('expanded'): self.songpane.set_property("position", self.__handle_position) def __moved_pane_handle(self, widget, prop): if self.qexpander.get_property('expanded'): self.__handle_position = self.songpane.get_property("position") def __qex_size_allocate(self, event, param=None): if not self.qexpander.get_property('expanded'): p_max = self.songpane.get_property("max-position") p_cur = self.songpane.get_property("position") if p_max != p_cur: self.songpane.set_property("position", p_max) def __create_menu(self, player, library): ag = gtk.ActionGroup('QuodLibetWindowActions') actions = [ ('Music', None, _("_Music")), ('SwitchAudioOutputs', gtk.STOCK_FIND, _('_Audio Outputs'), ""), ('BrowseLibrary', gtk.STOCK_FIND, _('_Browse Library'), ""), ("Preferences", gtk.STOCK_PREFERENCES, None, None, None, self.__preferences), ("Quit", gtk.STOCK_QUIT, None, None, None, self.destroy), ('Filters', None, _("_Filters")), ("PlayedRecently", gtk.STOCK_FIND, _("Recently _Played"), "", None, self.__filter_menu_actions), ("AddedRecently", gtk.STOCK_FIND, _("Recently _Added"), "", None, self.__filter_menu_actions), ("TopRated", gtk.STOCK_FIND, _("_Top 40"), "", None, self.__filter_menu_actions), ("Control", None, _("_Control")), ("EditTags", gtk.STOCK_PROPERTIES, _("Edit _Tags"), "", None, self.__current_song_prop), ("Information", gtk.STOCK_INFO, None, None, None, self.__current_song_info), ("Jump", gtk.STOCK_JUMP_TO, _("_Jump to Playing Song"), "<control>J", None, self.__jump_to_current), ("View", None, _("_View")), ("Help", None, _("_Help")), ("OutputLog", gtk.STOCK_EDIT, _("_Output Log"), None, None, lambda *args: LoggingWindow(self)), ] if const.DEBUG: from quodlibet.debug import cause_error, enc actions.append(("DebugReload", gtk.STOCK_DIALOG_WARNING, _("_Edit and Continue"), None, None, lambda *args: enc.reload())) actions.append(("DebugCauseError", gtk.STOCK_DIALOG_ERROR, _("_Cause an Error"), None, None, cause_error)) actions.append(("Previous", gtk.STOCK_MEDIA_PREVIOUS, None, "<control>comma", None, self.__previous_song)) actions.append(("PlayPause", gtk.STOCK_MEDIA_PLAY, None, "<control>space", None, self.__play_pause)) actions.append(("Next", gtk.STOCK_MEDIA_NEXT, None, "<control>period", None, self.__next_song)) ag.add_actions(actions) act = gtk.Action("About", None, None, gtk.STOCK_ABOUT) act.connect_object('activate', self.__show_about, player) ag.add_action_with_accel(act, None) act = gtk.Action("OnlineHelp", _("Online Help"), None, gtk.STOCK_HELP) act.connect_object('activate', util.website, const.ONLINE_HELP) ag.add_action_with_accel(act, "F1") act = gtk.Action("SearchHelp", _("Search Help"), None, "") act.connect_object('activate', util.website, const.SEARCH_HELP) ag.add_action_with_accel(act, None) act = gtk.Action( "RefreshLibrary", _("Re_fresh Library"), None, gtk.STOCK_REFRESH) act.connect('activate', self.__rebuild, False) ag.add_action_with_accel(act, None) act = gtk.Action( "ConnectDisconnect", _("_Connect/Disconnect"), None, gtk.STOCK_REFRESH) act.connect('activate', self.__toggle_connected, True) ag.add_action_with_accel(act, None) for tag_, lab in [ ("genre", _("Filter on _Genre")), ("artist", _("Filter on _Artist")), ("album", _("Filter on Al_bum"))]: act = gtk.Action( "Filter%s" % util.capitalize(tag_), lab, None, gtk.STOCK_INDEX) act.connect_object('activate', self.__filter_on, tag_, None, player) ag.add_action_with_accel(act, None) for (tag_, accel, label) in [ ("genre", "G", _("Random _Genre")), ("artist", "T", _("Random _Artist")), ("album", "M", _("Random Al_bum"))]: act = gtk.Action("Random%s" % util.capitalize(tag_), label, None, gtk.STOCK_DIALOG_QUESTION) act.connect('activate', self.__random, tag_) ag.add_action_with_accel(act, "<control>" + accel) ag.add_toggle_actions([ ("SongList", None, _("Song _List"), None, None, self.showhide_playlist, config.getboolean("memory", "songlist"))]) ag.add_toggle_actions([ ("Queue", None, _("_Queue"), None, None, self.showhide_playqueue, config.getboolean("memory", "queue"))]) view_actions = [] for i, Kind in enumerate(browsers.browsers): action = "View" + Kind.__name__ label = Kind.accelerated_name view_actions.append((action, None, label, None, None, i)) current = browsers.index(config.get("memory", "browser")) ag.add_radio_actions( view_actions, current, self.select_browser, (library, player)) for Kind in browsers.browsers: if not Kind.in_menu: continue action = "Browser" + Kind.__name__ label = Kind.accelerated_name act = gtk.Action(action, label, None, None) act.connect_object('activate', LibraryBrowser, Kind, library) ag.add_action_with_accel(act, None) debug_menu = "" if const.DEBUG: debug_menu = ("<separator/>" "<menuitem action='OutputLog'/>" "<menuitem action='DebugReload'/>" "<menuitem action='DebugCauseError'/>") self.ui = gtk.UIManager() self.ui.insert_action_group(ag, -1) menustr = const.MENU % {"browsers": browsers.BrowseLibrary(), "views": browsers.ViewBrowser(), "mpd_audio_outputs": self._mpd.browse_audio_outputs(), "debug": debug_menu} self.ui.add_ui_from_string(menustr) # Cute. So. UIManager lets you attach tooltips, but when they're # for menu items, they just get ignored. So here I get to actually # attach them. self.ui.get_widget("/Menu/Music/RefreshLibrary").set_tooltip_text( _("Check for changes in your library")) self.ui.get_widget("/Menu/Filters/TopRated").set_tooltip_text( _("The 40 songs you've played most (more than 40 may " "be chosen if there are ties)")) def __show_about(self, player): about = AboutQuodLibet(self, player) about.run() about.destroy() def __browser_configure(self, paned, event, browser): if paned.get_property('position-set'): key = "%s_pos" % browser.__class__.__name__ config.set("browsers", key, str(paned.get_relative())) def select_browser(self, activator, current, library, player, restore=False): if isinstance(current, gtk.RadioAction): current = current.get_current_value() Browser = browsers.get(current) config.set("memory", "browser", Browser.__name__) if self.browser: container = self.browser.__container self.browser.unpack(container, self.songpane) if self.browser.accelerators: self.remove_accel_group(self.browser.accelerators) container.destroy() self.browser.destroy() self.browser = Browser(library, True) self.browser.connect('songs-selected', self.__browser_cb) self.browser.connect('activated', self.__browser_activate) if restore: self.browser.restore() self.browser.activate() self.browser.finalize(restore) if self.browser.reordered: self.songlist.enable_drop() elif self.browser.dropped: self.songlist.enable_drop(False) else: self.songlist.disable_drop() if self.browser.accelerators: self.add_accel_group(self.browser.accelerators) container = self.browser.__container = self.browser.pack(self.songpane) # Look for a paned if the container is none sub = container if not isinstance(container, RPaned): for child in container.get_children(): if isinstance(child, RPaned): sub = child # Save position if container is a RPaned if isinstance(sub, RPaned): try: key = "%s_pos" % self.browser.__class__.__name__ val = config.getfloat("browsers", key) # Use a minimum restore size val = max(val, 0.1) except: val = 0.4 sub.connect( 'notify::position', self.__browser_configure, self.browser) def set_size(paned, alloc, pos): paned.set_relative(pos) paned.disconnect(paned._size_sig) # The signal disconnects itself! I hate GTK sizing. del(paned._size_sig) sig = sub.connect('size-allocate', set_size, val) sub._size_sig = sig player.replaygain_profiles[1] = self.browser.replaygain_profiles player.volume = player.volume self.__browserbox.add(container) container.show() self.__hide_menus() self.__hide_headers() self.__refresh_size() def __update_paused(self, player, paused): menu = self.ui.get_widget("/Menu/Control/PlayPause") if paused: key = gtk.STOCK_MEDIA_PLAY else: key = gtk.STOCK_MEDIA_PAUSE text = gtk.stock_lookup(key)[1] menu.get_image().set_from_stock(key, gtk.ICON_SIZE_MENU) menu.set_label(text) menu.set_use_underline(True) def __check_remove_song(self, player, song): if song is None: return if not self.browser.dynamic(song): iter = self.songlist.model.find(song) if iter: self.songlist.remove_iters([iter]) self.__set_time() def __song_ended(self, player, song, stopped): self.__check_remove_song(player, song) def __song_changed(self, player, songs): self.__update_title(player) for song in songs: self.__check_remove_song(player, song) def __update_title(self, player): song = player.info title = "QuodMPD" if song: title = song.comma("~title~version~~people") + " - " + title self.set_title(title) def __song_started(self, player, song): self.__update_title(player) for wid in ["Jump", "Next", "EditTags", "Information"]: self.ui.get_widget('/Menu/Control/'+wid).set_sensitive(bool(song)) for wid in ["FilterAlbum", "FilterArtist", "FilterGenre"]: self.ui.get_widget('/Menu/Filters/'+wid).set_sensitive(bool(song)) if song: for h in ['genre', 'artist', 'album']: self.ui.get_widget( "/Menu/Filters/Filter%s" % h.capitalize()).set_sensitive( h in song) # don't jump on stream changes (player.info != player.song) if song and player.song is song and not self.songlist._activated and \ config.getboolean("settings", "jump"): self.__jump_to_current(False) def __refresh_size(self): ssv = self.song_scroller.get_property('visible') qex = self.qexpander.get_property('visible') brv = self.browser.expand if (not brv and not (ssv or qex)): width, height = self.get_size() height = self.size_request()[1] self.resize(width, height) self.set_geometry_hints(None, max_height=height, max_width=32000) else: self.set_geometry_hints(None, max_height=-1, max_width=-1) def showhide_playlist(self, toggle): self.song_scroller.set_property('visible', toggle.get_active()) self.__refresh_size() def showhide_playqueue(self, toggle): self.qexpander.set_property('visible', toggle.get_active()) self.__refresh_size() def __play_pause(self, *args): if player.playlist.song is None: player.playlist.reset() else: player.playlist.paused ^= True def __jump_to_current(self, explicit): """Select/scroll to the current playing song in the playlist. If it can't be found tell the browser to properly fill the playlist with an appropriate selection containing the song. explicit means that the jump request comes from the user and not from an event like song-started. """ def jump_to(song, select=True): model = self.songlist.model if song == model.current: path = model.current_path else: iter = model.find(song) if iter is None: return path = model[iter].path self.songlist.scroll_to_cell(path, use_align=True, row_align=0.5) if select: self.songlist.set_cursor(path) song = player.playlist.song model = self.songlist.model # We are not playing a song if song is None: return # model.find because the source could be the queue if song == model.current or (model.find(song) and explicit): jump_to(song, select=explicit) elif explicit: self.browser.scroll(player.playlist.song) # We need to wait until the browser has finished # scrolling/filling and the songlist is ready. # Not perfect, but works for now. gobject.idle_add(jump_to, song, priority=gobject.PRIORITY_LOW) def __next_song(self, *args): player.playlist.next() def __previous_song(self, *args): player.playlist.previous() def __random(self, item, key): self.browser.filter_random(key) def __filter_menu_actions(self, menuitem): name = menuitem.get_name() if name == "PlayedRecently": self.__make_query("#(lastplayed < 7 days ago)") elif name == "AddedRecently": self.__make_query("#(added < 7 days ago)") elif name == "TopRated": bg = background_filter() songs = (bg and filter(bg, self.__library)) or self.__library songs = [song.get("~#playcount", 0) for song in songs] if len(songs) == 0: return songs.sort() if len(songs) < 40: self.__make_query("#(playcount > %d)" % (songs[0] - 1)) else: self.__make_query("#(playcount > %d)" % (songs[-40] - 1)) def __rebuild(self, activator, force): paths = util.split_scan_dirs(config.get("settings", "scan")) exclude = config.get("library", "exclude").split(":") copool.add(self.__library.rebuild, paths, force, exclude, cofuncid="library", funcid="library") def __toggle_connected(self, activator, force): '''Try and connect/disconnect to/from MPD instance''' if self._mpd.is_connected(): self._mpd.disconnect() else: self._mpd.connect() self._mpd.print_current_song() # Set up the preferences window. def __preferences(self, activator): PreferencesWindow(self) def __plugins(self, activator): PluginWindow(self) def open_location(self, action): name = GetStringDialog(self, _("Add a Location"), _("Enter the location of an audio file:"), okbutton=gtk.STOCK_ADD).run() if name: if not util.uri_is_valid(name): ErrorMessage( self, _("Unable to add location"), _("<b>%s</b> is not a valid location.") %( util.escape(name))).run() elif not player.can_play_uri(name): ErrorMessage( self, _("Unable to add location"), _("<b>%s</b> uses an unsupported protocol.") %( util.escape(name))).run() else: if name not in self.__library: self.__library.add([RemoteFile(name)]) def open_chooser(self, action): if not os.path.exists(self.last_dir): self.last_dir = const.HOME if action.get_name() == "AddFolders": chooser = FolderChooser(self, _("Add Music"), self.last_dir) cb = gtk.CheckButton(_("Watch this folder for new songs")) cb.set_active(not config.get("settings", "scan")) cb.show() chooser.set_extra_widget(cb) else: chooser = FileChooser( self, _("Add Music"), formats.filter, self.last_dir) cb = None fns = chooser.run() chooser.destroy() if fns: if action.get_name() == "AddFolders": self.last_dir = fns[0] copool.add(self.__library.scan, fns, funcid="library") else: self.last_dir = os.path.basename(fns[0]) for filename in map(os.path.realpath, map(util.fsnative, fns)): if filename in self.__library: continue song = self.__library.add_filename(filename) if not song: from traceback import format_exception_only as feo tb = feo(sys.last_type, sys.last_value) msg = _("%s could not be added to your library.\n\n") msg %= util.escape(util.fsdecode( os.path.basename(filename))) msg += util.escape("".join(tb).decode( const.ENCODING, "replace")) d = ErrorMessage(self, _("Unable to add song"), msg) d.label.set_selectable(True) d.run() continue if cb and cb.get_active(): dirs = util.split_scan_dirs(config.get("settings", "scan")) for fn in fns: if fn not in dirs: dirs.append(fn) dirs = ":".join(dirs) config.set("settings", "scan", dirs) def __songs_popup_menu(self, songlist): path, col = songlist.get_cursor() header = col.header_name menu = self.songlist.Menu(header, self.browser, self.__library) if menu is not None: return self.songlist.popup_menu(menu, 0, gtk.get_current_event_time()) def __current_song_prop(self, *args): song = player.playlist.song if song: SongProperties(self.__library.librarian, [song], parent=self) def __current_song_info(self, *args): song = player.playlist.song if song: Information(self.__library.librarian, [song], self) def __hide_menus(self): menus = {'genre': ["/Menu/Filters/FilterGenre", "/Menu/Filters/RandomGenre"], 'artist': ["/Menu/Filters/FilterArtist", "/Menu/Filters/RandomArtist"], 'album': ["/Menu/Filters/FilterAlbum", "/Menu/Filters/RandomAlbum"], None: ["/Menu/Filters/PlayedRecently", "/Menu/Filters/AddedRecently", "/Menu/Filters/TopRated", "/Menu/Filters/TopRated"]} for key, widgets in menus.items(): c = self.browser.can_filter(key) for widget in widgets: self.ui.get_widget(widget).set_property('visible', c) def __browser_activate(self, browser): model = self.songlist.get_model() model.reset() if player.playlist.go_to(model.get_iter_first(), True): player.playlist.paused = False def __browser_cb(self, browser, songs, sorted): if browser.background: bg = background_filter() if bg: songs = filter(bg, songs) self.__set_time(songs=songs) self.songlist.set_songs(songs, sorted) def __filter_on(self, header, songs, player): browser = self.browser if not browser: return # Fall back to the playing song if songs is None: if player.song: songs = [player.song] else: return browser.filter_on(songs, header) def __hide_headers(self, activator=None): for column in self.songlist.get_columns(): if self.browser.headers is None: column.set_visible(True) else: for tag in util.tagsplit(column.header_name): if tag in self.browser.headers: column.set_visible(True) break else: column.set_visible(False) def __cols_changed(self, songlist): headers = [col.header_name for col in songlist.get_columns()] try: headers.remove('~current') except ValueError: pass if len(headers) == len(config.get("settings", "headers").split()): # Not an addition or removal (handled separately) config.set("settings", "headers", " ".join(headers)) SongList.headers = headers def __make_query(self, query): if self.browser.can_filter_text(): self.browser.filter_text(query.encode('utf-8')) self.browser.activate() def __set_time(self, *args, **kwargs): songs = kwargs.get("songs") or self.songlist.get_selected_songs() if "songs" not in kwargs and len(songs) <= 1: songs = self.songlist.get_songs() i = len(songs) length = sum([song("~#length", 0) for song in songs]) t = self.browser.statusbar(i) % { 'count': i, 'time': util.format_time_long(length)} self.statusbar.set_default_text(t)
def __init__(self, library, main): super(MediaDevices, self).__init__(spacing=6) self._register_instance() self.__cache = {} # Device list on the left pane swin = ScrolledWindow() swin.set_shadow_type(Gtk.ShadowType.IN) swin.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) self.pack_start(swin, True, True, 0) self.__view = view = AllTreeView() view.set_model(self.__devices) view.set_rules_hint(True) view.set_headers_visible(False) view.get_selection().set_mode(Gtk.SelectionMode.BROWSE) view.get_selection().connect_object('changed', self.__refresh, False) view.connect('popup-menu', self.__popup_menu, library) if main: view.connect('row-activated', lambda *a: self.emit("activated")) swin.add(view) col = Gtk.TreeViewColumn("Devices") view.append_column(col) render = Gtk.CellRendererPixbuf() col.pack_start(render, False) col.add_attribute(render, 'icon-name', 1) self.__render = render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) render.connect('edited', self.__edited) col.pack_start(render, True) col.set_cell_data_func(render, MediaDevices.cell_data) hbox = Gtk.HBox(spacing=6) hbox.set_homogeneous(True) if main: self.pack_start(Alignment(hbox, left=3, bottom=3), False, True, 0) else: self.pack_start(hbox, False, True, 0) # refresh button refresh = Button(_("_Refresh"), Gtk.STOCK_REFRESH, Gtk.IconSize.MENU) self.__refresh_button = refresh refresh.connect_object('clicked', self.__refresh, True) refresh.set_sensitive(False) hbox.pack_start(refresh, True, True, 0) # eject button eject = Button(_("_Eject"), "media-eject", Gtk.IconSize.MENU) self.__eject_button = eject eject.connect('clicked', self.__eject) eject.set_sensitive(False) hbox.pack_start(eject, True, True, 0) # Device info on the right pane self.__header = table = Gtk.Table() table.set_col_spacings(8) self.__device_icon = icon = Gtk.Image() icon.set_size_request(48, 48) table.attach(icon, 0, 1, 0, 2, 0) self.__device_name = label = Gtk.Label() label.set_ellipsize(Pango.EllipsizeMode.END) label.set_alignment(0, 0) table.attach(label, 1, 3, 0, 1) self.__device_space = label = Gtk.Label() label.set_ellipsize(Pango.EllipsizeMode.END) label.set_alignment(0, 0.5) table.attach(label, 1, 2, 1, 2) self.__progress = progress = Gtk.ProgressBar() progress.set_size_request(150, -1) table.attach(progress, 2, 3, 1, 2, xoptions=0, yoptions=0) self.accelerators = Gtk.AccelGroup() key, mod = Gtk.accelerator_parse('F2') self.accelerators.connect(key, mod, 0, self.__rename) self.__statusbar = WaitLoadBar() for child in self.get_children(): child.show_all()
def __init__(self, library, main): super(InternetRadio, self).__init__(spacing=12) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) gobject_weak(search.connect, 'query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_("_New Station..."), Gtk.STOCK_ADD) gobject_weak(new_item.connect, 'activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Gtk.STOCK_REFRESH) gobject_weak(update_item.connect, 'activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton( SymbolicIconImage("emblem-system", Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() gobject_weak(search.connect, 'focus-out', focus, parent=self) # treeview scrolled_window = ScrolledWindow() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.set_headers_visible(False) scrolled_window.set_policy( Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append(row=[self.TYPE_ALL, Gtk.STOCK_DIRECTORY, "__all", _("All Stations")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) #Translators: Favorite radio stations model.append(row=[self.TYPE_FAV, Gtk.STOCK_DIRECTORY, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Gtk.STOCK_FIND, k, text]) model.append(row=[self.TYPE_NOCAT, Gtk.STOCK_DIRECTORY, "nocat", _("No Category")]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "stock_id", self.STOCK) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = gobject_weak(selection.connect, 'changed', util.DeferredSignal(lambda x: self.activate()), parent=view) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) if main: self.pack_start(Alignment(box, left=6, right=6, top=6), True, True, 0) else: self.pack_start(box, True, True, 0) self.__filter_list = scrolled_window def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() self.show_all()
class InternetRadio(Gtk.VBox, Browser, util.InstanceTracker): __gsignals__ = Browser.__gsignals__ __stations = None __fav_stations = None __librarian = None __filter = None name = _("Internet Radio") accelerated_name = _("_Internet Radio") priority = 16 headers = "title artist ~people grouping genre website ~format " \ "channel-mode".split() TYPE, STOCK, KEY, NAME = range(4) TYPE_FILTER, TYPE_ALL, TYPE_FAV, TYPE_SEP, TYPE_NOCAT = range(5) STAR = ["artist", "title", "website", "genre", "comment"] @classmethod def _init(klass, library): klass.__librarian = library.librarian klass.__stations = SongLibrary("iradio-remote") klass.__stations.load(STATIONS_ALL) klass.__fav_stations = SongLibrary("iradio") klass.__fav_stations.load(STATIONS_FAV) klass.filters = GenreFilter() @classmethod def _destroy(klass): if klass.__stations.dirty: klass.__stations.save() klass.__stations.destroy() klass.__stations = None if klass.__fav_stations.dirty: klass.__fav_stations.save() klass.__fav_stations.destroy() klass.__fav_stations = None klass.__librarian = None klass.filters = None def __inhibit(self): self.view.get_selection().handler_block(self.__changed_sig) def __uninhibit(self): self.view.get_selection().handler_unblock(self.__changed_sig) def __destroy(self, *args): if not self.instances(): self._destroy() def __init__(self, library, main): super(InternetRadio, self).__init__(spacing=12) if not self.instances(): self._init(library) self._register_instance() self.connect('destroy', self.__destroy) completion = LibraryTagCompletion(self.__stations) self.accelerators = Gtk.AccelGroup() self.__searchbar = search = SearchBarBox(completion=completion, accel_group=self.accelerators) gobject_weak(search.connect, 'query-changed', self.__filter_changed) menu = Gtk.Menu() new_item = MenuItem(_("_New Station..."), Gtk.STOCK_ADD) gobject_weak(new_item.connect, 'activate', self.__add) menu.append(new_item) update_item = MenuItem(_("_Update Stations"), Gtk.STOCK_REFRESH) gobject_weak(update_item.connect, 'activate', self.__update) menu.append(update_item) menu.show_all() button = MenuButton(SymbolicIconImage("emblem-system", Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) def focus(widget, *args): qltk.get_top_parent(widget).songlist.grab_focus() gobject_weak(search.connect, 'focus-out', focus, parent=self) # treeview scrolled_window = ScrolledWindow() scrolled_window.show() scrolled_window.set_shadow_type(Gtk.ShadowType.IN) self.view = view = AllTreeView() view.show() view.set_headers_visible(False) scrolled_window.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scrolled_window.add(view) model = Gtk.ListStore(int, str, str, str) model.append(row=[ self.TYPE_ALL, Gtk.STOCK_DIRECTORY, "__all", _("All Stations") ]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) #Translators: Favorite radio stations model.append( row=[self.TYPE_FAV, Gtk.STOCK_DIRECTORY, "__fav", _("Favorites")]) model.append(row=[self.TYPE_SEP, Gtk.STOCK_DIRECTORY, "", ""]) filters = self.filters for text, k in sorted([(filters.text(k), k) for k in filters.keys()]): model.append(row=[self.TYPE_FILTER, Gtk.STOCK_FIND, k, text]) model.append(row=[ self.TYPE_NOCAT, Gtk.STOCK_DIRECTORY, "nocat", _("No Category") ]) def separator(model, iter, data): return model[iter][self.TYPE] == self.TYPE_SEP view.set_row_separator_func(separator, None) def search_func(model, column, key, iter, data): return key.lower() not in model[iter][column].lower() view.set_search_column(self.NAME) view.set_search_equal_func(search_func, None) column = Gtk.TreeViewColumn("genres") column.set_sizing(Gtk.TreeViewColumnSizing.FIXED) renderpb = Gtk.CellRendererPixbuf() renderpb.props.xpad = 3 column.pack_start(renderpb, False) column.add_attribute(renderpb, "stock_id", self.STOCK) render = Gtk.CellRendererText() render.set_property('ellipsize', Pango.EllipsizeMode.END) view.append_column(column) column.pack_start(render, True) column.add_attribute(render, "text", self.NAME) view.set_model(model) # selection selection = view.get_selection() selection.set_mode(Gtk.SelectionMode.MULTIPLE) self.__changed_sig = gobject_weak( selection.connect, 'changed', util.DeferredSignal(lambda x: self.activate()), parent=view) box = Gtk.HBox(spacing=6) box.pack_start(search, True, True, 0) box.pack_start(button, False, True, 0) if main: self._searchbox = Alignment(box, left=0, right=6, top=6) else: self._searchbox = box self._searchbox.show_all() def qbar_response(infobar, response_id): if response_id == infobar.RESPONSE_LOAD: self.__update() self.qbar = QuestionBar() self.qbar.connect("response", qbar_response) if self._is_library_empty(): self.qbar.show() pane = qltk.RHPaned() pane.show() pane.pack1(scrolled_window, resize=False, shrink=False) songbox = Gtk.VBox(spacing=6) songbox.pack_start(self._searchbox, False, True, 0) self._songpane_container = Gtk.VBox() self._songpane_container.show() songbox.pack_start(self._songpane_container, True, True, 0) songbox.pack_start(self.qbar, False, True, 0) songbox.show() pane.pack2(songbox, resize=True, shrink=False) self.pack_start(pane, True, True, 0) self.show() def _is_library_empty(self): return not len(self.__stations) and not len(self.__fav_stations) def pack(self, songpane): container = Gtk.VBox() container.add(self) self._songpane_container.add(songpane) return container def unpack(self, container, songpane): self._songpane_container.remove(songpane) container.remove(self) def __update(self, *args): self.qbar.hide() copool.add(download_taglist, self.__update_done, cofuncid="radio-load", funcid="radio-load") def __update_done(self, stations): if not stations: print_w("Loading remote station list failed.") return # filter stations based on quality, listenercount def filter_stations(station): peak = station.get("~#listenerpeak", 0) if peak < 10: return False aac = "AAC" in station("~format") bitrate = station("~#bitrate", 50) if (aac and bitrate < 40) or (not aac and bitrate < 60): return False return True stations = filter(filter_stations, stations) # group them based on the title groups = {} for s in stations: key = s("~title~artist") groups.setdefault(key, []).append(s) # keep at most 2 URLs for each group stations = [] for key, sub in groups.iteritems(): sub.sort(key=lambda s: s.get("~#listenerpeak", 0), reverse=True) stations.extend(sub[:2]) # only keep the ones in at least one category all_ = [self.filters.query(k) for k in self.filters.keys()] assert all_ anycat_filter = reduce(lambda x, y: x | y, all_) stations = filter(anycat_filter.search, stations) # remove listenerpeak for s in stations: s.pop("~#listenerpeak", None) # update the libraries stations = dict(((s.key, s) for s in stations)) # don't add ones that are in the fav list for fav in self.__fav_stations.iterkeys(): stations.pop(fav, None) # separate o, n = set(self.__stations.iterkeys()), set(stations) to_add, to_change, to_remove = n - o, o & n, o - n del o, n # migrate stats to_change = [stations.pop(k) for k in to_change] for new in to_change: old = self.__stations[new.key] # clear everything except stats AudioFile.reload(old) # add new metadata except stats for k in (x for x in new.iterkeys() if x not in MIGRATE): old[k] = new[k] to_add = [stations.pop(k) for k in to_add] to_remove = [self.__stations[k] for k in to_remove] self.__stations.remove(to_remove) self.__stations.changed(to_change) self.__stations.add(to_add) def __filter_changed(self, bar, text, restore=False): self.__filter = None if not Query.match_all(text): self.__filter = Query(text, self.STAR) if not restore: self.activate() def __get_selected_libraries(self): """Returns the libraries to search in depending on the filter selection""" selection = self.view.get_selection() model, rows = selection.get_selected_rows() types = [model[row][self.TYPE] for row in rows] libs = [self.__fav_stations] if types != [self.TYPE_FAV]: libs.append(self.__stations) return libs def __get_selection_filter(self): """Retuns a filter object for the current selection or None if nothing should be filtered""" selection = self.view.get_selection() model, rows = selection.get_selected_rows() filter_ = None for row in rows: type_ = model[row][self.TYPE] if type_ == self.TYPE_FILTER: key = model[row][self.KEY] current_filter = self.filters.query(key) if current_filter: if filter_: filter_ |= current_filter else: filter_ = current_filter elif type_ == self.TYPE_NOCAT: # if notcat is selected, combine all filters, negate and merge all_ = [self.filters.query(k) for k in self.filters.keys()] nocat_filter = all_ and -reduce(lambda x, y: x | y, all_) if nocat_filter: if filter_: filter_ |= nocat_filter else: filter_ = nocat_filter elif type_ == self.TYPE_ALL: filter_ = None break return filter_ def __add_fav(self, songs): songs = [s for s in songs if s in self.__stations] type(self).__librarian.move(songs, self.__stations, self.__fav_stations) def __remove_fav(self, songs): songs = [s for s in songs if s in self.__fav_stations] type(self).__librarian.move(songs, self.__fav_stations, self.__stations) def __add(self, button): parent = qltk.get_top_parent(self) uri = (AddNewStation(parent).run(clipboard=True) or "").strip() if uri != "": self.__add_station(uri) def __add_station(self, uri): irfs = add_station(uri) if not irfs: qltk.ErrorMessage( None, _("No stations found"), _("No Internet radio stations were found at %s.") % util.escape(uri)).run() return irfs = filter(lambda station: station not in self.__fav_stations, irfs) if not irfs: qltk.WarningMessage( None, _("Unable to add station"), _("All stations listed are already in your library.")).run() if irfs: self.__fav_stations.add(irfs) def Menu(self, songs, songlist, library): menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True, queue=False, devices=False, parent=self) menu.prepend(SeparatorMenuItem()) in_fav = False in_all = False for song in songs: if song in self.__fav_stations: in_fav = True elif song in self.__stations: in_all = True if in_fav and in_all: break button = MenuItem(_("Remove from Favorites"), Gtk.STOCK_REMOVE) button.set_sensitive(in_fav) gobject_weak(button.connect_object, 'activate', self.__remove_fav, songs) menu.prepend(button) button = MenuItem(_("Add to Favorites"), Gtk.STOCK_ADD) button.set_sensitive(in_all) gobject_weak(button.connect_object, 'activate', self.__add_fav, songs) menu.prepend(button) return menu def restore(self): text = config.get("browsers", "query_text").decode("utf-8") self.__searchbar.set_text(text) if Query.is_parsable(text): self.__filter_changed(self.__searchbar, text, restore=True) keys = config.get("browsers", "radio").splitlines() def select_func(row): return row[self.TYPE] != self.TYPE_SEP and row[self.KEY] in keys self.__inhibit() view = self.view if not view.select_by_func(select_func): for row in view.get_model(): if row[self.TYPE] == self.TYPE_FAV: view.set_cursor(row.path) break self.__uninhibit() def __get_filter(self): filter_ = self.__get_selection_filter() if filter_: if self.__filter: filter_ &= self.__filter else: filter_ = self.__filter return filter_ def activate(self): filter_ = self.__get_filter() libs = self.__get_selected_libraries() songs = itertools.chain(*libs) if filter_: songs = filter(filter_.search, songs) else: songs = list(songs) self.emit('songs-selected', songs, None) def active_filter(self, song): for lib in self.__get_selected_libraries(): if song in lib: break else: return False filter_ = self.__get_filter() if filter_: return filter_.search(song) return True def save(self): text = self.__searchbar.get_text().encode("utf-8") config.set("browsers", "query_text", text) selection = self.view.get_selection() model, rows = selection.get_selected_rows() names = filter(None, [model[row][self.KEY] for row in rows]) config.set("browsers", "radio", "\n".join(names)) def scroll(self, song): # nothing we care about if song not in self.__stations and song not in self.__fav_stations: return path = None for row in self.view.get_model(): if row[self.TYPE] == self.TYPE_FILTER: if self.filters.query(row[self.KEY]).search(song): path = row.path break else: # in case nothing matches, select all path = (0, ) self.view.scroll_to_cell(path, use_align=True, row_align=0.5) self.view.set_cursor(path) def statusbar(self, i): return ngettext("%(count)d station", "%(count)d stations", i)