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')