def __init__(self, exaile):
self.bookmarks = []
# self.auto_db = {}
self.exaile = exaile
self.use_covers = settings.get_option('plugin/bookmarks/use_covers',
False)
self.counter = 0
# setup menus
self.menu = menu.Menu(self)
self.delete_menu = menu.Menu(self)
# define factory-factory for sensitive-aware menuitems
def factory_factory(display_name,
icon_name,
callback=None,
submenu=None):
def factory(menu_, parent, context):
item = Gtk.ImageMenuItem.new_with_mnemonic(display_name)
image = Gtk.Image.new_from_icon_name(icon_name,
size=Gtk.IconSize.MENU)
item.set_image(image)
# insensitive if no bookmarks present
if len(self.bookmarks) == 0:
item.set_sensitive(False)
else:
if callback is not None:
item.connect('activate', callback)
if submenu is not None:
item.set_submenu(submenu)
return item
return factory
items = []
items.append(
_smi('bookmark', [], _('_Bookmark This Track'), 'bookmark-new',
self.add_bookmark))
items.append(
menu.MenuItem(
'delete',
factory_factory(_('_Delete Bookmark'),
'gtk-close',
submenu=self.delete_menu), ['bookmark']))
items.append(
menu.MenuItem(
'clear',
factory_factory(_('_Clear Bookmarks'),
'gtk-clear',
callback=self.clear), ['delete']))
items.append(_sep('sep', ['clear']))
for item in items:
self.menu.add_item(item)
def __setup_menu(self):
self.menu = menu.Menu(self)
self.delete_menu = menu.Menu(self)
def factory_factory(display_name,
icon_name,
callback=None,
submenu=None):
"define factory-factory for sensitive-aware menuitems"
def factory(_menu, _parent, _context):
item = Gtk.ImageMenuItem.new_with_mnemonic(display_name)
image = Gtk.Image.new_from_icon_name(icon_name,
size=Gtk.IconSize.MENU)
item.set_image(image)
if callback is not None:
item.connect('activate', callback)
if submenu is not None:
item.set_submenu(submenu)
# insensitive if no bookmarks present
if len(self.__bookmarks) == 0:
item.set_sensitive(False)
return item
return factory
items = []
items.append(
_smi(
'bookmark',
[],
_('_Bookmark This Track'),
'bookmark-new',
self.__on_add_bookmark,
))
delete_cb = factory_factory(_('_Delete Bookmark'),
'gtk-close',
submenu=self.delete_menu)
items.append(menu.MenuItem('delete', delete_cb, ['bookmark']))
clear_cb = factory_factory(_('_Clear Bookmarks'),
'gtk-clear',
callback=self.__clear_bookmarks)
items.append(menu.MenuItem('clear', clear_cb, ['delete']))
items.append(_sep('sep', ['clear']))
for item in items:
self.menu.add_item(item)
def __init__(self, exaile, _menu, avahi):
'''
Init! Create manual menu item, and connect to avahi signal.
'''
self.exaile = exaile
self.avahi = avahi
self.panels = {}
hmenu = menu.Menu(None)
def hmfactory(_menu, _parent, _context):
item = Gtk.MenuItem.new_with_mnemonic(_('History'))
item.set_submenu(hmenu)
sens = settings.get_option('plugin/daapclient/history', True)
item.set_sensitive(sens)
return item
_menu.add_item(
_smi('manual', [], _('Manually...'), callback=self.manual_connect))
_menu.add_item(menu.MenuItem('history', hmfactory, ['manual']))
_menu.add_item(_sep('sep', ['history']))
if avahi is not None:
avahi.connect("connect", self.connect_share)
self.history = DaapHistory(5, menu=hmenu, callback=self.connect_share)
def __create_menu_item(self, bookmarks_menu, delete_menu,
delete_bookmark_callback):
"""
Create menu entries for this bookmark.
"""
time = '%d:%02d' % (self.__time / 60, self.__time % 60)
label = '%s @ %s' % (self.__title, time)
def factory(menu_, _parent, _context):
"menu factory for new bookmarks"
menu_item = Gtk.ImageMenuItem.new_with_mnemonic(label)
if self.__cover_pixbuf:
menu_item.set_image(
Gtk.Image.new_from_pixbuf(self.__cover_pixbuf))
if menu_ is bookmarks_menu:
menu_item.connect('activate', self.__on_bookmark_activated)
else:
menu_item.connect('activate', delete_bookmark_callback, self)
return menu_item
item = menu.MenuItem('bookmark{0}'.format(Bookmark.__counter), factory,
['sep'])
Bookmark.__counter += 1
bookmarks_menu.add_item(item)
delete_menu.add_item(item)
self.item = item
def save_closed_tab(self, playlist):
# don't let the list grow indefinitely
if len(self.tab_history) > settings.get_option('gui/max_closed_tabs',
10):
self.remove_closed_tab(-1) # remove last item
item_name = 'playlist%05d' % self.history_counter
close_time = datetime.now()
# define a MenuItem factory that supports dynamic labels
def factory(menu_, parent, context):
item = None
dt = datetime.now() - close_time
if dt.seconds > 60:
display_name = _(
'{playlist_name} ({track_count} tracks, closed {minutes} min ago)'
).format(
playlist_name=playlist.name,
track_count=len(playlist),
minutes=dt.seconds // 60,
)
else:
display_name = _(
'{playlist_name} ({track_count} tracks, closed {seconds} sec ago)'
).format(
playlist_name=playlist.name,
track_count=len(playlist),
seconds=dt.seconds,
)
item = Gtk.ImageMenuItem.new_with_mnemonic(display_name)
item.set_image(
Gtk.Image.new_from_icon_name('music-library',
Gtk.IconSize.MENU))
# Add accelerator to top item
if self.tab_history[0][1].name == item_name:
key, mods = Gtk.accelerator_parse(self.accelerator.keys)
item.add_accelerator('activate', menu.FAKEACCELGROUP, key,
mods, Gtk.AccelFlags.VISIBLE)
item.connect(
'activate',
lambda w: self.restore_closed_tab(item_name=item_name))
return item
# create menuitem
item = menu.MenuItem(item_name, factory, [])
providers.register('playlist-closed-tab-menu', item, self)
self.history_counter -= 1
# add
self.tab_history.insert(0, (playlist, item))
def display_bookmark(self, key, pos):
"""
Create menu entrees for this bookmark.
"""
pix = None
# add menu item
try:
item = trax.Track(key)
title = item.get_tag_display('title')
if self.use_covers:
image = covers.MANAGER.get_cover(item, set_only=True)
if image:
try:
pix = icons.MANAGER.pixbuf_from_data(image,
size=(16, 16))
except GLib.GError:
logger.warn('Could not load cover')
pix = None
# no cover
else:
pix = None
except Exception:
logger.exception("Cannot open %s", key)
# delete offending key?
return
time = '%d:%02d' % (pos / 60, pos % 60)
label = '%s @ %s' % (title, time)
counter = self.counter # closure magic (workaround for factories not having access to item)
# factory for new bookmarks
def factory(menu_, parent, context):
menu_item = Gtk.ImageMenuItem.new_with_mnemonic(label)
if pix:
menu_item.set_image(Gtk.image_new_from_pixbuf(pix))
if menu_ is self.menu:
menu_item.connect('activate', self.do_bookmark, (key, pos))
else:
menu_item.connect('activate', self.delete_bookmark,
(counter, key, pos))
return menu_item
item = menu.MenuItem('bookmark{0}'.format(self.counter), factory,
['sep'])
self.menu.add_item(item)
self.delete_menu.add_item(item)
self.counter += 1
# save addition
self.save_db()
def PlayPauseMenuItem(name, player, after):
def factory(menu, parent, context):
if player.is_playing():
stock_id = gtk.STOCK_MEDIA_PAUSE
else:
stock_id = gtk.STOCK_MEDIA_PLAY
item = gtk.ImageMenuItem(stock_id)
item.connect('activate', lambda *args: playpause( player ), name, parent, context)
return item
return menu.MenuItem(name, factory, after=after)
def setup_menu(self):
self.menu_agr = self.exaile.gui.main.accel_group
providers.register('menubar-tools-menu',
menu.simple_separator('plugin-sep', ['track-properties']))
def factory(menu_, parent, context):
item = Gtk.CheckMenuItem.new_with_label(_('Enable audioscrobbling'))
item.set_active(self.submit)
key, mods = Gtk.accelerator_parse('<Control>B')
item.add_accelerator('activate', menu.FAKEACCELGROUP, key, mods,
Gtk.AccelFlags.VISIBLE)
item.connect('toggled', self._menu_entry_toggled)
return item
item = menu.MenuItem('scrobbler', factory, ['plugin-sep'])
providers.register('menubar-tools-menu', item)
def __init__(self, manager_name, player, hotkey):
SmartNotebook.__init__(self)
self.tab_manager = PlaylistManager(manager_name)
self.manager_name = manager_name
self.player = player
# For saving closed tab history
self._moving_tab = False
self.tab_history = []
self.history_counter = 90000 # to get unique (reverse-ordered) item names
# Build static menu entries
item = menu.simple_separator('clear-sep', [])
item.register('playlist-closed-tab-menu', self)
item = menu.simple_menu_item(
'clear-history',
['clear-sep'],
_("_Clear Tab History"),
'edit-clear-all',
self.clear_closed_tabs,
)
item.register('playlist-closed-tab-menu', self)
# Simple factory for 'Recently Closed Tabs' MenuItem
submenu = menu.ProviderMenu('playlist-closed-tab-menu', self)
def factory(menu_, parent, context):
if self.page_num(parent) == -1:
return None
item = Gtk.MenuItem.new_with_mnemonic(_("Recently Closed _Tabs"))
if len(self.tab_history) > 0:
item.set_submenu(submenu)
else:
item.set_sensitive(False)
return item
# Add menu to tab context menu
item = menu.MenuItem('%s-tab-history' % manager_name, factory, ['tab-close'])
item.register('playlist-tab-context-menu')
# Add menu to View menu
# item = menu.MenuItem('tab-history', factory, ['clear-playlist'])
# providers.register('menubar-view-menu', item)
# setup notebook actions
self.actions = NotebookActionService(self, 'playlist-notebook-actions')
# Add hotkey
self.accelerator = Accelerator(
hotkey, _('Restore closed tab'), lambda *x: self.restore_closed_tab(0)
)
providers.register('mainwindow-accelerators', self.accelerator)
# Load saved tabs
self.load_saved_tabs()
self.tab_placement_map = {
'left': Gtk.PositionType.LEFT,
'right': Gtk.PositionType.RIGHT,
'top': Gtk.PositionType.TOP,
'bottom': Gtk.PositionType.BOTTOM,
}
self.connect('page-added', self.on_page_added)
self.connect('page-removed', self.on_page_removed)
self.on_option_set('gui_option_set', settings, 'gui/show_tabbar')
self.on_option_set('gui_option_set', settings, 'gui/tab_placement')
event.add_ui_callback(self.on_option_set, 'gui_option_set')
