sungmg/mutter-performance-source
1
0
Fork 0
Code Activity

Passes through the plugin manager and default plugin trying to rename

Browse source 
terse variable names, simplify the plugin interface or consider tweaks
for maintainability.

* Renames plg -> plugin
* Renames mgr ->plugin_mgr (since in a combined window and composite
manager I think "mgr" will end up being ambiguous in places)
* Renames PluginWorkspaceRectangle -> MetaRectangle (We are no longer
concerned about mbwm2 portability)
* Renames a few one letter variable names e.g. a -> window, r ->rect
* Renames some vars to indicate what they represent not their data type,
e.g. group1, group2 ->workspace0, workspace1
* Renames the variable mcw -> mc_window to make it more immediately
obvious what it represents.
* Removes the verbose META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE macro,
and just uses metacity_plugin instead.
* Instead of hanging data of the plugins global descriptor, we just use a
standalone static global variable.
* Make do_init a function pointer inside the plugin descriptors instead of
special casing it and using another g_module_symbol call. This also removes
the need for the META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC macro.
* A bunch of anal 80char fixes
* Removes the screen_width,height variables from the plugin descriptor struct
and add a plugin API instead.
This commit is contained in:
Robert Bragg 2008-10-13 12:23:47 +01:00
parent 74b34fe239
commit c4fe54d004
3 changed files with 498 additions and 512 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

412
src/compositor/clutter/clutter-plugins/default.c
View file

