# Copyright (C) 2008-2010 Adam Olsen
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
#
# The developers of the Exaile media player hereby grant permission
# for non-GPL compatible GStreamer and Exaile plugins to be used and
# distributed together with GStreamer and Exaile. This permission is
# above and beyond the permissions granted by the GPL license by which
# Exaile is covered. If you modify this code, you may extend this
# exception to your version of the code, but you are not obligated to
# do so. If you do not wish to do so, delete this exception statement
# from your version.
import locale
from gi.repository import GLib
from gi.repository import Gtk
from xl import event, main, plugins, xdg
from xlgui.widgets import common, dialogs
from xl.nls import gettext as _, ngettext
import logging
logger = logging.getLogger(__name__)
name = _('Plugins')
ui = xdg.get_data_path('ui', 'preferences', 'plugin.ui')
class PluginManager:
"""
Gui to manage plugins
"""
def __init__(self, preferences, builder):
"""
Initializes the manager
"""
self.preferences = preferences
builder.connect_signals(self)
self.plugins = main.exaile().plugins
self.window = builder.get_object('PreferencesDialog')
self.message = dialogs.MessageBar(
parent=builder.get_object('preferences_pane'), buttons=Gtk.ButtonsType.CLOSE
)
self.message.connect('response', self.on_messagebar_response)
self.list = builder.get_object('plugin_tree')
self.enabled_cellrenderer = builder.get_object('enabled_cellrenderer')
if main.exaile().options.Debug:
reload_cellrenderer = common.ClickableCellRendererPixbuf()
reload_cellrenderer.props.icon_name = 'view-refresh'
reload_cellrenderer.props.xalign = 1
reload_cellrenderer.connect('clicked', self.on_reload_cellrenderer_clicked)
name_column = builder.get_object('name_column')
name_column.pack_start(reload_cellrenderer, True)
name_column.add_attribute(reload_cellrenderer, 'visible', 3)
"""Show trash can"""
remove_cellrenderer = common.ClickableCellRendererPixbuf()
remove_cellrenderer.props.icon_name = 'edit-delete'
remove_cellrenderer.props.xalign = 1
remove_cellrenderer.connect('clicked', self.on_remove_cellrenderer_clicked)
name_column = builder.get_object('name_column')
name_column.pack_start(remove_cellrenderer, True)
name_column.add_attribute(remove_cellrenderer, 'visible', 8)
self.version_label = builder.get_object('version_label')
self.author_label = builder.get_object('author_label')
self.name_label = builder.get_object('name_label')
self.description = builder.get_object('description_view')
self.model = builder.get_object('model')
self.filter_model = self.model.filter_new()
self.show_incompatible_cb = builder.get_object('show_incompatible_cb')
self.filter_model.set_visible_func(self._model_visible_func)
selection = self.list.get_selection()
selection.connect('changed', self.on_selection_changed)
self._load_plugin_list()
self._evt_rm1 = event.add_ui_callback(
self.on_plugin_event, 'plugin_enabled', None, True
)
self._evt_rm2 = event.add_ui_callback(
self.on_plugin_event, 'plugin_disabled', None, False
)
self.list.connect('destroy', self.on_destroy)
GLib.idle_add(selection.select_path, (0,))
GLib.idle_add(self.list.grab_focus)
def _load_plugin_list(self, select_plugin=None):
"""
Loads the plugin list
"""
plugins = self.plugins.list_installed_plugins()
uncategorized = _('Uncategorized')
plugins_dict = {uncategorized: []}
failed_list = []
self.plugin_to_path = {}
for plugin_name in plugins:
try:
info = self.plugins.get_plugin_info(plugin_name)
compatible = self.plugins.is_compatible(info)
broken = self.plugins.is_potentially_broken(info)
user_installed = self.plugins.is_user_installed(plugin_name)
except Exception:
logger.exception("Error loading plugin info for %r", plugin_name)
failed_list += [plugin_name]
continue
# determine icon to show
if not compatible:
icon = 'dialog-error'
elif broken:
icon = 'dialog-warning'
else:
icon = None
enabled = plugin_name in self.plugins.enabled_plugins
plugin_data = (
plugin_name,
info['Name'],
str(info['Version']),
enabled,
icon,
broken,
compatible,
True,
user_installed,
)
if 'Category' in info:
cat = plugins_dict.setdefault(info['Category'], [])
cat.append(plugin_data)
else:
plugins_dict[uncategorized].append(plugin_data)
self.list.set_model(None)
self.model.clear()
def categorykey(item):
if item[0] == uncategorized:
return '\xff' * 10
return locale.strxfrm(item[0])
plugins_dict = sorted(plugins_dict.items(), key=categorykey)
for category, plugins_list in plugins_dict:
plugins_list.sort(key=lambda x: locale.strxfrm(x[1]))
it = self.model.append(
None, (None, category, '', False, '', False, True, False, False)
)
for plugin_data in plugins_list:
pit = self.model.append(it, plugin_data)
path = self.model.get_string_from_iter(pit)
self.plugin_to_path[plugin_data[0]] = path
self.list.set_model(self.filter_model)
# TODO: Keep track of which categories are already expanded, and only expand those
self.list.expand_all()
if select_plugin:
path = self.plugin_to_path[select_plugin]
selection = self.list.get_selection()
selection.select_path(path)
self.list.scroll_to_cell(path)
if failed_list:
self.message.show_error(
_('Could not load plugin info!'),
ngettext('Failed plugin: %s', 'Failed plugins: %s', len(failed_list))
% ', '.join(failed_list),
)
def on_destroy(self, widget):
self._evt_rm1()
self._evt_rm2()
def on_messagebar_response(self, widget, response):
"""
Hides the messagebar if requested
"""
if response == Gtk.ResponseType.CLOSE:
widget.hide()
def on_plugin_tree_row_activated(self, tree, path, column):
"""
Enables or disables the selected plugin
"""
self.enabled_cellrenderer.emit('toggled', path[0])
def on_remove_cellrenderer_clicked(self, cellrenderer, path: str) -> None:
"""
Remove a user installed plugin
"""
plugin_name = self.filter_model[path][0]
user_installed = self.filter_model[path][8]
if not user_installed:
return
GLib.idle_add(self.ask_for_remove, plugin_name)
def ask_for_remove(self, plugin_name: str):
response = dialogs.yesno(
self.window,
"\n".join(
[
_('Do you really want to remove this plugin?'),
]
),
)
if response != Gtk.ResponseType.YES:
return
try:
self.plugins.uninstall_plugin(plugin_name)
except Exception as e:
self.message.show_error(_('Could not remove plugin!'), str(e))
return
self._load_plugin_list()
def on_reload_cellrenderer_clicked(self, cellrenderer, path):
"""
Reloads a plugin from scratch
"""
plugin_name = self.filter_model[path][0]
enabled = self.filter_model[path][3]
if enabled:
try:
self.plugins.disable_plugin(plugin_name)
except Exception as e:
self.message.show_error(_('Could not disable plugin!'), str(e))
return
logger.info('Reloading plugin %s...', plugin_name)
self.plugins.load_plugin(plugin_name, reload_plugin=True)
if enabled:
try:
self.plugins.enable_plugin(plugin_name)
except Exception as e:
self.message.show_error(_('Could not enable plugin!'), str(e))
return
def on_install_plugin_button_clicked(self, button):
"""
Shows a dialog allowing the user to choose a plugin to install
from the filesystem
"""
dialog = Gtk.FileChooserDialog(
title=_('Choose a Plugin'),
transient_for=self.preferences.parent,
)
dialog.add_buttons(
Gtk.STOCK_CANCEL,
Gtk.ResponseType.CANCEL,
Gtk.STOCK_ADD,
Gtk.ResponseType.OK,
)
filter = Gtk.FileFilter()
filter.set_name(_('Plugin Archives'))
filter.add_pattern("*.exz")
filter.add_pattern("*.tar.gz")
filter.add_pattern("*.tar.bz2")
dialog.add_filter(filter)
filter = Gtk.FileFilter()
filter.set_name(_('All Files'))
filter.add_pattern('*')
dialog.add_filter(filter)
result = dialog.run()
dialog.hide()
if result == Gtk.ResponseType.OK:
def install(filename: str, overwrite_existing: bool = False) -> str:
try:
plugin_name = self.plugins.install_plugin(
filename, overwrite_existing
)
except plugins.PluginExistsError as e:
response = dialogs.yesno(
self.window,
"\n".join(
[
_('Plugin already exists!'),
_('Do you want to override it?'),
]
),
)
if response == Gtk.ResponseType.YES:
return install(filename, True)
except plugins.InvalidPluginError as e:
self.message.show_error(
_('Plugin file installation failed!'), str(e)
)
return ''
return plugin_name
plugin_name = install(dialog.get_filename())
if not plugin_name:
return
self._load_plugin_list(plugin_name)
def on_selection_changed(self, selection, user_data=None):
"""
Called when a row is selected
"""
model, paths = selection.get_selected_rows()
if not paths:
return
row = model[paths[0]]
if not row[7]:
self.author_label.set_label('')
self.description.get_buffer().set_text('')
self.name_label.set_label('')
return
info = self.plugins.get_plugin_info(row[0])
self.author_label.set_label(",\n".join(info['Authors']))
self.description.get_buffer().set_text(info['Description'].replace(r'\n', "\n"))
self.name_label.set_markup(
"%s %s" % (info['Name'], info['Version'])
)
def on_enabled_cellrenderer_toggled(self, cellrenderer, path):
"""
Called when the checkbox is toggled
"""
path = Gtk.TreePath.new_from_string(path)
plugin_name = self.filter_model[path][0]
if plugin_name is None:
return
enable = not self.filter_model[path][3]
if enable:
try:
self.plugins.enable_plugin(plugin_name, True)
except Exception as e:
self.message.show_error(_('Could not enable plugin!'), str(e))
return
else:
try:
self.plugins.disable_plugin(plugin_name)
except Exception as e:
self.message.show_error(_('Could not disable plugin!'), str(e))
return
self.on_selection_changed(self.list.get_selection())
def on_plugin_event(self, evtname, obj, plugin_name, enabled):
if hasattr(self.plugins.loaded_plugins[plugin_name], 'get_preferences_pane'):
self.preferences._load_plugin_pages()
path = self.plugin_to_path[plugin_name]
self.model[path][3] = enabled
def on_show_incompatible_cb_toggled(self, widget):
self.filter_model.refilter()
def _model_visible_func(self, model, iter, data):
row = model[iter]
compatible = row[6]
return compatible or self.show_incompatible_cb.get_active()
def init(preferences, xml):
PluginManager(preferences, xml)