def get_cfg(option): cfg_option = "%s_%s" % (_PLUGIN_ID, option) if option == "feed": return config.getint("plugins", cfg_option, _PRESETS[0][4]) elif option == "fcut": return config.getint("plugins", cfg_option, _PRESETS[0][3])
def __init__(self): for (key, text, func) in self.keys: val = config.getfloat("plugins", "randomalbum_%s" % key, 0.0) self.weights[key] = val use = config.getint("plugins", "randomalbum_use_weights", 0) self.use_weights = use delay = config.getint("plugins", "randomalbum_delay", 0) self.delay = delay
def set_variables_from_config(self, configuration): """Initialize user settings from the configuration storage.""" for key, vdict in INT_SETTINGS.items(): try: setattr(configuration, key, config.getint("plugins", "autoqueue_%s" % key)) except: setattr(configuration, key, vdict['value']) config.set("plugins", "autoqueue_%s" % key, vdict['value']) for key, vdict in BOOL_SETTINGS.items(): try: setattr( configuration, key, config.get("plugins", "autoqueue_%s" % key).lower() == 'true') except: setattr(configuration, key, vdict['value']) config.set("plugins", "autoqueue_%s" % key, vdict['value'] and 'true' or 'false') for key, vdict in STR_SETTINGS.items(): try: setattr(configuration, key, config.get("plugins", "autoqueue_%s" % key)) except: setattr(configuration, key, vdict['value']) config.set("plugins", "autoqueue_%s" % key, vdict['value'])
def refresh_panes(self): self.multi_paned.destroy() # Fill in the pane list. The last pane reports back to us. self._panes = [self] for header in reversed(get_headers()): pane = Pane(self._library, header, self._panes[0]) pane.connect('row-activated', lambda *x: self.songs_activated()) self._panes.insert(0, pane) self._panes.pop() # remove self # Put the panes in scrollable windows sws = [] for pane in self._panes: sw = ScrolledWindow() sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.set_shadow_type(Gtk.ShadowType.IN) sw.add(pane) sws.append(sw) self.multi_paned.set_widgets(sws) self.multi_paned.show_all() self.main_box.pack1(self.multi_paned.get_paned(), True, False) self.__star = {} for p in self._panes: tags = [t for t in p.tags if not t.startswith("~#")] self.__star.update(dict.fromkeys(tags)) self.set_column_mode( config.getint("browsers", "pane_mode", ColumnMode.SMALL))
def test_get(self): config.set("foo", "int", "1") config.set("foo", "float", "1.25") config.set("foo", "str", "foobar") config.set("foo", "bool", "True") self.failUnlessEqual(config.getint("foo", "int"), 1) self.failUnlessEqual(config.getfloat("foo", "float"), 1.25) self.failUnlessEqual(config.get("foo", "str"), "foobar") self.failUnlessEqual(config.getboolean("foo", "bool"), True)
def __init__(self, filename=None, completion=None, accel_group=None, timeout=DEFAULT_TIMEOUT, validator=Query.validator, star=None): super().__init__(orientation=Gtk.Orientation.HORIZONTAL, spacing=6) if filename is None: filename = os.path.join( quodlibet.get_user_dir(), "lists", "queries") historic_entries_count = config.getint("browsers", "searchbar_historic_entries") combo = ComboBoxEntrySave( filename, count=historic_entries_count, validator=validator, title=_("Saved Searches"), edit_title=_(u"Edit saved searches…")) self.__deferred_changed = DeferredSignal( self._filter_changed, timeout=timeout, owner=self) self.__combo = combo entry = combo.get_child() self._entry = entry if completion: entry.set_completion(completion) self._star = star self._query = None self.__sig = combo.connect('text-changed', self.__text_changed) entry.connect('clear', self._filter_changed) entry.connect('backspace', self.__text_changed) entry.connect('populate-popup', self.__menu) entry.connect('activate', self._filter_changed) entry.connect('activate', self.__save_search) entry.connect('focus-out-event', self.__save_search) entry.connect('key-press-event', self.__key_pressed) entry.set_placeholder_text(_("Search")) entry.set_tooltip_text(_("Search your library, " "using free text or QL queries")) combo.enable_clear_button() self.pack_start(combo, True, True, 0) if accel_group: key, mod = Gtk.accelerator_parse("<Primary>L") accel_group.connect(key, mod, 0, lambda *x: entry.mnemonic_activate(True)) for child in self.get_children(): child.show_all()
def __init__(self, browser, model): super(PreferencesButton, self).__init__() sort_orders = [ (_("_Title"), self.__compare_title), (_("_Artist"), self.__compare_artist), (_("_Date"), self.__compare_date), (_("_Original Date"), self.__compare_original_date), (_("_Genre"), self.__compare_genre), (_("_Rating"), self.__compare_rating), (_("_Playcount"), self.__compare_avgplaycount), ] menu = Gtk.Menu() sort_item = Gtk.MenuItem( label=_(u"Sort _by…"), use_underline=True) sort_menu = Gtk.Menu() active = config.getint('browsers', 'album_sort', 1) item = None for i, (label, func) in enumerate(sort_orders): item = RadioMenuItem(group=item, label=label, use_underline=True) model.set_sort_func(100 + i, func) if i == active: model.set_sort_column_id(100 + i, Gtk.SortType.ASCENDING) item.set_active(True) item.connect("toggled", util.DeferredSignal(self.__sort_toggled_cb), model, i) sort_menu.append(item) sort_item.set_submenu(sort_menu) menu.append(sort_item) pref_item = MenuItem(_("_Preferences"), Icons.PREFERENCES_SYSTEM) menu.append(pref_item) connect_obj(pref_item, "activate", Preferences, browser) menu.show_all() button = MenuButton( SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) self.pack_start(button, True, True, 0)
def __init__(self, browser, model): super(PreferencesButton, self).__init__() sort_orders = [ (_("_Title"), self.__compare_title), (_("_Artist"), self.__compare_artist), (_("_Date"), self.__compare_date), (_("_Genre"), self.__compare_genre), (_("_Rating"), self.__compare_rating), (_("_Playcount"), self.__compare_avgplaycount), ] menu = Gtk.Menu() sort_item = Gtk.MenuItem( label=_(u"Sort _by…"), use_underline=True) sort_menu = Gtk.Menu() active = config.getint('browsers', 'album_sort', 1) item = None for i, (label, func) in enumerate(sort_orders): item = RadioMenuItem(group=item, label=label, use_underline=True) model.set_sort_func(100 + i, func) if i == active: model.set_sort_column_id(100 + i, Gtk.SortType.ASCENDING) item.set_active(True) item.connect("toggled", util.DeferredSignal(self.__sort_toggled_cb), model, i) sort_menu.append(item) sort_item.set_submenu(sort_menu) menu.append(sort_item) pref_item = MenuItem(_("_Preferences"), Icons.PREFERENCES_SYSTEM) menu.append(pref_item) connect_obj(pref_item, "activate", Preferences, browser) menu.show_all() button = MenuButton( SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU), arrow=True) button.set_menu(menu) self.pack_start(button, True, True, 0)
def __init__(self, model): super(PreferencesButton, self).__init__() sort_orders = [ (_("_Title"), self.__compare_title), (_("_Artist"), self.__compare_artist), (_("_Date"), self.__compare_date), (_("_Genre"), self.__compare_genre), ] menu = gtk.Menu() sort_item = gtk.MenuItem(_("Sort _by...")) sort_menu = gtk.Menu() active = config.getint('browsers', 'album_sort', 1) item = None for i, (label, func) in enumerate(sort_orders): item = gtk.RadioMenuItem(item, label) model.set_sort_func(100 + i, func) if i == active: model.set_sort_column_id(100 + i, gtk.SORT_ASCENDING) item.set_active(True) gobject_weak(item.connect, "toggled", util.DeferredSignal(self.__sort_toggled_cb), model, i) sort_menu.append(item) sort_item.set_submenu(sort_menu) menu.append(sort_item) pref_item = MenuItem(_("_Preferences"), gtk.STOCK_PREFERENCES) menu.append(pref_item) gobject_weak(pref_item.connect_object, "activate", Preferences, self) menu.show_all() button = MenuButton( gtk.image_new_from_stock( gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_MENU), arrow=False) button.set_menu(menu) self.pack_start(button)
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)
class MenuItemPlugin(Gtk.ImageMenuItem): """ A base plugin that appears in a menu, typically. During plugin callbacks, `self.plugin_window` will be available. This is the `Gtk.Window` that the plugin was invoked from. It provides access to two important widgets, `self.plugin_window.browser` and `self.plugin_window.songlist`. """ MAX_INVOCATIONS = config.getint("plugins", "default_max_invocations", 30) """An upper limit on how many instances of the plugin should be launched at once without warning. Heavyweight plugins should override this value to prevent users killing their performance by opening on many songs.""" REQUIRES_ACTION = False """This plugin will run a user interface first (e.g. dialog) requiring action from the user. The menu entry may be altered accordingly""" def __init__(self): label = self.PLUGIN_NAME + ("…" if self.REQUIRES_ACTION else "") super(Gtk.ImageMenuItem, self).__init__(label=label) self.__set_icon() self.__initialized = True @property def plugin_window(self): return get_menu_item_top_parent(self) def __set_icon(self): """Sets the GTK icon for this plugin item""" icon = getattr(self, "PLUGIN_ICON", Icons.SYSTEM_RUN) image = Gtk.Image.new_from_icon_name(icon, Gtk.IconSize.MENU) self.set_always_show_image(True) self.set_image(image) @property def initialized(self): # If the GObject __init__ method is bypassed, it can cause segfaults. # This explicitly prevents a bad plugin from taking down the app. return self.__initialized
def set_variables_from_config(self, configuration): """Initialize user settings from the configuration storage.""" for key, vdict in INT_SETTINGS.items(): try: setattr(configuration, key, config.getint("plugins", "autoqueue_%s" % key)) except: setattr(configuration, key, vdict["value"]) config.set("plugins", "autoqueue_%s" % key, vdict["value"]) for key, vdict in BOOL_SETTINGS.items(): try: setattr(configuration, key, config.get("plugins", "autoqueue_%s" % key).lower() == "true") except: setattr(configuration, key, vdict["value"]) config.set("plugins", "autoqueue_%s" % key, vdict["value"] and "true" or "false") for key, vdict in STR_SETTINGS.items(): try: setattr(configuration, key, config.get("plugins", "autoqueue_%s" % key)) except: setattr(configuration, key, vdict["value"]) config.set("plugins", "autoqueue_%s" % key, vdict["value"])
def restore(self): filter_type = config.getint("browsers", "soundcloud_selection", FilterType.SEARCH) model = self.view.get_model() it = model.get_iter_first() while it: if model.get_value(it, 0) == filter_type: break it = model.iter_next(it) if filter_type == FilterType.SEARCH: self.__searchbar.set_enabled() self.__inhibit() self.view.get_selection().select_iter(it) self.__uninhibit() text = config.gettext("browsers", "query_text") self.__searchbar.set_text(text) self.__query_changed(None, text, restore=True)
class MenuItemPlugin(Gtk.ImageMenuItem): """ A base plugin that appears in a menu, typically During plugin callbacks, `self.plugin_window` will be available. This is the `Gtk.Window` that the plugin was invoked from. It provides access to two important widgets, `self.plugin_window.browser` and `self.plugin_window.songlist`. """ # An upper limit on how many instances of the plugin should be launched # at once without warning. Heavyweight plugins should override this value # to prevent users killing their performance by opening on many songs. MAX_INVOCATIONS = config.getint("plugins", "default_max_invocations", 30) def __init__(self): super(Gtk.ImageMenuItem, self).__init__(label=self.PLUGIN_NAME) self.__set_icon() self.__initialized = True @property def plugin_window(self): return get_menu_item_top_parent(self) def __set_icon(self): """Sets the GTK icon for this plugin item""" icon = getattr(self, "PLUGIN_ICON", Gtk.STOCK_EXECUTE) image = (Gtk.Image.new_from_stock(icon, Gtk.IconSize.MENU) if Gtk.stock_lookup(icon) else Gtk.Image.new_from_icon_name( icon, Gtk.IconSize.MENU)) self.set_always_show_image(True) self.set_image(image) @property def initialized(self): # If the GObject __init__ method is bypassed, it can cause segfaults. # This explicitly prevents a bad plugin from taking down the app. return self.__initialized
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) if self.__restore_cb: self.__restore_cb() self.__restore_cb = None
def __init__(self, browser): super(ColumnModeSelection, self).__init__(spacing=6) self.browser = browser self.buttons = [] group = None mode_label = { ColumnMode.SMALL: _("Small"), ColumnMode.WIDE: _("Wide"), ColumnMode.COLUMNAR: _("Columnar"), } for mode in ColumnMode.values: lbl = mode_label[ColumnMode.value_of(mode)] group = Gtk.RadioButton(group=group, label=lbl) if mode == config.getint("browsers", "pane_mode", ColumnMode.SMALL): group.set_active(True) self.pack_start(group, False, True, 0) self.buttons.append(group) # Connect to signal after the correct radio button has been # selected for button in self.buttons: button.connect('toggled', self.toggled)
def __init__(self, library): Browser.__init__(self, spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self.songcontainer = qltk.paned.ConfigRVPaned( "browsers", "covergrid_pos", 0.4) if config.getboolean("browsers", "covergrid_wide", False): self.songcontainer.set_orientation(Gtk.Orientation.HORIZONTAL) self._register_instance() if self.__model is None: self._init_model(library) self._cover_cancel = Gio.Cancellable() self.scrollwin = sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.view = view = IconView(model_filter) #view.set_item_width(get_cover_size() + 12) self.view.set_row_spacing(config.getint("browsers", "row_spacing", 6)) self.view.set_column_spacing(config.getint("browsers", "column_spacing", 6)) self.view.set_item_padding(config.getint("browsers", "item_padding", 6)) self.view.set_has_tooltip(True) self.view.connect("query-tooltip", self._show_tooltip) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) mag = config.getfloat("browsers", "covergrid_magnification", 3.) self.view.set_item_width(get_cover_size() * mag + 8) self.__cover = render = Gtk.CellRendererPixbuf() render.set_property('width', get_cover_size() * mag + 8) render.set_property('height', get_cover_size() * mag + 8) view.pack_start(render, False) def cell_data_pb(view, cell, model, iter_, no_cover): item = model.get_value(iter_) if item.album is None: surface = None elif item.cover: pixbuf = item.cover pixbuf = add_border_widget(pixbuf, self.view) surface = get_surface_for_pixbuf(self, pixbuf) # don't cache, too much state has an effect on the result self.__last_render_surface = None else: surface = no_cover if self.__last_render_surface == surface: return self.__last_render_surface = surface cell.set_property("surface", surface) view.set_cell_data_func(render, cell_data_pb, self._no_cover) self.__text_cells = render = Gtk.CellRendererText() render.set_visible(config.getboolean("browsers", "album_text", True)) render.set_property('alignment', Pango.Alignment.CENTER) render.set_property('xalign', 0.5) render.set_property('ellipsize', Pango.EllipsizeMode.END) view.pack_start(render, False) def cell_data(view, 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 = self.display_pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) view.set_cell_data_func(render, cell_data, None) view.set_selection_mode(Gtk.SelectionMode.MULTIPLE) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.add(view) view.connect('item-activated', self.__play_selection, None) self.__sig = connect_destroy( view, 'selection-changed', util.DeferredSignal(self.__update_songs, owner=self)) 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) # NOT WORKING connect_obj(view, 'button-press-event', self.__rightclick, view, library) connect_obj(view, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) self.pack_start(Align(search, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.view) self.__update_filter() self.connect('key-press-event', self.__key_pressed, library.librarian) if app.cover_manager: connect_destroy( app.cover_manager, "cover-changed", self._cover_changed) self.show_all()
def main(): try: # we want basic commands not to import gtk (doubles process time) assert "gi.repository.Gtk" not in sys.modules sys.modules["gi.repository.Gtk"] = None startup_actions, cmds_todo = process_arguments() finally: sys.modules.pop("gi.repository.Gtk", None) import quodlibet from quodlibet import app from quodlibet.qltk import add_signal_watch, icons add_signal_watch(app.quit) import quodlibet.player import quodlibet.library from quodlibet import config from quodlibet import browsers from quodlibet import const from quodlibet import util config.init(const.CONFIG) app.name = "Quod Libet" app.id = "quodlibet" quodlibet.init(icon=icons.QUODLIBET, name=app.name, proc_title=app.id) print_d("Initializing main library (%s)" % (quodlibet.util.path.unexpand(const.LIBRARY))) library = quodlibet.library.init(const.LIBRARY) app.library = library from quodlibet.player import PlayerError # this assumes that nullbe will always succeed for backend in [config.get("player", "backend"), "nullbe"]: try: player = quodlibet.init_backend(backend, app.librarian) except PlayerError as error: print_e("%s. %s" % (error.short_desc, error.long_desc)) else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList, get_columns from quodlibet.util.collection import Album try: cover_size = config.getint("browsers", "cover_size") except config.Error: pass else: if cover_size > 0: Album.COVER_SIZE = cover_size headers = get_columns() SongList.set_all_column_headers(headers) for opt in config.options("header_maps"): val = config.get("header_maps", opt) util.tags.add(opt, val) in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount " "~#added ~#bitrate ~current ~#laststarted ~basename " "~dirname").split() for Kind in browsers.browsers: if Kind.headers is not None: Kind.headers.extend(in_all) Kind.init(library) pm = quodlibet.init_plugins("no-plugins" in startup_actions) if hasattr(player, "init_plugins"): player.init_plugins() from quodlibet.qltk import unity unity.init("quodlibet.desktop", player) from quodlibet.qltk.songsmenu import SongsMenu SongsMenu.init_plugins() from quodlibet.util.cover import CoverManager app.cover_manager = CoverManager() app.cover_manager.init_plugins() from quodlibet.plugins.playlist import PLAYLIST_HANDLER PLAYLIST_HANDLER.init_plugins() from gi.repository import GLib def exec_commands(*args): for cmd in cmds_todo: try: resp = cmd_registry.run(app, *cmd) except CommandError: pass else: if resp is not None: print_(resp, end="") from quodlibet.qltk.quodlibetwindow import QuodLibetWindow # Call exec_commands after the window is restored, but make sure # it's after the mainloop has started so everything is set up. app.window = window = QuodLibetWindow( library, player, restore_cb=lambda: GLib.idle_add(exec_commands, priority=GLib.PRIORITY_HIGH)) from quodlibet.plugins.events import EventPluginHandler pm.register_handler(EventPluginHandler(library.librarian, player)) from quodlibet.mmkeys import MMKeysHandler from quodlibet.remote import Remote, RemoteError from quodlibet.commands import registry as cmd_registry, CommandError from quodlibet.qltk.tracker import SongTracker, FSInterface try: from quodlibet.qltk.dbus_ import DBusHandler except ImportError: DBusHandler = lambda player, library: None mmkeys_handler = MMKeysHandler(app.name, window, player) if "QUODLIBET_NO_MMKEYS" not in os.environ: mmkeys_handler.start() fsiface = FSInterface(player) remote = Remote(app, cmd_registry) try: remote.start() except RemoteError: exit_(1, True) DBusHandler(player, library) tracker = SongTracker(library.librarian, player, window.playlist) from quodlibet.qltk import session session.init("quodlibet") quodlibet.enable_periodic_save(save_library=True) if "start-playing" in startup_actions: player.paused = False # restore browser windows from quodlibet.qltk.browser import LibraryBrowser GLib.idle_add(LibraryBrowser.restore, library, player, priority=GLib.PRIORITY_HIGH) def before_quit(): print_d("Saving active browser state") try: app.browser.save() except NotImplementedError: pass quodlibet.main(window, before_quit=before_quit) quodlibet.finish_first_session(app.id) mmkeys_handler.quit() remote.stop() fsiface.destroy() print_d("Shutting down player device %r." % player.version_info) player.destroy() tracker.destroy() quodlibet.library.save(force=True) config.save(const.CONFIG) print_d("Finished shutdown.")
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)
def getter(section, option): return unicode(config.getint(section, option))
def main(): try: # we want basic commands not to import gtk (doubles process time) assert "gi.repository.Gtk" not in sys.modules sys.modules["gi.repository.Gtk"] = None startup_actions = process_arguments() # this will exit if it succeeds control('focus', ignore_error=True) finally: sys.modules.pop("gi.repository.Gtk", None) import quodlibet from quodlibet import app from quodlibet.qltk import add_signal_watch, icons add_signal_watch(app.quit) import quodlibet.player import quodlibet.library from quodlibet import config from quodlibet import browsers from quodlibet import const from quodlibet import util config.init(const.CONFIG) app.name = "Quod Libet" app.id = "quodlibet" quodlibet.init(icon=icons.QUODLIBET, name=app.name, proc_title=app.id) print_d("Initializing main library (%s)" % ( quodlibet.util.path.unexpand(const.LIBRARY))) library = quodlibet.library.init(const.LIBRARY) app.library = library from quodlibet.player import PlayerError # this assumes that nullbe will always succeed for backend in [config.get("player", "backend"), "nullbe"]: try: player = quodlibet.init_backend(backend, app.librarian) except PlayerError as error: print_e("%s. %s" % (error.short_desc, error.long_desc)) else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList, get_columns from quodlibet.util.collection import Album try: cover_size = config.getint("browsers", "cover_size") except config.Error: pass else: if cover_size > 0: Album.COVER_SIZE = cover_size headers = get_columns() SongList.set_all_column_headers(headers) for opt in config.options("header_maps"): val = config.get("header_maps", opt) util.tags.add(opt, val) in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount " "~#added ~#bitrate ~current ~#laststarted ~basename " "~dirname").split() for Kind in browsers.browsers: if Kind.headers is not None: Kind.headers.extend(in_all) Kind.init(library) pm = quodlibet.init_plugins("no-plugins" in startup_actions) if hasattr(player, "init_plugins"): player.init_plugins() from quodlibet.qltk import unity unity.init("quodlibet.desktop", player) from quodlibet.qltk.songsmenu import SongsMenu SongsMenu.init_plugins() from quodlibet.util.cover import CoverManager app.cover_manager = CoverManager() app.cover_manager.init_plugins() from quodlibet.plugins.playlist import PLAYLIST_HANDLER PLAYLIST_HANDLER.init_plugins() from quodlibet.qltk.quodlibetwindow import QuodLibetWindow app.window = window = QuodLibetWindow(library, player) from quodlibet.plugins.events import EventPluginHandler pm.register_handler(EventPluginHandler(library.librarian, player)) from quodlibet.mmkeys import MMKeysHandler from quodlibet.remote import Remote from quodlibet.commands import registry as cmd_registry from quodlibet.qltk.tracker import SongTracker, FSInterface try: from quodlibet.qltk.dbus_ import DBusHandler except ImportError: DBusHandler = lambda player, library: None mmkeys_handler = MMKeysHandler(app.name, window, player) if "QUODLIBET_NO_MMKEYS" not in os.environ: mmkeys_handler.start() fsiface = FSInterface(player) remote = Remote(app, cmd_registry) remote.start() DBusHandler(player, library) tracker = SongTracker(library.librarian, player, window.playlist) from quodlibet.qltk import session session.init("quodlibet") quodlibet.enable_periodic_save(save_library=True) if "start-playing" in startup_actions: player.paused = False # restore browser windows from quodlibet.qltk.browser import LibraryBrowser from gi.repository import GLib GLib.idle_add(LibraryBrowser.restore, library, player, priority=GLib.PRIORITY_HIGH) def before_quit(): print_d("Saving active browser state") try: app.browser.save() except NotImplementedError: pass quodlibet.main(window, before_quit=before_quit) quodlibet.finish_first_session(app.id) mmkeys_handler.quit() remote.stop() fsiface.destroy() print_d("Shutting down player device %r." % player.version_info) player.destroy() tracker.destroy() quodlibet.library.save(force=True) config.save(const.CONFIG) print_d("Finished shutdown.")
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)
def __restore_state(self): print_d("Restore state") if config.getint("memory", self.__conf("maximized"), 0): self.maximize() else: self.unmaximize()
def getter(section, option): return str(config.getint(section, option))
def getter(section, option): return text_type(config.getint(section, option))
def main(argv): import quodlibet quodlibet.init_cli() try: # we want basic commands not to import gtk (doubles process time) assert "gi.repository.Gtk" not in sys.modules sys.modules["gi.repository.Gtk"] = None startup_actions, cmds_todo = process_arguments(argv) finally: sys.modules.pop("gi.repository.Gtk", None) quodlibet.init() from quodlibet import app from quodlibet.qltk import add_signal_watch, Icons add_signal_watch(app.quit) import quodlibet.player import quodlibet.library from quodlibet import config from quodlibet import browsers from quodlibet import util app.name = "Quod Libet" app.id = "quodlibet" quodlibet.set_application_info(Icons.QUODLIBET, app.id, app.name) config.init(os.path.join(quodlibet.get_user_dir(), "config")) library_path = os.path.join(quodlibet.get_user_dir(), "songs") print_d("Initializing main library (%s)" % (quodlibet.util.path.unexpand(library_path))) library = quodlibet.library.init(library_path) app.library = library # this assumes that nullbe will always succeed from quodlibet.player import PlayerError wanted_backend = os.environ.get("QUODLIBET_BACKEND", config.get("player", "backend")) backend_traceback = None for backend in [wanted_backend, "nullbe"]: try: player = quodlibet.player.init_player(backend, app.librarian) except PlayerError: backend_traceback = format_exc() else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList, get_columns from quodlibet.util.collection import Album try: cover_size = config.getint("browsers", "cover_size") except config.Error: pass else: if cover_size > 0: Album.COVER_SIZE = cover_size headers = get_columns() SongList.set_all_column_headers(headers) for opt in config.options("header_maps"): val = config.get("header_maps", opt) util.tags.add(opt, val) in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount " "~#added ~#bitrate ~current ~#laststarted ~basename " "~dirname").split() for Kind in browsers.browsers: if Kind.headers is not None: Kind.headers.extend(in_all) Kind.init(library) pm = quodlibet.init_plugins("no-plugins" in startup_actions) if hasattr(player, "init_plugins"): player.init_plugins() from quodlibet.qltk import unity unity.init("quodlibet.desktop", player) from quodlibet.qltk.songsmenu import SongsMenu SongsMenu.init_plugins() from quodlibet.util.cover import CoverManager app.cover_manager = CoverManager() app.cover_manager.init_plugins() from quodlibet.plugins.playlist import PLAYLIST_HANDLER PLAYLIST_HANDLER.init_plugins() from quodlibet.plugins.query import QUERY_HANDLER QUERY_HANDLER.init_plugins() from gi.repository import GLib def exec_commands(*args): for cmd in cmds_todo: try: resp = cmd_registry.run(app, *cmd) except CommandError: pass else: if resp is not None: print_(resp, end="") from quodlibet.qltk.quodlibetwindow import QuodLibetWindow, PlayerOptions # Call exec_commands after the window is restored, but make sure # it's after the mainloop has started so everything is set up. app.window = window = QuodLibetWindow( library, player, restore_cb=lambda: GLib.idle_add(exec_commands, priority=GLib.PRIORITY_HIGH)) app.player_options = PlayerOptions(window) from quodlibet.qltk.debugwindow import MinExceptionDialog from quodlibet.qltk.window import on_first_map if backend_traceback is not None: def show_backend_error(window): d = MinExceptionDialog( window, _("Audio Backend Failed to Load"), _("Loading the audio backend '%(name)s' failed. " "Audio playback will be disabled.") % {"name": wanted_backend}, backend_traceback) d.run() # so we show the main window first on_first_map(app.window, show_backend_error, app.window) from quodlibet.plugins.events import EventPluginHandler pm.register_handler(EventPluginHandler(library.librarian, player)) from quodlibet.mmkeys import MMKeysHandler from quodlibet.remote import Remote, RemoteError from quodlibet.commands import registry as cmd_registry, CommandError from quodlibet.qltk.tracker import SongTracker, FSInterface try: from quodlibet.qltk.dbus_ import DBusHandler except ImportError: DBusHandler = lambda player, library: None mmkeys_handler = MMKeysHandler(app) mmkeys_handler.start() current_path = os.path.join(quodlibet.get_user_dir(), "current") fsiface = FSInterface(current_path, player) remote = Remote(app, cmd_registry) try: remote.start() except RemoteError: exit_(1, True) DBusHandler(player, library) tracker = SongTracker(library.librarian, player, window.playlist) from quodlibet.qltk import session session.init("quodlibet") quodlibet.enable_periodic_save(save_library=True) if "start-playing" in startup_actions: player.paused = False # restore browser windows from quodlibet.qltk.browser import LibraryBrowser GLib.idle_add(LibraryBrowser.restore, library, player, priority=GLib.PRIORITY_HIGH) def before_quit(): print_d("Saving active browser state") try: app.browser.save() except NotImplementedError: pass print_d("Shutting down player device %r." % player.version_info) player.destroy() quodlibet.main(window, before_quit=before_quit) app.player_options.destroy() quodlibet.finish_first_session(app.id) mmkeys_handler.quit() remote.stop() fsiface.destroy() tracker.destroy() quodlibet.library.save() config.save() print_d("Finished shutdown.")
def test_get_default(self): self.failUnlessEqual(config.getboolean("foo", "nothing", True), True) self.failUnlessEqual(config.getint("foo", "nothing", 42), 42) self.failUnlessEqual(config.getfloat("foo", "nothing", 42.42), 42.42) self.failUnlessEqual(config.get("foo", "nothing", "foo"), "foo")
def get_port_num(): return config.getint("plugins", "mpdserver_port", DEFAULT_PORT)
def test_set(self): config.set("foo", "bar", 1) self.failUnlessEqual(config.get("foo", "bar"), "1") self.failUnlessEqual(config.getint("foo", "bar"), 1)
def __init__(self, library, player): super().__init__(spacing=3) sw = ScrolledWindow() sw.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) sw.set_shadow_type(Gtk.ShadowType.IN) save_interval_secs = config.getint("autosave", "queue_interval") self.queue = PlayQueue(library, player, save_interval_secs) self.queue.props.expand = True sw.add(self.queue) add_css(self, ".ql-expanded title { margin-bottom: 5px; }") outer = ExpandBoxHack() left = Gtk.HBox(spacing=12) hb2 = Gtk.HBox(spacing=3) state_icon = PlaybackStatusIcon() state_icon.stop() state_icon.show() hb2.pack_start(state_icon, True, True, 0) name_label = Gtk.Label(label=_("_Queue"), use_underline=True) name_label.set_size_request(-1, 24) hb2.pack_start(name_label, True, True, 0) left.pack_start(hb2, False, True, 0) menu = Gtk.Menu() self.count_label = count_label = Gtk.Label() self.count_label.set_property("ellipsize", Pango.EllipsizeMode.END) self.count_label.set_width_chars(10) self.count_label.get_style_context().add_class("dim-label") left.pack_start(count_label, False, True, 0) outer.pack_start(left, True, True, 0) self.set_label_fill(True) clear_item = SmallImageButton(image=SymbolicIconImage( Icons.USER_TRASH, Gtk.IconSize.MENU), relief=Gtk.ReliefStyle.NONE, tooltip_text=_("Clear Queue")) clear_item.connect("clicked", self.__clear_queue) outer.pack_start(clear_item, False, False, 3) toggle = SmallImageToggleButton( image=SymbolicIconImage(Icons.SYSTEM_LOCK_SCREEN, Gtk.IconSize.MENU), relief=Gtk.ReliefStyle.NONE, tooltip_text=_( "Disable queue - the queue will be ignored when playing")) disabled = config.getboolean("memory", "queue_disable", False) toggle.props.active = disabled self.__queue_disable(disabled) toggle.connect('toggled', lambda b: self.__queue_disable(b.props.active)) outer.pack_start(toggle, False, False, 3) mode_menu = Gtk.Menu() norm_mode_item = RadioMenuItem( label=_("Ephemeral"), tooltip_text=_("Remove songs from the queue after playing them"), group=None) mode_menu.append(norm_mode_item) norm_mode_item.set_active(True) norm_mode_item.connect("toggled", lambda _: self.__keep_songs_enable(False)) keep_mode_item = RadioMenuItem( label=_("Persistent"), tooltip_text=_("Keep songs in the queue after playing them"), group=norm_mode_item) mode_menu.append(keep_mode_item) keep_mode_item.connect("toggled", lambda b: self.__keep_songs_enable(True)) keep_mode_item.set_active( config.getboolean("memory", "queue_keep_songs", False)) mode_item = MenuItem(_("Mode"), Icons.SYSTEM_RUN) mode_item.set_submenu(mode_menu) menu.append(mode_item) rand_checkbox = ConfigCheckMenuItem(_("_Random"), "memory", "shufflequeue", populate=True) rand_checkbox.connect('toggled', self.__queue_shuffle) self.set_shuffled(rand_checkbox.get_active()) menu.append(rand_checkbox) stop_checkbox = ConfigCheckMenuItem(_("Stop at End"), "memory", "queue_stop_at_end", populate=True) menu.append(stop_checkbox) button = SmallMenuButton(SymbolicIconImage(Icons.EMBLEM_SYSTEM, Gtk.IconSize.MENU), arrow=True) button.set_relief(Gtk.ReliefStyle.NORMAL) button.show_all() button.hide() button.set_no_show_all(True) menu.show_all() button.set_menu(menu) outer.pack_start(button, False, False, 3) close_button = SmallImageButton(image=SymbolicIconImage( "window-close", Gtk.IconSize.MENU), relief=Gtk.ReliefStyle.NONE) close_button.connect("clicked", lambda *x: self.hide()) outer.pack_start(close_button, False, False, 6) self.set_label_widget(outer) self.add(sw) self.connect('notify::expanded', self.__expand, button) self.connect('notify::expanded', self.__expand, button) targets = [("text/x-quodlibet-songs", Gtk.TargetFlags.SAME_APP, DND_QL), ("text/uri-list", 0, 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-motion', self.__motion) self.connect('drag-data-received', self.__drag_data_received) self.queue.model.connect_after('row-inserted', DeferredSignal(self.__check_expand), count_label) self.queue.model.connect_after('row-deleted', DeferredSignal(self.__update_count), count_label) self.__update_count(self.model, None, count_label) connect_destroy(player, 'song-started', self.__update_state_icon, state_icon) connect_destroy(player, 'paused', self.__update_state_icon_pause, state_icon, True) connect_destroy(player, 'unpaused', self.__update_state_icon_pause, state_icon, False) connect_destroy(player, 'song-started', self.__song_started, self.queue.model) connect_destroy(player, 'song-ended', self.__update_queue_stop, self.queue.model) # to make the children clickable if mapped # ....no idea why, but works def hack(expander): label = expander.get_label_widget() if label: label.unmap() label.map() self.connect("map", hack) self.set_expanded(config.getboolean("memory", "queue_expanded")) self.notify("expanded") for child in self.get_children(): child.show_all()
def main(): process_arguments() from quodlibet import const if isrunning() and not const.DEBUG: print_(_("Quod Libet is already running.")) control('focus') import quodlibet quodlibet._init_signal() import quodlibet.player from quodlibet import app from quodlibet import config from quodlibet import browsers from quodlibet import const from quodlibet import util config.init(const.CONFIG) library = quodlibet.init(library=const.LIBRARY, icon="quodlibet", name="Quod Libet", title=const.PROCESS_TITLE_QL) app.library = library from quodlibet.player import PlayerError for backend in [config.get("player", "backend"), "nullbe"]: try: player = quodlibet.init_backend(backend, app.librarian) except PlayerError as error: print_e("%s. %s" % (error.short_desc, error.long_desc)) else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList from quodlibet.util.collection import Album try: cover_size = config.getint("browsers", "cover_size") except config.Error: pass else: if cover_size > 0: Album.COVER_SIZE = cover_size headers = config.get_columns() SongList.set_all_column_headers(headers) for opt in config.options("header_maps"): val = config.get("header_maps", opt) util.tags.add(opt, val) in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount " "~#added ~#bitrate ~current ~#laststarted ~basename " "~dirname").split() for Kind in browsers.browsers: if Kind.headers is not None: Kind.headers.extend(in_all) Kind.init(library) pm = quodlibet.init_plugins(no_plugins) if hasattr(player, "init_plugins"): player.init_plugins() from quodlibet.qltk import unity unity.init("quodlibet.desktop", player) from quodlibet.qltk.songsmenu import SongsMenu SongsMenu.init_plugins() from quodlibet.util.cover.manager import cover_plugins cover_plugins.init_plugins() from quodlibet.plugins.playlist import PLAYLIST_HANDLER PLAYLIST_HANDLER.init_plugins() from quodlibet.qltk.quodlibetwindow import QuodLibetWindow app.window = window = QuodLibetWindow(library, player) from quodlibet.plugins.events import EventPluginHandler pm.register_handler(EventPluginHandler(library.librarian, player)) from quodlibet.qltk import mmkeys_ as mmkeys from quodlibet.qltk.remote import FSInterface, FIFOControl from quodlibet.qltk.tracker import SongTracker try: from quodlibet.qltk.dbus_ import DBusHandler except ImportError: DBusHandler = lambda player, library: None mmkeys.init(window, player) fsiface = FSInterface(player) quodlibet.quit_add(1, fsiface.destroy) fifoctrl = FIFOControl(app) quodlibet.quit_add(1, fifoctrl.destroy) DBusHandler(player, library) SongTracker(library.librarian, player, window.playlist) from quodlibet.qltk import session session.init("quodlibet") quodlibet.enable_periodic_save(save_library=True) if play: player.paused = False # restore browser windows from quodlibet.qltk.browser import LibraryBrowser from gi.repository import GLib GLib.idle_add(LibraryBrowser.restore, library, priority=GLib.PRIORITY_HIGH) quodlibet.main(window) print_d("Shutting down player device %r." % player.version_info) player.destroy() quodlibet.library.save(force=True) config.save(const.CONFIG) print_d("Finished shutdown.")
try: player = quodlibet.init_backend(backend, app.librarian) except quodlibet.player.error, error: print_e("%s. %s" % (error.short_desc, error.long_desc)) else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList try: ratings = config.getint("settings", "ratings") except (ValueError, TypeError): pass else: util.RATING_PRECISION = 1.0/ratings try: default_rating = config.getfloat("settings", "default_rating") except (ValueError, TypeError): pass else: const.DEFAULT_RATING = default_rating try: symbol = config.get("settings", "rating_symbol").decode("utf-8") except UnicodeDecodeError: pass else: util.RATING_SYMBOL = symbol if config.get("settings", "headers").split() == []: config.set("settings", "headers", "title") headers = config.get("settings", "headers").split() SongList.set_all_column_headers(headers)
def COVER_SIZE(self): size = config.getint("browsers", "cover_size") if size <= 0: size = 48 return size
def __init__(self, library): Browser.__init__(self, spacing=6) self.set_orientation(Gtk.Orientation.VERTICAL) self._register_instance() if self.__model is None: self._init_model(library) self._cover_cancel = Gio.Cancellable.new() self.scrollwin = sw = ScrolledWindow() sw.set_shadow_type(Gtk.ShadowType.IN) model_sort = AlbumSortModel(model=self.__model) model_filter = AlbumFilterModel(child_model=model_sort) self.view = view = Gtk.IconView(model_filter) #view.set_item_width(get_cover_size() + 12) self.view.set_row_spacing(config.getint("browsers", "row_spacing", 6)) self.view.set_column_spacing(config.getint("browsers", "column_spacing", 6)) self.view.set_item_padding(config.getint("browsers", "item_padding", 6)) self.view.set_has_tooltip(True) self.view.connect("query-tooltip", self._show_tooltip) self.__bg_filter = background_filter() self.__filter = None model_filter.set_visible_func(self.__parse_query) mag = config.getfloat("browsers", "covergrid_magnification", 3.) self.view.set_item_width(get_cover_size() * mag + 8) self.__cover = render = Gtk.CellRendererPixbuf() render.set_property('width', get_cover_size() * mag + 8) render.set_property('height', get_cover_size() * mag + 8) view.pack_start(render, False) def cell_data_pb(view, cell, model, iter_, no_cover): item = model.get_value(iter_) if item.album is None: surface = None elif item.cover: pixbuf = item.cover pixbuf = add_border_widget(pixbuf, self.view) surface = get_surface_for_pixbuf(self, pixbuf) # don't cache, too much state has an effect on the result self.__last_render_surface = None else: surface = no_cover if self.__last_render_surface == surface: return self.__last_render_surface = surface cell.set_property("surface", surface) view.set_cell_data_func(render, cell_data_pb, self._no_cover) self.__text_cells = render = Gtk.CellRendererText() render.set_visible(config.getboolean("browsers", "album_text", True)) render.set_property('alignment', Pango.Alignment.CENTER) render.set_property('xalign', 0.5) render.set_property('ellipsize', Pango.EllipsizeMode.END) view.pack_start(render, False) def cell_data(view, 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 = self.display_pattern % album if self.__last_render == markup: return self.__last_render = markup cell.markup = markup cell.set_property('markup', markup) view.set_cell_data_func(render, cell_data, None) view.set_selection_mode(Gtk.SelectionMode.MULTIPLE) sw.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) sw.add(view) view.connect('item-activated', self.__play_selection, None) self.__sig = connect_destroy( view, 'selection-changed', util.DeferredSignal(self.__update_songs, owner=self)) 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) connect_obj(view, 'popup-menu', self.__popup, view, library) self.accelerators = Gtk.AccelGroup() search = SearchBarBox(completion=AlbumTagCompletion(), accel_group=self.accelerators) search.connect('query-changed', self.__update_filter) connect_obj(search, 'focus-out', lambda w: w.grab_focus(), view) self.__search = search prefs = PreferencesButton(self, model_sort) search.pack_start(prefs, False, True, 0) self.pack_start(Align(search, left=6, top=6), False, True, 0) self.pack_start(sw, True, True, 0) self.connect("destroy", self.__destroy) self.enable_row_update(view, sw, self.view) self.connect('key-press-event', self.__key_pressed, library.librarian) if app.cover_manager: connect_destroy( app.cover_manager, "cover-changed", self._cover_changed) self.show_all()
def main(argv): import quodlibet quodlibet.init_cli() try: # we want basic commands not to import gtk (doubles process time) assert "gi.repository.Gtk" not in sys.modules sys.modules["gi.repository.Gtk"] = None startup_actions, cmds_todo = process_arguments(argv) finally: sys.modules.pop("gi.repository.Gtk", None) quodlibet.init() from quodlibet import app from quodlibet.qltk import add_signal_watch, Icons add_signal_watch(app.quit) import quodlibet.player import quodlibet.library from quodlibet import config from quodlibet import browsers from quodlibet import util from quodlibet.util.string import decode app.name = "Quod Libet" app.id = "quodlibet" quodlibet.set_application_info(Icons.QUODLIBET, app.id, app.name) config.init(os.path.join(quodlibet.get_user_dir(), "config")) library_path = os.path.join(quodlibet.get_user_dir(), "songs") print_d("Initializing main library (%s)" % ( quodlibet.util.path.unexpand(library_path))) library = quodlibet.library.init(library_path) app.library = library # this assumes that nullbe will always succeed from quodlibet.player import PlayerError wanted_backend = os.environ.get( "QUODLIBET_BACKEND", config.get("player", "backend")) backend_traceback = None for backend in [wanted_backend, "nullbe"]: try: player = quodlibet.player.init_player(backend, app.librarian) except PlayerError: backend_traceback = decode(traceback.format_exc()) else: break app.player = player os.environ["PULSE_PROP_media.role"] = "music" os.environ["PULSE_PROP_application.icon_name"] = "quodlibet" browsers.init() from quodlibet.qltk.songlist import SongList, get_columns from quodlibet.util.collection import Album try: cover_size = config.getint("browsers", "cover_size") except config.Error: pass else: if cover_size > 0: Album.COVER_SIZE = cover_size headers = get_columns() SongList.set_all_column_headers(headers) for opt in config.options("header_maps"): val = config.get("header_maps", opt) util.tags.add(opt, val) in_all = ("~filename ~uri ~#lastplayed ~#rating ~#playcount ~#skipcount " "~#added ~#bitrate ~current ~#laststarted ~basename " "~dirname").split() for Kind in browsers.browsers: if Kind.headers is not None: Kind.headers.extend(in_all) Kind.init(library) pm = quodlibet.init_plugins("no-plugins" in startup_actions) if hasattr(player, "init_plugins"): player.init_plugins() from quodlibet.qltk import unity unity.init("quodlibet.desktop", player) from quodlibet.qltk.songsmenu import SongsMenu SongsMenu.init_plugins() from quodlibet.util.cover import CoverManager app.cover_manager = CoverManager() app.cover_manager.init_plugins() from quodlibet.plugins.playlist import PLAYLIST_HANDLER PLAYLIST_HANDLER.init_plugins() from gi.repository import GLib def exec_commands(*args): for cmd in cmds_todo: try: resp = cmd_registry.run(app, *cmd) except CommandError: pass else: if resp is not None: print_(resp, end="") from quodlibet.qltk.quodlibetwindow import QuodLibetWindow, PlayerOptions # Call exec_commands after the window is restored, but make sure # it's after the mainloop has started so everything is set up. app.window = window = QuodLibetWindow( library, player, restore_cb=lambda: GLib.idle_add(exec_commands, priority=GLib.PRIORITY_HIGH)) app.player_options = PlayerOptions(window) from quodlibet.qltk.debugwindow import MinExceptionDialog from quodlibet.qltk.window import on_first_map if backend_traceback is not None: def show_backend_error(window): d = MinExceptionDialog(window, _("Audio Backend Failed to Load"), _("Loading the audio backend '%(name)s' failed. " "Audio playback will be disabled.") % {"name": wanted_backend}, backend_traceback) d.run() # so we show the main window first on_first_map(app.window, show_backend_error, app.window) from quodlibet.plugins.events import EventPluginHandler pm.register_handler(EventPluginHandler(library.librarian, player)) from quodlibet.mmkeys import MMKeysHandler from quodlibet.remote import Remote, RemoteError from quodlibet.commands import registry as cmd_registry, CommandError from quodlibet.qltk.tracker import SongTracker, FSInterface try: from quodlibet.qltk.dbus_ import DBusHandler except ImportError: DBusHandler = lambda player, library: None mmkeys_handler = MMKeysHandler(app.name, window, player) if "QUODLIBET_NO_MMKEYS" not in os.environ: mmkeys_handler.start() current_path = os.path.join(quodlibet.get_user_dir(), "current") fsiface = FSInterface(current_path, player) remote = Remote(app, cmd_registry) try: remote.start() except RemoteError: exit_(1, True) DBusHandler(player, library) tracker = SongTracker(library.librarian, player, window.playlist) from quodlibet.qltk import session session.init("quodlibet") quodlibet.enable_periodic_save(save_library=True) if "start-playing" in startup_actions: player.paused = False # restore browser windows from quodlibet.qltk.browser import LibraryBrowser GLib.idle_add(LibraryBrowser.restore, library, player, priority=GLib.PRIORITY_HIGH) def before_quit(): print_d("Saving active browser state") try: app.browser.save() except NotImplementedError: pass print_d("Shutting down player device %r." % player.version_info) player.destroy() quodlibet.main(window, before_quit=before_quit) app.player_options.destroy() quodlibet.finish_first_session(app.id) mmkeys_handler.quit() remote.stop() fsiface.destroy() tracker.destroy() quodlibet.library.save() config.save() print_d("Finished shutdown.")
def __init__(self): # try: # self.clientid = config.get('plugins', self.c_clientid) # except: # self.clientid = DEFAULT_CLIENTID # config.set('plugins', c_clientid, DEFAULT_CLIENTID) print("initializing" + __name__) self.song = None self.pause = "pause_gr" self.play = "play_gr" self.playing = self.pause try: self._cid = config.get('plugins', self.c_cid) except: print("Error: " + _cid) self._cid = self.DEFAULT_CID config.set('plugins', self.c_cid, self._cid) try: self.tpattern = config.get('plugins', self.c_tpattern) except: print("Error: " + tpattern) self.tpattern = self.DEFAULT_TPATTERN config.set('plugins', self.c_tpattern, self.tpattern) try: self.bpattern = config.get('plugins', self.c_bpattern) except: print("Error: " + bpattern) self.bpattern = self.DEFAULT_BPATTERN config.set('plugins', self.c_bpattern, self.bpattern) try: self._enabled = config.getint('plugins', self.c_enabled) except: print("Error: " + _enabled) self._enabled = 0 config.set('plugins', self.c_enabled, self._enabled) config.set('plugins', self.c_error, "not enabled") # try: # self.tcurrent = int(config.get('plugins', self.c_tcurrent)) # except: # self.tcurrent = self.DEFAULT_TCURRENT # config.set('plugins', self.c_tcurrent, self.tcurrent) # try: # self.bcurrent = int(config.get('plugins', self.c_bcurrent)) # except: # self.bcurrent = self.DEFAULT_BCURRENT # config.set('plugins', self.c_bcurrent, self.bcurrent) if (self._enabled): config.set('plugins', self.c_error, "enabled") self.RPC = Presence(int(self._cid)) try: self.RPC.connect() print("RPC connected") except PyPresenceException: self._cid = 0 config.set('plugins', self.c_cid, self._cid) self.RPC = None print("RPC not connected: PyPresenceException") else: self.RPC = None print("RPC not connected: not enabled")