Merge lp:~smspillaz/compiz-core/compiz-core.drop-legacy-2 into lp:compiz-core/0.9.5

[Sam Spilsbury]

Drop /legacy

[Tim Penhey (thumper)]

Sounds fine.

review: Approve

=== removed directory 'legacy'
=== removed file 'legacy/compiz-cube.h'
--- legacy/compiz-cube.h	2009-03-15 23:00:03 +0000
+++ legacy/compiz-cube.h	1970-01-01 00:00:00 +0000
@@ -1,230 +0,0 @@
-/*
- * Copyright © 2007 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Novell, Inc. not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Novell, Inc. makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Author: David Reveman <[e-mail]>
- */
-
-#ifndef _COMPIZ_CUBE_H
-#define _COMPIZ_CUBE_H
-
-#include <compiz-core.h>
-
-COMPIZ_BEGIN_DECLS
-
-#define CUBE_ABIVERSION 20080424
-
-typedef struct _CubeCore {
-    SetOptionForPluginProc setOptionForPlugin;
-} CubeCore;
-
-#define CUBE_MOMODE_AUTO  0
-#define CUBE_MOMODE_MULTI 1
-#define CUBE_MOMODE_ONE   2
-#define CUBE_MOMODE_LAST  CUBE_MOMODE_ONE
-
-#define CUBE_DISPLAY_OPTION_ABI        0
-#define CUBE_DISPLAY_OPTION_INDEX      1
-#define CUBE_DISPLAY_OPTION_UNFOLD_KEY 2
-#define CUBE_DISPLAY_OPTION_NEXT_KEY   3
-#define CUBE_DISPLAY_OPTION_PREV_KEY   4
-#define CUBE_DISPLAY_OPTION_NUM        5
-
-typedef struct _CubeDisplay {
-    int	screenPrivateIndex;
-
-    CompOption opt[CUBE_DISPLAY_OPTION_NUM];
-} CubeDisplay;
-
-#define CUBE_SCREEN_OPTION_COLOR	           0
-#define CUBE_SCREEN_OPTION_IN		           1
-#define CUBE_SCREEN_OPTION_SCALE_IMAGE	           2
-#define CUBE_SCREEN_OPTION_IMAGES	           3
-#define CUBE_SCREEN_OPTION_SKYDOME	           4
-#define CUBE_SCREEN_OPTION_SKYDOME_IMG	           5
-#define CUBE_SCREEN_OPTION_SKYDOME_ANIM	           6
-#define CUBE_SCREEN_OPTION_SKYDOME_GRAD_START      7
-#define CUBE_SCREEN_OPTION_SKYDOME_GRAD_END        8
-#define CUBE_SCREEN_OPTION_ACCELERATION	           9
-#define CUBE_SCREEN_OPTION_SPEED	           10
-#define CUBE_SCREEN_OPTION_TIMESTEP	           11
-#define CUBE_SCREEN_OPTION_MIPMAP	           12
-#define CUBE_SCREEN_OPTION_ADJUST_IMAGE	           13
-#define CUBE_SCREEN_OPTION_ACTIVE_OPACITY          14
-#define CUBE_SCREEN_OPTION_INACTIVE_OPACITY        15
-#define CUBE_SCREEN_OPTION_TRANSPARENT_MANUAL_ONLY 16
-#define CUBE_SCREEN_OPTION_MULTIOUTPUT_MODE        17
-#define CUBE_SCREEN_OPTION_NUM                     18
-
-typedef enum _PaintOrder {
-    BTF = 0,
-    FTB
-} PaintOrder;
-
-typedef enum _RotationState {
-    RotationNone = 0,
-    RotationChange,
-    RotationManual
-} RotationState;
-
-typedef void (*CubeGetRotationProc) (CompScreen *s,
-				     float      *x,
-				     float      *v,
-				     float      *progress);
-
-typedef void (*CubeClearTargetOutputProc) (CompScreen *s,
-					   float      xRotate,
-					   float      vRotate);
-
-typedef void (*CubePaintTopProc) (CompScreen			*s,
-				  const ScreenPaintAttrib	*sAttrib,
-				  const CompTransform		*transform,
-				  CompOutput			*output,
-				  int				size);
-
-typedef void (*CubePaintBottomProc) (CompScreen			*s,
-				     const ScreenPaintAttrib	*sAttrib,
-				     const CompTransform	*transform,
-				     CompOutput			*output,
-				     int			size);
-
-typedef void (*CubePaintInsideProc) (CompScreen			*s,
-				     const ScreenPaintAttrib	*sAttrib,
-				     const CompTransform	*transform,
-				     CompOutput			*output,
-				     int			size);
-
-typedef Bool (*CubeCheckOrientationProc) (CompScreen              *s,
-					  const ScreenPaintAttrib *sAttrib,
-					  const CompTransform     *transform,
-					  CompOutput              *output,
-					  CompVector              *points);
-
-typedef void (*CubePaintViewportProc) (CompScreen              *s,
-				       const ScreenPaintAttrib *sAttrib,
-				       const CompTransform     *transform,
-				       Region                  region,
-				       CompOutput              *output,
-				       unsigned int            mask);
-
-typedef Bool (*CubeShouldPaintViewportProc) (CompScreen              *s,
-					     const ScreenPaintAttrib *sAttrib,
-					     const CompTransform     *transform,
-					     CompOutput              *output,
-					     PaintOrder              order);
-
-typedef struct _CubeScreen {
-    PreparePaintScreenProc       preparePaintScreen;
-    DonePaintScreenProc	         donePaintScreen;
-    PaintScreenProc		 paintScreen;
-    PaintOutputProc	         paintOutput;
-    PaintTransformedOutputProc   paintTransformedOutput;
-    EnableOutputClippingProc     enableOutputClipping;
-    PaintWindowProc              paintWindow;
-    ApplyScreenTransformProc     applyScreenTransform;
-    OutputChangeNotifyProc       outputChangeNotify;
-    InitWindowWalkerProc         initWindowWalker;
-
-    CubeGetRotationProc	         getRotation;
-    CubeClearTargetOutputProc    clearTargetOutput;
-    CubePaintTopProc             paintTop;
-    CubePaintBottomProc          paintBottom;
-    CubePaintInsideProc          paintInside;
-    CubeCheckOrientationProc     checkOrientation;
-    CubePaintViewportProc        paintViewport;
-    CubeShouldPaintViewportProc  shouldPaintViewport;
-
-    CompOption opt[CUBE_SCREEN_OPTION_NUM];
-
-    int       invert;
-    int       xRotations;
-    PaintOrder paintOrder;
-
-    RotationState rotationState;
-
-    Bool paintAllViewports;
-
-    GLfloat  distance;
-    GLushort color[3];
-    GLfloat  tc[12];
-
-    int grabIndex;
-
-    int srcOutput;
-
-    Bool    unfolded;
-    GLfloat unfold, unfoldVelocity;
-
-    GLfloat  *vertices;
-    int      nVertices;
-
-    GLuint skyListId;
-
-    int		 pw, ph;
-    unsigned int skyW, skyH;
-    CompTexture  texture, sky;
-
-    int	imgCurFile;
-
-    int nOutput;
-    int output[64];
-    int outputMask[64];
-
-    Bool cleared[64];
-
-    Bool capsPainted[64];
-
-    Bool fullscreenOutput;
-
-    float outputXScale;
-    float outputYScale;
-    float outputXOffset;
-    float outputYOffset;
-
-    float desktopOpacity;
-    float toOpacity;
-    int   lastOpacityIndex;
-
-    int  moMode;
-    Bool recalcOutput;
-} CubeScreen;
-
-#define GET_CUBE_CORE(c)					\
-    ((CubeCore *) (c)->base.privates[cubeCorePrivateIndex].ptr)
-
-#define CUBE_CORE(c)		     \
-    CubeCore *cc = GET_CUBE_CORE (c)
-
-#define GET_CUBE_DISPLAY(d)					      \
-    ((CubeDisplay *) (d)->base.privates[cubeDisplayPrivateIndex].ptr)
-
-#define CUBE_DISPLAY(d)			   \
-    CubeDisplay *cd = GET_CUBE_DISPLAY (d)
-
-#define GET_CUBE_SCREEN(s, cd)					      \
-    ((CubeScreen *) (s)->base.privates[(cd)->screenPrivateIndex].ptr)
-
-#define CUBE_SCREEN(s)							\
-    CubeScreen *cs = GET_CUBE_SCREEN (s, GET_CUBE_DISPLAY (s->display))
-
-COMPIZ_END_DECLS
-
-#endif

=== removed file 'legacy/compiz-cube.pc.in'
--- legacy/compiz-cube.pc.in	2009-03-15 05:15:26 +0000
+++ legacy/compiz-cube.pc.in	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-prefix=@prefix@
-exec_prefix=@exec_prefix@
-libdir=@libdir@
-includedir=@includedir@
-
-Name: compiz-cube
-Description: Cube plugin for compiz
-Version: @VERSION@
-
-Requires: compiz
-Libs:
-Cflags: @COMPIZ_CFLAGS@ @GL_CFLAGS@ -I${includedir}/compiz
-

=== removed file 'legacy/fs.xml.in'
--- legacy/fs.xml.in	2009-03-15 05:15:26 +0000
+++ legacy/fs.xml.in	1970-01-01 00:00:00 +0000
@@ -1,13 +0,0 @@
-<compiz>
-    <plugin name="fs">
-	<_short>Userspace File System</_short>
-	<_long>Userspace file system</_long>
-	<display>
-	    <option name="mount_point" type="string">
-		<_short>Mount Point</_short>
-		<_long>Mount point</_long>
-		<default>compiz</default>
-	    </option>
-	</display>
-    </plugin>
-</compiz>

