'''

class for all supported ExternalPlugins

'''

def __init__(self, **kargs):

super(ExternalPlugin, self).__init__(**kargs)

# dict of attributes associated with the external plugin

self.attributes = {}

self.attributes['is_album_menu'] = False

self.attributes['new_menu_name'] = ''

self.attributes['action_type'] = ''

self.attributes['action_group_name'] = ''

def appendattribute(self, key, val):

'''

append another attribute to the dict

:param key: `str` name of attribute

:param val: `str` value of attribute

'''

if key == 'is_album_menu':

if val == 'yes':

self.attributes[key] = True

else:

self.attributes[key] = False

else:

self.attributes[key] = val

def is_activated(self):

'''

method to test whether the plugin is actually loaded. Returns a bool

'''

peas = Peas.Engine.get_default()

loaded_plugins = peas.get_loaded_plugins()

if self.attributes['plugin_name'] in CaseInsensitiveDict(loaded_plugins):

print ("found %s" % self.attributes['plugin_name'])

return True

print ("search for %s" % self.attributes['plugin_name'])

print (loaded_plugins)

return False

def create_menu_item(self, menubar, section_name, at_position,

save_actiongroup, save_menu, for_album = False):

'''

method to create the menu item appropriate to the plugin.

A plugin can have many menu items - all menuitems are enclosed

in a section.

:param menubar: `str` name for the GtkMenu - ignored for RB2.99

:param section_name: `str` unique name of the section holding the menu items

:param at_position: `int` position within the GtkMenu to create menu - ignored for RB2.99

:param save_actiongroup: `ActionGroup` container for all menu-item Actions

:param save_menu: `Menu` whole popupmenu including sub-menus

:param for_album: `bool` create the menu for the album - if not given

then its assumed the menu item is appropriate just for tracks

'''

if for_album and not self.attributes['is_album_menu']:

return False

if not self.is_activated():

return False

action = ApplicationShell(save_menu.shell).lookup_action(self.attributes['action_group_name'],

self.attributes['action_name'], self.attributes['action_type'])

if action:

self.attributes['action']=action

if self.attributes['new_menu_name'] != '':

self.attributes['label'] = self.attributes['new_menu_name']

else:

self.attributes['label']=action.label

#self.attributes['sensitive']=action.get_sensitive()

else:

print ("action not found")

print (self.attributes)

return False

action = save_actiongroup.add_action(func=self.menuitem_callback,

action_name=self.attributes['action_name'], album=for_album,

shell=save_menu.shell, label=self.attributes['label'])

new_menu_item = save_menu.insert_menu_item(menubar, section_name,

at_position, action)

return new_menu_item

def do_deactivate(self):

pass

def set_entry_view_selected_entries(self, shell):

'''

method called just before the external plugin action is activated

Normally only called for album menus to mimic selecting all the

EntryView rows

'''

page = shell.props.selected_page

if not hasattr(page, "get_entry_view"):

return

page.get_entry_view().select_all()

def menuitem_callback(self, action, param, args):

'''

method called when a menu-item is clicked. Basically, an Action

is activated by the user

:param action: `Gio.SimpleAction` or `Gtk.Action`

:param param: Not used

:param args: dict associated with the action

'''

for_album = args['album']

shell = args['shell']

if for_album:

self.set_entry_view_selected_entries(shell)

'''

This is the key class called to initialise all supported plugins

:param section_name: `str` unique name of the section holding the menu items

:param at_position: `int` position within the GtkMenu to create menu - ignored for RB2.99

:param popup: `Menu` whole popupmenu including sub-menus

'''

def __init__(self, section_name, at_position, popup, **kargs):

super(CreateExternalPluginMenu, self).__init__(**kargs)

self.menu = popup

self.section_name = section_name

self.at_position = at_position

self._actiongroup = ActionGroup(popup.shell, section_name + '_externalplugins')

# all supported plugins will be defined in the following array by parsing

# the plugins XML file for the definition. Supported plugins are split between

# rb2.99 and later and rb2.98 and earlier due to the likelihood that earlier

# plugins may never be updated by their authors

self.supported_plugins = []

extplugins = rb.find_plugin_file(popup.plugin, 'ui/coverart_external_plugins.xml')

root = ET.parse(open(extplugins)).getroot()

if rb3compat.is_rb3(popup.shell):

base = 'rb3/plugin'

else:

base = 'rb2/plugin'

for elem in root.xpath(base):

pluginname = elem.attrib['name']

basemenu = base + "[@name='" + pluginname + "']/menu"

for menuelem in root.xpath(basemenu):

ext = ExternalPlugin()

ext.appendattribute('plugin_name', pluginname)

label = menuelem.attrib['label']

if label != "":

ext.appendattribute('new_menu_name', label)

baseattrib = basemenu + "[@label='" + label + "']/attribute"

else:

baseattrib = basemenu + "/attribute"

for attribelem in root.xpath(baseattrib):

key = attribelem.attrib['name']

val = attribelem.text

ext.appendattribute(key, val)

self.supported_plugins.append(ext)

def create_menu(self, menu_name, for_album = False):

'''

method to create the menu items for all supported plugins

:param menu_name: `str` unique name (GtkMenu) id for the menu to create

:for_album: `bool` - create a menu applicable for Albums

by default a menu is assumed to be applicable to a track in an

EntryView

'''

self.menu_name = menu_name

self._actiongroup.remove_actions()

self.menu.remove_menu_items(self.menu_name, self.section_name)

items_added = False

for plugin in self.supported_plugins:

new_menu_item = plugin.create_menu_item(self.menu_name, self.section_name,

self.at_position, self._actiongroup, self.menu, for_album)

if (not items_added) and new_menu_item:

items_added = True

if items_added: