def Menu(self, songs, songlist, library):
menu = SongsMenu(self.__librarian, songs, playlists=False, remove=True,
queue=False, accels=songlist.accelerators,
devices=False, parent=self)
menu.prepend(gtk.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 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 enable_row_update(self, view, sw, column):
gobject_weak(view.connect_object, 'draw',
self.__update_visibility, view)
gobject_weak(sw.get_vadjustment().connect, "value-changed",
self.__stop_update, view, parent=view)
self.__pending_paths = []
self.__scan_timeout = None
self.__column = column
self.__first_expose = True
def enable_row_update(self, view, sw, column):
gobject_weak(view.connect_object, 'expose-event',
self.__update_visibility, view)
gobject_weak(sw.get_vadjustment().connect, "value-changed",
self.__stop_update ,view)
self.__pending_paths = []
self.__scan_timeout = None
self.__column = column
self.__first_expose = True
def __popup(self, view, library):
albums = self.__get_selected_albums()
songs = self.__get_songs_from_albums(albums)
menu = SongsMenu(library, songs, parent=self)
if self.__cover_column.get_visible():
num = len(albums)
button = MenuItem(
ngettext("Reload album _cover", "Reload album _covers", num),
Gtk.STOCK_REFRESH)
gobject_weak(button.connect, 'activate',
self.__refresh_album, view)
menu.prepend(SeparatorMenuItem())
menu.prepend(button)
menu.show_all()
return view.popup_menu(menu, 0, Gtk.get_current_event_time())
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),
]
menu = Gtk.Menu()
sort_item = Gtk.MenuItem(label=_("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)
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, browser)
menu.show_all()
button = MenuButton(
SymbolicIconImage("emblem-system", Gtk.IconSize.MENU),
arrow=True)
button.set_menu(menu)
self.pack_start(button, True, True, 0)
def __popup(self, view, library):
selection = view.get_selection()
albums = self.__get_selected_albums(selection)
songs = self.__get_songs_from_albums(albums)
menu = SongsMenu(library, songs, parent=self)
if self.__cover_column.get_visible():
num = len(albums)
button = MenuItem(
ngettext("Reload album _cover", "Reload album _covers", num),
gtk.STOCK_REFRESH)
gobject_weak(button.connect, 'activate',
self.__refresh_album, view)
menu.prepend(gtk.SeparatorMenuItem())
menu.prepend(button)
menu.show_all()
return view.popup_menu(menu, 0, gtk.get_current_event_time())
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 __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, parent):
if self.is_not_unique(): return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences") + " - Quod Libet")
self.set_default_size(400, 270)
self.set_transient_for(qltk.get_top_parent(parent))
box = gtk.VBox(spacing=6)
cb = ConfigCheckButton(
_("Show album _covers"), "browsers", "album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
gobject_weak(cb.connect, 'toggled', lambda s: AlbumList.toggle_covers())
box.pack_start(cb, expand=False)
cb = ConfigCheckButton(
_("Inline _search includes people"),
"browsers", "album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
box.pack_start(cb, expand=False)
vbox = gtk.VBox(spacing=6)
label = gtk.Label()
label.set_alignment(0.0, 0.5)
edit = PatternEditBox(PATTERN)
edit.text = AlbumList._pattern_text
gobject_weak(edit.apply.connect, 'clicked', self.__set_pattern, edit)
gobject_weak(edit.buffer.connect_object, 'changed',
self.__preview_pattern, edit, label, parent=edit)
vbox.pack_start(label, expand=False)
vbox.pack_start(edit)
self.__preview_pattern(edit, label)
f = qltk.Frame(_("Album Display"), child=vbox)
box.pack_start(f)
main_box = gtk.VBox(spacing=12)
close = gtk.Button(stock=gtk.STOCK_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = gtk.HButtonBox()
b.set_layout(gtk.BUTTONBOX_END)
b.pack_start(close)
main_box.pack_start(box)
main_box.pack_start(b, expand=False)
self.add(main_box)
close.grab_focus()
self.show_all()
def __init__(self, browser):
if self.is_not_unique():
return
super(Preferences, self).__init__()
self.set_border_width(12)
self.set_title(_("Album List Preferences") + " - Quod Libet")
self.set_default_size(420, 380)
self.set_transient_for(qltk.get_top_parent(browser))
# Do this config-driven setup at instance-time
self._EXAMPLE_ALBUM["~rating"] = format_rating(0.75)
box = Gtk.VBox(spacing=6)
vbox = Gtk.VBox(spacing=6)
cb = ConfigCheckButton(_("Show album _covers"), "browsers",
"album_covers")
cb.set_active(config.getboolean("browsers", "album_covers"))
gobject_weak(cb.connect, 'toggled', lambda s: browser.toggle_covers())
vbox.pack_start(cb, False, True, 0)
cb = ConfigCheckButton(_("Inline _search includes people"), "browsers",
"album_substrings")
cb.set_active(config.getboolean("browsers", "album_substrings"))
vbox.pack_start(cb, False, True, 0)
f = qltk.Frame(_("Options"), child=vbox)
box.pack_start(f, False, True, 12)
vbox = Gtk.VBox(spacing=6)
label = Gtk.Label()
label.set_alignment(0.0, 0.5)
label.set_padding(6, 6)
eb = Gtk.EventBox()
eb.get_style_context().add_class("entry")
eb.add(label)
edit = PatternEditBox(PATTERN)
edit.text = browser._pattern_text
gobject_weak(edit.apply.connect, 'clicked', self.__set_pattern, edit,
browser)
gobject_weak(edit.buffer.connect_object,
'changed',
self.__preview_pattern,
edit,
label,
parent=edit)
vbox.pack_start(eb, False, True, 3)
vbox.pack_start(edit, True, True, 0)
self.__preview_pattern(edit, label)
f = qltk.Frame(_("Album Display"), child=vbox)
box.pack_start(f, True, True, 0)
main_box = Gtk.VBox(spacing=12)
close = Gtk.Button(stock=Gtk.STOCK_CLOSE)
close.connect('clicked', lambda *x: self.destroy())
b = Gtk.HButtonBox()
b.set_layout(Gtk.ButtonBoxStyle.END)
b.pack_start(close, True, True, 0)
main_box.pack_start(box, True, True, 0)
main_box.pack_start(b, False, True, 0)
self.add(main_box)
close.grab_focus()
self.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()
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 PluginPreferences(cls, window):
prefs = Preferences()
gobject_weak(prefs.connect, "changed", lambda *x: cls.queue_update())
return prefs
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, 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(
gtk.image_new_from_stock(
gtk.STOCK_PREFERENCES, gtk.ICON_SIZE_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.SHADOW_IN)
self.view = view = AllTreeView()
view.set_headers_visible(False)
scrolled_window.set_policy(gtk.POLICY_NEVER, gtk.POLICY_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):
return model[iter][self.TYPE] == self.TYPE_SEP
view.set_row_separator_func(separator)
def search_func(model, column, key, iter):
return key.lower() not in model[iter][column].lower()
view.set_search_column(self.NAME)
view.set_search_equal_func(search_func)
column = gtk.TreeViewColumn("genres")
column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
renderpb = gtk.CellRendererPixbuf()
renderpb.props.xpad = 3
column.pack_start(renderpb, False)
column.set_attributes(renderpb, stock_id=self.STOCK)
render = gtk.CellRendererText()
view.append_column(column)
column.pack_start(render)
column.set_attributes(render, text=self.NAME)
view.set_model(model)
# selection
selection = view.get_selection()
selection.set_mode(gtk.SELECTION_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)
box.pack_start(button, expand=False)
if main:
self.pack_start(Alignment(box, left=3, right=3, top=3))
else:
self.pack_start(box)
self.__filter_list = scrolled_window
self.show_all()
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.SHADOW_IN)
self.view = view = AllTreeView()
view.set_headers_visible(False)
model_sort = gtk.TreeModelSort(self.__model)
model_filter = model_sort.filter_new()
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.TREE_VIEW_COLUMN_FIXED)
column.set_fixed_width(60)
render.set_property('height', 56)
def cell_data_pb(column, cell, model, iter, no_cover):
album = model[iter][0]
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)
render.set_property('ellipsize', pango.ELLIPSIZE_END)
def cell_data(column, cell, model, iter):
album = model[iter][0]
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.SELECTION_MULTIPLE)
view.set_rules_hint(True)
view.set_search_equal_func(self.__search_func)
view.set_search_column(0)
view.set_model(model_filter)
sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_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.TARGET_SAME_APP, 1),
("text/uri-list", 0, 2)]
view.drag_source_set(
gtk.gdk.BUTTON1_MASK, targets, gtk.gdk.ACTION_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(button=False, 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(model_sort)
search.pack_start(prefs, expand=False)
if main:
self.pack_start(Alignment(search, left=3, top=3), expand=False)
else:
self.pack_start(search, expand=False)
self.pack_start(sw, expand=True)
self.connect("destroy", self.__destroy)
self.enable_row_update(view, sw, self.__cover_column)
self.show_all()