=== removed file 'legacy/fuse.cpp'
--- legacy/fuse.cpp	2009-03-15 05:15:26 +0000
+++ legacy/fuse.cpp	1970-01-01 00:00:00 +0000
@@ -1,1442 +0,0 @@
-/*
- * Copyright © 2007 David Reveman
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * David Reveman not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * David Reveman makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Author: David Reveman <[e-mail]>
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include <poll.h>
-#include <signal.h>
-#include <sys/mount.h>
-#include <fuse.h>
-#include <fuse_lowlevel.h>
-
-#include <compiz-core.h>
-
-static CompMetadata fuseMetadata;
-
-#define FUSE_INODE_TYPE_ROOT        (1 << 0)
-#define FUSE_INODE_TYPE_PLUGIN      (1 << 1)
-#define FUSE_INODE_TYPE_SCREEN      (1 << 2)
-#define FUSE_INODE_TYPE_DISPLAY     (1 << 3)
-#define FUSE_INODE_TYPE_OPTION      (1 << 4)
-#define FUSE_INODE_TYPE_TYPE        (1 << 5)
-#define FUSE_INODE_TYPE_VALUE       (1 << 6)
-#define FUSE_INODE_TYPE_ITEM_COUNT  (1 << 7)
-#define FUSE_INODE_TYPE_ITEM_TYPE   (1 << 8)
-#define FUSE_INODE_TYPE_ITEMS       (1 << 9)
-#define FUSE_INODE_TYPE_ITEM_VALUE  (1 << 10)
-#define FUSE_INODE_TYPE_MIN         (1 << 11)
-#define FUSE_INODE_TYPE_MAX         (1 << 12)
-#define FUSE_INODE_TYPE_PRECISION   (1 << 13)
-
-#define DIR_MASK (FUSE_INODE_TYPE_ROOT    | \
-		  FUSE_INODE_TYPE_PLUGIN  | \
-		  FUSE_INODE_TYPE_SCREEN  | \
-		  FUSE_INODE_TYPE_DISPLAY | \
-		  FUSE_INODE_TYPE_OPTION  | \
-		  FUSE_INODE_TYPE_ITEMS)
-
-#define CONST_DIR_MASK (FUSE_INODE_TYPE_PLUGIN  | \
-			FUSE_INODE_TYPE_SCREEN  | \
-			FUSE_INODE_TYPE_DISPLAY | \
-			FUSE_INODE_TYPE_OPTION)
-
-#define WRITE_MASK (FUSE_INODE_TYPE_VALUE | \
-		    FUSE_INODE_TYPE_ITEM_VALUE)
-
-#define FUSE_INODE_FLAG_TRUNC (1 << 0)
-
-typedef struct _FuseInode {
-    struct _FuseInode *parent;
-    struct _FuseInode *child;
-    struct _FuseInode *sibling;
-
-    int	       type;
-    int	       flags;
-    fuse_ino_t ino;
-    char       *name;
-} FuseInode;
-
-typedef struct _FuseWriteBuffer {
-    char *data;
-    int  size;
-    Bool dirty;
-} FuseWriteBuffer;
-
-static int displayPrivateIndex;
-
-#define FUSE_DISPLAY_OPTION_MOUNT_POINT 0
-#define FUSE_DISPLAY_OPTION_NUM		1
-
-typedef struct _FuseDisplay {
-    CompOption opt[FUSE_DISPLAY_OPTION_NUM];
-
-    struct fuse_session *session;
-    struct fuse_chan    *channel;
-    char		*mountPoint;
-    CompWatchFdHandle   watchFdHandle;
-    char		*buffer;
-} FuseDisplay;
-
-#define GET_FUSE_DISPLAY(d)					  \
-    ((FuseDisplay *) (d)->base.privates[displayPrivateIndex].ptr)
-
-#define FUSE_DISPLAY(d)			   \
-    FuseDisplay *fd = GET_FUSE_DISPLAY (d)
-
-#define NUM_OPTIONS(d) (sizeof ((d)->opt) / sizeof (CompOption))
-
-static fuse_ino_t nextIno = 1;
-static FuseInode  *inodes = NULL;
-
-static FuseInode *
-fuseAddInode (FuseInode	 *parent,
-	      int	 type,
-	      const char *name)
-{
-    FuseInode *inode;
-
-    inode = malloc (sizeof (FuseInode));
-    if (!inode)
-	return NULL;
-
-    inode->parent  = parent;
-    inode->sibling = NULL;
-    inode->child   = NULL;
-    inode->type    = type;
-    inode->flags   = 0;
-    inode->ino     = nextIno++;
-    inode->name	   = strdup (name);
-
-    if (parent)
-    {
-	if (parent->child)
-	    inode->sibling = parent->child;
-
-	parent->child = inode;
-    }
-
-    return inode;
-}
-
-static void
-fuseRemoveInode (FuseInode *parent,
-		 FuseInode *inode)
-{
-    while (inode->child)
-	fuseRemoveInode (inode, inode->child);
-
-    if (parent)
-    {
-	FuseInode *s, *prev = NULL;
-
-	for (s = parent->child; s; s = s->sibling)
-	{
-	    if (s == inode)
-		break;
-
-	    prev = s;
-	}
-
-	if (prev)
-	    prev->sibling = inode->sibling;
-	else
-	    parent->child = NULL;
-    }
-
-    if (inode->name)
-	free (inode->name);
-
-    free (inode);
-}
-
-static FuseInode *
-fuseFindInode (FuseInode  *inode,
-	       fuse_ino_t ino,
-	       int	  mask)
-{
-    if (inode->ino != ino)
-    {
-	FuseInode *c = inode->child;
-
-	inode = NULL;
-	while (c)
-	{
-	    inode = fuseFindInode (c, ino, ~0);
-	    if (inode)
-		break;
-
-	    c = c->sibling;
-	}
-    }
-
-    if (inode && (inode->type & mask))
-	return inode;
-
-    return NULL;
-}
-
-static FuseInode *
-fuseLookupChild (FuseInode  *inode,
-		 const char *name)
-{
-    FuseInode *c;
-
-    for (c = inode->child; c; c = c->sibling)
-	if (strcmp (c->name, name) == 0)
-	    return c;
-
-    return NULL;
-}
-
-/* MULTIDPYERROR: only works with one or less displays present */
-/* OBJECTOPTION: only display and screen options are supported */
-static CompObject *
-fuseGetObjectFromInode (FuseInode *inode)
-{
-    CompObject *object;
-
-    object = compObjectFind (&core.base, COMP_OBJECT_TYPE_DISPLAY, NULL);
-    if (!object)
-	return NULL;
-
-    if (inode->type & FUSE_INODE_TYPE_SCREEN)
-    {
-	return compObjectFind (object, COMP_OBJECT_TYPE_SCREEN,
-			       inode->name + 6);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_DISPLAY)
-    {
-	return object;
-    }
-
-    return NULL;
-}
-
-static CompOption *
-fuseGetOptionsFromInode (CompObject *object,
-			 FuseInode  *inode,
-			 int	    *nOption)
-{
-    CompOption *option = NULL;
-
-    if (inode->type & FUSE_INODE_TYPE_PLUGIN)
-    {
-	CompPlugin *p;
-
-	p = findActivePlugin (inode->name);
-	if (p && p->vTable->getObjectOptions)
-	    option = (*p->vTable->getObjectOptions) (p, object, nOption);
-    }
-
-    return option;
-}
-
-static CompOption *
-fuseGetOptionFromInode (FuseInode *inode)
-{
-    if (inode->type & (FUSE_INODE_TYPE_OPTION |
-		       FUSE_INODE_TYPE_ITEMS))
-    {
-	CompObject *object;
-	CompOption *option;
-	int	   nOption;
-
-	if (inode->type & FUSE_INODE_TYPE_ITEMS)
-	    inode = inode->parent;
-
-	object = fuseGetObjectFromInode (inode);
-	if (!object)
-	    return NULL;
-
-	option = fuseGetOptionsFromInode (object, inode->parent, &nOption);
-	if (option)
-	{
-	    while (nOption--)
-	    {
-		if (strcmp (inode->name, option->name) == 0)
-		    return option;
-
-		option++;
-	    }
-	}
-    }
-
-    return NULL;
-}
-
-/* MULTIDPYERROR: only works with one or less displays present */
-static char *
-fuseGetStringFromInode (FuseInode *inode)
-{
-    CompOption *option;
-    char       str[256];
-
-    if (!inode->parent)
-	return NULL;
-
-    option = fuseGetOptionFromInode (inode->parent);
-    if (!option)
-	return NULL;
-
-    if (inode->flags & FUSE_INODE_FLAG_TRUNC)
-	return strdup ("");
-
-    if (inode->type & FUSE_INODE_TYPE_TYPE)
-    {
-	return strdup (optionTypeToString (option->type));
-    }
-    else if (inode->type & (FUSE_INODE_TYPE_VALUE | FUSE_INODE_TYPE_ITEM_VALUE))
-    {
-	CompOptionValue *value = NULL;
-	CompOptionType  type;
-
-	if (inode->type & FUSE_INODE_TYPE_ITEM_VALUE)
-	{
-	    int i;
-
-	    if (sscanf (inode->name, "value%d", &i))
-	    {
-		if (i < option->value.list.nValue)
-		{
-		    value = &option->value.list.value[i];
-		    type  = option->value.list.type;
-		}
-	    }
-	}
-	else
-	{
-	    value = &option->value;
-	    type  = option->type;
-	}
-
-	if (value)
-	{
-	    switch (type) {
-	    case CompOptionTypeBool:
-		return strdup (value->b ? "true" : "false");
-	    case CompOptionTypeInt:
-		snprintf (str, 256, "%d", value->i);
-		return strdup (str);
-	    case CompOptionTypeFloat:
-		snprintf (str, 256, "%f", value->f);
-		return strdup (str);
-	    case CompOptionTypeString:
-		return strdup (value->s);
-	    case CompOptionTypeColor:
-		return colorToString (value->c);
-	    case CompOptionTypeKey:
-		if (core.displays)
-		    return keyActionToString (core.displays, &value->action);
-	    case CompOptionTypeButton:
-		if (core.displays)
-		    return buttonActionToString (core.displays,
-						 &value->action);
-	    case CompOptionTypeEdge:
-		return edgeMaskToString (value->action.edgeMask);
-	    case CompOptionTypeBell:
-		return strdup (value->action.bell ? "true" : "false");
-	    case CompOptionTypeMatch:
-		return matchToString (&value->match);
-	    default:
-		break;
-	    }
-	}
-    }
-    else if (inode->type & FUSE_INODE_TYPE_MIN)
-    {
-	if (option->type == CompOptionTypeInt)
-	    snprintf (str, 256, "%d", option->rest.i.min);
-	else
-	    snprintf (str, 256, "%f", option->rest.f.min);
-
-	return strdup (str);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_MAX)
-    {
-	if (option->type == CompOptionTypeInt)
-	    snprintf (str, 256, "%d", option->rest.i.max);
-	else
-	    snprintf (str, 256, "%f", option->rest.f.max);
-
-	return strdup (str);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_PRECISION)
-    {
-	snprintf (str, 256, "%f", option->rest.f.precision);
-	return strdup (str);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_ITEM_COUNT)
-    {
-	snprintf (str, 256, "%d", option->value.list.nValue);
-	return strdup (str);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_ITEM_TYPE)
-    {
-	return strdup (optionTypeToString (option->value.list.type));
-    }
-
-    return NULL;
-}
-
-static void
-fuseUpdateInode (CompDisplay *d,
-		 FuseInode   *inode)
-{
-    CompScreen *s;
-    CompPlugin *p;
-    CompOption *option;
-    char       str[256];
-
-    if (inode->type & FUSE_INODE_TYPE_ROOT)
-    {
-	FuseInode *c;
-
-	for (c = inode->child; c; c = c->sibling)
-	{
-	    if (!findActivePlugin (c->name))
-		fuseRemoveInode (inode, c);
-	}
-
-	for (p = getPlugins (); p; p = p->next)
-	    if (!fuseLookupChild (inode, p->vTable->name))
-		fuseAddInode (inode, FUSE_INODE_TYPE_PLUGIN,
-			      p->vTable->name);
-    }
-    else if (inode->type & FUSE_INODE_TYPE_PLUGIN)
-    {
-	int n;
-
-	if (fuseGetOptionsFromInode (&d->base, inode, &n))
-	    fuseAddInode (inode, FUSE_INODE_TYPE_DISPLAY, "allscreens");
-
-	for (s = d->screens; s; s = s->next)
-	{
-	    if (fuseGetOptionsFromInode (&s->base, inode, &n))
-	    {
-		sprintf (str, "screen%d", s->screenNum);
-		fuseAddInode (inode, FUSE_INODE_TYPE_SCREEN, str);
-	    }
-	}
-    }
-    else if (inode->type & (FUSE_INODE_TYPE_DISPLAY | FUSE_INODE_TYPE_SCREEN))
-    {
-	CompObject *object;
-
-	object = fuseGetObjectFromInode (inode);
-	if (object)
-	{
-	    int nOption;
-
-	    option = fuseGetOptionsFromInode (object, inode->parent, &nOption);
-	    if (option)
-	    {
-		while (nOption--)
-		{
-		    fuseAddInode (inode, FUSE_INODE_TYPE_OPTION, option->name);
-
-		    option++;
-		}
-	    }
-	}
-    }
-    else if (inode->type & FUSE_INODE_TYPE_OPTION)
-    {
-	option = fuseGetOptionFromInode (inode);
-	if (option)
-	{
-	    fuseAddInode (inode, FUSE_INODE_TYPE_TYPE, "type");
-
-	    switch (option->type) {
-	    case CompOptionTypeFloat:
-		fuseAddInode (inode, FUSE_INODE_TYPE_PRECISION, "precision");
-		/* fall-through */
-	    case CompOptionTypeInt:
-		fuseAddInode (inode, FUSE_INODE_TYPE_MIN, "min");
-		fuseAddInode (inode, FUSE_INODE_TYPE_MAX, "max");
-		/* fall-through */
-	    case CompOptionTypeBool:
-	    case CompOptionTypeString:
-	    case CompOptionTypeColor:
-	    case CompOptionTypeKey:
-	    case CompOptionTypeButton:
-	    case CompOptionTypeEdge:
-	    case CompOptionTypeBell:
-	    case CompOptionTypeMatch:
-		fuseAddInode (inode, FUSE_INODE_TYPE_VALUE, "value");
-		break;
-	    case CompOptionTypeList:
-		fuseAddInode (inode, FUSE_INODE_TYPE_ITEMS, "items");
-		fuseAddInode (inode, FUSE_INODE_TYPE_ITEM_COUNT,
-			      "number_of_items");
-		fuseAddInode (inode, FUSE_INODE_TYPE_ITEM_TYPE, "item_type");
-	    default:
-		break;
-	    }
-	}
-    }
-    else if (inode->type & FUSE_INODE_TYPE_ITEMS)
-    {
-	option = fuseGetOptionFromInode (inode->parent);
-	if (option && option->type == CompOptionTypeList)
-	{
-	    FuseInode *c, *next;
-	    int	      i, nValue = option->value.list.nValue;
-
-	    for (i = 0; i < option->value.list.nValue; i++)
-	    {
-		sprintf (str, "value%d", i);
-		if (!fuseLookupChild (inode, str))
-		    fuseAddInode (inode, FUSE_INODE_TYPE_ITEM_VALUE, str);
-	    }
-
-	    for (c = inode->child; c; c = next)
-	    {
-		next = c->sibling;
-
-		if (sscanf (c->name, "value%d", &i) == 0 || i >= nValue)
-		    fuseRemoveInode (inode, c);
-	    }
-	}
-    }
-}
-
-static void
-fuseInodeStat (CompDisplay *d,
-	       FuseInode   *inode,
-	       struct stat *stbuf)
-{
-    stbuf->st_ino = inode->ino;
-
-    if (inode->type & DIR_MASK)
-    {
-	stbuf->st_mode  = S_IFDIR | 0755;
-	stbuf->st_nlink = 2;
-    }
-    else
-    {
-	char *str;
-
-	if (inode->type & WRITE_MASK)
-	    stbuf->st_mode = S_IFREG | 0666;
-	else
-	    stbuf->st_mode = S_IFREG | 0444;
-
-	stbuf->st_nlink = 1;
-	stbuf->st_size  = 0;
-
-	str = fuseGetStringFromInode (inode);
-	if (str)
-	{
-	    stbuf->st_size = strlen (str);
-	    free (str);
-	}
-    }
-}
-
-static Bool
-fuseInitValue (CompOptionValue *value,
-	       CompOptionType  type,
-	       CompOptionValue *src)
-{
-    switch (type) {
-    case CompOptionTypeBool:
-	value->b = src->b;
-	break;
-    case CompOptionTypeInt:
-	value->i = src->i;
-	break;
-    case CompOptionTypeFloat:
-	value->f = src->f;
-	break;
-    case CompOptionTypeString:
-	value->s = strdup (src->s);
-	break;
-    case CompOptionTypeColor:
-	memcpy (value->c, src->c, sizeof (*src->c));
-	break;
-    case CompOptionTypeKey:
-    case CompOptionTypeButton:
-    case CompOptionTypeEdge:
-    case CompOptionTypeBell:
-	value->action = src->action;
-	break;
-    case CompOptionTypeMatch:
-	matchInit (&value->match);
-	matchCopy (&value->match, &src->match);
-	break;
-    default:
-	return FALSE;
-    }
-
-    return TRUE;
-}
-
-static Bool
-fuseInitValueFromString (CompObject	 *object,
-			 CompOptionValue *value,
-			 CompOptionType  type,
-			 char		 *str)
-{
-    switch (type) {
-    case CompOptionTypeBool:
-	value->b = strcmp (str, "true") ? FALSE : TRUE;
-	break;
-    case CompOptionTypeInt:
-	value->i = atoi (str);
-	break;
-    case CompOptionTypeFloat:
-	value->f = strtod (str, NULL);
-	break;
-    case CompOptionTypeString:
-	value->s = strdup (str);
-	break;
-    case CompOptionTypeColor:
-	if (!stringToColor (str, value->c))
-	    return FALSE;
-	break;
-    case CompOptionTypeKey:
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return FALSE;
-
-	stringToKeyAction (GET_CORE_DISPLAY (object), str, &value->action);
-	break;
-    case CompOptionTypeButton:
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return FALSE;
-
-	stringToButtonAction (GET_CORE_DISPLAY (object), str, &value->action);
-	break;
-    case CompOptionTypeEdge:
-	value->action.edgeMask = stringToEdgeMask (str);
-	break;
-    case CompOptionTypeBell:
-	value->action.bell = strcmp (str, "true") ? FALSE : TRUE;
-	break;
-    case CompOptionTypeMatch:
-	matchInit (&value->match);
-	matchAddFromString (&value->match, str);
-	break;
-    default:
-	return FALSE;
-    }
-
-    return TRUE;
-}
-
-static void
-fuseSetInodeOptionUsingString (FuseInode *inode,
-			       char	 *str)
-{
-    CompOption *option;
-
-    option = fuseGetOptionFromInode (inode->parent);
-    if (option)
-    {
-	CompOptionValue value;
-	CompObject	*object;
-	const char	*pluginName;
-
-	if (inode->type & FUSE_INODE_TYPE_VALUE)
-	{
-	    object = fuseGetObjectFromInode (inode->parent->parent);
-	    if (!object)
-		return;
-
-	    if (!fuseInitValueFromString (object, &value, option->type, str))
-		return;
-
-	    pluginName = inode->parent->parent->parent->name;
-	}
-	else if (inode->type & FUSE_INODE_TYPE_ITEM_VALUE)
-	{
-	    int i, item, nValue = option->value.list.nValue;
-
-	    if (!sscanf (inode->name, "value%d", &item))
-		return;
-
-	    if (item >= nValue)
-		return;
-
-	    object = fuseGetObjectFromInode (inode->parent->parent->parent);
-	    if (!object)
-		return;
-
-	    value.list.value = malloc (sizeof (CompOptionValue) * nValue);
-	    if (!value.list.value)
-		return;
-
-	    value.list.type   = option->value.list.type;
-	    value.list.nValue = 0;
-
-	    for (i = 0; i < nValue; i++)
-	    {
-		if (i == item)
-		{
-		    if (!fuseInitValueFromString (object,
-						  &value.list.value[i],
-						  value.list.type,
-						  str))
-			break;
-		}
-		else
-		{
-		    if (!fuseInitValue (&value.list.value[i],
-					value.list.type,
-					&option->value.list.value[i]))
-			break;
-		}
-
-		value.list.nValue++;
-	    }
-
-	    /* failed */
-	    if (value.list.nValue < nValue)
-	    {
-		compFiniOptionValue (&value, option->type);
-		return;
-	    }
-
-	    pluginName = inode->parent->parent->parent->parent->name;
-	}
-	else
-	{
-	    return;
-	}
-
-	(*core.setOptionForPlugin) (object, pluginName, option->name, &value);
-
-	compFiniOptionValue (&value, option->type);
-    }
-}
-
-static void
-compiz_getattr (fuse_req_t	      req,
-		fuse_ino_t	      ino,
-		struct fuse_file_info *fi)
-{
-    CompDisplay	*d = (CompDisplay *) fuse_req_userdata (req);
-    FuseInode   *inode;
-
-    inode = fuseFindInode (inodes, ino, ~0);
-    if (inode)
-    {
-	struct stat stbuf;
-
-	memset (&stbuf, 0, sizeof (stbuf));
-
-	fuseInodeStat (d, inode, &stbuf);
-
-	fuse_reply_attr (req, &stbuf, 1.0);
-    }
-    else
-    {
-	fuse_reply_err (req, ENOENT);
-    }
-}
-
-static void
-compiz_setattr (fuse_req_t	      req,
-		fuse_ino_t	      ino,
-		struct stat	      *attr,
-		int		      to_set,
-		struct fuse_file_info *fi)
-{
-    CompDisplay *d = (CompDisplay *) fuse_req_userdata (req);
-    FuseInode   *inode;
-
-    inode = fuseFindInode (inodes, ino, WRITE_MASK);
-    if (inode)
-    {
-	struct stat stbuf;
-
-	if ((to_set & FUSE_SET_ATTR_SIZE) != FUSE_SET_ATTR_SIZE)
-	{
-	    fuse_reply_err (req, EACCES);
-	    return;
-	}
-
-	if (attr->st_size != 0)
-	{
-	    fuse_reply_err (req, EACCES);
-	    return;
-	}
-
-	inode->flags |= FUSE_INODE_FLAG_TRUNC;
-
-	memset (&stbuf, 0, sizeof (stbuf));
-
-	fuseInodeStat (d, inode, &stbuf);
-
-	fuse_reply_attr (req, &stbuf, 1.0);
-    }
-    else
-    {
-	fuse_reply_err (req, ENOENT);
-    }
-}
-
-static void
-compiz_lookup (fuse_req_t req,
-	       fuse_ino_t parent,
-	       const char *name)
-{
-    CompDisplay		    *d = (CompDisplay *) fuse_req_userdata (req);
-    FuseInode		    *inode;
-    struct fuse_entry_param e;
-
-    inode = fuseFindInode (inodes, parent, DIR_MASK);
-    if (!inode)
-    {
-	fuse_reply_err (req, ENOENT);
-	return;
-    }
-
-    if (!inode->child || !(inode->type & CONST_DIR_MASK))
-	fuseUpdateInode (d, inode);
-
-    inode = fuseLookupChild (inode, name);
-    if (!inode)
-    {
-	fuse_reply_err (req, ENOENT);
-	return;
-    }
-
-    memset (&e, 0, sizeof (e));
-
-    e.attr_timeout  = 1.0;
-    e.entry_timeout = 1.0;
-    e.ino	    = inode->ino;
-
-    fuseInodeStat (d, inode, &e.attr);
-
-    fuse_reply_entry (req, &e);
-}
-
-struct dirbuf {
-    char   *p;
-    size_t size;
-};
-
-static void
-dirbuf_add (fuse_req_t	  req,
-	    struct dirbuf *b,
-	    const char	  *name,
-	    fuse_ino_t	  ino)
-{
-    struct stat stbuf;
-    size_t	oldSize = b->size;
-
-    b->size += fuse_add_direntry (req, NULL, 0, name, NULL, 0);
-    b->p     = (char *) realloc (b->p, b->size);
-
-    memset (&stbuf, 0, sizeof (stbuf));
-
-    stbuf.st_ino = ino;
-
-    fuse_add_direntry (req, b->p + oldSize, b->size - oldSize, name, &stbuf,
-		       b->size);
-}
-
-static int
-reply_buf_limited (fuse_req_t req,
-		   const char *buf,
-		   size_t     bufsize,
-		   off_t      off,
-		   size_t     maxsize)
-{
-    if (off < bufsize)
-	return fuse_reply_buf (req, buf + off, MIN (bufsize - off, maxsize));
-    else
-	return fuse_reply_buf (req, NULL, 0);
-}
-
-static void
-compiz_readdir (fuse_req_t	      req,
-		fuse_ino_t	      ino,
-		size_t		      size,
-		off_t		      off,
-		struct fuse_file_info *fi)
-{
-    CompDisplay   *d = (CompDisplay *) fuse_req_userdata (req);
-    FuseInode	  *inode, *c;
-    struct dirbuf b;
-
-    inode = fuseFindInode (inodes, ino, DIR_MASK);
-    if (!inode)
-    {
-	fuse_reply_err (req, ENOTDIR);
-	return;
-    }
-
-    memset (&b, 0, sizeof (b));
-
-    dirbuf_add (req, &b, ".", ino);
-    dirbuf_add (req, &b, "..", inode->parent ? inode->parent->ino : ino);
-
-    if (!inode->child || !(inode->type & CONST_DIR_MASK))
-	fuseUpdateInode (d, inode);
-
-    for (c = inode->child; c; c = c->sibling)
-	dirbuf_add (req, &b, c->name, c->ino);
-
-    reply_buf_limited (req, b.p, b.size, off, size);
-
-    free (b.p);
-}
-
-static void
-compiz_open (fuse_req_t		   req,
-	     fuse_ino_t		   ino,
-	     struct fuse_file_info *fi)
-{
-    FuseInode *inode;
-
-    inode = fuseFindInode (inodes, ino, ~0);
-    if (!inode)
-    {
-	fuse_reply_err (req, ENOENT);
-	return;
-    }
-
-    fi->fh = 0;
-
-    if (inode->type & DIR_MASK)
-    {
-	fuse_reply_err (req, EISDIR);
-    }
-    else if (inode->type & WRITE_MASK)
-    {
-	if ((fi->flags & 3) != O_RDONLY)
-	{
-	    char *data;
-
-	    if (fi->flags & O_TRUNC)
-		data = strdup ("");
-	    else
-		data = fuseGetStringFromInode (inode);
-
-	    if (data)
-	    {
-		FuseWriteBuffer *wb;
-
-		wb = malloc (sizeof (FuseWriteBuffer));
-		if (wb)
-		{
-		    wb->data  = data;
-		    wb->size  = strlen (wb->data);
-		    wb->dirty = TRUE;
-
-		    fi->fh = (unsigned long) wb;
-		}
-		else
-		{
-		    free (data);
-		}
-	    }
-	}
-
-	fuse_reply_open (req, fi);
-    }
-    else if ((fi->flags & 3) != O_RDONLY)
-    {
-	fuse_reply_err (req, EACCES);
-    }
-    else
-    {
-	fuse_reply_open (req, fi);
-    }
-}
-
-static void
-compiz_read (fuse_req_t		   req,
-	     fuse_ino_t		   ino,
-	     size_t		   size,
-	     off_t		   off,
-	     struct fuse_file_info *fi)
-{
-    FuseInode *inode;
-    char      *str = NULL;
-
-    inode = fuseFindInode (inodes, ino, ~0);
-    if (inode)
-	str = fuseGetStringFromInode (inode);
-
-    if (str)
-    {
-	reply_buf_limited (req, str, strlen (str), off, size);
-	free (str);
-    }
-    else
-    {
-	reply_buf_limited (req, NULL, 0, off, size);
-    }
-}
-
-static void
-compiz_write (fuse_req_t	    req,
-	      fuse_ino_t	    ino,
-	      const char	    *buf,
-	      size_t		    size,
-	      off_t		    off,
-	      struct fuse_file_info *fi)
-{
-    FuseInode *inode;
-
-    inode = fuseFindInode (inodes, ino, WRITE_MASK);
-    if (inode && fi->fh)
-    {
-	FuseWriteBuffer *wb = (FuseWriteBuffer *) (uintptr_t) fi->fh;
-
-	if (off + size > wb->size)
-	{
-	    char *data;
-
-	    data = realloc (wb->data, off + size + 1);
-	    if (!data)
-	    {
-		fuse_reply_err (req, ENOBUFS);
-		return;
-	    }
-
-	    data[off + size] = '\0';
-
-	    wb->data = data;
-	    wb->size = off + size;
-	}
-
-	memcpy (wb->data + off, buf, size);
-
-	wb->dirty = TRUE;
-
-	fuse_reply_write (req, size);
-    }
-    else
-    {
-	fuse_reply_err (req, ENOENT);
-    }
-}
-
-static void
-compiz_release (fuse_req_t	      req,
-		fuse_ino_t	      ino,
-		struct fuse_file_info *fi)
-{
-    if (fi->fh)
-    {
-	FuseWriteBuffer *wb = (FuseWriteBuffer *) (uintptr_t) fi->fh;
-	FuseInode	*inode;
-
-	inode = fuseFindInode (inodes, ino, WRITE_MASK);
-	if (inode && wb->dirty)
-	{
-	    fuseSetInodeOptionUsingString (inode, wb->data);
-
-	    inode->flags &= ~FUSE_INODE_FLAG_TRUNC;
-	}
-
-	free (wb->data);
-	free (wb);
-    }
-
-    fuse_reply_err (req, 0);
-}
-
-static void
-compiz_fsync (fuse_req_t	    req,
-	      fuse_ino_t	    ino,
-	      int		    datasync,
-	      struct fuse_file_info *fi)
-{
-    if (fi->fh)
-    {
-	FuseWriteBuffer *wb = (FuseWriteBuffer *) (uintptr_t) fi->fh;
-	FuseInode	*inode;
-
-	inode = fuseFindInode (inodes, ino, WRITE_MASK);
-	if (inode && wb->dirty)
-	{
-	    fuseSetInodeOptionUsingString (inode, wb->data);
-
-	    inode->flags &= ~FUSE_INODE_FLAG_TRUNC;
-
-	    wb->dirty = FALSE;
-	}
-    }
-
-    fuse_reply_err (req, 0);
-}
-
-static struct fuse_lowlevel_ops compiz_ll_oper = {
-    .lookup  = compiz_lookup,
-    .getattr = compiz_getattr,
-    .setattr = compiz_setattr,
-    .readdir = compiz_readdir,
-    .open    = compiz_open,
-    .read    = compiz_read,
-    .write   = compiz_write,
-    .release = compiz_release,
-    .fsync   = compiz_fsync
-};
-
-static void
-fuseUnmount (CompDisplay *d)
-{
-    FUSE_DISPLAY (d);
-
-    if (fd->watchFdHandle)
-    {
-	compRemoveWatchFd (fd->watchFdHandle);
-	fd->watchFdHandle = 0;
-    }
-
-    if (fd->mountPoint)
-    {
-	/* unmount will destroy the channel */
-	fuse_unmount (fd->mountPoint, fd->channel);
-	free (fd->mountPoint);
-	fd->mountPoint = NULL;
-	fd->channel = NULL;
-    }
-
-    if (fd->buffer)
-    {
-	free (fd->buffer);
-	fd->buffer = NULL;
-    }
-}
-
-static Bool
-fuseProcessMessages (void *data)
-{
-    CompDisplay	     *d = (CompDisplay *) data;
-    struct fuse_chan *channel;
-    size_t	     bufferSize;
-    int		     res = 0;
-
-    FUSE_DISPLAY (d);
-
-    channel    = fuse_session_next_chan (fd->session, NULL);
-    bufferSize = fuse_chan_bufsize (channel);
-
-    if (fuse_session_exited (fd->session))
-	return FALSE;
-
-    for (;;)
-    {
-	struct fuse_chan *tmpch = channel;
-
-	res = fuse_chan_recv (&tmpch, fd->buffer, bufferSize);
-	if (res == -EINTR)
-	    continue;
-
-	if (res > 0)
-	    fuse_session_process (fd->session, fd->buffer, res, tmpch);
-
-	break;
-    }
-
-    return TRUE;
-}
-
-static void
-fuseMount (CompDisplay *d)
-{
-    char	     *mountPoint;
-    struct fuse_args args = FUSE_ARGS_INIT (0, NULL);
-
-    FUSE_DISPLAY (d);
-
-    mountPoint = strdup (fd->opt[FUSE_DISPLAY_OPTION_MOUNT_POINT].value.s);
-    if (!mountPoint)
-	return;
-
-    fuse_opt_add_arg (&args, "");
-    fuse_opt_add_arg (&args, "-o");
-    fuse_opt_add_arg (&args, "allow_root");
-
-    fd->channel = fuse_mount (mountPoint, &args);
-    if (!fd->channel)
-    {
-	fuse_opt_free_args (&args);
-	free (mountPoint);
-	return;
-    }
-
-    fuse_opt_free_args (&args);
-
-    fd->buffer = malloc (fuse_chan_bufsize (fd->channel));
-    if (!fd->buffer)
-    {
-	fuse_unmount (mountPoint, fd->channel);
-	free (mountPoint);
-	fd->channel = NULL;
-	return;
-    }
-
-    fd->mountPoint = mountPoint;
-
-    fuse_session_add_chan (fd->session, fd->channel);
-
-    fd->watchFdHandle = compAddWatchFd (fuse_chan_fd (fd->channel),
-					POLLIN | POLLPRI | POLLHUP | POLLERR,
-					fuseProcessMessages,
-					d);
-}
-
-static CompOption *
-fuseGetDisplayOptions (CompPlugin  *plugin,
-		       CompDisplay *display,
-		       int	   *count)
-{
-    FUSE_DISPLAY (display);
-
-    *count = NUM_OPTIONS (fd);
-    return fd->opt;
-}
-
-static Bool
-fuseSetDisplayOption (CompPlugin      *plugin,
-		      CompDisplay     *display,
-		      const char      *name,
-		      CompOptionValue *value)
-{
-    CompOption *o;
-    int	       index;
-
-    FUSE_DISPLAY (display);
-
-    o = compFindOption (fd->opt, NUM_OPTIONS (fd), name, &index);
-    if (!o)
-	return FALSE;
-
-    switch (index) {
-    case FUSE_DISPLAY_OPTION_MOUNT_POINT:
-	if (compSetStringOption (o, value))
-	{
-	    fuseUnmount (display);
-	    fuseMount (display);
-	    return TRUE;
-	}
-    default:
-	break;
-    }
-
-    return FALSE;
-}
-
-static const CompMetadataOptionInfo fuseDisplayOptionInfo[] = {
-    { "mount_point", "string", 0, 0, 0 }
-};
-
-static Bool
-fuseInitDisplay (CompPlugin  *p,
-		 CompDisplay *d)
-{
-    FuseDisplay	     *fd;
-    struct sigaction sa;
-
-    if (!checkPluginABI ("core", CORE_ABIVERSION))
-	return FALSE;
-
-    memset (&sa, 0, sizeof (struct sigaction));
-
-    sa.sa_handler = SIG_IGN;
-    sigemptyset (&sa.sa_mask);
-    sa.sa_flags = 0;
-
-    if (sigaction (SIGPIPE, &sa, NULL) == -1)
-	return FALSE;
-
-    fd = malloc (sizeof (FuseDisplay));
-    if (!fd)
-	return FALSE;
-
-    if (!compInitDisplayOptionsFromMetadata (d,
-					     &fuseMetadata,
-					     fuseDisplayOptionInfo,
-					     fd->opt,
-					     FUSE_DISPLAY_OPTION_NUM))
-    {
-	free (fd);
-	return FALSE;
-    }
-
-    fd->session = fuse_lowlevel_new (NULL,
-				     &compiz_ll_oper, sizeof (compiz_ll_oper),
-				     (void *) d);
-    if (!fd->session)
-    {
-	compFiniDisplayOptions (d, fd->opt, FUSE_DISPLAY_OPTION_NUM);
-	free (fd);
-	return FALSE;
-    }
-
-    fd->watchFdHandle = 0;
-    fd->channel	      = NULL;
-    fd->buffer	      = NULL;
-    fd->mountPoint    = NULL;
-
-    d->base.privates[displayPrivateIndex].ptr = fd;
-
-    fuseMount (d);
-
-    return TRUE;
-}
-
-static void
-fuseFiniDisplay (CompPlugin  *p,
-		 CompDisplay *d)
-{
-    FUSE_DISPLAY (d);
-
-    fuseUnmount (d);
-
-    fuse_session_destroy (fd->session);
-
-    compFiniDisplayOptions (d, fd->opt, FUSE_DISPLAY_OPTION_NUM);
-
-    free (fd);
-}
-
-static Bool
-fuseInit (CompPlugin *p)
-{
-    if (!compInitPluginMetadataFromInfo (&fuseMetadata,
-					 p->vTable->name,
-					 fuseDisplayOptionInfo,
-					 FUSE_DISPLAY_OPTION_NUM,
-					 0, 0))
-	return FALSE;
-
-    inodes = fuseAddInode (NULL, FUSE_INODE_TYPE_ROOT, ".");
-    if (!inodes)
-    {
-	compFiniMetadata (&fuseMetadata);
-	return FALSE;
-    }
-
-    displayPrivateIndex = allocateDisplayPrivateIndex ();
-    if (displayPrivateIndex < 0)
-    {
-	fuseRemoveInode (NULL, inodes);
-	compFiniMetadata (&fuseMetadata);
-	return FALSE;
-    }
-
-    compAddMetadataFromFile (&fuseMetadata, p->vTable->name);
-
-    return TRUE;
-}
-
-static CompBool
-fuseInitObject (CompPlugin *p,
-		CompObject *o)
-{
-    static InitPluginObjectProc dispTab[] = {
-	(InitPluginObjectProc) 0, /* InitCore */
-	(InitPluginObjectProc) fuseInitDisplay
-    };
-
-    RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
-}
-
-static void
-fuseFiniObject (CompPlugin *p,
-		CompObject *o)
-{
-    static FiniPluginObjectProc dispTab[] = {
-	(FiniPluginObjectProc) 0, /* FiniCore */
-	(FiniPluginObjectProc) fuseFiniDisplay
-    };
-
-    DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
-}
-
-static CompOption *
-fuseGetObjectOptions (CompPlugin *plugin,
-		      CompObject *object,
-		      int	 *count)
-{
-    static GetPluginObjectOptionsProc dispTab[] = {
-	(GetPluginObjectOptionsProc) 0, /* GetCoreOptions */
-	(GetPluginObjectOptionsProc) fuseGetDisplayOptions
-    };
-
-    RETURN_DISPATCH (object, dispTab, ARRAY_SIZE (dispTab),
-		     (void *) (*count = 0), (plugin, object, count));
-}
-
-static CompBool
-fuseSetObjectOption (CompPlugin      *plugin,
-		     CompObject      *object,
-		     const char      *name,
-		     CompOptionValue *value)
-{
-    static SetPluginObjectOptionProc dispTab[] = {
-	(SetPluginObjectOptionProc) 0, /* SetCoreOption */
-	(SetPluginObjectOptionProc) fuseSetDisplayOption
-    };
-
-    RETURN_DISPATCH (object, dispTab, ARRAY_SIZE (dispTab), FALSE,
-		     (plugin, object, name, value));
-}
-
-static void
-fuseFini (CompPlugin *p)
-{
-    fuseRemoveInode (NULL, inodes);
-    freeDisplayPrivateIndex (displayPrivateIndex);
-    compFiniMetadata (&fuseMetadata);
-}
-
-static CompMetadata *
-fuseGetMetadata (CompPlugin *plugin)
-{
-    return &fuseMetadata;
-}
-
-CompPluginVTable fuseVTable = {
-    "fs",
-    fuseGetMetadata,
-    fuseInit,
-    fuseFini,
-    fuseInitObject,
-    fuseFiniObject,
-    fuseGetObjectOptions,
-    fuseSetObjectOption
-};
-
-CompPluginVTable *
-getCompPluginInfo20070830 (void)
-{
-    return &fuseVTable;
-}

