isa/mutter
1
0
Fork 0
mirror of https://github.com/brl/mutter.git synced 2024-11-28 19:10:43 -05:00
Code Issues Packages Projects Releases Wiki Activity

Remove some unused plugin functionality

Browse Source 
Revert the early_initialize changes (which get in the way in the
"libmutter-wm" paradigm), remove the GConf key for setting plugins,
and remove plugin "params", which weren't being used. Also remove all
the logic for unloading and reloading plugins, since the list never
changes after startup now.

https://bugzilla.gnome.org/show_bug.cgi?id=643959
This commit is contained in:
Dan Winship 2011-03-04 15:11:38 -05:00
parent a66ae4ad55
commit 4c76791d4c
11 changed files with 83 additions and 612 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
configure.in
View File

@ -7,7 +7,7 @@ m4_define([mutter_micro_version], [90])
m4_define([mutter_version], m4_define([mutter_version],
[mutter_major_version.mutter_minor_version.mutter_micro_version]) [mutter_major_version.mutter_minor_version.mutter_micro_version])
m4_define([mutter_plugin_api_version], [4]) m4_define([mutter_plugin_api_version], [3])
AC_INIT([mutter], [mutter_version], AC_INIT([mutter], [mutter_version],
[http://bugzilla.gnome.org/enter_bug.cgi?product=mutter]) [http://bugzilla.gnome.org/enter_bug.cgi?product=mutter])

13
src/compositor/compositor.c
View File

@ -550,18 +550,7 @@ meta_compositor_manage_screen (MetaCompositor *compositor,
info->plugin_mgr = info->plugin_mgr =
meta_plugin_manager_get (screen); meta_plugin_manager_get (screen);
meta_plugin_manager_initialize (info->plugin_mgr);
if (info->plugin_mgr != meta_plugin_manager_get_default ())
{
/* The default plugin manager has been initialized during
* global preferences load.
*/
if (!meta_plugin_manager_load (info->plugin_mgr))
g_critical ("failed to load plugins");
}
if (!meta_plugin_manager_initialize (info->plugin_mgr))
g_critical ("failed to initialize plugins");
/* /*
* Delay the creation of the overlay window as long as we can, to avoid * Delay the creation of the overlay window as long as we can, to avoid

348
src/compositor/meta-plugin-manager.c
View File

@ -35,10 +35,7 @@
#include <clutter/x11/clutter-x11.h> #include <clutter/x11/clutter-x11.h>
/* static GSList *plugin_types;
* There is only one instace of each module per the process.
*/
static GHashTable *plugin_modules = NULL;
/* /*
* We have one "default plugin manager" that acts for the first screen, * We have one "default plugin manager" that acts for the first screen,
@ -46,250 +43,35 @@ static GHashTable *plugin_modules = NULL;
* plugin managers for each screen. (This is ugly. Probably we should * plugin managers for each screen. (This is ugly. Probably we should
* have one plugin manager and only make the plugins per-screen.) * have one plugin manager and only make the plugins per-screen.)
*/ */
static MetaPluginManager *default_plugin_manager; static MetaPluginManager *default_plugin_manager;
static gboolean meta_plugin_manager_reload (MetaPluginManager *plugin_mgr);
struct MetaPluginManager struct MetaPluginManager
{ {
MetaScreen *screen; MetaScreen *screen;
gboolean plugin_load_attempted;
GList /* MetaPlugin */ *plugins; /* TODO -- maybe use hash table */ GList /* MetaPlugin */ *plugins; /* TODO -- maybe use hash table */
GList *unload; /* Plugins that are disabled and pending unload */
guint idle_unload_id;
}; };
/* /*
* Checks that the plugin is compatible with the WM and sets up the plugin * Loads the given plugin.
* struct.
*/ */
static MetaPlugin * void
meta_plugin_load (MetaPluginManager *mgr, meta_plugin_manager_load (MetaPluginManager *plugin_mgr,
MetaModule *module, const gchar *plugin_name)
const gchar *params)
{
MetaPlugin *plugin = NULL;
GType plugin_type = meta_module_get_plugin_type (module);
if (!plugin_type)
{
g_warning ("Plugin type not registered !!!");
return NULL;
}
plugin = g_object_new (plugin_type,
"params", params,
NULL);
return plugin;
}
/*
* Attempst to unload a plugin; returns FALSE if plugin cannot be unloaded at
* present (e.g., and effect is in progress) and should be scheduled for
* removal later.
*/
static gboolean
meta_plugin_unload (MetaPlugin *plugin)
{
if (meta_plugin_running (plugin))
{
g_object_set (plugin, "disabled", TRUE, NULL);
return FALSE;
}
g_object_unref (plugin);
return TRUE;
}
/*
* Iddle callback to remove plugins that could not be removed directly and are
* pending for removal.
*/
static gboolean
meta_plugin_manager_idle_unload (MetaPluginManager *plugin_mgr)
{
GList *l = plugin_mgr->unload;
gboolean dont_remove = TRUE;
while (l)
{
MetaPlugin *plugin = l->data;
if (meta_plugin_unload (plugin))
{
/* Remove from list */
GList *p = l->prev;
GList *n = l->next;
if (!p)
plugin_mgr->unload = n;
else
p->next = n;
if (n)
n->prev = p;
g_list_free_1 (l);
l = n;
}
else
l = l->next;
}
if (!plugin_mgr->unload)
{
/* If no more unloads are pending, remove the handler as well */
dont_remove = FALSE;
plugin_mgr->idle_unload_id = 0;
}
return dont_remove;
}
/*
* Unloads all plugins
*/
static void
meta_plugin_manager_unload (MetaPluginManager *plugin_mgr)
{
GList *plugins = plugin_mgr->plugins;
while (plugins)
{
MetaPlugin *plugin = plugins->data;
/* If the plugin could not be removed, move it to the unload list */
if (!meta_plugin_unload (plugin))
{
plugin_mgr->unload = g_list_prepend (plugin_mgr->unload, plugin);
if (!plugin_mgr->idle_unload_id)
{
plugin_mgr->idle_unload_id = g_idle_add ((GSourceFunc)
meta_plugin_manager_idle_unload,
plugin_mgr);
}
}
plugins = plugins->next;
}
g_list_free (plugin_mgr->plugins);
plugin_mgr->plugins = NULL;
plugin_mgr->plugin_load_attempted = FALSE;
}
static void
prefs_changed_callback (MetaPreference pref,
void *data)
{
MetaPluginManager *plugin_mgr = data;
if (pref == META_PREF_CLUTTER_PLUGINS)
{
meta_plugin_manager_reload (plugin_mgr);
}
}
static MetaModule *
meta_plugin_manager_get_module (const gchar *path)
{
MetaModule *module = g_hash_table_lookup (plugin_modules, path);
if (!module &&
(module = g_object_new (META_TYPE_MODULE, "path", path, NULL)))
{
g_hash_table_insert (plugin_modules, g_strdup (path), module);
}
return module;
}
/*
* Loads all plugins listed in gconf registry.
*/
gboolean
meta_plugin_manager_load (MetaPluginManager *plugin_mgr)
{ {
const gchar *dpath = MUTTER_PLUGIN_DIR "/"; const gchar *dpath = MUTTER_PLUGIN_DIR "/";
GSList *plugins, *fallback = NULL;
if (plugin_mgr->plugin_load_attempted)
return TRUE;
plugin_mgr->plugin_load_attempted = TRUE;
plugins = meta_prefs_get_clutter_plugins ();
if (!plugins)
{
/*
* If no plugins are specified, try to load the default plugin.
*/
fallback = g_slist_append (fallback, "default");
plugins = fallback;
}
while (plugins)
{
gchar *plugin_string;
gchar *params;
plugin_string = g_strdup (plugins->data);
if (plugin_string)
{
MetaModule *module;
gchar *path; gchar *path;
MetaModule *module;
GType plugin_type;
MetaPlugin *plugin;
params = strchr (plugin_string, ':'); if (g_path_is_absolute (plugin_name))
path = g_strdup (plugin_name);
if (params)
{
*params = 0;
++params;
}
if (g_path_is_absolute (plugin_string))
path = g_strdup (plugin_string);
else else
path = g_strconcat (dpath, plugin_string, ".so", NULL); path = g_strconcat (dpath, plugin_name, ".so", NULL);
module = meta_plugin_manager_get_module (path); module = g_object_new (META_TYPE_MODULE, "path", path, NULL);
if (!module || !g_type_module_use (G_TYPE_MODULE (module)))
if (module)
{
gboolean use_succeeded;
/*
* This dlopens the module and registers the plugin type with the
* GType system, if the module is not already loaded. When we
* create a plugin, the type system also calls g_type_module_use()
* to guarantee the module will not be unloaded during the plugin
* life time. Consequently we can unuse() the module again.
*/
use_succeeded = g_type_module_use (G_TYPE_MODULE (module));
if (use_succeeded)
{
MetaPlugin *plugin = meta_plugin_load (plugin_mgr, module, params);
if (plugin)
plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
else
g_warning ("Plugin load for [%s] failed", path);
g_type_module_unuse (G_TYPE_MODULE (module));
}
}
else
{ {
/* This is fatal under the assumption that a monitoring /* This is fatal under the assumption that a monitoring
* process like gnome-session will take over and handle * process like gnome-session will take over and handle
@ -300,59 +82,29 @@ meta_plugin_manager_load (MetaPluginManager *plugin_mgr)
exit (1); exit (1);
} }
plugin_type = meta_module_get_plugin_type (module);
plugin_types = g_slist_prepend (plugin_types, GSIZE_TO_POINTER (plugin_type));
plugin = g_object_new (plugin_type, NULL);
plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
g_type_module_unuse (G_TYPE_MODULE (module));
g_free (path); g_free (path);
g_free (plugin_string);
}
plugins = plugins->next;
}
if (fallback)
g_slist_free (fallback);
if (plugin_mgr->plugins != NULL)
{
meta_prefs_add_listener (prefs_changed_callback, plugin_mgr);
return TRUE;
}
return FALSE;
} }
/** void
* meta_plugin_manager_initialize_early:
* @plugin_mgr: a #MetaPluginManager
*
* This function invokes any plugin handling code that needs to be run
* effectively immediately after we know which plugins are going to be
* used. This means before the process has an X connection, or
* talks to the session manager, for example.
*
* An example intended use is claiming DBus names.
*/
gboolean
meta_plugin_manager_initialize_early (MetaPluginManager *plugin_mgr)
{
GList *iter;
for (iter = plugin_mgr->plugins; iter; iter = iter->next)
{
MetaPlugin *plugin = (MetaPlugin*) iter->data;
MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
if (klass->early_initialize)
klass->early_initialize (plugin);
}
return TRUE;
}
gboolean
meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr) meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr)
{ {
GList *iter; GList *iter;
if (!plugin_mgr->plugins)
{
/*
* If no plugins are specified, load the default plugin.
*/
meta_plugin_manager_load (plugin_mgr, "default");
}
for (iter = plugin_mgr->plugins; iter; iter = iter->next) for (iter = plugin_mgr->plugins; iter; iter = iter->next)
{ {
MetaPlugin *plugin = (MetaPlugin*) iter->data; MetaPlugin *plugin = (MetaPlugin*) iter->data;
@ -365,26 +117,6 @@ meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr)
if (klass->start) if (klass->start)
klass->start (plugin); klass->start (plugin);
} }
return TRUE;
}
/*
* Reloads all plugins
*/
static gboolean
meta_plugin_manager_reload (MetaPluginManager *plugin_mgr)
{
/* TODO -- brute force; should we build a list of plugins to load and list of
* plugins to unload? We are probably not going to have large numbers of
* plugins loaded at the same time, so it might not be worth it.
*/
/* Prevent stale grabs on unloaded plugins */
meta_check_end_modal (plugin_mgr->screen);
meta_plugin_manager_unload (plugin_mgr);
return meta_plugin_manager_load (plugin_mgr);
} }
static MetaPluginManager * static MetaPluginManager *
@ -392,14 +124,7 @@ meta_plugin_manager_new (MetaScreen *screen)
{ {
MetaPluginManager *plugin_mgr; MetaPluginManager *plugin_mgr;
if (!plugin_modules)
{
plugin_modules = g_hash_table_new_full (g_str_hash, g_str_equal, g_free,
NULL);
}
plugin_mgr = g_new0 (MetaPluginManager, 1); plugin_mgr = g_new0 (MetaPluginManager, 1);
plugin_mgr->screen = screen; plugin_mgr->screen = screen;
if (screen) if (screen)
@ -441,7 +166,20 @@ meta_plugin_manager_get (MetaScreen *screen)
} }
else else
{ {
return meta_plugin_manager_new (screen); GSList *iter;
GType plugin_type;
MetaPlugin *plugin;
plugin_mgr = meta_plugin_manager_new (screen);
for (iter = plugin_types; iter; iter = iter->next)
{
plugin_type = (GType)GPOINTER_TO_SIZE (iter->data);
plugin = g_object_new (plugin_type, "screen", screen, NULL);
plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, plugin);
}
return plugin_mgr;
} }
} }

7
src/compositor/meta-plugin-manager.h
View File

@ -49,9 +49,10 @@ typedef struct MetaPluginManager MetaPluginManager;
MetaPluginManager * meta_plugin_manager_get (MetaScreen *screen); MetaPluginManager * meta_plugin_manager_get (MetaScreen *screen);
MetaPluginManager * meta_plugin_manager_get_default (void); MetaPluginManager * meta_plugin_manager_get_default (void);
gboolean meta_plugin_manager_load (MetaPluginManager *mgr); void meta_plugin_manager_load (MetaPluginManager *mgr,
gboolean meta_plugin_manager_initialize_early (MetaPluginManager *plugin_mgr); const gchar *plugin_name);
gboolean meta_plugin_manager_initialize (MetaPluginManager *plugin_mgr); void meta_plugin_manager_initialize (MetaPluginManager *mgr);
gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr, gboolean meta_plugin_manager_event_simple (MetaPluginManager *mgr,
MetaWindowActor *actor, MetaWindowActor *actor,
unsigned long event); unsigned long event);

97
src/compositor/meta-plugin.c
View File

@ -43,7 +43,6 @@ enum
{ {
PROP_0, PROP_0,
PROP_SCREEN, PROP_SCREEN,
PROP_PARAMS,
PROP_FEATURES, PROP_FEATURES,
PROP_DISABLED, PROP_DISABLED,
PROP_DEBUG_MODE, PROP_DEBUG_MODE,
@ -52,7 +51,6 @@ enum
struct _MetaPluginPrivate struct _MetaPluginPrivate
{ {
MetaScreen *screen; MetaScreen *screen;
gchar *params;
gulong features; gulong features;
gint running; gint running;
@ -70,95 +68,38 @@ meta_plugin_dispose (GObject *object)
static void static void
meta_plugin_finalize (GObject *object) meta_plugin_finalize (GObject *object)
{ {
MetaPluginPrivate *priv = META_PLUGIN (object)->priv;
g_free (priv->params);
priv->params = NULL;
G_OBJECT_CLASS (meta_plugin_parent_class)->finalize (object); G_OBJECT_CLASS (meta_plugin_parent_class)->finalize (object);
} }
static void static void
meta_plugin_parse_params (MetaPlugin *plugin) meta_plugin_set_features (MetaPlugin *plugin)
{ {
char *p;
gulong features = 0;
MetaPluginPrivate *priv = plugin->priv; MetaPluginPrivate *priv = plugin->priv;
MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin); MetaPluginClass *klass = META_PLUGIN_GET_CLASS (plugin);
/* priv->features = 0;
/*
* Feature flags: identify events that the plugin can handle; a plugin can * Feature flags: identify events that the plugin can handle; a plugin can
* handle one or more events. * handle one or more events.
*/ */
if (klass->minimize) if (klass->minimize)
features |= META_PLUGIN_MINIMIZE; priv->features |= META_PLUGIN_MINIMIZE;
if (klass->maximize) if (klass->maximize)
features |= META_PLUGIN_MAXIMIZE; priv->features |= META_PLUGIN_MAXIMIZE;
if (klass->unmaximize) if (klass->unmaximize)
features |= META_PLUGIN_UNMAXIMIZE; priv->features |= META_PLUGIN_UNMAXIMIZE;
if (klass->map) if (klass->map)
features |= META_PLUGIN_MAP; priv->features |= META_PLUGIN_MAP;
if (klass->destroy) if (klass->destroy)
features |= META_PLUGIN_DESTROY; priv->features |= META_PLUGIN_DESTROY;
if (klass->switch_workspace) if (klass->switch_workspace)
features |= META_PLUGIN_SWITCH_WORKSPACE; priv->features |= META_PLUGIN_SWITCH_WORKSPACE;
if (priv->params)
{
gboolean debug = FALSE;
if ((p = strstr (priv->params, "disable:")))
{
gchar *d = g_strdup (p+8);
p = strchr (d, ';');
if (p)
*p = 0;
if (strstr (d, "minimize"))
features &= ~ META_PLUGIN_MINIMIZE;
if (strstr (d, "maximize"))
features &= ~ META_PLUGIN_MAXIMIZE;
if (strstr (d, "unmaximize"))
features &= ~ META_PLUGIN_UNMAXIMIZE;
if (strstr (d, "map"))
features &= ~ META_PLUGIN_MAP;
if (strstr (d, "destroy"))
features &= ~ META_PLUGIN_DESTROY;
if (strstr (d, "switch-workspace"))
features &= ~META_PLUGIN_SWITCH_WORKSPACE;
g_free (d);
}
if (strstr (priv->params, "debug"))
debug = TRUE;
if (debug != priv->debug)
{
priv->debug = debug;
g_object_notify (G_OBJECT (plugin), "debug-mode");
}
}
if (features != priv->features)
{
priv->features = features;
g_object_notify (G_OBJECT (plugin), "features");
}
} }
static void static void
@ -174,10 +115,6 @@ meta_plugin_set_property (GObject *object,
case PROP_SCREEN: case PROP_SCREEN:
priv->screen = g_value_get_object (value); priv->screen = g_value_get_object (value);
break; break;
case PROP_PARAMS:
priv->params = g_value_dup_string (value);
meta_plugin_parse_params (META_PLUGIN (object));
break;
case PROP_DISABLED: case PROP_DISABLED:
priv->disabled = g_value_get_boolean (value); priv->disabled = g_value_get_boolean (value);
break; break;
@ -203,9 +140,6 @@ meta_plugin_get_property (GObject *object,
case PROP_SCREEN: case PROP_SCREEN:
g_value_set_object (value, priv->screen); g_value_set_object (value, priv->screen);
break; break;
case PROP_PARAMS:
g_value_set_string (value, priv->params);
break;
case PROP_DISABLED: case PROP_DISABLED:
g_value_set_boolean (value, priv->disabled); g_value_set_boolean (value, priv->disabled);
break; break;
@ -240,15 +174,6 @@ meta_plugin_class_init (MetaPluginClass *klass)
META_TYPE_SCREEN, META_TYPE_SCREEN,
G_PARAM_READWRITE)); G_PARAM_READWRITE));
g_object_class_install_property (gobject_class,
PROP_PARAMS,
g_param_spec_string ("params",
"Parameters",
"Plugin Parameters",
NULL,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT));
g_object_class_install_property (gobject_class, g_object_class_install_property (gobject_class,
PROP_FEATURES, PROP_FEATURES,
g_param_spec_ulong ("features", g_param_spec_ulong ("features",
@ -282,6 +207,8 @@ meta_plugin_init (MetaPlugin *self)
MetaPluginPrivate *priv; MetaPluginPrivate *priv;
self->priv = priv = META_PLUGIN_GET_PRIVATE (self); self->priv = priv = META_PLUGIN_GET_PRIVATE (self);
meta_plugin_set_features (self);
} }
gulong gulong

41
src/compositor/plugins/README
View File

@ -1,41 +0,0 @@
Plugins implement effects associated with WM events, such as window map,
minimizing, maximizing, unmaximizing, destruction and workspace switching. The
plugin API is documented in src/include/compositor-clutter-plugin.h; in
addition the simple plugin can be used as a reference implementation.
The API is intended to be generic, exposing no implementation details of the WM
to the plugins; this will facilitate reuse without modification with another WM
(there are plans to use the same plugin API with Matchbox 2).
Multiple plugins can implement the same effect and be loaded at the same time;
however, stacking arbitrary effects in this way might not work as expected;
this is particularly true of more complex effects, such as those for workspace
switching.
Plugins are installed in ${prefix}/lib/metacity/plugins/clutter; from there the
WM will load plugins listed in the clutter_plugins key in the Metacity gconf
general preferences group. Each entry in preferences has the format
'name: optional parameters'
where 'name' is the name of the library without the .so suffix.
As noted above, additional parameters can be passed to the plugin via the
preference key. In such case, the plugin name is immediately followed by a
colon, separating it from the parameters. Two common parameters should be
handled by all plugins:
'debug' indicates that the plugin is run in a debug mode (what exactly that
means is left to the plugin to determine).
'disable' parameter indicates which effects within the plugin should be
disabled; the format of the disable parameter is
'disable: effect1[, effect2];'
where effect1, etc., matches the effects listed in the
compositor-clutter-plugin.h file (currently one of 'map', 'destroy',
'maximize', 'unmaximize', 'switch-workspace'). Example 'disable:
minimize, maximize;'.

40
src/core/main.c
View File

@ -481,6 +481,7 @@ main (int argc, char **argv)
guint i; guint i;
GIOChannel *channel; GIOChannel *channel;
GOptionContext *ctx; GOptionContext *ctx;
MetaPluginManager *mgr;
if (!g_thread_supported ()) if (!g_thread_supported ())
g_thread_init (NULL); g_thread_init (NULL);
@ -536,12 +537,18 @@ main (int argc, char **argv)
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8"); bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE); textdomain (GETTEXT_PACKAGE);
#ifdef HAVE_INTROSPECTION
g_irepository_prepend_search_path (MUTTER_PKGLIBDIR);
#endif
/* Parse command line arguments.*/ /* Parse command line arguments.*/
ctx = meta_parse_options (&argc, &argv, &meta_args); ctx = meta_parse_options (&argc, &argv, &meta_args);
if (meta_args.print_version) if (meta_args.print_version)
version (); version ();
mgr = meta_plugin_manager_get_default ();
/* This must come before the introspect below, so we load all the plugins /* This must come before the introspect below, so we load all the plugins
* in order to get their get_type functions. * in order to get their get_type functions.
*/ */
@ -549,38 +556,20 @@ main (int argc, char **argv)
{ {
char **plugins = g_strsplit (meta_args.mutter_plugins, ",", -1); char **plugins = g_strsplit (meta_args.mutter_plugins, ",", -1);
char **plugin; char **plugin;
GSList *plugins_list = NULL;
for (plugin = plugins; *plugin; plugin++) for (plugin = plugins; *plugin; plugin++)
{ {
g_strstrip (*plugin); g_strstrip (*plugin);
plugins_list = g_slist_prepend (plugins_list, *plugin); meta_plugin_manager_load (mgr, *plugin);
} }
plugins_list = g_slist_reverse (plugins_list);
meta_prefs_override_clutter_plugins (plugins_list);
g_slist_free(plugins_list);
g_strfreev (plugins); g_strfreev (plugins);
} }
#ifdef HAVE_INTROSPECTION #ifdef HAVE_INTROSPECTION
g_irepository_prepend_search_path (MUTTER_PKGLIBDIR);
if (meta_args.introspect) if (meta_args.introspect)
{ {
GError *error = NULL; GError *error = NULL;
if (meta_args.mutter_plugins)
{
/* We need to load all plugins so that we can call their
* get_type functions. We do not call
* mutter_plugin_manager_initialize because almost nothing else
* is initialized at this point, and we don't plan to run any real
* plugin code.
*/
MetaPluginManager *mgr = meta_plugin_manager_get_default ();
if (!meta_plugin_manager_load (mgr))
g_critical ("failed to load plugins");
}
if (!g_irepository_dump (meta_args.introspect, &error)) if (!g_irepository_dump (meta_args.introspect, &error))
{ {
g_printerr ("failed to dump: %s\n", error->message); g_printerr ("failed to dump: %s\n", error->message);
@ -590,17 +579,6 @@ main (int argc, char **argv)
} }
#endif #endif
/* Early initialization for plugins comes before almost anything
else here */
{
MetaPluginManager *mgr = meta_plugin_manager_get_default ();
if (!meta_plugin_manager_load (mgr))
g_error ("failed to load plugins");
meta_plugin_manager_initialize_early (mgr);
}
meta_set_syncing (meta_args.sync || (g_getenv ("MUTTER_SYNC") != NULL)); meta_set_syncing (meta_args.sync || (g_getenv ("MUTTER_SYNC") != NULL));
meta_select_display (meta_args.display_name); meta_select_display (meta_args.display_name);

86
src/core/prefs.c
View File

@ -27,7 +27,6 @@
#include "prefs.h" #include "prefs.h"
#include "ui.h" #include "ui.h"
#include "util.h" #include "util.h"
#include "compositor/meta-plugin-manager.h"
#ifdef HAVE_GCONF #ifdef HAVE_GCONF
#include <gconf/gconf-client.h> #include <gconf/gconf-client.h>
#endif #endif
@ -66,8 +65,6 @@
#define KEY_WORKSPACE_NAME_DIRECTORY "/apps/metacity/workspace_names" #define KEY_WORKSPACE_NAME_DIRECTORY "/apps/metacity/workspace_names"
#define KEY_WORKSPACE_NAME_PREFIX "/apps/metacity/workspace_names/name_" #define KEY_WORKSPACE_NAME_PREFIX "/apps/metacity/workspace_names/name_"
#define KEY_CLUTTER_PLUGINS "/apps/mutter/general/clutter_plugins"
#define KEY_LIVE_HIDDEN_WINDOWS "/apps/mutter/general/live_hidden_windows" #define KEY_LIVE_HIDDEN_WINDOWS "/apps/mutter/general/live_hidden_windows"
#define KEY_NO_TAB_POPUP "/apps/metacity/general/no_tab_popup" #define KEY_NO_TAB_POPUP "/apps/metacity/general/no_tab_popup"
@ -115,9 +112,6 @@ static char *terminal_command = NULL;
static char *workspace_names[MAX_REASONABLE_WORKSPACES] = { NULL, }; static char *workspace_names[MAX_REASONABLE_WORKSPACES] = { NULL, };
static gboolean clutter_plugins_overridden = FALSE;
static GSList *clutter_plugins = NULL;
static gboolean live_hidden_windows = FALSE; static gboolean live_hidden_windows = FALSE;
static gboolean no_tab_popup = FALSE; static gboolean no_tab_popup = FALSE;
@ -1051,7 +1045,6 @@ meta_prefs_init (void)
#ifdef HAVE_GCONF #ifdef HAVE_GCONF
GError *err = NULL; GError *err = NULL;
gchar **gconf_dir_cursor; gchar **gconf_dir_cursor;
MetaPluginManager *plugin_manager;
if (default_client != NULL) if (default_client != NULL)
return; return;
@ -1070,19 +1063,6 @@ meta_prefs_init (void)
cleanup_error (&err); cleanup_error (&err);
} }
/* The plugin list is special and needs to be handled first */
if (!clutter_plugins_overridden)
clutter_plugins = gconf_client_get_list (default_client, KEY_CLUTTER_PLUGINS,
GCONF_VALUE_STRING, &err);
cleanup_error (&err);
/* We now initialize plugins so that they can override any preference locations */
plugin_manager = meta_plugin_manager_get_default ();
meta_plugin_manager_load (plugin_manager);
/* Pick up initial values. */ /* Pick up initial values. */
handle_preference_init_enum (); handle_preference_init_enum ();
@ -1396,23 +1376,6 @@ change_notify (GConfClient *client,
{ {
queue_changed (META_PREF_KEYBINDINGS); queue_changed (META_PREF_KEYBINDINGS);
} }
else if (g_str_equal (key, KEY_CLUTTER_PLUGINS) && !clutter_plugins_overridden)
{
GError *err = NULL;
GSList *l;
l = gconf_client_get_list (default_client, KEY_CLUTTER_PLUGINS,
GCONF_VALUE_STRING, &err);
if (!l)
{
cleanup_error (&err);
goto out;
}
clutter_plugins = l;
queue_changed (META_PREF_CLUTTER_PLUGINS);
}
else else
{ {
meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Mutter\n", meta_topic (META_DEBUG_PREFS, "Key %s doesn't mean anything to Mutter\n",
@ -2006,9 +1969,6 @@ meta_preference_to_string (MetaPreference pref)
case META_PREF_FORCE_FULLSCREEN: case META_PREF_FORCE_FULLSCREEN:
return "FORCE_FULLSCREEN"; return "FORCE_FULLSCREEN";
case META_PREF_CLUTTER_PLUGINS:
return "CLUTTER_PLUGINS";
case META_PREF_LIVE_HIDDEN_WINDOWS: case META_PREF_LIVE_HIDDEN_WINDOWS:
return "LIVE_HIDDEN_WINDOWS"; return "LIVE_HIDDEN_WINDOWS";
@ -3000,52 +2960,6 @@ meta_prefs_get_force_fullscreen (void)
return force_fullscreen; return force_fullscreen;
} }
/**
* meta_prefs_get_clutter_plugins:
*
* Returns: (transfer none) (element-type utf8): Plugin names to load
*/
GSList *
meta_prefs_get_clutter_plugins (void)
{
return clutter_plugins;
}
void
meta_prefs_set_clutter_plugins (GSList *list)
{
#ifdef HAVE_GCONF
GError *err = NULL;
gconf_client_set_list (default_client,
KEY_CLUTTER_PLUGINS,
GCONF_VALUE_STRING,
list,
&err);
if (err)
{
meta_warning (_("Error setting clutter plugin list: %s\n"),
err->message);
g_error_free (err);
}
#endif
}
void
meta_prefs_override_clutter_plugins (GSList *list)
{
GSList *l;
clutter_plugins_overridden = TRUE;
clutter_plugins = NULL;
for (l = list; l; l = l->next)
clutter_plugins = g_slist_prepend (clutter_plugins, g_strdup(l->data));
clutter_plugins = g_slist_reverse (clutter_plugins);
}
gboolean gboolean
meta_prefs_get_live_hidden_windows (void) meta_prefs_get_live_hidden_windows (void)
{ {

2
src/include/meta-plugin.h
View File

@ -64,8 +64,6 @@ struct _MetaPluginClass
{ {
GObjectClass parent_class; GObjectClass parent_class;
void (*early_initialize) (MetaPlugin *plugin);
void (*start) (MetaPlugin *plugin); void (*start) (MetaPlugin *plugin);
void (*minimize) (MetaPlugin *plugin, void (*minimize) (MetaPlugin *plugin,

18
src/include/prefs.h
View File

@ -61,7 +61,6 @@ typedef enum
META_PREF_RESIZE_WITH_RIGHT_BUTTON, META_PREF_RESIZE_WITH_RIGHT_BUTTON,
META_PREF_EDGE_TILING, META_PREF_EDGE_TILING,
META_PREF_FORCE_FULLSCREEN, META_PREF_FORCE_FULLSCREEN,
META_PREF_CLUTTER_PLUGINS,
META_PREF_LIVE_HIDDEN_WINDOWS, META_PREF_LIVE_HIDDEN_WINDOWS,
META_PREF_NO_TAB_POPUP META_PREF_NO_TAB_POPUP
} MetaPreference; } MetaPreference;
@ -134,23 +133,6 @@ void meta_prefs_set_compositing_manager (gboolean whether);
void meta_prefs_set_force_fullscreen (gboolean whether); void meta_prefs_set_force_fullscreen (gboolean whether);
GSList * meta_prefs_get_clutter_plugins (void);
/**
* Sets the list of plugins persistently in GConf
*
* \param list list of plugin:option pairs
*/
void meta_prefs_set_clutter_plugins (GSList *list);
/**
* Sets the list of plugins temporarily for this process. The value
* from GConf will be ignored.
*
* \param list list of plugin:option pairs
*/
void meta_prefs_override_clutter_plugins (GSList *list);
gboolean meta_prefs_get_live_hidden_windows (void); gboolean meta_prefs_get_live_hidden_windows (void);
void meta_prefs_set_live_hidden_windows (gboolean whether); void meta_prefs_set_live_hidden_windows (gboolean whether);

15
src/mutter.schemas.in
View File

@ -22,21 +22,6 @@
</locale> </locale>
</schema> </schema>
<schema>
<key>/schemas/apps/mutter/general/clutter_plugins</key>
<applyto>/apps/mutter/general/clutter_plugins</applyto>
<owner>mutter</owner>
<type>list</type>
<list_type>string</list_type>
<default>[default]</default>
<locale name="C">
<short>Clutter Plugins</short>
<long>
Plugins to load for the Clutter-based compositing manager.
</long>
</locale>
</schema>
<schema> <schema>
<key>/schemas/apps/mutter/general/attach_modal_dialogs</key> <key>/schemas/apps/mutter/general/attach_modal_dialogs</key>
<applyto>/apps/mutter/general/attach_modal_dialogs</applyto> <applyto>/apps/mutter/general/attach_modal_dialogs</applyto>