@ -42,9 +42,7 @@
#define ACTOR_DATA_KEY "MCCP-Default-actor-data"
static GQuark actor_data_quark = 0;
typedef struct PluginPrivate PluginPrivate;
typedef struct ActorPrivate ActorPrivate;
static gboolean do_init (const char *params);
static void minimize (MetaCompWindow *actor);
static void map (MetaCompWindow *actor);
static void destroy (MetaCompWindow *actor);
@ -58,14 +56,15 @@ static void switch_workspace (const GList **actors, gint from, gint to,
static void kill_effect (MetaCompWindow *actor, gulong event);
static gboolean reload (void);
static gboolean reload (const char *params);
/*
* First we create the header struct and initialize its static members.
* Any dynamically allocated data should be initialized in the
* init () function below.
*/
MetaCompositorClutterPlugin META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT =
G_MODULE_EXPORT MetaCompositorClutterPlugin metacity_plugin =
{
/*
* These are predefined values; do not modify.
@ -78,6 +77,9 @@ MetaCompositorClutterPlugin META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT =
/* Human readable name (for use in UI) */
.name = "Default Effects",
/* Plugin load time initialiser */
.do_init = do_init,
/* Which types of events this plugin supports */
.features = META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE |
META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY |
@ -104,7 +106,7 @@ MetaCompositorClutterPlugin META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT =
/*
* Plugin private data that we store in the .plugin_private member.
*/
struct PluginPrivate
typedef struct _DefaultPluginState
{
ClutterEffectTemplate *destroy_effect;
ClutterEffectTemplate *minimize_effect;
@ -120,12 +122,12 @@ struct PluginPrivate
ClutterActor *desktop2;
gboolean debug_mode : 1;
};
} DefaultPluginState;
/*
* Per actor private data we attach to each actor.
*/
struct ActorPrivate
typedef struct _ActorPrivate
{
ClutterActor *orig_parent;
@ -136,7 +138,9 @@ struct ActorPrivate
gboolean is_minimized : 1;
gboolean is_maximized : 1;
};
} ActorPrivate;
static DefaultPluginState *plugin_state;
/*
* Actor private data accessor
@ -168,26 +172,18 @@ get_actor_private (MetaCompWindow *actor)
return priv;
}
static inline
MetaCompositorClutterPlugin *
get_plugin ()
{
return &META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT;
}
static void
on_switch_workspace_effect_complete (ClutterActor *group, gpointer data)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *ppriv = plugin->plugin_private;
GList *l = *((GList**)data);
MetaCompWindow *actor_for_cb = l->data;
DefaultPluginState *state = plugin_state;
GList *l = *((GList**)data);
MetaCompWindow *actor_for_cb = l->data;
while (l)
{
ClutterActor *a = l->data;
MetaCompWindow *mcw = META_COMP_WINDOW (a);
ActorPrivate *priv = get_actor_private (mcw);
MetaCompWindow *mc_window = META_COMP_WINDOW (a);
ActorPrivate *priv = get_actor_private (mc_window);
if (priv->orig_parent)
{
@ -198,16 +194,16 @@ on_switch_workspace_effect_complete (ClutterActor *group, gpointer data)
l = l->next;
}
clutter_actor_destroy (ppriv->desktop1);
clutter_actor_destroy (ppriv->desktop2);
clutter_actor_destroy (state->desktop1);
clutter_actor_destroy (state->desktop2);
ppriv->actors = NULL;
ppriv->tml_switch_workspace1 = NULL;
ppriv->tml_switch_workspace2 = NULL;
ppriv->desktop1 = NULL;
ppriv->desktop2 = NULL;
state->actors = NULL;
state->tml_switch_workspace1 = NULL;
state->tml_switch_workspace2 = NULL;
state->desktop1 = NULL;
state->desktop2 = NULL;
meta_comp_clutter_plugin_effect_completed (plugin, actor_for_cb,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, actor_for_cb,
META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE);
}
@ -215,33 +211,35 @@ static void
switch_workspace (const GList **actors, gint from, gint to,
MetaMotionDirection direction)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *ppriv = plugin->plugin_private;
MetaCompositorClutterPlugin *plugin = &metacity_plugin;
DefaultPluginState *state = plugin_state;
GList *l;
gint n_workspaces;
ClutterActor *group1 = clutter_group_new ();
ClutterActor *group2 = clutter_group_new ();
ClutterActor *workspace0 = clutter_group_new ();
ClutterActor *workspace1 = clutter_group_new ();
ClutterActor *stage;
int screen_width, screen_height;
stage = meta_comp_clutter_plugin_get_stage (plugin);
#if 1
clutter_actor_set_anchor_point (group2,
plugin->screen_width,
plugin->screen_height);
clutter_actor_set_position (group2,
plugin->screen_width,
plugin->screen_height);
#endif
meta_comp_clutter_plugin_query_screen_size (plugin,
&screen_width,
&screen_height);
clutter_actor_set_anchor_point (workspace1,
screen_width,
screen_height);
clutter_actor_set_position (workspace1,
screen_width,
screen_height);
clutter_actor_set_scale (group2, 0.0, 0.0);
clutter_actor_set_scale (workspace1, 0.0, 0.0);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group2);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), group1);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), workspace1);
clutter_container_add_actor (CLUTTER_CONTAINER (stage), workspace0);
if (from == to)
{
meta_comp_clutter_plugin_effect_completed (plugin, NULL,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, NULL,
META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE);
return;
}
@ -252,28 +250,29 @@ switch_workspace (const GList **actors, gint from, gint to,
while (l)
{
MetaCompWindow *mcw = l->data;
ActorPrivate *priv = get_actor_private (mcw);
ClutterActor *a = CLUTTER_ACTOR (mcw);
gint workspace;
MetaCompWindow *mc_window = l->data;
ActorPrivate *priv = get_actor_private (mc_window);
ClutterActor *window = CLUTTER_ACTOR (mc_window);
gint win_workspace;
workspace = meta_comp_window_get_workspace (mcw);
win_workspace = meta_comp_window_get_workspace (mc_window);
if (workspace == to || workspace == from)
if (win_workspace == to || win_workspace == from)
{
gint x, y;
guint w, h;
clutter_actor_get_position (a, &x, &y);
clutter_actor_get_size (a, &w, &h);
clutter_actor_get_position (window, &x, &y);
clutter_actor_get_size (window, &w, &h);
priv->orig_parent = clutter_actor_get_parent (a);
priv->orig_parent = clutter_actor_get_parent (window);
clutter_actor_reparent (a, workspace == to ? group2 : group1);
clutter_actor_show_all (a);
clutter_actor_raise_top (a);
clutter_actor_reparent (window,
win_workspace == to ? workspace1 : workspace0);
clutter_actor_show_all (window);
clutter_actor_raise_top (window);
}
else if (workspace < 0)
else if (win_workspace < 0)
{
/* Sticky window */
priv->orig_parent = NULL;
@ -281,27 +280,27 @@ switch_workspace (const GList **actors, gint from, gint to,
else
{
/* Window on some other desktop */
clutter_actor_hide (a);
clutter_actor_hide (window);
priv->orig_parent = NULL;
}
l = l->prev;
}
ppriv->actors = (GList **)actors;
ppriv->desktop1 = group1;
ppriv->desktop2 = group2;
state->actors = (GList **)actors;
state->desktop1 = workspace0;
state->desktop2 = workspace1;
ppriv->tml_switch_workspace2 = clutter_effect_scale (
ppriv->switch_workspace_effect,
group2, 1.0, 1.0,
on_switch_workspace_effect_complete,
(gpointer)actors);
state->tml_switch_workspace2 =
clutter_effect_scale (state->switch_workspace_effect,
workspace1, 1.0, 1.0,
on_switch_workspace_effect_complete,
(gpointer)actors);
ppriv->tml_switch_workspace1 = clutter_effect_scale (
ppriv->switch_workspace_effect,
group1, 0.0, 0.0,
NULL, NULL);
state->tml_switch_workspace1 =
clutter_effect_scale (state->switch_workspace_effect,
workspace0, 0.0, 0.0,
NULL, NULL);
}
@ -316,24 +315,24 @@ on_minimize_effect_complete (ClutterActor *actor, gpointer data)
* Must reverse the effect of the effect; must hide it first to ensure
* that the restoration will not be visible.
*/
MetaCompositorClutterPlugin *plugin = get_plugin ();
ActorPrivate *apriv;
MetaCompWindow *mcw = META_COMP_WINDOW (actor);
MetaCompWindow *mc_window = META_COMP_WINDOW (actor);
apriv = get_actor_private (META_COMP_WINDOW (actor));
apriv->tml_minimize = NULL;
clutter_actor_hide (actor);
/* FIXME - we shouldn't assume the original scale, it should be saved
* at the start of the effect */
clutter_actor_set_scale (actor, 1.0, 1.0);
clutter_actor_move_anchor_point_from_gravity (actor,
CLUTTER_GRAVITY_NORTH_WEST);
/* Decrease the running effect counter */
plugin->running--;
metacity_plugin.running--;
/* Now notify the manager that we are done with this effect */
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE);
}
@ -342,28 +341,26 @@ on_minimize_effect_complete (ClutterActor *actor, gpointer data)
* completion).
*/
static void
minimize (MetaCompWindow *mcw)
minimize (MetaCompWindow *mc_window)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *priv = plugin->plugin_private;
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mcw);
DefaultPluginState *state = plugin_state;
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mc_window);
type = meta_comp_window_get_window_type (mcw);
type = meta_comp_window_get_window_type (mc_window);
if (type == META_COMP_WINDOW_NORMAL)
{
ActorPrivate *apriv = get_actor_private (mcw);
ActorPrivate *apriv = get_actor_private (mc_window);
apriv->is_minimized = TRUE;
clutter_actor_move_anchor_point_from_gravity (actor,
CLUTTER_GRAVITY_CENTER);
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.running++;
metacity_plugin.running++;
apriv->tml_minimize = clutter_effect_scale (priv->minimize_effect,
apriv->tml_minimize = clutter_effect_scale (state->minimize_effect,
actor,
0.0,
0.0,
@ -372,7 +369,7 @@ minimize (MetaCompWindow *mcw)
NULL);
}
else
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE);
}
@ -386,21 +383,21 @@ on_maximize_effect_complete (ClutterActor *actor, gpointer data)
/*
* Must reverse the effect of the effect.
*/
MetaCompositorClutterPlugin *plugin = get_plugin ();
MetaCompWindow *mcw = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mcw);
MetaCompWindow *mc_window = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mc_window);
apriv->tml_maximize = NULL;
/* FIXME - don't assume the original scale was 1.0 */
clutter_actor_set_scale (actor, 1.0, 1.0);
clutter_actor_move_anchor_point_from_gravity (actor,
CLUTTER_GRAVITY_NORTH_WEST);
/* Decrease the running effect counter */
plugin->running--;
metacity_plugin.running--;
/* Now notify the manager that we are done with this effect */
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE);
}
@ -413,24 +410,22 @@ on_maximize_effect_complete (ClutterActor *actor, gpointer data)
* (Something like a sound would be more appropriate.)
*/
static void
maximize (MetaCompWindow *mcw,
maximize (MetaCompWindow *mc_window,
gint end_x, gint end_y, gint end_width, gint end_height)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *priv = plugin->plugin_private;
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mcw);
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mc_window);
gdouble scale_x = 1.0;
gdouble scale_y = 1.0;
gint anchor_x = 0;
gint anchor_y = 0;
type = meta_comp_window_get_window_type (mcw);
type = meta_comp_window_get_window_type (mc_window);
if (type == META_COMP_WINDOW_NORMAL)
{
ActorPrivate *apriv = get_actor_private (mcw);
ActorPrivate *apriv = get_actor_private (mc_window);
guint width, height;
gint x, y;
@ -453,18 +448,19 @@ maximize (MetaCompWindow *mcw,
clutter_actor_move_anchor_point (actor, anchor_x, anchor_y);
apriv->tml_maximize = clutter_effect_scale (priv->maximize_effect,
actor,
scale_x,
scale_y,
(ClutterEffectCompleteFunc)
on_maximize_effect_complete,
NULL);
apriv->tml_maximize =
clutter_effect_scale (plugin_state->maximize_effect,
actor,
scale_x,
scale_y,
(ClutterEffectCompleteFunc)
on_maximize_effect_complete,
NULL);
return;
}
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE);
}
@ -474,23 +470,20 @@ maximize (MetaCompWindow *mcw,
* (Just a skeleton code.)
*/
static void
unmaximize (MetaCompWindow *mcw,
unmaximize (MetaCompWindow *mc_window,
gint end_x, gint end_y, gint end_width, gint end_height)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
MetaCompWindowType type;
type = meta_comp_window_get_window_type (mcw);
MetaCompWindowType type = meta_comp_window_get_window_type (mc_window);
if (type == META_COMP_WINDOW_NORMAL)
{
ActorPrivate *apriv = get_actor_private (mcw);
ActorPrivate *apriv = get_actor_private (mc_window);
apriv->is_maximized = FALSE;
}
/* Do this conditionally, if the effect requires completion callback. */
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE);
}
@ -500,9 +493,8 @@ on_map_effect_complete (ClutterActor *actor, gpointer data)
/*
* Must reverse the effect of the effect.
*/
MetaCompositorClutterPlugin *plugin = get_plugin ();
MetaCompWindow *mcw = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mcw);
MetaCompWindow *mc_window = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mc_window);
apriv->tml_map = NULL;
@ -510,10 +502,10 @@ on_map_effect_complete (ClutterActor *actor, gpointer data)
CLUTTER_GRAVITY_NORTH_WEST);
/* Decrease the running effect counter */
plugin->running--;
metacity_plugin.running--;
/* Now notify the manager that we are done with this effect */
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MAP);
}
@ -522,28 +514,26 @@ on_map_effect_complete (ClutterActor *actor, gpointer data)
* completion).
*/
static void
map (MetaCompWindow *mcw)
map (MetaCompWindow *mc_window)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *priv = plugin->plugin_private;
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mcw);
ClutterActor *actor = CLUTTER_ACTOR (mc_window);
type = meta_comp_window_get_window_type (mcw);
type = meta_comp_window_get_window_type (mc_window);
if (type == META_COMP_WINDOW_NORMAL)
{
ActorPrivate *apriv = get_actor_private (mcw);
ActorPrivate *apriv = get_actor_private (mc_window);
clutter_actor_move_anchor_point_from_gravity (actor,
CLUTTER_GRAVITY_CENTER);
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.running++;
metacity_plugin.running++;
clutter_actor_set_scale (actor, 0.0, 0.0);
clutter_actor_show (actor);
apriv->tml_map = clutter_effect_scale (priv->map_effect,
apriv->tml_map = clutter_effect_scale (plugin_state->map_effect,
actor,
1.0,
1.0,
@ -555,7 +545,7 @@ map (MetaCompWindow *mcw)
}
else
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_MAP);
}
@ -567,15 +557,15 @@ map (MetaCompWindow *mcw)
static void
on_destroy_effect_complete (ClutterActor *actor, gpointer data)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
MetaCompWindow *mcw = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mcw);
MetaCompositorClutterPlugin *plugin = &metacity_plugin;
MetaCompWindow *mc_window = META_COMP_WINDOW (actor);
ActorPrivate *apriv = get_actor_private (mc_window);
apriv->tml_destroy = NULL;
plugin->running--;
metacity_plugin.running--;
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY);
}
@ -583,25 +573,23 @@ on_destroy_effect_complete (ClutterActor *actor, gpointer data)
* Simple TV-out like effect.
*/
static void
destroy (MetaCompWindow *mcw)
destroy (MetaCompWindow *mc_window)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
PluginPrivate *priv = plugin->plugin_private;
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mcw);
MetaCompWindowType type;
ClutterActor *actor = CLUTTER_ACTOR (mc_window);
type = meta_comp_window_get_window_type (mcw);
type = meta_comp_window_get_window_type (mc_window);
if (type == META_COMP_WINDOW_NORMAL)
{
ActorPrivate *apriv = get_actor_private (mcw);
ActorPrivate *apriv = get_actor_private (mc_window);
clutter_actor_move_anchor_point_from_gravity (actor,
CLUTTER_GRAVITY_CENTER);
plugin->running++;
metacity_plugin.running++;
apriv->tml_destroy = clutter_effect_scale (priv->destroy_effect,
apriv->tml_destroy = clutter_effect_scale (plugin_state->destroy_effect,
actor,
1.0,
0.0,
@ -610,16 +598,16 @@ destroy (MetaCompWindow *mcw)
NULL);
}
else
meta_comp_clutter_plugin_effect_completed (plugin, mcw,
meta_comp_clutter_plugin_effect_completed (&metacity_plugin, mc_window,
META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY);
}
static void
kill_effect (MetaCompWindow *mcw, gulong event)
kill_effect (MetaCompWindow *mc_window, gulong event)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
MetaCompositorClutterPlugin *plugin = &metacity_plugin;
ActorPrivate *apriv;
ClutterActor *actor = CLUTTER_ACTOR (mcw);
ClutterActor *actor = CLUTTER_ACTOR (mc_window);
if (!(plugin->features & event))
{
@ -629,13 +617,13 @@ kill_effect (MetaCompWindow *mcw, gulong event)
if (event & META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE)
{
PluginPrivate *ppriv = plugin->plugin_private;
DefaultPluginState *state = plugin_state;
if (ppriv->tml_switch_workspace1)
if (state->tml_switch_workspace1)
{
clutter_timeline_stop (ppriv->tml_switch_workspace1);
clutter_timeline_stop (ppriv->tml_switch_workspace2);
on_switch_workspace_effect_complete (ppriv->desktop1, ppriv->actors);
clutter_timeline_stop (state->tml_switch_workspace1);
clutter_timeline_stop (state->tml_switch_workspace2);
on_switch_workspace_effect_complete (state->desktop1, state->actors);
}
if (!(event & ~META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE))
@ -645,7 +633,7 @@ kill_effect (MetaCompWindow *mcw, gulong event)
}
}
apriv = get_actor_private (mcw);
apriv = get_actor_private (mc_window);
if ((event & META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE) && apriv->tml_minimize)
{
@ -694,36 +682,23 @@ g_module_check_init (GModule *module)
* by the reload() function. Returns TRUE on success.
*/
static gboolean
do_init ()
do_init (const char *params)
{
MetaCompositorClutterPlugin *plugin = get_plugin ();
guint destroy_timeout = DESTROY_TIMEOUT;
guint minimize_timeout = MINIMIZE_TIMEOUT;
guint maximize_timeout = MAXIMIZE_TIMEOUT;
guint map_timeout = MAP_TIMEOUT;
guint switch_timeout = SWITCH_TIMEOUT;
PluginPrivate *priv = g_new0 (PluginPrivate, 1);
const gchar *params;
guint destroy_timeout = DESTROY_TIMEOUT;
guint minimize_timeout = MINIMIZE_TIMEOUT;
guint maximize_timeout = MAXIMIZE_TIMEOUT;
guint map_timeout = MAP_TIMEOUT;
guint switch_timeout = SWITCH_TIMEOUT;
const gchar *name;
plugin->plugin_private = priv;
name = plugin->name;
plugin->name = _(name);
params = plugin->params;
plugin_state = g_new0 (DefaultPluginState, 1);
if (params)
{
gchar *p;
if (strstr (params, "debug"))
{
g_debug ("%s: Entering debug mode.",
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.name);
g_debug ("%s: Entering debug mode.", metacity_plugin.name);
priv->debug_mode = TRUE;
plugin_state->debug_mode = TRUE;
/*
* Double the effect duration to make them easier to observe.
@ -734,60 +709,30 @@ do_init ()
map_timeout *= 2;
switch_timeout *= 2;
}
if ((p = strstr (params, "disable:")))
{
gchar *d = g_strdup (p+8);
p = strchr (d, ';');
if (p)
*p = 0;
if (strstr (d, "minimize"))
plugin->features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE;
if (strstr (d, "maximize"))
plugin->features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE;
if (strstr (d, "unmaximize"))
plugin->features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE;
if (strstr (d, "map"))
plugin->features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MAP;
if (strstr (d, "destroy"))
plugin->features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY;
if (strstr (d, "switch-workspace"))
plugin->features &= ~META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE;
g_free (d);
}
}
priv->destroy_effect
plugin_state->destroy_effect
= clutter_effect_template_new (clutter_timeline_new_for_duration (
destroy_timeout),
CLUTTER_ALPHA_SINE_INC);
priv->minimize_effect
plugin_state->minimize_effect
= clutter_effect_template_new (clutter_timeline_new_for_duration (
minimize_timeout),
CLUTTER_ALPHA_SINE_INC);
priv->maximize_effect
plugin_state->maximize_effect
= clutter_effect_template_new (clutter_timeline_new_for_duration (
maximize_timeout),
CLUTTER_ALPHA_SINE_INC);
priv->map_effect
plugin_state->map_effect
= clutter_effect_template_new (clutter_timeline_new_for_duration (
map_timeout),
CLUTTER_ALPHA_SINE_INC);
priv->switch_workspace_effect
plugin_state->switch_workspace_effect
= clutter_effect_template_new (clutter_timeline_new_for_duration (
switch_timeout),
CLUTTER_ALPHA_SINE_INC);
@ -795,22 +740,15 @@ do_init ()
return TRUE;
}
META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC
{
return do_init ();
}
static void
free_plugin_private (PluginPrivate *priv)
free_plugin_private (DefaultPluginState *state)
{
g_object_unref (priv->destroy_effect);
g_object_unref (priv->minimize_effect);
g_object_unref (priv->maximize_effect);
g_object_unref (priv->switch_workspace_effect);
g_object_unref (state->destroy_effect);
g_object_unref (state->minimize_effect);
g_object_unref (state->maximize_effect);
g_object_unref (state->switch_workspace_effect);
g_free (priv);
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.plugin_private = NULL;
g_free (state);
}
/*
@ -818,22 +756,22 @@ free_plugin_private (PluginPrivate *priv)
* changed.
*/
static gboolean
reload ()
reload (const char *params)
{
PluginPrivate *priv;
DefaultPluginState *state;
priv = META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.plugin_private;
state = plugin_state;
if (do_init ())
if (do_init (params))
{
/* Success; free the old private struct */
free_plugin_private (priv);
/* Success; free the old state */
free_plugin_private (plugin_state);
return TRUE;
}
else
{
/* Fail -- fall back to the old private. */
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.plugin_private = priv;
/* Fail -- fall back to the old state. */
plugin_state = state;
}
return FALSE;
@ -842,12 +780,10 @@ reload ()
/*
* GModule unload function -- do any cleanup required.
*/
void g_module_unload (GModule *module);
void g_module_unload (GModule *module)
G_MODULE_EXPORT void g_module_unload (GModule *module);
G_MODULE_EXPORT void
g_module_unload (GModule *module)
{
PluginPrivate *priv;
priv = META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT.plugin_private;
free_plugin_private (priv);
free_plugin_private (plugin_state);
}

440
src/compositor/clutter/compositor-clutter-plugin-manager.c
View file

@ -30,7 +30,8 @@
#include <gmodule.h>
#include <string.h>
static gboolean meta_compositor_clutter_plugin_manager_reload (MetaCompositorClutterPluginManager *mgr);
static gboolean meta_compositor_clutter_plugin_manager_reload (
MetaCompositorClutterPluginManager *plugin_mgr);
struct MetaCompositorClutterPluginManager
{
@ -42,23 +43,23 @@ struct MetaCompositorClutterPluginManager
guint idle_unload_id;
};
typedef struct MetaCompositorClutterPluginPrivate MetaCompositorClutterPluginPrivate;
struct MetaCompositorClutterPluginPrivate
typedef struct MetaCompositorClutterPluginPrivate
{
char *name;
MetaCompositorClutterPluginManager *self;
GModule *module;
gulong features;
gboolean disabled : 1;
};
} MetaCompositorClutterPluginPrivate;
static void
free_plugin_workspaces (MetaCompositorClutterPlugin *plg)
free_plugin_workspaces (MetaCompositorClutterPlugin *plugin)
{
GList *l;
l = plg->work_areas;
l = plugin->work_areas;
while (l)
{
@ -66,21 +67,21 @@ free_plugin_workspaces (MetaCompositorClutterPlugin *plg)
l = l->next;
}
if (plg->work_areas)
g_list_free (plg->work_areas);
if (plugin->work_areas)
g_list_free (plugin->work_areas);
plg->work_areas = NULL;
plugin->work_areas = NULL;
}
/*
* Gets work area geometry and stores it in list in the plugin.
*
* If the plg list is already populated, we simply replace it (we are dealing
* with a small number of items in the list and unfrequent changes).
* If the plugin list is already populated, we simply replace it (we are
* dealing with a small number of items in the list and unfrequent changes).
*/
static void
update_plugin_workspaces (MetaScreen *screen,
MetaCompositorClutterPlugin *plg)
MetaCompositorClutterPlugin *plugin)
{
GList *l, *l2 = NULL;
@ -89,9 +90,9 @@ update_plugin_workspaces (MetaScreen *screen,
while (l)
{
MetaWorkspace *w = l->data;
PluginWorkspaceRectangle *r;
MetaRectangle *r;
r = g_new0 (PluginWorkspaceRectangle, 1);
r = g_new0 (MetaRectangle, 1);
meta_workspace_get_work_area_all_xineramas (w, (MetaRectangle*)r);
@ -100,9 +101,57 @@ update_plugin_workspaces (MetaScreen *screen,
l = l->next;
}
free_plugin_workspaces (plg);
free_plugin_workspaces (plugin);
plg->work_areas = l2;
plugin->work_areas = l2;
}
/**
* parse_disable_params:
* @params: as read from gconf, a ':' seperated list of plugin options
* @features: The mask of features the plugin advertises
*
* This function returns a new mask of features removing anything that
* the user has disabled.
*/
static gulong
parse_disable_params (const char *params, gulong features)
{
char *p;
if (!params)
return features;
if ((p = strstr (params, "disable:")))
{
gchar *d = g_strdup (p+8);
p = strchr (d, ';');
if (p)
*p = 0;
if (strstr (d, "minimize"))
features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE;
if (strstr (d, "maximize"))
features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE;
if (strstr (d, "unmaximize"))
features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE;
if (strstr (d, "map"))
features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_MAP;
if (strstr (d, "destroy"))
features &= ~ META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY;
if (strstr (d, "switch-workspace"))
features &= ~META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE;
g_free (d);
}
return features;
}
/*
@ -110,51 +159,48 @@ update_plugin_workspaces (MetaScreen *screen,
* struct.
*/
static MetaCompositorClutterPlugin *
meta_compositor_clutter_plugin_load (MetaCompositorClutterPluginManager *mgr,
GModule *module,
const gchar *params)
meta_compositor_clutter_plugin_load (
MetaCompositorClutterPluginManager *plugin_mgr,
GModule *module,
const gchar *params)
{
MetaCompositorClutterPlugin *plg;
MetaCompositorClutterPlugin *plugin;
if (g_module_symbol (module,
META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT_NAME,
(gpointer *)&plg))
if (g_module_symbol (module, "metacity_plugin", (gpointer *)&plugin))
{
if (plg->version_api == METACITY_CLUTTER_PLUGIN_API_VERSION)
if (plugin->version_api == METACITY_CLUTTER_PLUGIN_API_VERSION)
{
MetaCompositorClutterPluginPrivate *priv;
gboolean (*init_func) (void);
priv = g_new0 (MetaCompositorClutterPluginPrivate, 1);
plg->params = g_strdup (params);
plg->manager_private = priv;
priv->module = module;
priv->self = mgr;
priv = g_new0 (MetaCompositorClutterPluginPrivate, 1);
priv->name = _(plugin->name);
priv->module = module;
priv->self = plugin_mgr;
meta_screen_get_size (mgr->screen,
&plg->screen_width, &plg->screen_height);
/* FIXME: instead of hanging private data of the plugin descriptor
* we could make the descriptor const if we were to hang it off
* a plugin manager structure */
plugin->manager_private = priv;
update_plugin_workspaces (mgr->screen, plg);
update_plugin_workspaces (plugin_mgr->screen, plugin);
priv->features = parse_disable_params (params, plugin->features);
/*
* Check for and run the plugin init function.
*/
if (g_module_symbol (module,
META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC_NAME,
(gpointer *)&init_func) &&
!init_func())
if (!plugin->do_init || !(plugin->do_init (params)))
{
g_free (plg->params);
g_free (priv);
free_plugin_workspaces (plg);
free_plugin_workspaces (plugin);
return NULL;
}
meta_verbose ("Loaded plugin [%s]\n", plg->name);
meta_verbose ("Loaded plugin [%s]\n", priv->name);
return plg;
return plugin;
}
}
@ -167,25 +213,22 @@ meta_compositor_clutter_plugin_load (MetaCompositorClutterPluginManager *mgr,
* removal later.
*/
static gboolean
meta_compositor_clutter_plugin_unload (MetaCompositorClutterPlugin *plg)
meta_compositor_clutter_plugin_unload (MetaCompositorClutterPlugin *plugin)
{
MetaCompositorClutterPluginPrivate *priv;
GModule *module;
priv = plg->manager_private;
priv = plugin->manager_private;
module = priv->module;
if (plg->running)
if (plugin->running)
{
priv->disabled = TRUE;
return FALSE;
}
g_free (plg->params);
plg->params = NULL;
g_free (priv);
plg->manager_private = NULL;
plugin->manager_private = NULL;
g_module_close (module);
@ -197,23 +240,24 @@ meta_compositor_clutter_plugin_unload (MetaCompositorClutterPlugin *plg)
* pending for removal.
*/
static gboolean
meta_compositor_clutter_plugin_manager_idle_unload (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_idle_unload (
MetaCompositorClutterPluginManager *plugin_mgr)
{
GList *l = mgr->unload;
GList *l = plugin_mgr->unload;
gboolean dont_remove = TRUE;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPlugin *plugin = l->data;
if (meta_compositor_clutter_plugin_unload (plg))
if (meta_compositor_clutter_plugin_unload (plugin))
{
/* Remove from list */
GList *p = l->prev;
GList *n = l->next;
if (!p)
mgr->unload = n;
plugin_mgr->unload = n;
else
p->next = n;
@ -228,11 +272,11 @@ meta_compositor_clutter_plugin_manager_idle_unload (MetaCompositorClutterPluginM
l = l->next;
}
if (!mgr->unload)
if (!plugin_mgr->unload)
{
/* If no more unloads are pending, remove the handler as well */
dont_remove = FALSE;
mgr->idle_unload_id = 0;
plugin_mgr->idle_unload_id = 0;
}
return dont_remove;
@ -242,47 +286,48 @@ meta_compositor_clutter_plugin_manager_idle_unload (MetaCompositorClutterPluginM
* Unloads all plugins
*/
static void
meta_compositor_clutter_plugin_manager_unload (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_unload (
MetaCompositorClutterPluginManager *plugin_mgr)
{
GList *plugins = mgr->plugins;
GList *plugins = plugin_mgr->plugins;
while (plugins)
{
MetaCompositorClutterPlugin *plg = plugins->data;
MetaCompositorClutterPlugin *plugin = plugins->data;
/* If the plugin could not be removed, move it to the unload list */
if (!meta_compositor_clutter_plugin_unload (plg))
if (!meta_compositor_clutter_plugin_unload (plugin))
{
mgr->unload = g_list_prepend (mgr->unload, plg);
plugin_mgr->unload = g_list_prepend (plugin_mgr->unload, plugin);
if (!mgr->idle_unload_id)
if (!plugin_mgr->idle_unload_id)
{
mgr->idle_unload_id = g_idle_add ((GSourceFunc)
plugin_mgr->idle_unload_id = g_idle_add ((GSourceFunc)
meta_compositor_clutter_plugin_manager_idle_unload,
mgr);
plugin_mgr);
}
}
plugins = plugins->next;
}
g_list_free (mgr->plugins);
mgr->plugins = NULL;
g_list_free (plugin_mgr->plugins);
plugin_mgr->plugins = NULL;
}
static void
prefs_changed_callback (MetaPreference pref,
void *data)
{
MetaCompositorClutterPluginManager *mgr = data;
MetaCompositorClutterPluginManager *plugin_mgr = data;
if (pref == META_PREF_CLUTTER_PLUGINS)
{
meta_compositor_clutter_plugin_manager_reload (mgr);
meta_compositor_clutter_plugin_manager_reload (plugin_mgr);
}
else if (pref == META_PREF_NUM_WORKSPACES)
{
meta_compositor_clutter_plugin_manager_update_workspaces (mgr);
meta_compositor_clutter_plugin_manager_update_workspaces (plugin_mgr);
}
}
@ -290,7 +335,8 @@ prefs_changed_callback (MetaPreference pref,
* Loads all plugins listed in gconf registry.
*/
static gboolean
meta_compositor_clutter_plugin_manager_load (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_load (
MetaCompositorClutterPluginManager *plugin_mgr)
{
const gchar *dpath = METACITY_PKGLIBDIR "/plugins/clutter/";
GSList *plugins, *fallback = NULL;
@ -308,17 +354,17 @@ meta_compositor_clutter_plugin_manager_load (MetaCompositorClutterPluginManager
while (plugins)
{
gchar *plg_string;
gchar *plugin_string;
gchar *params;
plg_string = g_strdup (plugins->data);
plugin_string = g_strdup (plugins->data);
if (plg_string)
if (plugin_string)
{
GModule *plg;
GModule *plugin;
gchar *path;
params = strchr (plg_string, ':');
params = strchr (plugin_string, ':');
if (params)
{
@ -326,26 +372,26 @@ meta_compositor_clutter_plugin_manager_load (MetaCompositorClutterPluginManager
++params;
}
path = g_strconcat (dpath, plg_string, ".so", NULL);
path = g_strconcat (dpath, plugin_string, ".so", NULL);
if ((plg = g_module_open (path, 0)))
if ((plugin = g_module_open (path, 0)))
{
MetaCompositorClutterPlugin *p;
if ((p = meta_compositor_clutter_plugin_load (mgr,
plg, params)))
mgr->plugins = g_list_prepend (mgr->plugins, p);
if ((p = meta_compositor_clutter_plugin_load (plugin_mgr,
plugin, params)))
plugin_mgr->plugins = g_list_prepend (plugin_mgr->plugins, p);
else
{
g_message ("Plugin load for [%s] failed\n", path);
g_module_close (plg);
g_module_close (plugin);
}
}
else
g_message ("Unable to load plugin [%s]\n", path);
g_free (path);
g_free (plg_string);
g_free (plugin_string);
}
plugins = plugins->next;
@ -355,9 +401,9 @@ meta_compositor_clutter_plugin_manager_load (MetaCompositorClutterPluginManager
if (fallback)
g_slist_free (fallback);
if (mgr->plugins != NULL)
if (plugin_mgr->plugins != NULL)
{
meta_prefs_add_listener (prefs_changed_callback, mgr);
meta_prefs_add_listener (prefs_changed_callback, plugin_mgr);
return TRUE;
}
@ -368,44 +414,47 @@ meta_compositor_clutter_plugin_manager_load (MetaCompositorClutterPluginManager
* Reloads all plugins
*/
static gboolean
meta_compositor_clutter_plugin_manager_reload (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_reload (
MetaCompositorClutterPluginManager *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.
*/
meta_compositor_clutter_plugin_manager_unload (mgr);
return meta_compositor_clutter_plugin_manager_load (mgr);
meta_compositor_clutter_plugin_manager_unload (plugin_mgr);
return meta_compositor_clutter_plugin_manager_load (plugin_mgr);
}
static gboolean
meta_compositor_clutter_plugin_manager_init (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_init (
MetaCompositorClutterPluginManager *plugin_mgr)
{
return meta_compositor_clutter_plugin_manager_load (mgr);
return meta_compositor_clutter_plugin_manager_load (plugin_mgr);
}
void
meta_compositor_clutter_plugin_manager_update_workspace (MetaCompositorClutterPluginManager *mgr, MetaWorkspace *w)
meta_compositor_clutter_plugin_manager_update_workspace (
MetaCompositorClutterPluginManager *plugin_mgr, MetaWorkspace *workspace)
{
GList *l;
gint n;
gint index;
n = meta_workspace_index (w);
l = mgr->plugins;
index = meta_workspace_index (workspace);
l = plugin_mgr->plugins;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
PluginWorkspaceRectangle *r = g_list_nth_data (plg->work_areas, n);
MetaCompositorClutterPlugin *plugin = l->data;
MetaRectangle *rect = g_list_nth_data (plugin->work_areas, index);
if (r)
if (rect)
{
meta_workspace_get_work_area_all_xineramas (w, (MetaRectangle*)r);
meta_workspace_get_work_area_all_xineramas (workspace, rect);
}
else
{
/* Something not entirely right; redo the whole thing */
update_plugin_workspaces (mgr->screen, plg);
update_plugin_workspaces (plugin_mgr->screen, plugin);
return;
}
@ -414,16 +463,17 @@ meta_compositor_clutter_plugin_manager_update_workspace (MetaCompositorClutterPl
}
void
meta_compositor_clutter_plugin_manager_update_workspaces (MetaCompositorClutterPluginManager *mgr)
meta_compositor_clutter_plugin_manager_update_workspaces (
MetaCompositorClutterPluginManager *plugin_mgr)
{
GList *l;
l = mgr->plugins;
l = plugin_mgr->plugins;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPlugin *plugin = l->data;
update_plugin_workspaces (mgr->screen, plg);
update_plugin_workspaces (plugin_mgr->screen, plugin);
l = l->next;
}
@ -432,35 +482,38 @@ meta_compositor_clutter_plugin_manager_update_workspaces (MetaCompositorClutterP
MetaCompositorClutterPluginManager *
meta_compositor_clutter_plugin_manager_new (MetaScreen *screen)
{
MetaCompositorClutterPluginManager *mgr;
MetaCompositorClutterPluginManager *plugin_mgr;
mgr = g_new0 (MetaCompositorClutterPluginManager, 1);
plugin_mgr = g_new0 (MetaCompositorClutterPluginManager, 1);
mgr->screen = screen;
plugin_mgr->screen = screen;
if (!meta_compositor_clutter_plugin_manager_init (mgr))
if (!meta_compositor_clutter_plugin_manager_init (plugin_mgr))
{
g_free (mgr);
mgr = NULL;
g_free (plugin_mgr);
plugin_mgr = NULL;
}
return mgr;
return plugin_mgr;
}
static void
meta_compositor_clutter_plugin_manager_kill_effect (MetaCompositorClutterPluginManager *mgr,
MetaCompWindow *actor,
unsigned long events)
meta_compositor_clutter_plugin_manager_kill_effect (
MetaCompositorClutterPluginManager *plugin_mgr,
MetaCompWindow *actor,
unsigned long events)
{
GList *l = mgr->plugins;
GList *l = plugin_mgr->plugins;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPluginPrivate *priv = plg->manager_private;
MetaCompositorClutterPlugin *plugin = l->data;
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
if (!priv->disabled && (plg->features & events) && plg->kill_effect)
plg->kill_effect (actor, events);
if (!priv->disabled
&& (plugin->features & events)
&& plugin->kill_effect)
plugin->kill_effect (actor, events);
l = l->next;
}
@ -479,46 +532,51 @@ meta_compositor_clutter_plugin_manager_kill_effect (MetaCompositorClutterPluginM
* appropriate post-effect cleanup is carried out.
*/
gboolean
meta_compositor_clutter_plugin_manager_event_simple (MetaCompositorClutterPluginManager *mgr,
MetaCompWindow *actor,
unsigned long event)
meta_compositor_clutter_plugin_manager_event_simple (
MetaCompositorClutterPluginManager *plugin_mgr,
MetaCompWindow *actor,
unsigned long event)
{
GList *l = mgr->plugins;
GList *l = plugin_mgr->plugins;
gboolean retval = FALSE;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPluginPrivate *priv = plg->manager_private;
MetaCompositorClutterPlugin *plugin = l->data;
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
if (!priv->disabled && (plg->features & event))
if (!priv->disabled && (plugin->features & event))
{
retval = TRUE;
switch (event)
{
case META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE:
if (plg->minimize)
if (plugin->minimize)
{
meta_compositor_clutter_plugin_manager_kill_effect (mgr,
actor,
ALL_BUT_SWITCH);
plg->minimize (actor);
meta_compositor_clutter_plugin_manager_kill_effect (
plugin_mgr,
actor,
ALL_BUT_SWITCH);
plugin->minimize (actor);
}
break;
case META_COMPOSITOR_CLUTTER_PLUGIN_MAP:
if (plg->map)
if (plugin->map)
{
meta_compositor_clutter_plugin_manager_kill_effect (mgr,
actor,
ALL_BUT_SWITCH);
plg->map (actor);
meta_compositor_clutter_plugin_manager_kill_effect (
plugin_mgr,
actor,
ALL_BUT_SWITCH);
plugin->map (actor);
}
break;
case META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY:
if (plg->destroy)
if (plugin->destroy)
{
plg->destroy (actor);
plugin->destroy (actor);
}
break;
default:
@ -542,46 +600,50 @@ meta_compositor_clutter_plugin_manager_event_simple (MetaCompositorClutterPlugin
* appropriate post-effect cleanup is carried out.
*/
gboolean
meta_compositor_clutter_plugin_manager_event_maximize (MetaCompositorClutterPluginManager *mgr,
MetaCompWindow *actor,
unsigned long event,
gint target_x,
gint target_y,
gint target_width,
gint target_height)
meta_compositor_clutter_plugin_manager_event_maximize (
MetaCompositorClutterPluginManager *plugin_mgr,
MetaCompWindow *actor,
unsigned long event,
gint target_x,
gint target_y,
gint target_width,
gint target_height)
{
GList *l = mgr->plugins;
GList *l = plugin_mgr->plugins;
gboolean retval = FALSE;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPluginPrivate *priv = plg->manager_private;
MetaCompositorClutterPlugin *plugin = l->data;
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
if (!priv->disabled && (plg->features & event))
if (!priv->disabled && (plugin->features & event))
{
retval = TRUE;
switch (event)
{
case META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE:
if (plg->maximize)
if (plugin->maximize)
{
meta_compositor_clutter_plugin_manager_kill_effect (mgr,
actor,
ALL_BUT_SWITCH);
plg->maximize (actor,
meta_compositor_clutter_plugin_manager_kill_effect (
plugin_mgr,
actor,
ALL_BUT_SWITCH);
plugin->maximize (actor,
target_x, target_y,
target_width, target_height);
}
break;
case META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE:
if (plg->unmaximize)
if (plugin->unmaximize)
{
meta_compositor_clutter_plugin_manager_kill_effect (mgr,
actor,
ALL_BUT_SWITCH);
plg->unmaximize (actor,
meta_compositor_clutter_plugin_manager_kill_effect (
plugin_mgr,
actor,
ALL_BUT_SWITCH);
plugin->unmaximize (actor,
target_x, target_y,
target_width, target_height);
}
@ -606,31 +668,34 @@ meta_compositor_clutter_plugin_manager_event_maximize (MetaCompositorClutterPlug
* appropriate post-effect cleanup is carried out.
*/
gboolean
meta_compositor_clutter_plugin_manager_switch_workspace (MetaCompositorClutterPluginManager *mgr,
const GList **actors,
gint from,
gint to,
MetaMotionDirection direction)
meta_compositor_clutter_plugin_manager_switch_workspace (
MetaCompositorClutterPluginManager *plugin_mgr,
const GList **actors,
gint from,
gint to,
MetaMotionDirection direction)
{
GList *l = mgr->plugins;
GList *l = plugin_mgr->plugins;
gboolean retval = FALSE;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPluginPrivate *priv = plg->manager_private;
MetaCompositorClutterPlugin *plugin = l->data;
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
if (!priv->disabled &&
(plg->features & META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE) &&
(plugin->features & META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE) &&
(actors && *actors))
{
if (plg->switch_workspace)
if (plugin->switch_workspace)
{
retval = TRUE;
meta_compositor_clutter_plugin_manager_kill_effect (mgr,
META_COMP_WINDOW ((*actors)->data),
META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE);
plg->switch_workspace (actors, from, to, direction);
meta_compositor_clutter_plugin_manager_kill_effect (
plugin_mgr,
META_COMP_WINDOW ((*actors)->data),
META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE);
plugin->switch_workspace (actors, from, to, direction);
}
}
@ -649,23 +714,23 @@ meta_compositor_clutter_plugin_manager_switch_workspace (MetaCompositorClutterPl
* appropriate post-effect cleanup is carried out.
*/
gboolean
meta_compositor_clutter_plugin_manager_xevent_filter
(MetaCompositorClutterPluginManager *mgr, XEvent *xev)
meta_compositor_clutter_plugin_manager_xevent_filter (
MetaCompositorClutterPluginManager *plugin_mgr, XEvent *xev)
{
GList *l;
if (!mgr)
if (!plugin_mgr)
return FALSE;
l = mgr->plugins;
l = plugin_mgr->plugins;
while (l)
{
MetaCompositorClutterPlugin *plg = l->data;
MetaCompositorClutterPlugin *plugin = l->data;
if (plg->xevent_filter)
if (plugin->xevent_filter)
{
if (plg->xevent_filter (xev) == TRUE)
if (plugin->xevent_filter (xev) == TRUE)
return TRUE;
}
@ -682,18 +747,18 @@ ClutterActor *
meta_comp_clutter_plugin_get_overlay_group (MetaCompositorClutterPlugin *plugin)
{
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
MetaCompositorClutterPluginManager *mgr = priv->self;
MetaCompositorClutterPluginManager *plugin_mgr = priv->self;
return meta_compositor_clutter_get_overlay_group_for_screen (mgr->screen);
return meta_compositor_clutter_get_overlay_group_for_screen (plugin_mgr->screen);
}
ClutterActor *
meta_comp_clutter_plugin_get_stage (MetaCompositorClutterPlugin *plugin)
{
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
MetaCompositorClutterPluginManager *mgr = priv->self;
MetaCompositorClutterPluginManager *plugin_mgr = priv->self;
return meta_compositor_clutter_get_stage_for_screen (mgr->screen);
return meta_compositor_clutter_get_stage_for_screen (plugin_mgr->screen);
}
void
@ -710,3 +775,14 @@ meta_comp_clutter_plugin_effect_completed (MetaCompositorClutterPlugin *plugin,
meta_compositor_clutter_window_effect_completed (actor, event);
}
void
meta_comp_clutter_plugin_query_screen_size (MetaCompositorClutterPlugin *plugin,
int *width,
int *height)
{
MetaCompositorClutterPluginPrivate *priv = plugin->manager_private;
MetaCompositorClutterPluginManager *plugin_mgr = priv->self;
meta_screen_get_size (plugin_mgr->screen, width, height);
}

158
src/include/compositor-clutter-plugin.h
View file

@ -34,65 +34,27 @@
/*
* This file defines the plugin API.
*
* Effects plugin is shared library loaded via dlopen(); it is recommended
* that the GModule API is used (otherwise you are on your own to do proper
* plugin clean up when the module is unloaded).
* Effects plugin is shared library loaded via g_module_open(); it is
* recommended that the GModule API is used (otherwise you are on your own to
* do proper plugin clean up when the module is unloaded).
*
* The plugin interface is exported via the MetaCompositorClutterPlugin struct.
*/
/*
* Alias MetaRectangle to PluginWorkspaceRectangle in anticipation of
* making this file metacity-independent (we want the plugins to be portable
* between different WMs.
*/
typedef MetaRectangle PluginWorkspaceRectangle;
/*
* The name of the header struct; use as:
*
* MetaCompositorClutterPlugin META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT =
* {
* ...
* };
*
* See clutter-plugins/simple.c for example code.
*/
#define META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT MCCPS__
/*
* Definition for the plugin init function; use as:
*
* META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC
* {
* init code ...
* }
*
* See clutter-plugins/simple.c for example code.
*/
#define META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC \
gboolean mccp_init__(void); \
gboolean mccp_init__()
/* Private; must match the above */
#define META_COMPOSITOR_CLUTTER_PLUGIN_STRUCT_NAME "MCCPS__"
#define META_COMPOSITOR_CLUTTER_PLUGIN_INIT_FUNC_NAME "mccp_init__"
typedef struct MetaCompositorClutterPlugin MetaCompositorClutterPlugin;
/*
* Feature flags: identify events that the plugin can handle; a plugin can
* handle one or more events.
*/
#define META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE 0x00000001UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE 0x00000002UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE 0x00000004UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_MAP 0x00000008UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY 0x00000010UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE 0x00000020UL
#define META_COMPOSITOR_CLUTTER_PLUGIN_MINIMIZE (1<<0)
#define META_COMPOSITOR_CLUTTER_PLUGIN_MAXIMIZE (1<<1)
#define META_COMPOSITOR_CLUTTER_PLUGIN_UNMAXIMIZE (1<<2)
#define META_COMPOSITOR_CLUTTER_PLUGIN_MAP (1<<3)
#define META_COMPOSITOR_CLUTTER_PLUGIN_DESTROY (1<<4)
#define META_COMPOSITOR_CLUTTER_PLUGIN_SWITCH_WORKSPACE (1<<5)
#define META_COMPOSITOR_CLUTTER_PLUGIN_ALL_EFFECTS 0xffffffffUL
#define META_COMPOSITOR_CLUTTER_PLUGIN_ALL_EFFECTS (~0)
struct MetaCompositorClutterPlugin
{
@ -117,6 +79,47 @@ struct MetaCompositorClutterPlugin
#endif
gchar *name; /* Human-readable name for UI */
gulong features; /* or-ed feature flags */
/*
* This function is called once the plugin has been loaded.
*
* @params is a string containing additional parameters for the plugin and is
* specified after the plugin name in the gconf database, separated by a
* colon.
*
* The following parameter tokens need to be handled by all
* plugins:
*
* 'debug'
* Indicates running in debug mode; the plugin
* might want to print useful debug info, or
* extend effect duration, etc.
*
* 'disable: ...;'
*
* The disable token indicates that the effects
* listed after the colon should be disabled.
*
* The list is comma-separated, terminated by a
* semicolon and consisting of the following
* tokens:
*
* minimize
* maximize
* unmaximize
* map
* destroy
* switch-workspace
*
* FIXME: ^^^ Instead of configuring in terms of what should be
* disabled, and needing a mechanism for coping with the user
* mistakenly not disabling the right things, it might be neater
* if plugins were enabled on a per effect basis in the first
* place. I.e. in gconf we could have effect:plugin key value
* pairs.
*/
gboolean (*do_init) (const char *params);
/*
* Event handlers
@ -153,6 +156,7 @@ struct MetaCompositorClutterPlugin
* Each actor in the list has a workspace number attached to it using
* g_object_set_data() with key META_COMPOSITOR_CLUTTER_PLUGIN_WORKSPACE_KEY;
* workspace < 0 indicates the window is sticky (i.e., on all desktops).
* TODO: Add accessor for sticky bit in new MetaCompWindow structure
*/
void (*switch_workspace) (const GList **actors,
gint from,
@ -168,58 +172,22 @@ struct MetaCompositorClutterPlugin
void (*kill_effect) (MetaCompWindow *actor,
gulong events);
/*
* The plugin manager will call this function when module should be reloaded.
* This happens, for example, when the parameters for the plugin changed.
*/
gboolean (*reload) (void);
gboolean (*reload) (const char *params);
/* General XEvent filter. This is fired *before* metacity itself handles
* an event. Return TRUE to block any further processing.
*/
*/
gboolean (*xevent_filter) (XEvent *event);
#ifdef META_COMPOSITOR_CLUTTER_BUILDING_PLUGIN
const
#endif
gchar *params; /* String containing additional parameters for the plugin;
* this is specified after the pluing name in the gconf
* database, separated by a colon.
*
* The following parameter tokens need to be handled by all
* plugins:
*
* 'debug'
* Indicates running in debug mode; the plugin
* might want to print useful debug info, or
* extend effect duration, etc.
*
* 'disable: ...;'
*
* The disable token indicates that the effects
* listed after the colon should be disabled.
*
* The list is comma-separated, terminated by a
* semicolon and consisting of the following
* tokens:
*
* minimize
* maximize
* unmaximize
* map
* destroy
* switch-workspace
*/
gint screen_width;
gint screen_height;
GList *work_areas; /* List of PluginWorkspaceRectangles defining the
* geometry of individual workspaces.
*/
/* List of PluginWorkspaceRectangles defining the geometry of individual
* workspaces. */
GList *work_areas;
/* FIXME: It should be possible to hide this from plugins */
gint running; /* Plugin must increase this counter for each effect it starts
* decrease it again once the effect finishes.
*/
@ -243,4 +211,10 @@ meta_comp_clutter_plugin_get_overlay_group (MetaCompositorClutterPlugin *plugin)
ClutterActor *
meta_comp_clutter_plugin_get_stage (MetaCompositorClutterPlugin *plugin);
#endif
void
meta_comp_clutter_plugin_query_screen_size (MetaCompositorClutterPlugin *plugin,
int *width,
int *height);
#endif /* META_COMPOSITOR_CLUTTER_PLUGIN_H_ */