=== removed file 'legacy/gconf.cpp'
--- legacy/gconf.cpp	2009-03-15 05:15:26 +0000
+++ legacy/gconf.cpp	1970-01-01 00:00:00 +0000
@@ -1,848 +0,0 @@
-/*
- * Copyright © 2005 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Novell, Inc. not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Novell, Inc. makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Author: David Reveman <[e-mail]>
- */
-
-#define _GNU_SOURCE
-#include <string.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <ctype.h>
-
-#include <glib.h>
-#include <glib/gprintf.h>
-#include <gconf/gconf-client.h>
-
-#include <compiz-core.h>
-
-static CompMetadata gconfMetadata;
-
-#define APP_NAME "compiz"
-
-/* From gconf-internal.h. Bleah. */
-int gconf_value_compare (const GConfValue *value_a,
-			 const GConfValue *value_b);
-
-static int corePrivateIndex;
-
-typedef struct _GConfCore {
-    GConfClient *client;
-    guint	cnxn;
-
-    CompTimeoutHandle reloadHandle;
-
-    InitPluginForObjectProc initPluginForObject;
-    SetOptionForPluginProc  setOptionForPlugin;
-} GConfCore;
-
-#define GET_GCONF_CORE(c)				     \
-    ((GConfCore *) (c)->base.privates[corePrivateIndex].ptr)
-
-#define GCONF_CORE(c)		       \
-    GConfCore *gc = GET_GCONF_CORE (c)
-
-
-static gchar *
-gconfGetKey (CompObject  *object,
-	     const gchar *plugin,
-	     const gchar *option)
-{
-    const gchar *type;
-    gchar	*key, *name, *objectName;
-
-    type = compObjectTypeName (object->type);
-    if (strcmp (type, "display") == 0)
-	type = "allscreens";
-
-    name = compObjectName (object);
-    if (name)
-    {
-	objectName = g_strdup_printf ("%s%s", type, name);
-	free (name);
-    }
-    else
-	objectName = g_strdup (type);
-
-    if (strcmp (plugin, "core") == 0)
-	key = g_strjoin ("/", "/apps", APP_NAME, "general", objectName,
-			 "options", option, NULL);
-    else
-	key = g_strjoin ("/", "/apps", APP_NAME, "plugins", plugin, objectName,
-			 "options", option, NULL);
-
-    g_free (objectName);
-
-    return key;
-}
-
-static GConfValueType
-gconfTypeFromCompType (CompOptionType type)
-{
-    switch (type) {
-    case CompOptionTypeBool:
-    case CompOptionTypeBell:
-	return GCONF_VALUE_BOOL;
-    case CompOptionTypeInt:
-	return GCONF_VALUE_INT;
-    case CompOptionTypeFloat:
-	return GCONF_VALUE_FLOAT;
-    case CompOptionTypeString:
-    case CompOptionTypeColor:
-    case CompOptionTypeKey:
-    case CompOptionTypeButton:
-    case CompOptionTypeEdge:
-    case CompOptionTypeMatch:
-	return GCONF_VALUE_STRING;
-    case CompOptionTypeList:
-	return GCONF_VALUE_LIST;
-    default:
-	break;
-    }
-
-    return GCONF_VALUE_INVALID;
-}
-
-static void
-gconfSetValue (CompObject      *object,
-	       CompOptionValue *value,
-	       CompOptionType  type,
-	       GConfValue      *gvalue)
-{
-    switch (type) {
-    case CompOptionTypeBool:
-	gconf_value_set_bool (gvalue, value->b);
-	break;
-    case CompOptionTypeInt:
-	gconf_value_set_int (gvalue, value->i);
-	break;
-    case CompOptionTypeFloat:
-	gconf_value_set_float (gvalue, value->f);
-	break;
-    case CompOptionTypeString:
-	gconf_value_set_string (gvalue, value->s);
-	break;
-    case CompOptionTypeColor: {
-	gchar *color;
-
-	color = colorToString (value->c);
-	gconf_value_set_string (gvalue, color);
-
-	free (color);
-    } break;
-    case CompOptionTypeKey: {
-	gchar *action;
-
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return;
-
-	action = keyActionToString (GET_CORE_DISPLAY (object), &value->action);
-	gconf_value_set_string (gvalue, action);
-
-	free (action);
-    } break;
-    case CompOptionTypeButton: {
-	gchar *action;
-
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return;
-
-	action = buttonActionToString (GET_CORE_DISPLAY (object),
-				       &value->action);
-	gconf_value_set_string (gvalue, action);
-
-	free (action);
-    } break;
-    case CompOptionTypeEdge: {
-	gchar *edge;
-
-	edge = edgeMaskToString (value->action.edgeMask);
-	gconf_value_set_string (gvalue, edge);
-
-	free (edge);
-    } break;
-    case CompOptionTypeBell:
-	gconf_value_set_bool (gvalue, value->action.bell);
-	break;
-    case CompOptionTypeMatch: {
-	gchar *match;
-
-	match = matchToString (&value->match);
-	gconf_value_set_string (gvalue, match);
-
-	free (match);
-    } break;
-    default:
-	break;
-    }
-}
-
-static void
-gconfSetOption (CompObject  *object,
-		CompOption  *o,
-		const gchar *plugin)
-{
-    GConfValueType type = gconfTypeFromCompType (o->type);
-    GConfValue     *gvalue, *existingValue = NULL;
-    gchar          *key;
-
-    GCONF_CORE (&core);
-
-    if (type == GCONF_VALUE_INVALID)
-	return;
-
-    key = gconfGetKey (object, plugin, o->name);
-
-    existingValue = gconf_client_get (gc->client, key, NULL);
-    gvalue = gconf_value_new (type);
-
-    if (o->type == CompOptionTypeList)
-    {
-	GSList     *node, *list = NULL;
-	GConfValue *gv;
-	int	   i;
-
-	type = gconfTypeFromCompType (o->value.list.type);
-
-	for (i = 0; i < o->value.list.nValue; i++)
-	{
-	    gv = gconf_value_new (type);
-	    gconfSetValue (object, &o->value.list.value[i],
-			   o->value.list.type, gv);
-	    list = g_slist_append (list, gv);
-	}
-
-	gconf_value_set_list_type (gvalue, type);
-	gconf_value_set_list (gvalue, list);
-
-	if (!existingValue || gconf_value_compare (existingValue, gvalue))
-	    gconf_client_set (gc->client, key, gvalue, NULL);
-
-	for (node = list; node; node = node->next)
-	    gconf_value_free ((GConfValue *) node->data);
-
-	g_slist_free (list);
-    }
-    else
-    {
-	gconfSetValue (object, &o->value, o->type, gvalue);
-
-	if (!existingValue || gconf_value_compare (existingValue, gvalue))
-	    gconf_client_set (gc->client, key, gvalue, NULL);
-    }
-
-    gconf_value_free (gvalue);
-
-    if (existingValue)
-	gconf_value_free (existingValue);
-
-    g_free (key);
-}
-
-static Bool
-gconfGetValue (CompObject      *object,
-	       CompOptionValue *value,
-	       CompOptionType  type,
-	       GConfValue      *gvalue)
-
-{
-    if (type         == CompOptionTypeBool &&
-	gvalue->type == GCONF_VALUE_BOOL)
-    {
-	value->b = gconf_value_get_bool (gvalue);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeInt &&
-	     gvalue->type == GCONF_VALUE_INT)
-    {
-	value->i = gconf_value_get_int (gvalue);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeFloat &&
-	     gvalue->type == GCONF_VALUE_FLOAT)
-    {
-	value->f = gconf_value_get_float (gvalue);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeString &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const char *str;
-
-	str = gconf_value_get_string (gvalue);
-	if (str)
-	{
-	    value->s = strdup (str);
-	    if (value->s)
-		return TRUE;
-	}
-    }
-    else if (type         == CompOptionTypeColor &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const gchar *color;
-
-	color = gconf_value_get_string (gvalue);
-
-	if (stringToColor (color, value->c))
-	    return TRUE;
-    }
-    else if (type         == CompOptionTypeKey &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const gchar *action;
-
-	action = gconf_value_get_string (gvalue);
-
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return FALSE;
-
-	stringToKeyAction (GET_CORE_DISPLAY (object), action, &value->action);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeButton &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const gchar *action;
-
-	action = gconf_value_get_string (gvalue);
-
-	while (object && object->type != COMP_OBJECT_TYPE_DISPLAY)
-	    object = object->parent;
-
-	if (!object)
-	    return FALSE;
-
-	stringToButtonAction (GET_CORE_DISPLAY (object), action,
-			      &value->action);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeEdge &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const gchar *edge;
-
-	edge = gconf_value_get_string (gvalue);
-
-	value->action.edgeMask = stringToEdgeMask (edge);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeBell &&
-	     gvalue->type == GCONF_VALUE_BOOL)
-    {
-	value->action.bell = gconf_value_get_bool (gvalue);
-	return TRUE;
-    }
-    else if (type         == CompOptionTypeMatch &&
-	     gvalue->type == GCONF_VALUE_STRING)
-    {
-	const gchar *match;
-
-	match = gconf_value_get_string (gvalue);
-
-	matchInit (&value->match);
-	matchAddFromString (&value->match, match);
-	return TRUE;
-    }
-
-    return FALSE;
-}
-
-static Bool
-gconfReadOptionValue (CompObject      *object,
-		      GConfEntry      *entry,
-		      CompOption      *o,
-		      CompOptionValue *value)
-{
-    GConfValue *gvalue;
-
-    gvalue = gconf_entry_get_value (entry);
-    if (!gvalue)
-	return FALSE;
-
-    compInitOptionValue (value);
-
-    if (o->type      == CompOptionTypeList &&
-	gvalue->type == GCONF_VALUE_LIST)
-    {
-	GConfValueType type;
-	GSList	       *list;
-	int	       i, n;
-
-	type = gconf_value_get_list_type (gvalue);
-	if (gconfTypeFromCompType (o->value.list.type) != type)
-	    return FALSE;
-
-	list = gconf_value_get_list (gvalue);
-	n    = g_slist_length (list);
-
-	value->list.value  = NULL;
-	value->list.nValue = 0;
-	value->list.type   = o->value.list.type;
-
-	if (n)
-	{
-	    value->list.value = (CompOptionValue *) malloc (sizeof (CompOptionValue) * n);
-	    if (value->list.value)
-	    {
-		for (i = 0; i < n; i++)
-		{
-		    if (!gconfGetValue (object,
-					&value->list.value[i],
-					o->value.list.type,
-					(GConfValue *) list->data))
-			break;
-
-		    value->list.nValue++;
-
-		    list = g_slist_next (list);
-		}
-
-		if (value->list.nValue != n)
-		{
-		    compFiniOptionValue (value, o->type);
-		    return FALSE;
-		}
-	    }
-	}
-    }
-    else
-    {
-	if (!gconfGetValue (object, value, o->type, gvalue))
-	    return FALSE;
-    }
-
-    return TRUE;
-}
-
-static void
-gconfGetOption (CompObject *object,
-		CompOption *o,
-		const char *plugin)
-{
-    GConfEntry *entry;
-    gchar      *key;
-
-    GCONF_CORE (&core);
-
-    key = gconfGetKey (object, plugin, o->name);
-
-    entry = gconf_client_get_entry (gc->client, key, NULL, TRUE, NULL);
-    if (entry)
-    {
-	CompOptionValue value;
-
-	if (gconfReadOptionValue (object, entry, o, &value))
-	{
-	    (*core.setOptionForPlugin) (object, plugin, o->name, &value);
-	    compFiniOptionValue (&value, o->type);
-	}
-	else
-	{
-	    gconfSetOption (object, o, plugin);
-	}
-
-	gconf_entry_free (entry);
-    }
-
-    g_free (key);
-}
-
-static CompBool
-gconfReloadObjectTree (CompObject *object,
-			 void       *closure);
-
-static CompBool
-gconfReloadObjectsWithType (CompObjectType type,
-			      CompObject     *parent,
-			      void	     *closure)
-{
-    compObjectForEach (parent, type, gconfReloadObjectTree, closure);
-
-    return TRUE;
-}
-
-static CompBool
-gconfReloadObjectTree (CompObject *object,
-		       void       *closure)
-{
-    CompPlugin *p = (CompPlugin *) closure;
-    CompOption  *option;
-    int		nOption;
-
-    option = (*p->vTable->getObjectOptions) (p, object, &nOption);
-    while (nOption--)
-	gconfGetOption (object, option++, p->vTable->name);
-
-    compObjectForEachType (object, gconfReloadObjectsWithType, closure);
-
-    return TRUE;
-}
-
-static Bool
-gconfReload (void *closure)
-{
-    CompPlugin  *p;
-
-    GCONF_CORE (&core);
-
-    for (p = getPlugins (); p; p = p->next)
-    {
-	if (!p->vTable->getObjectOptions)
-	    continue;
-
-	gconfReloadObjectTree (&core.base, (void *) p);
-    }
-
-    gc->reloadHandle = 0;
-
-    return FALSE;
-}
-
-static Bool
-gconfSetOptionForPlugin (CompObject      *object,
-			 const char	 *plugin,
-			 const char	 *name,
-			 CompOptionValue *value)
-{
-    CompBool status;
-
-    GCONF_CORE (&core);
-
-    UNWRAP (gc, &core, setOptionForPlugin);
-    status = (*core.setOptionForPlugin) (object, plugin, name, value);
-    WRAP (gc, &core, setOptionForPlugin, gconfSetOptionForPlugin);
-
-    if (status && !gc->reloadHandle)
-    {
-	CompPlugin *p;
-
-	p = findActivePlugin (plugin);
-	if (p && p->vTable->getObjectOptions)
-	{
-	    CompOption *option;
-	    int	       nOption;
-
-	    option = (*p->vTable->getObjectOptions) (p, object, &nOption);
-	    option = compFindOption (option, nOption, name, 0);
-	    if (option)
-		gconfSetOption (object, option, p->vTable->name);
-	}
-    }
-
-    return status;
-}
-
-static CompBool
-gconfInitPluginForObject (CompPlugin *p,
-			  CompObject *o)
-{
-    CompBool status;
-
-    GCONF_CORE (&core);
-
-    UNWRAP (gc, &core, initPluginForObject);
-    status = (*core.initPluginForObject) (p, o);
-    WRAP (gc, &core, initPluginForObject, gconfInitPluginForObject);
-
-    if (status && p->vTable->getObjectOptions)
-    {
-	CompOption *option;
-	int	   nOption;
-
-	option = (*p->vTable->getObjectOptions) (p, o, &nOption);
-	while (nOption--)
-	    gconfGetOption (o, option++, p->vTable->name);
-    }
-
-    return status;
-}
-
-/* MULTIDPYERROR: only works with one or less displays present */
-static void
-gconfKeyChanged (GConfClient *client,
-		 guint	     cnxn_id,
-		 GConfEntry  *entry,
-		 gpointer    user_data)
-{
-    CompPlugin *plugin;
-    CompObject *object;
-    CompOption *option = NULL;
-    int	       nOption = 0;
-    gchar      **token;
-    int	       objectIndex = 4;
-
-    token = g_strsplit (entry->key, "/", 8);
-
-    if (g_strv_length (token) < 7)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    if (strcmp (token[0], "")	    != 0 ||
-	strcmp (token[1], "apps")   != 0 ||
-	strcmp (token[2], APP_NAME) != 0)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    if (strcmp (token[3], "general") == 0)
-    {
-	plugin = findActivePlugin ("core");
-    }
-    else
-    {
-	if (strcmp (token[3], "plugins") != 0 || g_strv_length (token) < 8)
-	{
-	    g_strfreev (token);
-	    return;
-	}
-
-	objectIndex = 5;
-	plugin = findActivePlugin (token[4]);
-    }
-
-    if (!plugin)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    object = compObjectFind (&core.base, COMP_OBJECT_TYPE_DISPLAY, NULL);
-    if (!object)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    if (strncmp (token[objectIndex], "screen", 6) == 0)
-    {
-	object = compObjectFind (object, COMP_OBJECT_TYPE_SCREEN,
-				 token[objectIndex] + 6);
-	if (!object)
-	{
-	    g_strfreev (token);
-	    return;
-	}
-    }
-    else if (strcmp (token[objectIndex], "allscreens") != 0)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    if (strcmp (token[objectIndex + 1], "options") != 0)
-    {
-	g_strfreev (token);
-	return;
-    }
-
-    if (plugin->vTable->getObjectOptions)
-	option = (*plugin->vTable->getObjectOptions) (plugin, object,
-						      &nOption);
-
-    option = compFindOption (option, nOption, token[objectIndex + 2], 0);
-    if (option)
-    {
-	CompOptionValue value;
-
-	if (gconfReadOptionValue (object, entry, option, &value))
-	{
-	    (*core.setOptionForPlugin) (object,
-					plugin->vTable->name,
-					option->name,
-					&value);
-
-	    compFiniOptionValue (&value, option->type);
-	}
-    }
-
-    g_strfreev (token);
-}
-
-static void
-gconfSendGLibNotify (CompDisplay *d)
-{
-    Display *dpy = d->display;
-    XEvent  xev;
-
-    xev.xclient.type    = ClientMessage;
-    xev.xclient.display = dpy;
-    xev.xclient.format  = 32;
-
-    xev.xclient.message_type = XInternAtom (dpy, "_COMPIZ_GLIB_NOTIFY", 0);
-    xev.xclient.window	     = d->screens->root;
-
-    memset (xev.xclient.data.l, 0, sizeof (xev.xclient.data.l));
-
-    XSendEvent (dpy,
-		d->screens->root,
-		FALSE,
-		SubstructureRedirectMask | SubstructureNotifyMask,
-		&xev);
-}
-
-static Bool
-gconfInitCore (CompPlugin *p,
-	       CompCore   *c)
-{
-    GConfCore *gc;
-
-    if (!checkPluginABI ("core", CORE_ABIVERSION))
-	return FALSE;
-
-    gc = (GConfCore *) malloc (sizeof (GConfCore));
-    if (!gc)
-	return FALSE;
-
-    g_type_init ();
-
-    gc->client = gconf_client_get_default ();
-
-    gconf_client_add_dir (gc->client, "/apps/" APP_NAME,
-			  GCONF_CLIENT_PRELOAD_NONE, NULL);
-
-    gc->reloadHandle = compAddTimeout (0, 0, gconfReload, 0);
-
-    gc->cnxn = gconf_client_notify_add (gc->client, "/apps/" APP_NAME,
-					gconfKeyChanged, c, NULL, NULL);
-
-    WRAP (gc, c, initPluginForObject, gconfInitPluginForObject);
-    WRAP (gc, c, setOptionForPlugin, gconfSetOptionForPlugin);
-
-    c->base.privates[corePrivateIndex].ptr = gc;
-
-    return TRUE;
-}
-
-static void
-gconfFiniCore (CompPlugin *p,
-	       CompCore   *c)
-{
-    GCONF_CORE (c);
-
-    UNWRAP (gc, c, initPluginForObject);
-    UNWRAP (gc, c, setOptionForPlugin);
-
-    if (gc->reloadHandle)
-	compRemoveTimeout (gc->reloadHandle);
-
-    if (gc->cnxn)
-	gconf_client_notify_remove (gc->client, gc->cnxn);
-
-    gconf_client_remove_dir (gc->client, "/apps/" APP_NAME, NULL);
-    gconf_client_clear_cache (gc->client);
-
-    free (gc);
-}
-
-static Bool
-gconfInitDisplay (CompPlugin  *p,
-		  CompDisplay *d)
-{
-    gconfSendGLibNotify (d);
-
-    return TRUE;
-}
-
-static CompBool
-gconfInitObject (CompPlugin *p,
-		 CompObject *o)
-{
-    static InitPluginObjectProc dispTab[] = {
-	(InitPluginObjectProc) gconfInitCore,
-	(InitPluginObjectProc) gconfInitDisplay
-    };
-
-    RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
-}
-
-static void
-gconfFiniObject (CompPlugin *p,
-		 CompObject *o)
-{
-    static FiniPluginObjectProc dispTab[] = {
-	(FiniPluginObjectProc) gconfFiniCore
-    };
-
-    DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
-}
-
-static Bool
-gconfInit (CompPlugin *p)
-{
-    if (!compInitPluginMetadataFromInfo (&gconfMetadata, p->vTable->name,
-					 0, 0, 0, 0))
-	return FALSE;
-
-    corePrivateIndex = allocateCorePrivateIndex ();
-    if (corePrivateIndex < 0)
-    {
-	compFiniMetadata (&gconfMetadata);
-	return FALSE;
-    }
-
-    compAddMetadataFromFile (&gconfMetadata, p->vTable->name);
-
-    return TRUE;
-}
-
-static void
-gconfFini (CompPlugin *p)
-{
-    freeCorePrivateIndex (corePrivateIndex);
-    compFiniMetadata (&gconfMetadata);
-}
-
-static CompMetadata *
-gconfGetMetadata (CompPlugin *plugin)
-{
-    return &gconfMetadata;
-}
-
-CompPluginVTable gconfVTable = {
-    "gconf",
-    gconfGetMetadata,
-    gconfInit,
-    gconfFini,
-    gconfInitObject,
-    gconfFiniObject,
-    0, /* GetObjectOptions */
-    0  /* SetObjectOption */
-};
-
-CompPluginVTable *
-getCompPluginInfo20070830 (void)
-{
-    return &gconfVTable;
-}

=== removed file 'legacy/gconf.xml.in'
--- legacy/gconf.xml.in	2009-03-15 05:15:26 +0000
+++ legacy/gconf.xml.in	1970-01-01 00:00:00 +0000
@@ -1,18 +0,0 @@
-<compiz>
-    <plugin name="gconf">
-	<_short>GConf</_short>
-	<_long>GConf Control Backend</_long>
-	<deps>
-	    <relation type="after">
-		<plugin>glib</plugin>
-	    </relation>
-	    <relation type="before">
-		<plugin>decoration</plugin>
-		<plugin>wobbly</plugin>
-		<plugin>fade</plugin>
-		<plugin>cube</plugin>
-		<plugin>scale</plugin>
-	    </relation>
-	</deps>
-    </plugin>
-</compiz>

=== removed file 'legacy/metadata.cpp'
--- legacy/metadata.cpp	2009-03-15 23:01:28 +0000
+++ legacy/metadata.cpp	1970-01-01 00:00:00 +0000
@@ -1,1160 +0,0 @@
-/*
- * Copyright © 2008 Dennis Kasprzyk
- * Copyright © 2007 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Dennis Kasprzyk not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Dennis Kasprzyk makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Authors: Dennis Kasprzyk <[e-mail]>
- *          David Reveman <[e-mail]>
- */
-
-#include <string.h>
-#include <libxml/tree.h>
-#include <libxml/xpath.h>
-#include <libxml/xpathInternals.h>
-#include <locale.h>
-
-#include <boost/foreach.hpp>
-#define foreach BOOST_FOREACH
-
-#include <compiz.h>
-#include <core/metadata.h>
-#include <core/screen.h>
-#include "privatescreen.h"
-#include "privatemetadata.h"
-
-#define HOME_METADATADIR ".compiz/metadata"
-#define EXTENSION ".xml"
-
-static xmlDoc *
-readXmlFile (CompString name,
-	     CompString path = "")
-{
-    CompString file;
-    xmlDoc *doc = NULL;
-    FILE   *fp;
-
-    if (path.size ())
-	file = compPrintf ("%s/%s%s", path.c_str (), name.c_str (), EXTENSION);
-    else
-	file = compPrintf ("%s%s", name.c_str (), EXTENSION);
-
-    fp = fopen (file.c_str (), "r");
-    if (!fp)
-    {
-	return NULL;
-    }
-
-    fclose (fp);
-
-    doc = xmlReadFile (file.c_str (), NULL, 0);
-
-    return doc;
-}
-
-typedef struct _CompIOCtx {
-    unsigned int                   offset;
-    const char                     *name;
-    const CompMetadata::OptionInfo *oInfo;
-    unsigned int                   nOInfo;
-} CompIOCtx;
-
-typedef struct _CompXPath {
-    xmlXPathObjectPtr  obj;
-    xmlXPathContextPtr ctx;
-    xmlDocPtr	       doc;
-} CompXPath;
-
-
-static int
-readPluginXmlCallback (void *context,
-		       char *buffer,
-		       int  length)
-{
-    CompIOCtx    *ctx = (CompIOCtx *) context;
-    unsigned int offset = ctx->offset;
-    unsigned int i, j;
-
-    i = CompMetadata::readXmlChunk ("<compiz><plugin name=\"", &offset,
-				    buffer, length);
-    i += CompMetadata::readXmlChunk (ctx->name, &offset, buffer + i,
-				     length - i);
-    i += CompMetadata::readXmlChunk ("\">", &offset, buffer + i, length - i);
-
-    if (ctx->nOInfo)
-    {
-	i += CompMetadata::readXmlChunk ("<options>", &offset, buffer + i,
-					 length - i);
-
-	for (j = 0; j < ctx->nOInfo; j++)
-	    i += CompMetadata::readXmlChunkFromOptionInfo (
-		   &ctx->oInfo[j], &offset, buffer + i, length - i);
-
-	i += CompMetadata::readXmlChunk ("</options>", &offset, buffer + i,
-					 length - i);
-    }
-
-    i += CompMetadata::readXmlChunk ("</plugin></compiz>", &offset, buffer + i,
-				     length - i);
-
-    if (!offset && length > (int)i)
-	buffer[i++] = '\0';
-
-    ctx->offset += i;
-
-    return i;
-}
-
-static bool
-initXPathFromMetadataPath (CompXPath	 *xPath,
-			   CompMetadata  *metadata,
-			   const xmlChar *path)
-{
-    xmlXPathObjectPtr  obj;
-    xmlXPathContextPtr ctx;
-
-    foreach (xmlDoc *doc, metadata->doc ())
-    {
-	ctx = xmlXPathNewContext (doc);
-	if (ctx)
-	{
-	    obj = xmlXPathEvalExpression (path, ctx);
-	    if (obj)
-	    {
-		if (obj->nodesetval && obj->nodesetval->nodeNr)
-		{
-		    xPath->ctx = ctx;
-		    xPath->obj = obj;
-		    xPath->doc = doc;
-
-		    return true;
-		}
-
-		xmlXPathFreeObject (obj);
-	    }
-
-	    xmlXPathFreeContext (ctx);
-	}
-    }
-
-    return false;
-}
-
-static bool
-initXPathFromMetadataPathElement (CompXPath	*xPath,
-				  CompMetadata  *metadata,
-				  const xmlChar *path,
-				  const xmlChar *element)
-{
-    char str[1024];
-
-    snprintf (str, 1024, "%s/%s", path, element);
-
-    return initXPathFromMetadataPath (xPath, metadata, BAD_CAST str);
-}
-
-static void
-finiXPath (CompXPath *xPath)
-{
-    xmlXPathFreeObject (xPath->obj);
-    xmlXPathFreeContext (xPath->ctx);
-}
-
-static CompOption::Type
-getOptionType (const char *name)
-{
-    static struct _TypeMap {
-	const char       *name;
-	CompOption::Type type;
-    } map[] = {
-	{ "int",    CompOption::TypeInt    },
-	{ "float",  CompOption::TypeFloat  },
-	{ "string", CompOption::TypeString },
-	{ "color",  CompOption::TypeColor  },
-	{ "action", CompOption::TypeAction },
-	{ "key",    CompOption::TypeKey    },
-	{ "button", CompOption::TypeButton },
-	{ "edge",   CompOption::TypeEdge   },
-	{ "bell",   CompOption::TypeBell   },
-	{ "match",  CompOption::TypeMatch  },
-	{ "list",   CompOption::TypeList   }
-    };
-    unsigned int i;
-
-    for (i = 0; i < sizeof (map) / sizeof (map[0]); i++)
-	if (strcasecmp (name, map[i].name) == 0)
-	    return map[i].type;
-
-    return CompOption::TypeBool;
-}
-
-static void
-initBoolValue (CompOption::Value &v,
-	       xmlDocPtr         doc,
-	       xmlNodePtr        node)
-{
-    xmlChar *value;
-
-    v.set (false);
-
-    if (!doc)
-	return;
-
-    value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-    if (value)
-    {
-	if (strcasecmp ((char *) value, "true") == 0)
-	    v.set (true);
-
-	xmlFree (value);
-    }
-}
-
-static void
-initIntValue (CompOption::Value       &v,
-	      CompOption::Restriction &r,
-	      xmlDocPtr               doc,
-	      xmlNodePtr              node)
-{
-    xmlChar *value;
-
-    v.set ((r.iMin () + r.iMax ()) / 2);
-
-    if (!doc)
-	return;
-
-    value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-    if (value)
-    {
-	int i = strtol ((char *) value, NULL, 0);
-
-	if (r.inRange (i))
-	    v.set (i);
-
-	xmlFree (value);
-    }
-}
-
-static void
-initFloatValue (CompOption::Value       &v,
-		CompOption::Restriction &r,
-		xmlDocPtr               doc,
-		xmlNodePtr              node)
-{
-    xmlChar *value;
-    char *loc;
-
-    v.set ((r.fMin () + r.fMax ()) / 2);
-
-    if (!doc)
-	return;
-
-    loc = setlocale (LC_NUMERIC, NULL);
-    setlocale (LC_NUMERIC, "C");
-    value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-    if (value)
-    {
-	float f = strtod ((char *) value, NULL);
-
-	if (r.inRange (f))
-	    v.set (f);
-
-	xmlFree (value);
-    }
-    setlocale (LC_NUMERIC, loc);
-}
-
-static void
-initStringValue (CompOption::Value       &v,
-		 CompOption::Restriction &r,
-		 xmlDocPtr               doc,
-		 xmlNodePtr              node)
-{
-    xmlChar *value;
-
-    v.set ("");
-
-    if (!doc)
-	return;
-
-    value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-    if (value)
-    {
-	v.set (CompString ((char *) value));
-	xmlFree (value);
-    }
-}
-
-static void
-initColorValue (CompOption::Value &v,
-		xmlDocPtr         doc,
-		xmlNodePtr        node)
-{
-    xmlNodePtr child;
-
-    unsigned short c[4] = { 0x0000, 0x0000, 0x0000, 0xffff};
-    v.set (c);
-
-    if (!doc)
-	return;
-
-    for (child = node->xmlChildrenNode; child; child = child->next)
-    {
-	xmlChar *value;
-	int	index;
-
-	if (!xmlStrcmp (child->name, BAD_CAST "red"))
-	    index = 0;
-	else if (!xmlStrcmp (child->name, BAD_CAST "green"))
-	    index = 1;
-	else if (!xmlStrcmp (child->name, BAD_CAST "blue"))
-	    index = 2;
-	else if (!xmlStrcmp (child->name, BAD_CAST "alpha"))
-	    index = 3;
-	else
-	    continue;
-
-	value = xmlNodeListGetString (child->doc, child->xmlChildrenNode, 1);
-	if (value)
-	{
-	    int color = strtol ((char *) value, NULL , 0);
-
-	    c[index] = MAX (0, MIN (0xffff, color));
-
-	    xmlFree (value);
-	}
-    }
-    v.set (c);
-}
-
-static void
-initActionValue (CompOption::Value &v,
-		 CompAction::State state,
-		 xmlDocPtr         doc,
-		 xmlNodePtr        node)
-{
-    v.set (CompAction ());
-    v.action ().setState (state);
-}
-
-static void
-initKeyValue (CompOption::Value &v,
-	      CompAction::State state,
-	      xmlDocPtr         doc,
-	      xmlNodePtr        node)
-{
-    xmlChar    *value;
-    CompAction action;
-
-    action.setState (state | CompAction::StateInitKey);
-
-    if (doc)
-    {
-	value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-	if (value)
-	{
-	    char *binding = (char *) value;
-
-	    if (strcasecmp (binding, "disabled") && *binding)
-		action.keyFromString (binding);
-
-	    xmlFree (value);
-	}
-
-	v.set (action);
-
-	if (state & CompAction::StateAutoGrab)
-	    screen->addAction (&v.action ());
-    }
-    else
-	v.set (action);
-}
-
-static void
-initButtonValue (CompOption::Value &v,
-		 CompAction::State state,
-		 xmlDocPtr         doc,
-		 xmlNodePtr        node)
-{
-    xmlChar    *value;
-    CompAction action;
-
-    action.setState (state | CompAction::StateInitButton |
-		     CompAction::StateInitEdge);
-
-    if (doc)
-    {
-	value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-	if (value)
-	{
-	    char *binding = (char *) value;
-
-	    if (strcasecmp (binding, "disabled") && *binding)
-		action.buttonFromString (binding);
-
-	    xmlFree (value);
-	}
-
-	v.set (action);
-
-	if (state & CompAction::StateAutoGrab)
-	    screen->addAction (&v.action ());
-    }
-    else
-	v.set (action);
-}
-
-static void
-initEdgeValue (CompOption::Value &v,
-	       CompAction::State state,
-	       xmlDocPtr         doc,
-	       xmlNodePtr        node)
-{
-    xmlNodePtr   child;
-    xmlChar      *value;
-    CompAction   action;
-    unsigned int edge = 0;
-
-    action.setState (state | CompAction::StateInitEdge);
-
-    if (doc)
-    {
-	for (child = node->xmlChildrenNode; child; child = child->next)
-	{
-	    value = xmlGetProp (child, BAD_CAST "name");
-	    if (value)
-	    {
-		int i;
-
-		for (i = 0; i < SCREEN_EDGE_NUM; i++)
-		    if (strcasecmp ((char *) value,
-				    CompAction::edgeToString (i).c_str ()) == 0)
-			edge |= (1 << i);
-
-		xmlFree (value);
-	    }
-	}
-
-	action.setEdgeMask (edge);
-	v.set (action);
-
-	if (state & CompAction::StateAutoGrab)
-	    screen->addAction (&v.action ());
-    }
-    else
-    {
-	action.setEdgeMask (edge);
-	v.set (action);
-    }
-}
-
-static void
-initBellValue (CompOption::Value &v,
-	       CompAction::State state,
-	       xmlDocPtr         doc,
-	       xmlNodePtr        node)
-{
-    xmlChar    *value;
-    CompAction action;
-
-    action.setState (state | CompAction::StateInitBell);
-
-    if (doc)
-    {
-	value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-	if (value)
-	{
-	    if (strcasecmp ((char *) value, "true") == 0)
-		action.setBell (true);
-
-	    xmlFree (value);
-	}
-    }
-    v.set (action);
-}
-
-static void
-initMatchValue (CompOption::Value &v,
-		bool		  helper,
-		xmlDocPtr         doc,
-		xmlNodePtr        node)
-{
-    xmlChar *value;
-
-    v.set (CompMatch ());
-
-    if (!doc)
-	return;
-
-    value = xmlNodeListGetString (doc, node->xmlChildrenNode, 1);
-    if (value)
-    {
-	v.match () = (char *) value;
-	xmlFree (value);
-    }
-
-    if (!helper)
-	v.match ().update ();
-}
-
-static void
-initListValue (CompOption::Value       &v,
-	       CompOption::Restriction &r,
-	       CompAction::State       state,
-	       bool                    helper,
-	       xmlDocPtr               doc,
-	       xmlNodePtr              node)
-{
-    xmlNodePtr child;
-
-    v.list ().clear ();
-
-    if (!doc)
-	return;
-
-    for (child = node->xmlChildrenNode; child; child = child->next)
-    {
-	CompOption::Value value;
-
-	if (xmlStrcmp (child->name, BAD_CAST "value"))
-	    continue;
-
-	switch (v.listType ()) {
-	    case CompOption::TypeBool:
-		initBoolValue (value, doc, child);
-		break;
-	    case CompOption::TypeInt:
-		initIntValue (value, r, doc, child);
-		break;
-	    case CompOption::TypeFloat:
-		initFloatValue (value, r, doc, child);
-		break;
-	    case CompOption::TypeString:
-		initStringValue (value, r, doc, child);
-		break;
-	    case CompOption::TypeColor:
-		initColorValue (value, doc, child);
-		break;
-	    case CompOption::TypeAction:
-		initActionValue (value, state, doc, child);
-		break;
-	    case CompOption::TypeKey:
-		initKeyValue (value, state, doc, child);
-		break;
-	    case CompOption::TypeButton:
-		initButtonValue (value, state, doc, child);
-		break;
-	    case CompOption::TypeEdge:
-		initEdgeValue (value, state, doc, child);
-		break;
-	    case CompOption::TypeBell:
-		initBellValue (value, state, doc, child);
-		break;
-	    case CompOption::TypeMatch:
-		initMatchValue (value, helper, doc, child);
-	    default:
-		break;
-	}
-
-	v.list ().push_back (value);
-    }
-}
-
-static CompString
-stringFromMetadataPathElement (CompMetadata *metadata,
-			       const char   *path,
-			       const char   *element)
-{
-    return metadata->getStringFromPath (compPrintf ("%s/%s", path, element));
-}
-
-static Bool
-boolFromMetadataPathElement (CompMetadata *metadata,
-			     const char   *path,
-			     const char   *element,
-			     Bool	  defaultValue)
-{
-    Bool value = FALSE;
-    CompString str;
-
-    str = stringFromMetadataPathElement (metadata, path, element);
-
-    if (strcasecmp (str.c_str (), "true") == 0)
-	value = TRUE;
-
-    return value;
-}
-
-static void
-initIntRestriction (CompMetadata            *metadata,
-		    CompOption::Restriction &r,
-		    const char              *path)
-{
-    CompString value;
-    int  min = MINSHORT, max = MAXSHORT;
-
-    value = stringFromMetadataPathElement (metadata, path, "min");
-    if (!value.empty ())
-	min = strtol (value.c_str (), NULL, 0);
-
-    value = stringFromMetadataPathElement (metadata, path, "max");
-    if (!value.empty ())
-	max = strtol (value.c_str (), NULL, 0);
-
-    r.set (min, max);
-}
-
-static void
-initFloatRestriction (CompMetadata            *metadata,
-		      CompOption::Restriction &r,
-		      const char              *path)
-{
-    CompString value;
-    char *loc;
-
-    float min       = MINSHORT;
-    float max       = MAXSHORT;
-    float precision = 0.1f;
-
-    loc = setlocale (LC_NUMERIC, NULL);
-    setlocale (LC_NUMERIC, "C");
-    value = stringFromMetadataPathElement (metadata, path, "min");
-    if (!value.empty ())
-	min = strtod (value.c_str (), NULL);
-
-    value = stringFromMetadataPathElement (metadata, path, "max");
-    if (!value.empty ())
-	max = strtod (value.c_str (), NULL);
-
-    value = stringFromMetadataPathElement (metadata, path, "precision");
-    if (!value.empty ())
-	precision = strtod (value.c_str (), NULL);
-
-    r.set (min, max, precision);
-
-    setlocale (LC_NUMERIC, loc);
-}
-
-static void
-initActionState (CompMetadata      *metadata,
-		 CompOption::Type  type,
-		 CompAction::State *state,
-		 const char        *path)
-{
-    static struct _StateMap {
-	const char        *name;
-	CompAction::State state;
-    } map[] = {
-	{ "key",     CompAction::StateInitKey     },
-	{ "button",  CompAction::StateInitButton  },
-	{ "bell",    CompAction::StateInitBell    },
-	{ "edge",    CompAction::StateInitEdge    },
-	{ "edgednd", CompAction::StateInitEdgeDnd }
-    };
-
-    CompXPath xPath;
-    CompString value;
-
-    *state = CompAction::StateAutoGrab;
-
-    value = stringFromMetadataPathElement (metadata, path, "passive_grab");
-    if (!value.empty ())
-	if (value == "false")
-	    *state = 0;
-
-    if (type == CompOption::TypeEdge)
-    {
-	value = stringFromMetadataPathElement (metadata, path, "nodelay");
-	if (!value.empty ())
-	    if (value == "true")
-		*state |= CompAction::StateNoEdgeDelay;
-    }
-
-    if (!initXPathFromMetadataPathElement (&xPath, metadata, BAD_CAST path,
-					   BAD_CAST "allowed"))
-	return;
-
-    for (unsigned int i = 0; i < sizeof (map) / sizeof (map[0]); i++)
-    {
-	xmlChar *value;
-
-	value = xmlGetProp (*xPath.obj->nodesetval->nodeTab,
-			    BAD_CAST map[i].name);
-	if (value)
-	{
-	    if (xmlStrcmp (value, BAD_CAST "true") == 0)
-		*state |= map[i].state;
-	    xmlFree (value);
-	}
-    }
-
-    finiXPath (&xPath);
-}
-
-static bool
-initOptionFromMetadataPath (CompMetadata  *metadata,
-			    CompOption	  *option,
-			    const xmlChar *path)
-{
-    CompXPath	      xPath, xDefaultPath;
-    xmlNodePtr	      node, defaultNode;
-    xmlDocPtr	      defaultDoc;
-    xmlChar	      *name, *type;
-    CompString	      value;
-    CompAction::State state = 0;
-    bool	      helper = false;
-    CompOption::Type  oType = CompOption::TypeBool;
-
-    CompOption::Value::Vector emptyList (0);
-
-    if (!initXPathFromMetadataPath (&xPath, metadata, path))
-	return FALSE;
-
-    node = *xPath.obj->nodesetval->nodeTab;
-
-    type = xmlGetProp (node, BAD_CAST "type");
-    if (type)
-    {
-	oType = getOptionType ((char *) type);
-	xmlFree (type);
-    }
-
-    name = xmlGetProp (node, BAD_CAST "name");
-    option->setName ((char *) name, oType);
-    xmlFree (name);
-
-    if (initXPathFromMetadataPathElement (&xDefaultPath, metadata, path,
-					  BAD_CAST "default"))
-    {
-	defaultDoc  = xDefaultPath.doc;
-	defaultNode = *xDefaultPath.obj->nodesetval->nodeTab;
-    }
-    else
-    {
-	defaultDoc  = NULL;
-	defaultNode = NULL;
-    }
-
-    switch (option->type ()) {
-	case CompOption::TypeBool:
-	    initBoolValue (option->value (), defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeInt:
-	    initIntRestriction (metadata, option->rest (), (char *) path);
-	    initIntValue (option->value (), option->rest (),
-			  defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeFloat:
-	    initFloatRestriction (metadata, option->rest (), (char *) path);
-	    initFloatValue (option->value (), option->rest (),
-			    defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeString:
-	    initStringValue (option->value (), option->rest (),
-			     defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeColor:
-	    initColorValue (option->value (), defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeAction:
-	    initActionState (metadata, option->type (), &state, (char *) path);
-	    initActionValue (option->value (), state,
-			     defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeKey:
-	    initActionState (metadata, option->type (), &state, (char *) path);
-	    initKeyValue (option->value (), state,
-			  defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeButton:
-	    initActionState (metadata, option->type (), &state, (char *) path);
-	    initButtonValue (option->value (), state,
-			     defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeEdge:
-	    initActionState (metadata, option->type (), &state, (char *) path);
-	    initEdgeValue (option->value (), state,
-			   defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeBell:
-	    initActionState (metadata, option->type (), &state, (char *) path);
-	    initBellValue (option->value (), state,
-			   defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeMatch:
-	    helper = boolFromMetadataPathElement (metadata, (char *) path,
-						  "helper", false);
-	    initMatchValue (option->value (), helper,
-			    defaultDoc, defaultNode);
-	    break;
-	case CompOption::TypeList:
-	    value = stringFromMetadataPathElement (metadata, (char *) path,
-						   "type");
-	    if (!value.empty ())
-		option->value ().set (getOptionType (value.c_str ()), emptyList);
-	    else
-		option->value ().set (CompOption::TypeBool, emptyList);
-
-	    switch (option->value ().listType ()) {
-		case CompOption::TypeInt:
-		    initIntRestriction (metadata, option->rest (),
-					(char *) path);
-		    break;
-		case CompOption::TypeFloat:
-		    initFloatRestriction (metadata, option->rest (),
-					  (char *) path);
-		    break;
-		case CompOption::TypeAction:
-		case CompOption::TypeKey:
-		case CompOption::TypeButton:
-		case CompOption::TypeEdge:
-		case CompOption::TypeBell:
-		    initActionState (metadata, option->value ().listType (),
-				     &state, (char *) path);
-		    break;
-		case CompOption::TypeMatch:
-		    helper = boolFromMetadataPathElement (metadata,
-							  (char *) path,
-							  "helper", false);
-		default:
-		    break;
-	    }
-
-	    initListValue (option->value (), option->rest (), state, helper,
-			   defaultDoc, defaultNode);
-	    break;
-    }
-
-    if (defaultDoc)
-	finiXPath (&xDefaultPath);
-
-    finiXPath (&xPath);
-
-    return TRUE;
-}
-
-CompMetadata::CompMetadata (CompString       plugin,
-			    const OptionInfo *optionInfo,
-			    unsigned int     nOptionInfo)
-{
-    priv = new PrivateMetadata (plugin, compPrintf ("plugin[@name=\"%s\"]",
-						    plugin.c_str ()));
-    if (nOptionInfo)
-    {
-	CompIOCtx ctx;
-
-	ctx.offset	  = 0;
-	ctx.name	  = plugin.c_str ();
-	ctx.oInfo  = optionInfo;
-	ctx.nOInfo = nOptionInfo;
-
-	addFromIO (readPluginXmlCallback, NULL, (void *) &ctx);
-    }
-}
-
-CompMetadata::~CompMetadata ()
-{
-    delete priv;
-}
-
-std::vector<xmlDoc *> &
-CompMetadata::doc ()
-{
-    return priv->mDoc;
-}
-
-
-bool
-CompMetadata::addFromFile (CompString file, bool prepend)
-{
-    xmlDoc     *doc;
-    CompString home (getenv ("HOME"));
-    bool       status = false;
-
-    home = getenv ("HOME");
-    if (home.size ())
-    {
-	CompString path = compPrintf ("%s/%s", home.c_str (), HOME_METADATADIR);
-	doc = readXmlFile (file, path);
-	if (doc)
-	{
-	    if (prepend)
-		priv->mDoc.insert (priv->mDoc.begin (), doc);
-	    else
-		priv->mDoc.push_back (doc);
-
-	    status = true;
-	}
-    }
-
-    doc = readXmlFile (file, CompString (METADATADIR));
-    if (doc)
-    {
-	if (prepend)
-	    priv->mDoc.insert (priv->mDoc.begin (), doc);
-	else
-	    priv->mDoc.push_back (doc);
-
-	status |= true;
-    }
-
-    if (!status)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Unable to parse XML metadata from file \"%s%s\"",
-			file.c_str (), EXTENSION);
-
-	return false;
-    }
-
-    return true;
-}
-
-bool
-CompMetadata::addFromString (CompString string, bool prepend)
-{
-    xmlDoc *doc;
-
-    doc = xmlReadMemory (string.c_str (), string.size (), NULL, NULL, 0);
-    if (!doc)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Unable to parse XML metadata");
-
-	return false;
-    }
-
-    if (prepend)
-	priv->mDoc.insert (priv->mDoc.begin (), doc);
-    else
-	priv->mDoc.push_back (doc);
-
-    return true;
-}
-
-bool
-CompMetadata::addFromIO (xmlInputReadCallback  ioread,
-			 xmlInputCloseCallback ioclose,
-			 void                  *ioctx,
-			 bool                  prepend)
-{
-    xmlDoc *doc;
-
-    doc = xmlReadIO (ioread, ioclose, ioctx, NULL, NULL, 0);
-    if (!doc)
-    {
-	compLogMessage ("core", CompLogLevelWarn,
-			"Unable to parse XML metadata");
-
-	return false;
-    }
-
-    if (prepend)
-	priv->mDoc.insert (priv->mDoc.begin (), doc);
-    else
-	priv->mDoc.push_back (doc);
-
-    return true;
-}
-
-bool
-CompMetadata::addFromOptionInfo (const OptionInfo *optionInfo,
-				 unsigned int     nOptionInfo,
-				 bool             prepend)
-{
-    if (nOptionInfo)
-    {
-	CompIOCtx ctx;
-
-	ctx.offset	  = 0;
-	ctx.name	  = priv->mPlugin.c_str ();
-	ctx.oInfo  = optionInfo;
-	ctx.nOInfo = nOptionInfo;
-
-	return addFromIO (readPluginXmlCallback, NULL, (void *) &ctx, prepend);
-    }
-    else
-	return false;
-}
-
-bool
-CompMetadata::initOption (CompOption  *option,
-			  CompString  name)
-{
-    char str[1024];
-
-    sprintf (str, "/compiz/%s/options//option[@name=\"%s\"]",
-	     priv->mPath.c_str (), name.c_str ());
-
-    return initOptionFromMetadataPath (this, option, BAD_CAST str);
-}
-
-bool
-CompMetadata::initOptions (const OptionInfo   *info,
-			   unsigned int       nOptions,
-			   CompOption::Vector &opt)
-{
-    if (opt.size () < nOptions)
-	opt.resize (nOptions);
-
-    for (unsigned int i = 0; i < nOptions; i++)
-    {
-	if (!initOption (&opt[i], info[i].name))
-	{
-	    return false;
-	}
-	
-	if (info[i].initiate)
-	    opt[i].value ().action ().setInitiate  (info[i].initiate);
-
-	if (info[i].terminate)
-	    opt[i].value ().action ().setTerminate (info[i].terminate);
-    }
-
-    return true;
-}
-
-CompString
-CompMetadata::getShortPluginDescription ()
-{
-    return getStringFromPath (
-	compPrintf ("/compiz/%s/short/child::text()", priv->mPath.c_str ()));
-}
-
-CompString
-CompMetadata::getLongPluginDescription ()
-{
-    return getStringFromPath (
-	compPrintf ("/compiz/%s/long/child::text()", priv->mPath.c_str ()));
-}
-
-CompString
-CompMetadata::getShortOptionDescription (CompOption *option)
-{
-    return getStringFromPath (
-	compPrintf (
-	    "/compiz/%s/options//option[@name=\"%s\"]/short/child::text()",
-	    priv->mPath.c_str (), option->name ().c_str ()));
-}
-
-CompString
-CompMetadata::getLongOptionDescription (CompOption *option)
-{
-    return getStringFromPath (
-	compPrintf (
-	    "/compiz/%s/options//option[@name=\"%s\"]/long/child::text()",
-	    priv->mPath.c_str (), option->name ().c_str ()));
-}
-
-
-
-CompString
-CompMetadata::getStringFromPath (CompString path)
-{
-    CompXPath  xPath;
-    CompString v = "";
-
-    if (!initXPathFromMetadataPath (&xPath, this, BAD_CAST path.c_str ()))
-	return "";
-
-    xPath.obj = xmlXPathConvertString (xPath.obj);
-
-    if (xPath.obj->type == XPATH_STRING && xPath.obj->stringval)
-	v = (char *) xPath.obj->stringval;
-
-    finiXPath (&xPath);
-
-    return v;
-}
-
-unsigned int
-CompMetadata::readXmlChunk (const char   *src,
-			    unsigned int *offset,
-			    char         *buffer,
-			    unsigned int length)
-{
-    unsigned int srcLength = strlen (src);
-    unsigned int srcOffset = *offset;
-
-    if (srcOffset > srcLength)
-	srcOffset = srcLength;
-
-    *offset -= srcOffset;
-
-    src += srcOffset;
-    srcLength -= srcOffset;
-
-    if (srcLength > 0 && length > 0)
-    {
-	if (srcLength < length)
-	    length = srcLength;
-
-	memcpy (buffer, src, length);
-
-	return length;
-    }
-
-    return 0;
-}
-
-unsigned int
-CompMetadata::readXmlChunkFromOptionInfo (const CompMetadata::OptionInfo *info,
-					  unsigned int                   *offset,
-					  char                           *buffer,
-					  unsigned int                   length)
-{
-    unsigned int i;
-
-    i = readXmlChunk ("<option name=\"", offset, buffer, length);
-    i += readXmlChunk (info->name, offset, buffer + i, length - i);
-
-    if (info->type)
-    {
-	i += readXmlChunk ("\" type=\"", offset, buffer + i, length - i);
-	i += readXmlChunk (info->type, offset, buffer + i, length - i);
-    }
-
-    if (info->data)
-    {
-	i += readXmlChunk ("\">", offset, buffer + i, length - i);
-	i += readXmlChunk (info->data, offset, buffer + i, length - i);
-	i += readXmlChunk ("</option>", offset, buffer + i, length - i);
-    }
-    else
-    {
-	i += readXmlChunk ("\"/>", offset, buffer + i, length - i);
-    }
-
-    return i;
-}
-
-PrivateMetadata::PrivateMetadata (CompString plugin, CompString path) :
-    mPlugin (plugin),
-    mPath (path),
-    mDoc (0)
-{
-}
-
-PrivateMetadata::~PrivateMetadata ()
-{
-    foreach (xmlDoc *d, mDoc)
-	xmlFreeDoc (d);
-}
-

=== removed file 'legacy/metadata.h'
--- legacy/metadata.h	2009-03-15 23:01:28 +0000
+++ legacy/metadata.h	1970-01-01 00:00:00 +0000
@@ -1,106 +0,0 @@
-/*
- * Copyright © 2008 Dennis Kasprzyk
- * Copyright © 2007 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Dennis Kasprzyk not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Dennis Kasprzyk makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * DENNIS KASPRZYK DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL DENNIS KASPRZYK BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Authors: Dennis Kasprzyk <[e-mail]>
- *          David Reveman <[e-mail]>
- */
-
-#ifndef _COMPMETADATA_H
-#define _COMPMETADATA_H
-
-#include <vector>
-
-#include <libxml/parser.h>
-
-#include <core/action.h>
-
-#define STRINGIFY(x) #x
-#define TOSTRING(x) STRINGIFY (x)
-#define MINTOSTRING(x) "<min>" TOSTRING (x) "</min>"
-#define MAXTOSTRING(x) "<max>" TOSTRING (x) "</max>"
-#define RESTOSTRING(min, max) MINTOSTRING (min) MAXTOSTRING (max)
-
-class PrivateMetadata;
-
-class CompMetadata {
-    public:
-	struct OptionInfo {
-	    const char           *name;
-	    const char           *type;
-	    const char           *data;
-	    CompAction::CallBack initiate;
-	    CompAction::CallBack terminate;
-	};
-    public:
-        CompMetadata (CompString       plugin = "core",
-		      const OptionInfo *optionInfo = NULL,
-		      unsigned int     nOptionInfo = 0);
-	~CompMetadata ();
-
-	std::vector<xmlDoc *> &doc ();
-
-	bool addFromFile (CompString file, bool prepend = false);
-	bool addFromString (CompString string, bool prepend = false);
-	bool addFromIO (xmlInputReadCallback  ioread,
-		        xmlInputCloseCallback ioclose,
-		        void                  *ioctx,
-		        bool                  prepend = false);
-	bool addFromOptionInfo (const OptionInfo *optionInfo,
-		                unsigned int     nOptionInfo,
-				bool             prepend = false);
-
-	bool initOption (CompOption *option,
-			 CompString name);
-
-	bool initOptions (const OptionInfo   *info,
-			  unsigned int       nOptions,
-			  CompOption::Vector &options);
-
-
-
-	CompString getShortPluginDescription ();
-
-	CompString getLongPluginDescription ();
-
-	CompString getShortOptionDescription (CompOption *option);
-
-	CompString getLongOptionDescription (CompOption *option);
-	
-	CompString getStringFromPath (CompString path);
-
-	static unsigned int readXmlChunk (const char   *src,
-					  unsigned int *offset,
-					  char         *buffer,
-					  unsigned int length);
-
-	static unsigned int
-	readXmlChunkFromOptionInfo (const CompMetadata::OptionInfo *info,
-				    unsigned int                   *offset,
-				    char                           *buffer,
-				    unsigned int                   length);
-
-    private:
-	PrivateMetadata *priv;
-};
-
-#endif

=== removed file 'legacy/minimize.cpp'
--- legacy/minimize.cpp	2009-03-15 05:15:26 +0000
+++ legacy/minimize.cpp	1970-01-01 00:00:00 +0000
@@ -1,1059 +0,0 @@
-/*
- * Copyright © 2005 Novell, Inc.
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Novell, Inc. not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Novell, Inc. makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.
- *
- * NOVELL, INC. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
- * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN
- * NO EVENT SHALL NOVELL, INC. BE LIABLE FOR ANY SPECIAL, INDIRECT OR
- * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
- * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
- * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
- * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
- *
- * Author: David Reveman <[e-mail]>
- */
-
-#include <X11/Xatom.h>
-
-#include <stdlib.h>
-#include <string.h>
-#include <math.h>
-
-#include <compiz-core.h>
-
-static CompMetadata minMetadata;
-
-static int displayPrivateIndex;
-
-typedef struct _MinDisplay {
-    int		    screenPrivateIndex;
-    HandleEventProc handleEvent;
-    Atom	    winChangeStateAtom;
-} MinDisplay;
-
-#define MIN_SCREEN_OPTION_SPEED		   0
-#define MIN_SCREEN_OPTION_TIMESTEP	   1
-#define MIN_SCREEN_OPTION_WINDOW_MATCH	   2
-#define MIN_SCREEN_OPTION_SHADE_RESISTANCE 3
-#define MIN_SCREEN_OPTION_NUM		   4
-
-typedef struct _MinScreen {
-    int	windowPrivateIndex;
-
-    CompOption opt[MIN_SCREEN_OPTION_NUM];
-
-    PreparePaintScreenProc preparePaintScreen;
-    DonePaintScreenProc    donePaintScreen;
-    PaintOutputProc        paintOutput;
-    PaintWindowProc        paintWindow;
-    DamageWindowRectProc   damageWindowRect;
-    FocusWindowProc	   focusWindow;
-
-    int shadeStep;
-    int moreAdjust;
-} MinScreen;
-
-typedef struct _MinWindow {
-    GLfloat xVelocity, yVelocity, xScaleVelocity, yScaleVelocity;
-    GLfloat xScale, yScale;
-    GLfloat tx, ty;
-
-    Bool adjust;
-
-    int state, newState;
-
-    int    shade;
-    Region region;
-
-    int unmapCnt;
-
-    Bool ignoreDamage;
-} MinWindow;
-
-#define GET_MIN_DISPLAY(d)					 \
-    ((MinDisplay *) (d)->base.privates[displayPrivateIndex].ptr)
-
-#define MIN_DISPLAY(d)			 \
-    MinDisplay *md = GET_MIN_DISPLAY (d)
-
-#define GET_MIN_SCREEN(s, md)					     \
-    ((MinScreen *) (s)->base.privates[(md)->screenPrivateIndex].ptr)
-
-#define MIN_SCREEN(s)						     \
-    MinScreen *ms = GET_MIN_SCREEN (s, GET_MIN_DISPLAY (s->display))
-
-#define GET_MIN_WINDOW(w, ms)					     \
-    ((MinWindow *) (w)->base.privates[(ms)->windowPrivateIndex].ptr)
-
-#define MIN_WINDOW(w)					   \
-    MinWindow *mw = GET_MIN_WINDOW  (w,			   \
-		    GET_MIN_SCREEN  (w->screen,		   \
-		    GET_MIN_DISPLAY (w->screen->display)))
-
-#define NUM_OPTIONS(s) (sizeof ((s)->opt) / sizeof (CompOption))
-
-static CompOption *
-minGetScreenOptions (CompPlugin *plugin,
-		     CompScreen *screen,
-		     int	*count)
-{
-    MIN_SCREEN (screen);
-
-    *count = NUM_OPTIONS (ms);
-    return ms->opt;
-}
-
-static Bool
-minSetScreenOption (CompPlugin      *plugin,
-		    CompScreen      *screen,
-		    const char	    *name,
-		    CompOptionValue *value)
-{
-    CompOption *o;
-    int	       index;
-
-    MIN_SCREEN (screen);
-
-    o = compFindOption (ms->opt, NUM_OPTIONS (ms), name, &index);
-    if (!o)
-	return FALSE;
-
-    switch (index) {
-    case MIN_SCREEN_OPTION_SHADE_RESISTANCE:
-	if (compSetIntOption (o, value))
-	{
-	    if (o->value.i)
-		ms->shadeStep = o->rest.i.max - o->value.i + 1;
-	    else
-		ms->shadeStep = 0;
-
-	    return TRUE;
-	}
-	break;
-    default:
-	if (compSetOption (o, value))
-	    return TRUE;
-	break;
-    }
-
-    return FALSE;
-}
-
-static void
-minSetShade (CompWindow *w,
-	     int	shade)
-{
-    REGION rect;
-    int	   h = w->attrib.height + w->attrib.border_width * 2;
-
-    MIN_WINDOW (w);
-
-    EMPTY_REGION (w->region);
-
-    rect.rects = &rect.extents;
-    rect.numRects = rect.size = 1;
-
-    w->height = shade;
-
-    rect.extents.x1 = 0;
-    rect.extents.y1 = h - shade;
-    rect.extents.x2 = w->width;
-    rect.extents.y2 = h;
-
-    XIntersectRegion (mw->region, &rect, w->region);
-    XOffsetRegion (w->region, w->attrib.x, w->attrib.y - (h - shade));
-
-    w->matrix = w->texture->matrix;
-    w->matrix.x0 -= (w->attrib.x * w->matrix.xx);
-    w->matrix.y0 -= ((w->attrib.y - (h - shade)) * w->matrix.yy);
-
-    (*w->screen->windowResizeNotify) (w, 0, 0, 0, 0);
-}
-
-static int
-minGetWindowState (CompWindow *w)
-{
-    Atom	  actual;
-    int		  result, format;
-    unsigned long n, left;
-    unsigned char *data;
-
-    result = XGetWindowProperty (w->screen->display->display, w->id,
-				 w->screen->display->wmStateAtom, 0L, 1L, FALSE,
-				 w->screen->display->wmStateAtom,
-				 &actual, &format, &n, &left, &data);
-
-    if (result == Success && n && data)
-    {
-	int state;
-
-	memcpy (&state, data, sizeof (int));
-	XFree ((void *) data);
-
-	return state;
-    }
-
-    return WithdrawnState;
-}
-
-static int
-adjustMinVelocity (CompWindow *w)
-{
-    float dx, dy, dxs, dys, adjust, amount;
-    float x1, y1, xScale, yScale;
-
-    MIN_WINDOW (w);
-
-    if (mw->newState == IconicState)
-    {
-	x1 = w->iconGeometry.x;
-	y1 = w->iconGeometry.y;
-	xScale = (float) w->iconGeometry.width  / w->width;
-	yScale = (float) w->iconGeometry.height / w->height;
-    }
-    else
-    {
-	x1 = w->serverX;
-	y1 = w->serverY;
-	xScale = yScale = 1.0f;
-    }
-
-    dx = x1 - (w->attrib.x + mw->tx);
-
-    adjust = dx * 0.15f;
-    amount = fabs (dx) * 1.5f;
-    if (amount < 0.5f)
-	amount = 0.5f;
-    else if (amount > 5.0f)
-	amount = 5.0f;
-
-    mw->xVelocity = (amount * mw->xVelocity + adjust) / (amount + 1.0f);
-
-    dy = y1 - (w->attrib.y + mw->ty);
-
-    adjust = dy * 0.15f;
-    amount = fabs (dy) * 1.5f;
-    if (amount < 0.5f)
-	amount = 0.5f;
-    else if (amount > 5.0f)
-	amount = 5.0f;
-
-    mw->yVelocity = (amount * mw->yVelocity + adjust) / (amount + 1.0f);
-
-    dxs = xScale - mw->xScale;
-
-    adjust = dxs * 0.15f;
-    amount = fabs (dxs) * 10.0f;
-    if (amount < 0.01f)
-	amount = 0.01f;
-    else if (amount > 0.15f)
-	amount = 0.15f;
-
-    mw->xScaleVelocity = (amount * mw->xScaleVelocity + adjust) /
-	(amount + 1.0f);
-
-    dys = yScale - mw->yScale;
-
-    adjust = dys * 0.15f;
-    amount = fabs (dys) * 10.0f;
-    if (amount < 0.01f)
-	amount = 0.01f;
-    else if (amount > 0.15f)
-	amount = 0.15f;
-
-    mw->yScaleVelocity = (amount * mw->yScaleVelocity + adjust) /
-	(amount + 1.0f);
-
-    if (fabs (dx) < 0.1f    && fabs (mw->xVelocity)      < 0.2f   &&
-	fabs (dy) < 0.1f    && fabs (mw->yVelocity)      < 0.2f   &&
-	fabs (dxs) < 0.001f && fabs (mw->xScaleVelocity) < 0.002f &&
-	fabs (dys) < 0.001f && fabs (mw->yScaleVelocity) < 0.002f)
-    {
-	mw->xVelocity = mw->yVelocity = mw->xScaleVelocity =
-	    mw->yScaleVelocity = 0.0f;
-	mw->tx = x1 - w->attrib.x;
-	mw->ty = y1 - w->attrib.y;
-	mw->xScale = xScale;
-	mw->yScale = yScale;
-
-	return 0;
-    }
-
-    return 1;
-}
-
-static void
-minPreparePaintScreen (CompScreen *s,
-		       int	  msSinceLastPaint)
-{
-    MIN_SCREEN (s);
-
-    if (ms->moreAdjust)
-    {
-	CompWindow *w;
-	int        steps, h;
-	float      amount, chunk;
-
-	amount = msSinceLastPaint * 0.05f *
-	    ms->opt[MIN_SCREEN_OPTION_SPEED].value.f;
-	steps  = amount / (0.5f * ms->opt[MIN_SCREEN_OPTION_TIMESTEP].value.f);
-	if (!steps) steps = 1;
-	chunk  = amount / (float) steps;
-
-	while (steps--)
-	{
-	    ms->moreAdjust = 0;
-
-	    for (w = s->windows; w; w = w->next)
-	    {
-		MIN_WINDOW (w);
-
-		if (mw->adjust)
-		{
-		    mw->adjust = adjustMinVelocity (w);
-
-		    ms->moreAdjust |= mw->adjust;
-
-		    mw->tx += mw->xVelocity * chunk;
-		    mw->ty += mw->yVelocity * chunk;
-		    mw->xScale += mw->xScaleVelocity * chunk;
-		    mw->yScale += mw->yScaleVelocity * chunk;
-
-		    if (!mw->adjust)
-		    {
-			mw->state = mw->newState;
-
-			mw->ignoreDamage = TRUE;
-			while (mw->unmapCnt)
-			{
-			    unmapWindow (w);
-			    mw->unmapCnt--;
-			}
-			mw->ignoreDamage = FALSE;
-		    }
-		}
-		else if (mw->region && w->damaged)
-		{
-		    if (w->shaded)
-		    {
-			if (mw->shade > 0)
-			{
-			    mw->shade -= (chunk * ms->shadeStep) + 1;
-
-			    if (mw->shade > 0)
-			    {
-				ms->moreAdjust = TRUE;
-			    }
-			    else
-			    {
-				mw->shade = 0;
-
-				mw->ignoreDamage = TRUE;
-				while (mw->unmapCnt)
-				{
-				    unmapWindow (w);
-				    mw->unmapCnt--;
-				}
-				mw->ignoreDamage = FALSE;
-			    }
-			}
-		    }
-		    else
-		    {
-			h = w->attrib.height + w->attrib.border_width * 2;
-			if (mw->shade < h)
-			{
-			    mw->shade += (chunk * ms->shadeStep) + 1;
-
-			    if (mw->shade < h)
-			    {
-				ms->moreAdjust = TRUE;
-			    }
-			    else
-			    {
-				mw->shade = MAXSHORT;
-
-				minSetShade (w, h);
-
-				XDestroyRegion (mw->region);
-				mw->region = NULL;
-
-				addWindowDamage (w);
-			    }
-			}
-		    }
-		}
-	    }
-
-	    if (!ms->moreAdjust)
-		break;
-	}
-
-	if (ms->moreAdjust)
-	{
-	    for (w = s->windows; w; w = w->next)
-	    {
-		MIN_WINDOW (w);
-
-		if (mw->adjust)
-		{
-		    addWindowDamage (w);
-		}
-		else if (mw->region && w->damaged)
-		{
-		    h = w->attrib.height + w->attrib.border_width * 2;
-		    if (mw->shade && mw->shade < h)
-		    {
-			minSetShade (w, mw->shade);
-			addWindowDamage (w);
-		    }
-		}
-	    }
-	}
-    }
-
-    UNWRAP (ms, s, preparePaintScreen);
-    (*s->preparePaintScreen) (s, msSinceLastPaint);
-    WRAP (ms, s, preparePaintScreen, minPreparePaintScreen);
-}
-
-static void
-minDonePaintScreen (CompScreen *s)
-{
-    MIN_SCREEN (s);
-
-    if (ms->moreAdjust)
-    {
-	CompWindow *w;
-	int	   h;
-
-	for (w = s->windows; w; w = w->next)
-	{
-	    MIN_WINDOW (w);
-
-	    if (mw->adjust)
-	    {
-		addWindowDamage (w);
-	    }
-	    else if (mw->region)
-	    {
-		h = w->attrib.height + w->attrib.border_width * 2;
-		if (mw->shade && mw->shade < h)
-		    addWindowDamage (w);
-	    }
-	}
-    }
-
-    UNWRAP (ms, s, donePaintScreen);
-    (*s->donePaintScreen) (s);
-    WRAP (ms, s, donePaintScreen, minDonePaintScreen);
-}
-
-static Bool
-minPaintOutput (CompScreen		*s,
-		const ScreenPaintAttrib *sAttrib,
-		const CompTransform	*transform,
-		Region		        region,
-		CompOutput		*output,
-		unsigned int		mask)
-{
-    Bool status;
-
-    MIN_SCREEN (s);
-
-    if (ms->moreAdjust)
-	mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
-
-    UNWRAP (ms, s, paintOutput);
-    status = (*s->paintOutput) (s, sAttrib, transform, region, output, mask);
-    WRAP (ms, s, paintOutput, minPaintOutput);
-
-    return status;
-}
-
-static Bool
-minPaintWindow (CompWindow		*w,
-		const WindowPaintAttrib *attrib,
-		const CompTransform	*transform,
-		Region			region,
-		unsigned int		mask)
-{
-    CompScreen *s = w->screen;
-    Bool       status;
-
-    MIN_SCREEN (s);
-    MIN_WINDOW (w);
-
-    if (mw->adjust)
-    {
-	FragmentAttrib fragment;
-	CompTransform  wTransform = *transform;
-
-	if (mask & PAINT_WINDOW_OCCLUSION_DETECTION_MASK)
-	    return FALSE;
-
-	UNWRAP (ms, s, paintWindow);
-	status = (*s->paintWindow) (w, attrib, transform, region,
-				    mask | PAINT_WINDOW_NO_CORE_INSTANCE_MASK);
-	WRAP (ms, s, paintWindow, minPaintWindow);
-
-	initFragmentAttrib (&fragment, &w->lastPaint);
-
-	if (w->alpha || fragment.opacity != OPAQUE)
-	    mask |= PAINT_WINDOW_TRANSLUCENT_MASK;
-
-	matrixTranslate (&wTransform, w->attrib.x, w->attrib.y, 0.0f);
-	matrixScale (&wTransform, mw->xScale, mw->yScale, 1.0f);
-	matrixTranslate (&wTransform,
-			 mw->tx / mw->xScale - w->attrib.x,
-			 mw->ty / mw->yScale - w->attrib.y,
-			 0.0f);
-
-	glPushMatrix ();
-	glLoadMatrixf (wTransform.m);
-
-	(*s->drawWindow) (w, &wTransform, &fragment, region,
-			  mask | PAINT_WINDOW_TRANSFORMED_MASK);
-
-	glPopMatrix ();
-    }
-    else
-    {
-	/* no core instance from windows that have been animated */
-	if (mw->state == IconicState)
-	    mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
-
-	UNWRAP (ms, s, paintWindow);
-	status = (*s->paintWindow) (w, attrib, transform, region, mask);
-	WRAP (ms, s, paintWindow, minPaintWindow);
-    }
-
-    return status;
-}
-
-static void
-minHandleEvent (CompDisplay *d,
-		XEvent      *event)
-{
-    CompWindow *w;
-
-    MIN_DISPLAY (d);
-
-    switch (event->type) {
-    case MapNotify:
-	w = findWindowAtDisplay (d, event->xmap.window);
-	if (w)
-	{
-	    MIN_WINDOW (w);
-
-	    if (mw->adjust)
-		mw->state = mw->newState;
-
-	    if (mw->region)
-		w->height = 0;
-
-	    mw->ignoreDamage = TRUE;
-	    while (mw->unmapCnt)
-	    {
-		unmapWindow (w);
-		mw->unmapCnt--;
-	    }
-	    mw->ignoreDamage = FALSE;
-	}
-	break;
-    case UnmapNotify:
-	w = findWindowAtDisplay (d, event->xunmap.window);
-	if (w)
-	{
-	    MIN_SCREEN (w->screen);
-
-	    if (w->pendingUnmaps && onCurrentDesktop (w)) /* Normal -> Iconic */
-	    {
-		CompMatch *match =
-		    &ms->opt[MIN_SCREEN_OPTION_WINDOW_MATCH].value.match;
-
-		MIN_WINDOW (w);
-
-		if (w->shaded)
-		{
-		    if (!mw->region)
-			mw->region = XCreateRegion ();
-
-		    if (mw->region && ms->shadeStep)
-		    {
-			XSubtractRegion (w->region, &emptyRegion, mw->region);
-			XOffsetRegion (mw->region, -w->attrib.x,
-				       w->attrib.height +
-				       w->attrib.border_width * 2 -
-				       w->height - w->attrib.y);
-
-			mw->shade = w->height;
-
-			mw->adjust     = FALSE;
-			ms->moreAdjust = TRUE;
-
-			mw->unmapCnt++;
-			w->unmapRefCnt++;
-
-			addWindowDamage (w);
-		    }
-		}
-		else if (!w->invisible && matchEval (match, w))
-		{
-		    if (w->iconGeometrySet)
-		    {
-			mw->newState = IconicState;
-
-			mw->xScale = w->paint.xScale;
-			mw->yScale = w->paint.yScale;
-			mw->tx	   = w->attrib.x - w->serverX;
-			mw->ty	   = w->attrib.y - w->serverY;
-
-			if (mw->region)
-			{
-			    XDestroyRegion (mw->region);
-			    mw->region = NULL;
-			}
-
-			mw->shade = MAXSHORT;
-
-			mw->adjust     = TRUE;
-			ms->moreAdjust = TRUE;
-
-			mw->unmapCnt++;
-			w->unmapRefCnt++;
-
-			addWindowDamage (w);
-		    }
-		}
-	    }
-	    else  /* X -> Withdrawn */
-	    {
-		MIN_WINDOW (w);
-
-		if (mw->adjust)
-		{
-		    mw->adjust = FALSE;
-		    mw->xScale = mw->yScale = 1.0f;
-		    mw->tx = mw->ty = 0.0f;
-		    mw->xVelocity = mw->yVelocity = 0.0f;
-		    mw->xScaleVelocity = mw->yScaleVelocity = 1.0f;
-		    mw->shade = MAXSHORT;
-
-		    if (mw->region)
-		    {
-			XDestroyRegion (mw->region);
-			mw->region = NULL;
-		    }
-		}
-
-		mw->state = NormalState;
-	    }
-	}
-    default:
-	break;
-    }
-
-    UNWRAP (md, d, handleEvent);
-    (*d->handleEvent) (d, event);
-    WRAP (md, d, handleEvent, minHandleEvent);
-}
-
-static Bool
-minDamageWindowRect (CompWindow *w,
-		     Bool	initial,
-		     BoxPtr     rect)
-{
-    Bool status = FALSE;
-
-    MIN_SCREEN (w->screen);
-    MIN_WINDOW (w);
-
-    if (mw->ignoreDamage)
-	return TRUE;
-
-    if (initial)
-    {
-	if (mw->state == IconicState)
-	{
-	    CompMatch *match =
-		&ms->opt[MIN_SCREEN_OPTION_WINDOW_MATCH].value.match;
-
-	    mw->state = NormalState;
-
-	    if (!w->invisible	   &&
-		w->iconGeometrySet &&
-		matchEval (match, w))
-	    {
-		if (!mw->adjust)
-		{
-		    mw->adjust     = TRUE;
-		    ms->moreAdjust = TRUE;
-
-		    mw->tx     = w->iconGeometry.x - w->serverX;
-		    mw->ty     = w->iconGeometry.y - w->serverY;
-		    mw->xScale = (float) w->iconGeometry.width  / w->width;
-		    mw->yScale = (float) w->iconGeometry.height / w->height;
-
-		    addWindowDamage (w);
-		}
-	    }
-	}
-	else if (mw->region && mw->shade < w->height)
-	{
-	    if (ms->shadeStep && !w->invisible)
-	    {
-		XSubtractRegion (w->region, &emptyRegion, mw->region);
-		XOffsetRegion (mw->region, -w->attrib.x, -w->attrib.y);
-
-		/* bind pixmap here so we have something to unshade with */
-		if (!w->texture->pixmap && !w->bindFailed)
-		    bindWindow (w);
-
-		ms->moreAdjust = TRUE;
-	    }
-	    else
-	    {
-		mw->shade = MAXSHORT;
-	    }
-	}
-
-	mw->newState = NormalState;
-    }
-    else if (mw->adjust)
-    {
-	damageTransformedWindowRect (w,
-				     mw->xScale,
-				     mw->yScale,
-				     mw->tx,
-				     mw->ty,
-				     rect);
-
-	status = TRUE;
-    }
-
-    UNWRAP (ms, w->screen, damageWindowRect);
-    status |= (*w->screen->damageWindowRect) (w, initial, rect);
-    WRAP (ms, w->screen, damageWindowRect, minDamageWindowRect);
-
-    return status;
-}
-
-static Bool
-minFocusWindow (CompWindow *w)
-{
-    Bool status;
-
-    MIN_SCREEN (w->screen);
-    MIN_WINDOW (w);
-
-    if (mw->unmapCnt)
-	return FALSE;
-
-    UNWRAP (ms, w->screen, focusWindow);
-    status = (*w->screen->focusWindow) (w);
-    WRAP (ms, w->screen, focusWindow, minFocusWindow);
-
-    return status;
-}
-
-static Bool
-minInitDisplay (CompPlugin  *p,
-		CompDisplay *d)
-{
-    MinDisplay *md;
-
-    if (!checkPluginABI ("core", CORE_ABIVERSION))
-	return FALSE;
-
-    md = malloc (sizeof (MinDisplay));
-    if (!md)
-	return FALSE;
-
-    md->screenPrivateIndex = allocateScreenPrivateIndex (d);
-    if (md->screenPrivateIndex < 0)
-    {
-	free (md);
-	return FALSE;
-    }
-
-    md->winChangeStateAtom  = XInternAtom (d->display, "WM_CHANGE_STATE", 0);
-
-    WRAP (md, d, handleEvent, minHandleEvent);
-
-    d->base.privates[displayPrivateIndex].ptr = md;
-
-    return TRUE;
-}
-
-static void
-minFiniDisplay (CompPlugin  *p,
-		CompDisplay *d)
-{
-    MIN_DISPLAY (d);
-
-    freeScreenPrivateIndex (d, md->screenPrivateIndex);
-
-    UNWRAP (md, d, handleEvent);
-
-    free (md);
-}
-
-static const CompMetadataOptionInfo minScreenOptionInfo[] = {
-    { "speed", "float", "<min>0.1</min>", 0, 0 },
-    { "timestep", "float", "<min>0.1</min>", 0, 0 },
-    { "window_match", "match", 0, 0, 0 },
-    { "shade_resistance", "int", "<min>0</min><max>100</max>", 0, 0 }
-};
-
-static Bool
-minInitScreen (CompPlugin *p,
-	       CompScreen *s)
-{
-    MinScreen *ms;
-
-    MIN_DISPLAY (s->display);
-
-    ms = malloc (sizeof (MinScreen));
-    if (!ms)
-	return FALSE;
-
-    if (!compInitScreenOptionsFromMetadata (s,
-					    &minMetadata,
-					    minScreenOptionInfo,
-					    ms->opt,
-					    MIN_SCREEN_OPTION_NUM))
-    {
-	free (ms);
-	return FALSE;
-    }
-
-    ms->windowPrivateIndex = allocateWindowPrivateIndex (s);
-    if (ms->windowPrivateIndex < 0)
-    {
-	compFiniScreenOptions (s, ms->opt, MIN_SCREEN_OPTION_NUM);
-	free (ms);
-	return FALSE;
-    }
-
-    ms->moreAdjust = FALSE;
-    ms->shadeStep  = ms->opt[MIN_SCREEN_OPTION_SHADE_RESISTANCE].rest.i.max -
-	ms->opt[MIN_SCREEN_OPTION_SHADE_RESISTANCE].value.i + 1;
-
-    WRAP (ms, s, preparePaintScreen, minPreparePaintScreen);
-    WRAP (ms, s, donePaintScreen, minDonePaintScreen);
-    WRAP (ms, s, paintOutput, minPaintOutput);
-    WRAP (ms, s, paintWindow, minPaintWindow);
-    WRAP (ms, s, damageWindowRect, minDamageWindowRect);
-    WRAP (ms, s, focusWindow, minFocusWindow);
-
-    s->base.privates[md->screenPrivateIndex].ptr = ms;
-
-    return TRUE;
-}
-
-static void
-minFiniScreen (CompPlugin *p,
-	       CompScreen *s)
-{
-    MIN_SCREEN (s);
-
-    freeWindowPrivateIndex (s, ms->windowPrivateIndex);
-
-    UNWRAP (ms, s, preparePaintScreen);
-    UNWRAP (ms, s, donePaintScreen);
-    UNWRAP (ms, s, paintOutput);
-    UNWRAP (ms, s, paintWindow);
-    UNWRAP (ms, s, damageWindowRect);
-    UNWRAP (ms, s, focusWindow);
-
-    compFiniScreenOptions (s, ms->opt, MIN_SCREEN_OPTION_NUM);
-
-    free (ms);
-}
-
-static Bool
-minInitWindow (CompPlugin *p,
-	       CompWindow *w)
-{
-    MinWindow *mw;
-
-    MIN_SCREEN (w->screen);
-
-    mw = malloc (sizeof (MinWindow));
-    if (!mw)
-	return FALSE;
-
-    mw->xScale = mw->yScale = 1.0f;
-    mw->tx = mw->ty = 0.0f;
-    mw->adjust = FALSE;
-    mw->xVelocity = mw->yVelocity = 0.0f;
-    mw->xScaleVelocity = mw->yScaleVelocity = 1.0f;
-
-    mw->unmapCnt = 0;
-
-    mw->ignoreDamage = FALSE;
-
-    if (w->state & CompWindowStateHiddenMask)
-    {
-	if (w->shaded)
-	{
-	    mw->state = mw->newState = NormalState;
-	    mw->shade = 0;
-	    mw->region = XCreateRegion ();
-	}
-	else
-	{
-	    mw->state = mw->newState = minGetWindowState (w);
-	    mw->shade = MAXSHORT;
-	    mw->region = NULL;
-	}
-    }
-    else
-    {
-	    mw->state = mw->newState = NormalState;
-	    mw->shade = MAXSHORT;
-	    mw->region = NULL;
-    }
-
-    w->base.privates[ms->windowPrivateIndex].ptr = mw;
-
-    return TRUE;
-}
-
-static void
-minFiniWindow (CompPlugin *p,
-	       CompWindow *w)
-{
-    MIN_WINDOW (w);
-
-    mw->ignoreDamage = TRUE;
-    while (mw->unmapCnt--)
-	unmapWindow (w);
-    mw->ignoreDamage = FALSE;
-
-    if (mw->region)
-	XDestroyRegion (mw->region);
-
-    free (mw);
-}
-
-static CompBool
-minInitObject (CompPlugin *p,
-	       CompObject *o)
-{
-    static InitPluginObjectProc dispTab[] = {
-	(InitPluginObjectProc) 0, /* InitCore */
-	(InitPluginObjectProc) minInitDisplay,
-	(InitPluginObjectProc) minInitScreen,
-	(InitPluginObjectProc) minInitWindow
-    };
-
-    RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
-}
-
-static void
-minFiniObject (CompPlugin *p,
-	       CompObject *o)
-{
-    static FiniPluginObjectProc dispTab[] = {
-	(FiniPluginObjectProc) 0, /* FiniCore */
-	(FiniPluginObjectProc) minFiniDisplay,
-	(FiniPluginObjectProc) minFiniScreen,
-	(FiniPluginObjectProc) minFiniWindow
-    };
-
-    DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
-}
-
-static CompOption *
-minGetObjectOptions (CompPlugin *plugin,
-		     CompObject *object,
-		     int	*count)
-{
-    static GetPluginObjectOptionsProc dispTab[] = {
-	(GetPluginObjectOptionsProc) 0, /* GetCoreOptions */
-	(GetPluginObjectOptionsProc) 0, /* GetDisplayOptions */
-	(GetPluginObjectOptionsProc) minGetScreenOptions
-    };
-
-    RETURN_DISPATCH (object, dispTab, ARRAY_SIZE (dispTab),
-		     (void *) (*count = 0), (plugin, object, count));
-}
-
-static CompBool
-minSetObjectOption (CompPlugin      *plugin,
-		    CompObject      *object,
-		    const char      *name,
-		    CompOptionValue *value)
-{
-    static SetPluginObjectOptionProc dispTab[] = {
-	(SetPluginObjectOptionProc) 0, /* SetCoreOption */
-	(SetPluginObjectOptionProc) 0, /* SetDisplayOption */
-	(SetPluginObjectOptionProc) minSetScreenOption
-    };
-
-    RETURN_DISPATCH (object, dispTab, ARRAY_SIZE (dispTab), FALSE,
-		     (plugin, object, name, value));
-}
-
-static Bool
-minInit (CompPlugin *p)
-{
-    if (!compInitPluginMetadataFromInfo (&minMetadata,
-					 p->vTable->name, 0, 0,
-					 minScreenOptionInfo,
-					 MIN_SCREEN_OPTION_NUM))
-	return FALSE;
-
-    displayPrivateIndex = allocateDisplayPrivateIndex ();
-    if (displayPrivateIndex < 0)
-    {
-	compFiniMetadata (&minMetadata);
-	return FALSE;
-    }
-
-    compAddMetadataFromFile (&minMetadata, p->vTable->name);
-
-    return TRUE;
-}
-
-static void
-minFini (CompPlugin *p)
-{
-    freeDisplayPrivateIndex (displayPrivateIndex);
-    compFiniMetadata (&minMetadata);
-}
-
-static CompMetadata *
-minGetMetadata (CompPlugin *plugin)
-{
-    return &minMetadata;
-}
-
-static CompPluginVTable minVTable = {
-    "minimize",
-    minGetMetadata,
-    minInit,
-    minFini,
-    minInitObject,
-    minFiniObject,
-    minGetObjectOptions,
-    minSetObjectOption
-};
-
-CompPluginVTable *
-getCompPluginInfo20070830 (void)
-{
-    return &minVTable;
-}

=== removed file 'legacy/minimize.xml.in'
--- legacy/minimize.xml.in	2009-03-15 05:15:26 +0000
+++ legacy/minimize.xml.in	1970-01-01 00:00:00 +0000
@@ -1,43 +0,0 @@
-<compiz>
-    <plugin name="minimize">
-	<_short>Minimize Effect</_short>
-	<_long>Transform windows when they are minimized and unminimized</_long>
-	<feature>windowanimations</feature>
-	<deps>
-	    <relation type="before">
-		<plugin>cube</plugin>
-		<plugin>scale</plugin>
-	    </relation>
-	</deps>
-	<screen>
-	    <option name="speed" type="float">
-		<_short>Speed</_short>
-		<_long>Minimize speed</_long>
-		<default>1.5</default>
-		<min>0.1</min>
-		<max>50.0</max>
-		<precision>0.1</precision>
-	    </option>
-	    <option name="timestep" type="float">
-		<_short>Timestep</_short>
-		<_long>Minimize timestep</_long>
-		<default>0.5</default>
-		<min>0.1</min>
-		<max>50.0</max>
-		<precision>0.1</precision>
-	    </option>
-	    <option name="window_match" type="match">
-		<_short>Minimize Windows</_short>
-		<_long>Windows that should be transformed when minimized</_long>
-		<default>toolbar | utility | dialog | normal</default>
-	    </option>
-	    <option name="shade_resistance" type="int">
-		<_short>Shade Resistance</_short>
-		<_long>Shade resistance</_long>
-		<default>75</default>
-		<min>0</min>
-		<max>100</max>
-	    </option>
-	</screen>
-    </plugin>
-</compiz>

=== removed file 'legacy/privatemetadata.h'
--- legacy/privatemetadata.h	2009-03-15 23:01:28 +0000
+++ legacy/privatemetadata.h	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright © 2008 Dennis Kasprzyk
- *
- * Permission to use, copy, modify, distribute, and sell this software
- * and its documentation for any purpose is hereby granted without
- * fee, provided that the above copyright notice appear in all copies
- * and that both that copyright notice and this permission notice
- * appear in supporting documentation, and that the name of
- * Dennis Kasprzyk not be used in advertising or publicity pertaining to
- * distribution of the software without specific, written prior permission.
- * Dennis Kasprzyk makes no representations about the suitability of this
- * software for any purpose. It is provided "as is" without express or
- * implied warranty.