diff --git a/compiz-0.8.2-wall.patch b/compiz-0.8.2-wall.patch
new file mode 100644
index 0000000..bab642b
--- /dev/null
+++ b/compiz-0.8.2-wall.patch
@@ -0,0 +1,4926 @@
+diff -upNr compiz-0.8.2.orign/metadata/wall.xml.in compiz-0.8.2/metadata/wall.xml.in
+--- compiz-0.8.2.orign/metadata/wall.xml.in 1970-01-01 01:00:00.000000000 +0100
++++ compiz-0.8.2/metadata/wall.xml.in 2009-03-05 04:36:21.000000000 +0100
+@@ -0,0 +1,357 @@
++
++
++
++ <_short>Desktop Wall
++ <_long>Desktop Wall Plugin
++ Desktop
++ largedesktop
++
++
++ decoration
++
++
++ wobbly
++ fade
++
++
++
++
++ <_short>Viewport Switch Preview
++
++
++
++
++
++
++
++
++ <_short>Background Gradient
++
++
++
++
++
++
++ <_short>Thumb Gradient
++
++
++
++
++
++ <_short>Highlight Gradient
++
++
++
++
++
++ <_short>Arrow Colors
++
++
++
++
++
++
++ <_short>Viewport Switching
++
++
++
++
++
++ <_short>Bindings
++
++ <_short>Move within wall
++
++
++
++
++
++
++
++
++
++
++
++
++
++
++ <_short>Move with window within wall
++
++
++
++
++
++
++ <_short>Edge flipping
++
++
++
++
++
++
++
++
++
++ <_short>Viewport Switching
++
++
++
++ <_short>Edge Flipping
++
++
++
++
++
++
++
+diff -upNr compiz-0.8.2.orign/src/Makefile.am compiz-0.8.2/src/Makefile.am
+--- compiz-0.8.2.orign/src/Makefile.am 2009-02-15 10:10:23.000000000 +0100
++++ compiz-0.8.2/src/Makefile.am 2009-07-10 23:09:39.215435000 +0200
+@@ -5,12 +5,13 @@ INCLUDES = \
+ -I$(top_builddir)/include \
+ -DPLUGINDIR=\"$(plugindir)\" \
+ -DIMAGEDIR=\"$(imagedir)\" \
+- -DMETADATADIR=\"$(metadatadir)\"
++ -DMETADATADIR=\"$(metadatadir)\" \
++ `pkg-config --cflags cairo`
+
+ bin_PROGRAMS = compiz
+
+ compiz_LDADD = @COMPIZ_LIBS@ @GL_LIBS@ -lm
+-compiz_LDFLAGS = -export-dynamic
++compiz_LDFLAGS = -export-dynamic `pkg-config --libs cairo`
+ compiz_SOURCES = \
+ main.c \
+ privates.c \
+@@ -29,4 +30,6 @@ compiz_SOURCES = \
+ matrix.c \
+ cursor.c \
+ match.c \
+- metadata.c
++ metadata.c \
++ wall_options.c \
++ wall.c
+diff -upNr compiz-0.8.2.orign/src/wall.c compiz-0.8.2/src/wall.c
+--- compiz-0.8.2.orign/src/wall.c 1970-01-01 01:00:00.000000000 +0100
++++ compiz-0.8.2/src/wall.c 2009-03-05 04:36:21.000000000 +0100
+@@ -0,0 +1,2215 @@
++/**
++ *
++ * Compiz wall plugin
++ *
++ * wall.c
++ *
++ * Copyright (c) 2006 Robert Carr
++ *
++ * Authors:
++ * Robert Carr
++ * Dennis Kasprzyk
++ *
++ * This program is free software; you can redistribute it and/or
++ * modify it under the terms of the GNU General Public License
++ * as published by the Free Software Foundation; either version 2
++ * of the License, or (at your option) any later version.
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ **/
++
++#include
++#include
++#include
++#include
++#include
++
++#include
++#include "wall_options.h"
++
++#include
++
++#include
++#include
++
++#define PI 3.14159265359f
++#define VIEWPORT_SWITCHER_SIZE 100
++#define ARROW_SIZE 33
++
++#define WIN_X(w) ((w)->attrib.x - (w)->input.left)
++#define WIN_Y(w) ((w)->attrib.y - (w)->input.top)
++#define WIN_W(w) ((w)->width + (w)->input.left + (w)->input.right)
++#define WIN_H(w) ((w)->height + (w)->input.top + (w)->input.bottom)
++
++#define getColorRGBA(name, _display) \
++ r = wallGet##name##Red(_display) / 65535.0f;\
++ g = wallGet##name##Green(_display) / 65535.0f; \
++ b = wallGet##name##Blue(_display) / 65535.0f; \
++ a = wallGet##name##Alpha(_display) / 65535.0f
++
++static int WallDisplayPrivateIndex;
++static int WallCorePrivateIndex;
++
++/* Enums */
++typedef enum
++{
++ Up = 0,
++ Left,
++ Down,
++ Right
++} Direction;
++
++typedef enum
++{
++ NoTransformation,
++ MiniScreen,
++ Sliding
++} ScreenTransformation;
++
++typedef struct _WallCairoContext
++{
++ Pixmap pixmap;
++ CompTexture texture;
++
++ cairo_surface_t *surface;
++ cairo_t *cr;
++
++ int width;
++ int height;
++} WallCairoContext;
++
++typedef struct _WallCore
++{
++ ObjectAddProc objectAdd;
++ SetOptionForPluginProc setOptionForPlugin;
++} WallCore;
++
++typedef struct _WallDisplay
++{
++ int screenPrivateIndex;
++
++ HandleEventProc handleEvent;
++ MatchExpHandlerChangedProc matchExpHandlerChanged;
++ MatchPropertyChangedProc matchPropertyChanged;
++} WallDisplay;
++
++typedef struct _WallScreen
++{
++ int windowPrivateIndex;
++
++ DonePaintScreenProc donePaintScreen;
++ PaintOutputProc paintOutput;
++ PaintScreenProc paintScreen;
++ PreparePaintScreenProc preparePaintScreen;
++ PaintTransformedOutputProc paintTransformedOutput;
++ PaintWindowProc paintWindow;
++ ActivateWindowProc activateWindow;
++
++ Bool moving; /* Used to track miniview movement */
++ Bool showPreview;
++
++ float curPosX;
++ float curPosY;
++ int gotoX;
++ int gotoY;
++ int direction; /* >= 0 : direction arrow angle, < 0 : no direction */
++
++ int boxTimeout;
++ int boxOutputDevice;
++
++ int grabIndex;
++ int timer;
++
++ Window moveWindow;
++
++ Bool focusDefault;
++
++ ScreenTransformation transform;
++ CompOutput *currOutput;
++
++ WindowPaintAttrib mSAttribs;
++ float mSzCamera;
++
++ int firstViewportX;
++ int firstViewportY;
++ int viewportWidth;
++ int viewportHeight;
++ int viewportBorder;
++
++ int moveWindowX;
++ int moveWindowY;
++
++ WallCairoContext switcherContext;
++ WallCairoContext thumbContext;
++ WallCairoContext highlightContext;
++ WallCairoContext arrowContext;
++} WallScreen;
++
++typedef struct _WallWindow
++{
++ Bool isSliding;
++} WallWindow;
++
++/* Helpers */
++#define WALL_CORE(c) PLUGIN_CORE(c, Wall, w)
++#define WALL_DISPLAY(d) PLUGIN_DISPLAY(d, Wall, w)
++#define WALL_SCREEN(s) PLUGIN_SCREEN(s, Wall, w)
++#define WALL_WINDOW(w) PLUGIN_WINDOW(w, Wall, w)
++
++#define GET_SCREEN \
++ CompScreen *s; \
++ Window xid; \
++ xid = getIntOptionNamed(option, nOption, "root", 0);\
++ s = findScreenAtDisplay(d, xid); \
++ if (!s) \
++ return FALSE;
++
++#define sigmoid(x) (1.0f / (1.0f + exp (-5.5f * 2 * ((x) - 0.5))))
++#define sigmoidProgress(x) ((sigmoid (x) - sigmoid (0)) / \
++ (sigmoid (1) - sigmoid (0)))
++
++
++static void
++wallClearCairoLayer (cairo_t *cr)
++{
++ cairo_save (cr);
++ cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
++ cairo_paint (cr);
++ cairo_restore (cr);
++}
++
++static void
++wallDrawSwitcherBackground (CompScreen *s)
++{
++ cairo_t *cr;
++ cairo_pattern_t *pattern;
++ float outline = 2.0f;
++ int width, height, radius;
++ float r, g, b, a;
++ int i, j;
++
++ WALL_SCREEN (s);
++
++ cr = ws->switcherContext.cr;
++ wallClearCairoLayer (cr);
++
++ width = ws->switcherContext.width - outline;
++ height = ws->switcherContext.height - outline;
++
++ cairo_save (cr);
++ cairo_translate (cr, outline / 2.0f, outline / 2.0f);
++
++ /* set the pattern for the switcher's background */
++ pattern = cairo_pattern_create_linear (0, 0, width, height);
++ getColorRGBA (BackgroundGradientBaseColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 0.00f, r, g, b, a);
++ getColorRGBA (BackgroundGradientHighlightColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 0.65f, r, g, b, a);
++ getColorRGBA (BackgroundGradientShadowColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 0.85f, r, g, b, a);
++ cairo_set_source (cr, pattern);
++
++ /* draw the border's shape */
++ radius = wallGetEdgeRadius (s->display);
++ if (radius)
++ {
++ cairo_arc (cr, radius, radius, radius, PI, 1.5f * PI);
++ cairo_arc (cr, radius + width - 2 * radius,
++ radius, radius, 1.5f * PI, 2.0 * PI);
++ cairo_arc (cr, width - radius, height - radius, radius, 0, PI / 2.0f);
++ cairo_arc (cr, radius, height - radius, radius, PI / 2.0f, PI);
++ }
++ else
++ cairo_rectangle (cr, 0, 0, width, height);
++
++ cairo_close_path (cr);
++
++ /* apply pattern to background... */
++ cairo_fill_preserve (cr);
++
++ /* ... and draw an outline */
++ cairo_set_line_width (cr, outline);
++ getColorRGBA (OutlineColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_stroke(cr);
++
++ cairo_pattern_destroy (pattern);
++ cairo_restore (cr);
++
++ cairo_save (cr);
++ for (i = 0; i < s->vsize; i++)
++ {
++ cairo_translate (cr, 0.0, ws->viewportBorder);
++ cairo_save (cr);
++ for (j = 0; j < s->hsize; j++)
++ {
++ cairo_translate (cr, ws->viewportBorder, 0.0);
++
++ /* this cuts a hole into our background */
++ cairo_set_operator (cr, CAIRO_OPERATOR_OVER);
++ cairo_set_source_rgba (cr, 0.0, 0.0, 0.0, 1.0);
++ cairo_rectangle (cr, 0, 0, ws->viewportWidth, ws->viewportHeight);
++
++ cairo_fill_preserve (cr);
++ cairo_set_operator (cr, CAIRO_OPERATOR_XOR);
++ cairo_fill (cr);
++
++ cairo_translate (cr, ws->viewportWidth, 0.0);
++ }
++ cairo_restore(cr);
++
++ cairo_translate (cr, 0.0, ws->viewportHeight);
++ }
++ cairo_restore (cr);
++}
++
++static void
++wallDrawThumb (CompScreen *s)
++{
++ cairo_t *cr;
++ cairo_pattern_t *pattern;
++ float r, g, b, a;
++ float outline = 2.0f;
++ int width, height;
++
++ WALL_SCREEN(s);
++
++ cr = ws->thumbContext.cr;
++ wallClearCairoLayer (cr);
++
++ width = ws->thumbContext.width - outline;
++ height = ws->thumbContext.height - outline;
++
++ cairo_translate (cr, outline / 2.0f, outline / 2.0f);
++
++ pattern = cairo_pattern_create_linear (0, 0, width, height);
++ getColorRGBA (ThumbGradientBaseColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 0.0f, r, g, b, a);
++ getColorRGBA (ThumbGradientHighlightColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 1.0f, r, g, b, a);
++
++ /* apply the pattern for thumb background */
++ cairo_set_source (cr, pattern);
++ cairo_rectangle (cr, 0, 0, width, height);
++ cairo_fill_preserve (cr);
++
++ cairo_set_line_width (cr, outline);
++ getColorRGBA (OutlineColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_stroke (cr);
++
++ cairo_pattern_destroy (pattern);
++
++ cairo_restore (cr);
++}
++
++static void
++wallDrawHighlight(CompScreen *s)
++{
++ cairo_t *cr;
++ cairo_pattern_t *pattern;
++ int width, height;
++ float r, g, b, a;
++ float outline = 2.0f;
++
++
++ WALL_SCREEN(s);
++
++ cr = ws->highlightContext.cr;
++ wallClearCairoLayer (cr);
++
++ width = ws->highlightContext.width - outline;
++ height = ws->highlightContext.height - outline;
++
++ cairo_translate (cr, outline / 2.0f, outline / 2.0f);
++
++ pattern = cairo_pattern_create_linear (0, 0, width, height);
++ getColorRGBA (ThumbHighlightGradientBaseColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 0.0f, r, g, b, a);
++ getColorRGBA (ThumbHighlightGradientShadowColor, s->display);
++ cairo_pattern_add_color_stop_rgba (pattern, 1.0f, r, g, b, a);
++
++ /* apply the pattern for thumb background */
++ cairo_set_source (cr, pattern);
++ cairo_rectangle (cr, 0, 0, width, height);
++ cairo_fill_preserve (cr);
++
++ cairo_set_line_width (cr, outline);
++ getColorRGBA (OutlineColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_stroke (cr);
++
++ cairo_pattern_destroy (pattern);
++
++ cairo_restore (cr);
++}
++
++static void
++wallDrawArrow (CompScreen *s)
++{
++ cairo_t *cr;
++ float outline = 2.0f;
++ float r, g, b, a;
++
++ WALL_SCREEN(s);
++
++ cr = ws->arrowContext.cr;
++ wallClearCairoLayer (cr);
++
++ cairo_translate (cr, outline / 2.0f, outline / 2.0f);
++
++ /* apply the pattern for thumb background */
++ cairo_set_line_width (cr, outline);
++
++ /* draw top part of the arrow */
++ getColorRGBA (ArrowBaseColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_move_to (cr, 15, 0);
++ cairo_line_to (cr, 30, 30);
++ cairo_line_to (cr, 15, 24.5);
++ cairo_line_to (cr, 15, 0);
++ cairo_fill (cr);
++
++ /* draw bottom part of the arrow */
++ getColorRGBA (ArrowShadowColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_move_to (cr, 15, 0);
++ cairo_line_to (cr, 0, 30);
++ cairo_line_to (cr, 15, 24.5);
++ cairo_line_to (cr, 15, 0);
++ cairo_fill (cr);
++
++ /* draw the arrow outline */
++ getColorRGBA (OutlineColor, s->display);
++ cairo_set_source_rgba (cr, r, g, b, a);
++ cairo_move_to (cr, 15, 0);
++ cairo_line_to (cr, 30, 30);
++ cairo_line_to (cr, 15, 24.5);
++ cairo_line_to (cr, 0, 30);
++ cairo_line_to (cr, 15, 0);
++ cairo_stroke (cr);
++
++ cairo_restore (cr);
++}
++
++static void
++wallSetupCairoContext (CompScreen *s,
++ WallCairoContext *context)
++{
++ XRenderPictFormat *format;
++ Screen *screen;
++ int width, height;
++
++ screen = ScreenOfDisplay (s->display->display, s->screenNum);
++
++ width = context->width;
++ height = context->height;
++
++ initTexture (s, &context->texture);
++
++ format = XRenderFindStandardFormat (s->display->display,
++ PictStandardARGB32);
++
++ context->pixmap = XCreatePixmap (s->display->display, s->root,
++ width, height, 32);
++
++ if (!bindPixmapToTexture(s, &context->texture, context->pixmap,
++ width, height, 32))
++ {
++ compLogMessage ("wall", CompLogLevelError,
++ "Couldn't create cairo context for switcher");
++ }
++
++ context->surface =
++ cairo_xlib_surface_create_with_xrender_format (s->display->display,
++ context->pixmap,
++ screen, format,
++ width, height);
++
++ context->cr = cairo_create (context->surface);
++ wallClearCairoLayer (context->cr);
++}
++
++static void
++wallDestroyCairoContext (CompScreen *s,
++ WallCairoContext *context)
++{
++ if (context->cr)
++ cairo_destroy (context->cr);
++
++ if (context->surface)
++ cairo_surface_destroy (context->surface);
++
++ finiTexture (s, &context->texture);
++
++ if (context->pixmap)
++ XFreePixmap (s->display->display, context->pixmap);
++}
++
++static Bool
++wallCheckDestination (CompScreen *s,
++ int destX,
++ int destY)
++{
++ if (s->x - destX < 0)
++ return FALSE;
++
++ if (s->x - destX >= s->hsize)
++ return FALSE;
++
++ if (s->y - destY >= s->vsize)
++ return FALSE;
++
++ if (s->y - destY < 0)
++ return FALSE;
++
++ return TRUE;
++}
++
++static void
++wallReleaseMoveWindow (CompScreen *s)
++{
++ CompWindow *w;
++ WALL_SCREEN (s);
++
++ w = findWindowAtScreen (s, ws->moveWindow);
++ if (w)
++ syncWindowPosition (w);
++
++ ws->moveWindow = 0;
++}
++
++static void
++wallComputeTranslation (CompScreen *s,
++ float *x,
++ float *y)
++{
++ float dx, dy, elapsed, duration;
++
++ WALL_SCREEN (s);
++
++ duration = wallGetSlideDuration (s->display) * 1000.0;
++ if (duration != 0.0)
++ elapsed = 1.0 - (ws->timer / duration);
++ else
++ elapsed = 1.0;
++
++ if (elapsed < 0.0)
++ elapsed = 0.0;
++ if (elapsed > 1.0)
++ elapsed = 1.0;
++
++ /* Use temporary variables to you can pass in &ps->cur_x */
++ dx = (ws->gotoX - ws->curPosX) * elapsed + ws->curPosX;
++ dy = (ws->gotoY - ws->curPosY) * elapsed + ws->curPosY;
++
++ *x = dx;
++ *y = dy;
++}
++
++/* movement remainder that gets ignored for direction calculation */
++#define IGNORE_REMAINDER 0.05
++
++static void
++wallDetermineMovementAngle (CompScreen *s)
++{
++ int angle;
++ float dx, dy;
++
++ WALL_SCREEN (s);
++
++ dx = ws->gotoX - ws->curPosX;
++ dy = ws->gotoY - ws->curPosY;
++
++ if (dy > IGNORE_REMAINDER)
++ angle = (dx > IGNORE_REMAINDER) ? 135 :
++ (dx < -IGNORE_REMAINDER) ? 225 : 180;
++ else if (dy < -IGNORE_REMAINDER)
++ angle = (dx > IGNORE_REMAINDER) ? 45 :
++ (dx < -IGNORE_REMAINDER) ? 315 : 0;
++ else
++ angle = (dx > IGNORE_REMAINDER) ? 90 :
++ (dx < -IGNORE_REMAINDER) ? 270 : -1;
++
++ ws->direction = angle;
++}
++
++static Bool
++wallMoveViewport (CompScreen *s,
++ int x,
++ int y,
++ Window moveWindow)
++{
++ WALL_SCREEN (s);
++
++ if (!x && !y)
++ return FALSE;
++
++ if (otherScreenGrabExist (s, "move", "switcher", "group-drag", "wall", 0))
++ return FALSE;
++
++ if (!wallCheckDestination (s, x, y))
++ return FALSE;
++
++ if (ws->moveWindow != moveWindow)
++ {
++ CompWindow *w;
++
++ wallReleaseMoveWindow (s);
++ w = findWindowAtScreen (s, moveWindow);
++ if (w)
++ {
++ if (!(w->type & (CompWindowTypeDesktopMask |
++ CompWindowTypeDockMask)))
++ {
++ if (!(w->state & CompWindowStateStickyMask))
++ {
++ ws->moveWindow = w->id;
++ ws->moveWindowX = w->attrib.x;
++ ws->moveWindowY = w->attrib.y;
++ raiseWindow (w);
++ }
++ }
++ }
++ }
++
++ if (!ws->moving)
++ {
++ ws->curPosX = s->x;
++ ws->curPosY = s->y;
++ }
++ ws->gotoX = s->x - x;
++ ws->gotoY = s->y - y;
++
++ wallDetermineMovementAngle (s);
++
++ if (!ws->grabIndex)
++ ws->grabIndex = pushScreenGrab (s, s->invisibleCursor, "wall");
++
++ moveScreenViewport (s, x, y, TRUE);
++
++ ws->moving = TRUE;
++ ws->focusDefault = TRUE;
++ ws->boxOutputDevice = outputDeviceForPoint (s, pointerX, pointerY);
++
++ if (wallGetShowSwitcher (s->display))
++ ws->boxTimeout = wallGetPreviewTimeout (s->display) * 1000;
++ else
++ ws->boxTimeout = 0;
++
++ ws->timer = wallGetSlideDuration (s->display) * 1000;
++
++ damageScreen (s);
++
++ return TRUE;
++}
++
++static void
++wallHandleEvent (CompDisplay *d,
++ XEvent *event)
++{
++ WALL_DISPLAY (d);
++
++ switch (event->type) {
++ case ClientMessage:
++ if (event->xclient.message_type == d->desktopViewportAtom)
++ {
++ int dx, dy;
++ CompScreen *s;
++
++ s = findScreenAtDisplay (d, event->xclient.window);
++ if (!s)
++ break;
++
++ if (otherScreenGrabExist (s, "switcher", "wall", 0))
++ break;
++
++ dx = event->xclient.data.l[0] / s->width - s->x;
++ dy = event->xclient.data.l[1] / s->height - s->y;
++
++ if (!dx && !dy)
++ break;
++
++ wallMoveViewport (s, -dx, -dy, None);
++ }
++ break;
++ }
++
++ UNWRAP (wd, d, handleEvent);
++ (*d->handleEvent) (d, event);
++ WRAP (wd, d, handleEvent, wallHandleEvent);
++}
++
++static void
++wallActivateWindow (CompWindow *w)
++{
++ CompScreen *s = w->screen;
++
++ WALL_SCREEN (s);
++
++ if (w->placed && !otherScreenGrabExist (s, "wall", "switcher", 0))
++ {
++ int dx, dy;
++
++ defaultViewportForWindow (w, &dx, &dy);
++ dx -= s->x;
++ dy -= s->y;
++
++ if (dx || dy)
++ {
++ wallMoveViewport (s, -dx, -dy, None);
++ ws->focusDefault = FALSE;
++ }
++ }
++
++ UNWRAP (ws, s, activateWindow);
++ (*s->activateWindow) (w);
++ WRAP (ws, s, activateWindow, wallActivateWindow);
++}
++
++static void
++wallCheckAmount (CompScreen *s,
++ int dx,
++ int dy,
++ int *amountX,
++ int *amountY)
++{
++ *amountX = -dx;
++ *amountY = -dy;
++
++ if (wallGetAllowWraparound (s->display))
++ {
++ if ((s->x + dx) < 0)
++ *amountX = -(s->hsize + dx);
++ else if ((s->x + dx) >= s->hsize)
++ *amountX = s->hsize - dx;
++
++ if ((s->y + dy) < 0)
++ *amountY = -(s->vsize + dy);
++ else if ((s->y + dy) >= s->vsize)
++ *amountY = s->vsize - dy;
++ }
++}
++
++static Bool
++wallInitiate (CompScreen *s,
++ int dx,
++ int dy,
++ Window win,
++ CompAction *action,
++ CompActionState state)
++{
++ int amountX, amountY;
++
++ WALL_SCREEN (s);
++
++ wallCheckAmount (s, dx, dy, &amountX, &amountY);
++ if (!wallMoveViewport (s, amountX, amountY, win))
++ return TRUE;
++
++ if (state & CompActionStateInitKey)
++ action->state |= CompActionStateTermKey;
++
++ if (state & CompActionStateInitButton)
++ action->state |= CompActionStateTermButton;
++
++ ws->showPreview = wallGetShowSwitcher (s->display);
++
++ return TRUE;
++}
++
++static Bool
++wallTerminate (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ CompScreen *s;
++
++ for (s = d->screens; s; s = s->next)
++ {
++ WALL_SCREEN (s);
++
++ if (ws->showPreview)
++ {
++ ws->showPreview = FALSE;
++ damageScreen (s);
++ }
++ }
++
++ if (action)
++ action->state &= ~(CompActionStateTermKey | CompActionStateTermButton);
++
++ return FALSE;
++}
++
++static Bool
++wallInitiateFlip (CompScreen *s,
++ Direction direction,
++ Bool dnd)
++{
++ int dx, dy;
++ int amountX, amountY;
++
++ if (otherScreenGrabExist (s, "wall", "move", "group-drag", 0))
++ return FALSE;
++
++ if (dnd)
++ {
++ if (!wallGetEdgeflipDnd (s))
++ return FALSE;
++
++ if (otherScreenGrabExist (s, "wall", 0))
++ return FALSE;
++ }
++ else if (otherScreenGrabExist (s, "wall", "group-drag", 0))
++ {
++ /* not wall or group means move */
++ if (!wallGetEdgeflipMove (s))
++ return FALSE;
++ }
++ else if (otherScreenGrabExist (s, "wall", 0))
++ {
++ /* move was ruled out before, so we have group */
++ if (!wallGetEdgeflipDnd (s))
++ return FALSE;
++ }
++ else if (!wallGetEdgeflipPointer (s))
++ return FALSE;
++
++ switch (direction) {
++ case Left:
++ dx = -1; dy = 0;
++ break;
++ case Right:
++ dx = 1; dy = 0;
++ break;
++ case Up:
++ dx = 0; dy = -1;
++ break;
++ case Down:
++ dx = 0; dy = 1;
++ break;
++ default:
++ dx = 0; dy = 0;
++ break;
++ }
++
++ wallCheckAmount (s, dx, dy, &amountX, &amountY);
++ if (wallMoveViewport (s, amountX, amountY, None))
++ {
++ int offsetX, offsetY;
++ int warpX, warpY;
++
++ if (dx < 0)
++ {
++ offsetX = s->width - 10;
++ warpX = pointerX + s->width;
++ }
++ else if (dx > 0)
++ {
++ offsetX = 1- s->width;
++ warpX = pointerX - s->width;
++ }
++ else
++ {
++ offsetX = 0;
++ warpX = lastPointerX;
++ }
++
++ if (dy < 0)
++ {
++ offsetY = s->height - 10;
++ warpY = pointerY + s->height;
++ }
++ else if (dy > 0)
++ {
++ offsetY = 1- s->height;
++ warpY = pointerY - s->height;
++ }
++ else
++ {
++ offsetY = 0;
++ warpY = lastPointerY;
++ }
++
++ warpPointer (s, offsetX, offsetY);
++ lastPointerX = warpX;
++ lastPointerY = warpY;
++ }
++
++ return TRUE;
++}
++
++static Bool
++wallLeft (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiate (s, -1, 0, None, action, state);
++}
++
++static Bool
++wallRight (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiate (s, 1, 0, None, action, state);
++}
++
++static Bool
++wallUp (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiate (s, 0, -1, None, action, state);
++}
++
++static Bool
++wallDown (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiate (s, 0, 1, None, action, state);
++}
++
++static Bool
++wallNext (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ int amountX, amountY;
++ GET_SCREEN;
++
++ if ((s->x == s->hsize - 1) && (s->y == s->vsize - 1))
++ {
++ amountX = -(s->hsize - 1);
++ amountY = -(s->vsize - 1);
++ }
++ else if (s->x == s->hsize - 1)
++ {
++ amountX = -(s->hsize - 1);
++ amountY = 1;
++ }
++ else
++ {
++ amountX = 1;
++ amountY = 0;
++ }
++
++ return wallInitiate (s, amountX, amountY, None, action, state);
++}
++
++static Bool
++wallPrev (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ int amountX, amountY;
++ GET_SCREEN;
++
++ if ((s->x == 0) && (s->y == 0))
++ {
++ amountX = s->hsize - 1;
++ amountY = s->vsize - 1;
++ }
++ else if (s->x == 0)
++ {
++ amountX = s->hsize - 1;
++ amountY = -1;
++ }
++ else
++ {
++ amountX = -1;
++ amountY = 0;
++ }
++
++ return wallInitiate (s, amountX, amountY, None, action, state);
++}
++
++static Bool
++wallFlipLeft (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiateFlip (s, Left, (state & CompActionStateInitEdgeDnd));
++}
++
++static Bool
++wallFlipRight (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiateFlip (s, Right, (state & CompActionStateInitEdgeDnd));
++}
++
++static Bool
++wallFlipUp (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiateFlip (s, Up, (state & CompActionStateInitEdgeDnd));
++}
++
++static Bool
++wallFlipDown (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++
++ return wallInitiateFlip (s, Down, (state & CompActionStateInitEdgeDnd));
++}
++
++static Bool
++wallLeftWithWindow (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++ Window win = getIntOptionNamed (option, nOption, "window", 0);
++
++ return wallInitiate (s, -1, 0, win, action, state);
++}
++
++static Bool
++wallRightWithWindow (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++ Window win = getIntOptionNamed (option, nOption, "window", 0);
++
++ return wallInitiate (s, 1, 0, win, action, state);
++}
++
++static Bool
++wallUpWithWindow (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++ Window win = getIntOptionNamed (option, nOption, "window", 0);
++
++ return wallInitiate (s, 0, -1, win, action, state);
++}
++
++static Bool
++wallDownWithWindow (CompDisplay *d,
++ CompAction *action,
++ CompActionState state,
++ CompOption *option,
++ int nOption)
++{
++ GET_SCREEN;
++ Window win = getIntOptionNamed (option, nOption, "window", 0);
++
++ return wallInitiate (s, 0, 1, win, action, state);
++}
++
++static inline void
++wallDrawQuad (CompMatrix *matrix, BOX *box)
++{
++ glTexCoord2f (COMP_TEX_COORD_X (matrix, box->x1),
++ COMP_TEX_COORD_Y (matrix, box->y2));
++ glVertex2i (box->x1, box->y2);
++ glTexCoord2f (COMP_TEX_COORD_X (matrix, box->x2),
++ COMP_TEX_COORD_Y (matrix, box->y2));
++ glVertex2i (box->x2, box->y2);
++ glTexCoord2f (COMP_TEX_COORD_X (matrix, box->x2),
++ COMP_TEX_COORD_Y (matrix, box->y1));
++ glVertex2i (box->x2, box->y1);
++ glTexCoord2f (COMP_TEX_COORD_X (matrix, box->x1),
++ COMP_TEX_COORD_Y (matrix, box->y1));
++ glVertex2i (box->x1, box->y1);
++}
++
++static void
++wallDrawCairoTextureOnScreen (CompScreen *s)
++{
++ float centerX, centerY;
++ float width, height;
++ float topLeftX, topLeftY;
++ float border;
++ int i, j;
++ CompMatrix matrix;
++ BOX box;
++
++ WALL_SCREEN(s);
++
++ glDisableClientState (GL_TEXTURE_COORD_ARRAY);
++ glEnable (GL_BLEND);
++
++ centerX = s->outputDev[ws->boxOutputDevice].region.extents.x1 +
++ (s->outputDev[ws->boxOutputDevice].width / 2.0f);
++ centerY = s->outputDev[ws->boxOutputDevice].region.extents.y1 +
++ (s->outputDev[ws->boxOutputDevice].height / 2.0f);
++
++ border = (float) ws->viewportBorder;
++ width = (float) ws->switcherContext.width;
++ height = (float) ws->switcherContext.height;
++
++ topLeftX = centerX - floor (width / 2.0f);
++ topLeftY = centerY - floor (height / 2.0f);
++
++ ws->firstViewportX = topLeftX + border;
++ ws->firstViewportY = topLeftY + border;
++
++ if (!ws->moving)
++ {
++ double left, timeout;
++
++ timeout = wallGetPreviewTimeout (s->display) * 1000.0f;
++ left = (timeout > 0) ? (float) ws->boxTimeout / timeout : 1.0f;
++
++ if (left < 0)
++ left = 0.0f;
++ else if (left > 0.5)
++ left = 1.0f;
++ else
++ left = 2 * left;
++
++ screenTexEnvMode (s, GL_MODULATE);
++
++ glColor4f (left, left, left, left);
++ glTranslatef (0.0f,0.0f, -(1 - left));
++
++ ws->mSzCamera = -(1 - left);
++ }
++ else
++ ws->mSzCamera = 0.0f;
++
++ /* draw background */
++
++ matrix = ws->switcherContext.texture.matrix;
++ matrix.x0 -= topLeftX * matrix.xx;
++ matrix.y0 -= topLeftY * matrix.yy;
++
++ box.x1 = topLeftX;
++ box.x2 = box.x1 + width;
++ box.y1 = topLeftY;
++ box.y2 = box.y1 + height;
++
++ enableTexture (s, &ws->switcherContext.texture, COMP_TEXTURE_FILTER_FAST);
++ glBegin (GL_QUADS);
++ wallDrawQuad (&matrix, &box);
++ glEnd ();
++ disableTexture (s, &ws->switcherContext.texture);
++
++ /* draw thumb */
++ width = (float) ws->thumbContext.width;
++ height = (float) ws->thumbContext.height;
++
++ enableTexture (s, &ws->thumbContext.texture, COMP_TEXTURE_FILTER_FAST);
++ glBegin (GL_QUADS);
++ for (i = 0; i < s->hsize; i++)
++ {
++ for (j = 0; j < s->vsize; j++)
++ {
++ if (i == ws->gotoX && j == ws->gotoY && ws->moving)
++ continue;
++
++ box.x1 = i * (width + border);
++ box.x1 += topLeftX + border;
++ box.x2 = box.x1 + width;
++ box.y1 = j * (height + border);
++ box.y1 += topLeftY + border;
++ box.y2 = box.y1 + height;
++
++ matrix = ws->thumbContext.texture.matrix;
++ matrix.x0 -= box.x1 * matrix.xx;
++ matrix.y0 -= box.y1 * matrix.yy;
++
++ wallDrawQuad (&matrix, &box);
++ }
++ }
++ glEnd ();
++ disableTexture (s, &ws->thumbContext.texture);
++
++ if (ws->moving || ws->showPreview)
++ {
++ /* draw highlight */
++ int aW, aH;
++
++ box.x1 = s->x * (width + border) + topLeftX + border;
++ box.x2 = box.x1 + width;
++ box.y1 = s->y * (height + border) + topLeftY + border;
++ box.y2 = box.y1 + height;
++
++ matrix = ws->highlightContext.texture.matrix;
++ matrix.x0 -= box.x1 * matrix.xx;
++ matrix.y0 -= box.y1 * matrix.yy;
++
++ enableTexture (s, &ws->highlightContext.texture,
++ COMP_TEXTURE_FILTER_FAST);
++ glBegin (GL_QUADS);
++ wallDrawQuad (&matrix, &box);
++ glEnd ();
++ disableTexture (s, &ws->highlightContext.texture);
++
++ /* draw arrow */
++ if (ws->direction >= 0)
++ {
++ enableTexture (s, &ws->arrowContext.texture,
++ COMP_TEXTURE_FILTER_GOOD);
++
++ aW = ws->arrowContext.width;
++ aH = ws->arrowContext.height;
++
++ /* if we have a viewport preview we just paint the
++ arrow outside the switcher */
++ if (wallGetMiniscreen (s->display))
++ {
++ width = (float) ws->switcherContext.width;
++ height = (float) ws->switcherContext.height;
++
++ switch (ws->direction)
++ {
++ /* top left */
++ case 315:
++ box.x1 = topLeftX - aW - border;
++ box.y1 = topLeftY - aH - border;
++ break;
++ /* up */
++ case 0:
++ box.x1 = topLeftX + width / 2.0f - aW / 2.0f;
++ box.y1 = topLeftY - aH - border;
++ break;
++ /* top right */
++ case 45:
++ box.x1 = topLeftX + width + border;
++ box.y1 = topLeftY - aH - border;
++ break;
++ /* right */
++ case 90:
++ box.x1 = topLeftX + width + border;
++ box.y1 = topLeftY + height / 2.0f - aH / 2.0f;
++ break;
++ /* bottom right */
++ case 135:
++ box.x1 = topLeftX + width + border;
++ box.y1 = topLeftY + height + border;
++ break;
++ /* down */
++ case 180:
++ box.x1 = topLeftX + width / 2.0f - aW / 2.0f;
++ box.y1 = topLeftY + height + border;
++ break;
++ /* bottom left */
++ case 225:
++ box.x1 = topLeftX - aW - border;
++ box.y1 = topLeftY + height + border;
++ break;
++ /* left */
++ case 270:
++ box.x1 = topLeftX - aW - border;
++ box.y1 = topLeftY + height / 2.0f - aH / 2.0f;
++ break;
++ default:
++ break;
++ }
++ }
++ else
++ {
++ /* arrow is visible (no preview is painted over it) */
++ box.x1 = s->x * (width + border) + topLeftX + border;
++ box.x1 += width / 2 - aW / 2;
++ box.y1 = s->y * (height + border) + topLeftY + border;
++ box.y1 += height / 2 - aH / 2;
++ }
++
++ box.x2 = box.x1 + aW;
++ box.y2 = box.y1 + aH;
++
++ glTranslatef (box.x1 + aW / 2, box.y1 + aH / 2, 0.0f);
++ glRotatef (ws->direction, 0.0f, 0.0f, 1.0f);
++ glTranslatef (-box.x1 - aW / 2, -box.y1 - aH / 2, 0.0f);
++
++ matrix = ws->arrowContext.texture.matrix;
++ matrix.x0 -= box.x1 * matrix.xx;
++ matrix.y0 -= box.y1 * matrix.yy;
++
++ glBegin (GL_QUADS);
++ wallDrawQuad (&matrix, &box);
++ glEnd ();
++
++ disableTexture (s, &ws->arrowContext.texture);
++ }
++ }
++
++ glDisable (GL_BLEND);
++ glEnableClientState (GL_TEXTURE_COORD_ARRAY);
++ screenTexEnvMode (s, GL_REPLACE);
++ glColor4usv (defaultColor);
++}
++
++static void
++wallPaintScreen (CompScreen *s,
++ CompOutput *outputs,
++ int numOutputs,
++ unsigned int mask)
++{
++ WALL_SCREEN (s);
++
++ if (ws->moving && numOutputs > 1 && wallGetMmmode(s) == MmmodeSwitchAll)
++ {
++ outputs = &s->fullscreenOutput;
++ numOutputs = 1;
++ }
++
++ UNWRAP (ws, s, paintScreen);
++ (*s->paintScreen) (s, outputs, numOutputs, mask);
++ WRAP (ws, s, paintScreen, wallPaintScreen);
++}
++
++static Bool
++wallPaintOutput (CompScreen *s,
++ const ScreenPaintAttrib *sAttrib,
++ const CompTransform *transform,
++ Region region,
++ CompOutput *output,
++ unsigned int mask)
++{
++ Bool status;
++
++ WALL_SCREEN (s);
++
++ ws->transform = NoTransformation;
++ if (ws->moving)
++ mask |= PAINT_SCREEN_TRANSFORMED_MASK |
++ PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
++
++ UNWRAP (ws, s, paintOutput);
++ status = (*s->paintOutput) (s, sAttrib, transform, region, output, mask);
++ WRAP (ws, s, paintOutput, wallPaintOutput);
++
++ if (wallGetShowSwitcher (s->display) &&
++ (ws->moving || ws->showPreview || ws->boxTimeout) &&
++ (output->id == ws->boxOutputDevice || output == &s->fullscreenOutput))
++ {
++ CompTransform sTransform = *transform;
++
++ transformToScreenSpace (s, output, -DEFAULT_Z_CAMERA, &sTransform);
++
++ glPushMatrix ();
++ glLoadMatrixf (sTransform.m);
++
++ wallDrawCairoTextureOnScreen (s);
++
++ glPopMatrix ();
++
++ if (wallGetMiniscreen (s->display))
++ {
++ int i, j;
++ float mw, mh;
++
++ mw = ws->viewportWidth;
++ mh = ws->viewportHeight;
++
++ ws->transform = MiniScreen;
++ ws->mSAttribs.xScale = mw / s->width;
++ ws->mSAttribs.yScale = mh / s->height;
++ ws->mSAttribs.opacity = OPAQUE * (1.0 + ws->mSzCamera);
++ ws->mSAttribs.saturation = COLOR;
++
++ for (j = 0; j < s->vsize; j++)
++ {
++ for (i = 0; i < s->hsize; i++)
++ {
++ float mx, my;
++ unsigned int msMask;
++
++ mx = ws->firstViewportX +
++ (i * (ws->viewportWidth + ws->viewportBorder));
++ my = ws->firstViewportY +
++ (j * (ws->viewportHeight + ws->viewportBorder));
++
++ ws->mSAttribs.xTranslate = mx / output->width;
++ ws->mSAttribs.yTranslate = -my / output->height;
++
++ ws->mSAttribs.brightness = 0.4f * BRIGHT;
++
++ if (i == s->x && j == s->y && ws->moving)
++ ws->mSAttribs.brightness = BRIGHT;
++
++ if ((ws->boxTimeout || ws->showPreview) &&
++ !ws->moving && i == s->x && j == s->y)
++ {
++ ws->mSAttribs.brightness = BRIGHT;
++ }
++
++ setWindowPaintOffset (s, (s->x - i) * s->width,
++ (s->y - j) * s->height);
++
++ msMask = mask | PAINT_SCREEN_TRANSFORMED_MASK;
++ (*s->paintTransformedOutput) (s, sAttrib, transform,
++ region, output, msMask);
++
++
++ }
++ }
++ ws->transform = NoTransformation;
++ setWindowPaintOffset (s, 0, 0);
++ }
++ }
++
++ return status;
++}
++
++static void
++wallPreparePaintScreen (CompScreen *s,
++ int msSinceLastPaint)
++{
++ WALL_SCREEN (s);
++
++ if (!ws->moving && !ws->showPreview && ws->boxTimeout)
++ ws->boxTimeout -= msSinceLastPaint;
++
++ if (ws->timer)
++ ws->timer -= msSinceLastPaint;
++
++ if (ws->moving)
++ {
++ wallComputeTranslation (s, &ws->curPosX, &ws->curPosY);
++
++ if (ws->moveWindow)
++ {
++ CompWindow *w;
++
++ w = findWindowAtScreen (s, ws->moveWindow);
++ if (w)
++ {
++ float dx, dy;
++
++ dx = ws->gotoX - ws->curPosX;
++ dy = ws->gotoY - ws->curPosY;
++
++ moveWindowToViewportPosition (w,
++ ws->moveWindowX - s->width * dx,
++ ws->moveWindowY - s->height * dy,
++ TRUE);
++ }
++ }
++ }
++
++ if (ws->moving && ws->curPosX == ws->gotoX && ws->curPosY == ws->gotoY)
++ {
++ ws->moving = FALSE;
++ ws->timer = 0;
++
++ if (ws->moveWindow)
++ wallReleaseMoveWindow (s);
++ else if (ws->focusDefault)
++ {
++ int i;
++ for (i = 0; i < s->maxGrab; i++)
++ if (s->grabs[i].active)
++ if (strcmp(s->grabs[i].name, "switcher") == 0)
++ break;
++
++ /* only focus default window if switcher is not active */
++ if (i == s->maxGrab)
++ focusDefaultWindow (s);
++ }
++ }
++
++ UNWRAP (ws, s, preparePaintScreen);
++ (*s->preparePaintScreen) (s, msSinceLastPaint);
++ WRAP (ws, s, preparePaintScreen, wallPreparePaintScreen);
++}
++
++static void
++wallPaintTransformedOutput (CompScreen *s,
++ const ScreenPaintAttrib *sAttrib,
++ const CompTransform *transform,
++ Region region,
++ CompOutput *output,
++ unsigned int mask)
++{
++ WALL_SCREEN (s);
++ Bool clear = (mask & PAINT_SCREEN_CLEAR_MASK);
++
++ if (ws->transform == MiniScreen)
++ {
++ CompTransform sTransform = *transform;
++
++ mask &= ~PAINT_SCREEN_CLEAR_MASK;
++
++ /* move each screen to the correct output position */
++
++ matrixTranslate (&sTransform,
++ -(float) output->region.extents.x1 /
++ (float) output->width,
++ (float) output->region.extents.y1 /
++ (float) output->height, 0.0f);
++ matrixTranslate (&sTransform, 0.0f, 0.0f, -DEFAULT_Z_CAMERA);
++
++ matrixTranslate (&sTransform,
++ ws->mSAttribs.xTranslate,
++ ws->mSAttribs.yTranslate,
++ ws->mSzCamera);
++
++ /* move origin to top left */
++ matrixTranslate (&sTransform, -0.5f, 0.5f, 0.0f);
++ matrixScale (&sTransform,
++ ws->mSAttribs.xScale, ws->mSAttribs.yScale, 1.0);
++
++ /* revert prepareXCoords region shift.
++ Now all screens display the same */
++ matrixTranslate (&sTransform, 0.5f, 0.5f, DEFAULT_Z_CAMERA);
++ matrixTranslate (&sTransform,
++ (float) output->region.extents.x1 /
++ (float) output->width,
++ -(float) output->region.extents.y2 /
++ (float) output->height, 0.0f);
++
++ UNWRAP (ws, s, paintTransformedOutput);
++ (*s->paintTransformedOutput) (s, sAttrib, &sTransform,
++ &s->region, output, mask);
++ WRAP (ws, s, paintTransformedOutput, wallPaintTransformedOutput);
++ return;
++ }
++
++ UNWRAP (ws, s, paintTransformedOutput);
++
++ if (!ws->moving)
++ (*s->paintTransformedOutput) (s, sAttrib, transform,
++ region, output, mask);
++
++ mask &= ~PAINT_SCREEN_CLEAR_MASK;
++
++ if (ws->moving)
++ {
++ ScreenTransformation oldTransform = ws->transform;
++ CompTransform sTransform = *transform;
++ float xTranslate, yTranslate;
++ float px, py;
++ int tx, ty;
++ Bool movingX, movingY;
++
++ if (clear)
++ clearTargetOutput (s->display, GL_COLOR_BUFFER_BIT);
++
++ ws->transform = Sliding;
++ ws->currOutput = output;
++
++ px = ws->curPosX;
++ py = ws->curPosY;
++
++ movingX = ((int) floor (px)) != ((int) ceil (px));
++ movingY = ((int) floor (py)) != ((int) ceil (py));
++
++ if (movingY)
++ {
++ ty = ceil (py) - s->y;
++ yTranslate = fmod (py, 1) - 1;
++
++ matrixTranslate (&sTransform, 0.0f, yTranslate, 0.0f);
++
++ if (movingX)
++ {
++ tx = ceil (px) - s->x;
++ xTranslate = 1 - fmod (px, 1);
++
++ setWindowPaintOffset (s, (s->x - ceil(px)) * s->width,
++ (s->y - ceil(py)) * s->height);
++
++ matrixTranslate (&sTransform, xTranslate, 0.0f, 0.0f);
++
++ (*s->paintTransformedOutput) (s, sAttrib, &sTransform,
++ &output->region, output, mask);
++
++ matrixTranslate (&sTransform, -xTranslate, 0.0f, 0.0f);
++ }
++
++ tx = floor (px) - s->x;
++ xTranslate = -fmod (px, 1);
++
++ setWindowPaintOffset (s, (s->x - floor(px)) * s->width,
++ (s->y - ceil(py)) * s->height);
++
++ matrixTranslate (&sTransform, xTranslate, 0.0f, 0.0f);
++
++ (*s->paintTransformedOutput) (s, sAttrib, &sTransform,
++ &output->region, output, mask);
++ matrixTranslate (&sTransform, -xTranslate, -yTranslate, 0.0f);
++ }
++
++ ty = floor (py) - s->y;
++ yTranslate = fmod (py, 1);
++
++ matrixTranslate (&sTransform, 0.0f, yTranslate, 0.0f);
++
++ if (movingX)
++ {
++ tx = ceil (px) - s->x;
++ xTranslate = 1 - fmod (px, 1);
++
++ setWindowPaintOffset (s, (s->x - ceil(px)) * s->width,
++ (s->y - floor(py)) * s->height);
++
++ matrixTranslate (&sTransform, xTranslate, 0.0f, 0.0f);
++
++ (*s->paintTransformedOutput) (s, sAttrib, &sTransform,
++ &output->region, output, mask);
++
++ matrixTranslate (&sTransform, -xTranslate, 0.0f, 0.0f);
++ }
++
++ tx = floor (px) - s->x;
++ xTranslate = -fmod (px, 1);
++
++ setWindowPaintOffset (s, (s->x - floor(px)) * s->width,
++ (s->y - floor(py)) * s->height);
++
++ matrixTranslate (&sTransform, xTranslate, 0.0f, 0.0f);
++ (*s->paintTransformedOutput) (s, sAttrib, &sTransform,
++ &output->region, output, mask);
++
++ setWindowPaintOffset (s, 0, 0);
++ ws->transform = oldTransform;
++ }
++
++ WRAP (ws, s, paintTransformedOutput, wallPaintTransformedOutput);
++}
++
++static Bool
++wallPaintWindow (CompWindow *w,
++ const WindowPaintAttrib *attrib,
++ const CompTransform *transform,
++ Region region,
++ unsigned int mask)
++{
++ Bool status;
++ CompScreen *s = w->screen;
++
++ WALL_SCREEN (s);
++
++ if (ws->transform == MiniScreen)
++ {
++ WindowPaintAttrib pA = *attrib;
++
++ pA.opacity = attrib->opacity *
++ ((float) ws->mSAttribs.opacity / OPAQUE);
++ pA.brightness = attrib->brightness *
++ ((float) ws->mSAttribs.brightness / BRIGHT);
++ pA.saturation = attrib->saturation *
++ ((float) ws->mSAttribs.saturation / COLOR);
++
++ if (!pA.opacity || !pA.brightness)
++ mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
++
++ UNWRAP (ws, s, paintWindow);
++ status = (*s->paintWindow) (w, &pA, transform, region, mask);
++ WRAP (ws, s, paintWindow, wallPaintWindow);
++ }
++ else if (ws->transform == Sliding)
++ {
++ CompTransform wTransform;
++
++ WALL_WINDOW (w);
++
++ if (!ww->isSliding)
++ {
++ matrixGetIdentity (&wTransform);
++ transformToScreenSpace (s, ws->currOutput, -DEFAULT_Z_CAMERA,
++ &wTransform);
++ mask |= PAINT_WINDOW_TRANSFORMED_MASK;
++ }
++ else
++ {
++ wTransform = *transform;
++ }
++
++ UNWRAP (ws, s, paintWindow);
++ status = (*s->paintWindow) (w, attrib, &wTransform, region, mask);
++ WRAP (ws, s, paintWindow, wallPaintWindow);
++ }
++ else
++ {
++ UNWRAP (ws, s, paintWindow);
++ status = (*s->paintWindow) (w, attrib, transform, region, mask);
++ WRAP (ws, s, paintWindow, wallPaintWindow);
++ }
++
++ return status;
++}
++
++static void
++wallDonePaintScreen (CompScreen *s)
++{
++ WALL_SCREEN (s);
++
++ if (ws->moving || ws->showPreview || ws->boxTimeout)
++ {
++ ws->boxTimeout = MAX (0, ws->boxTimeout);
++ damageScreen (s);
++ }
++
++ if (!ws->moving && !ws->showPreview && ws->grabIndex)
++ {
++ removeScreenGrab (s, ws->grabIndex, NULL);
++ ws->grabIndex = 0;
++ }
++
++ UNWRAP (ws, s, donePaintScreen);
++ (*s->donePaintScreen) (s);
++ WRAP (ws, s, donePaintScreen, wallDonePaintScreen);
++
++}
++
++static void
++wallCreateCairoContexts (CompScreen *s,
++ Bool initial)
++{
++ int width, height;
++
++ WALL_SCREEN (s);
++
++ ws->viewportWidth = VIEWPORT_SWITCHER_SIZE *
++ (float) wallGetPreviewScale (s->display) / 100.0f;
++ ws->viewportHeight = ws->viewportWidth *
++ (float) s->height / (float) s->width;
++ ws->viewportBorder = wallGetBorderWidth (s->display);
++
++ width = s->hsize * (ws->viewportWidth + ws->viewportBorder) +
++ ws->viewportBorder;
++ height = s->vsize * (ws->viewportHeight + ws->viewportBorder) +
++ ws->viewportBorder;
++
++ wallDestroyCairoContext (s, &ws->switcherContext);
++ ws->switcherContext.width = width;
++ ws->switcherContext.height = height;
++ wallSetupCairoContext (s, &ws->switcherContext);
++ wallDrawSwitcherBackground (s);
++
++ wallDestroyCairoContext (s, &ws->thumbContext);
++ ws->thumbContext.width = ws->viewportWidth;
++ ws->thumbContext.height = ws->viewportHeight;
++ wallSetupCairoContext (s, &ws->thumbContext);
++ wallDrawThumb (s);
++
++ wallDestroyCairoContext (s, &ws->highlightContext);
++ ws->highlightContext.width = ws->viewportWidth;
++ ws->highlightContext.height = ws->viewportHeight;
++ wallSetupCairoContext (s, &ws->highlightContext);
++ wallDrawHighlight (s);
++
++ if (initial)
++ {
++ ws->arrowContext.width = ARROW_SIZE;
++ ws->arrowContext.height = ARROW_SIZE;
++ wallSetupCairoContext (s, &ws->arrowContext);
++ wallDrawArrow (s);
++ }
++}
++
++static void
++wallDisplayOptionChanged (CompDisplay *display,
++ CompOption *opt,
++ WallDisplayOptions num)
++{
++ CompScreen *s;
++
++ switch(num)
++ {
++ case WallDisplayOptionOutlineColor:
++ for (s = display->screens; s; s = s->next)
++ {
++ wallDrawSwitcherBackground (s);
++ wallDrawHighlight (s);
++ wallDrawThumb (s);
++ }
++ break;
++
++ case WallDisplayOptionEdgeRadius:
++ case WallDisplayOptionBackgroundGradientBaseColor:
++ case WallDisplayOptionBackgroundGradientHighlightColor:
++ case WallDisplayOptionBackgroundGradientShadowColor:
++ for (s = display->screens; s; s = s->next)
++ wallDrawSwitcherBackground (s);
++ break;
++
++ case WallDisplayOptionBorderWidth:
++ case WallDisplayOptionPreviewScale:
++ for (s = display->screens; s; s = s->next)
++ wallCreateCairoContexts (s, FALSE);
++ break;
++
++ case WallDisplayOptionThumbGradientBaseColor:
++ case WallDisplayOptionThumbGradientHighlightColor:
++ for (s = display->screens; s; s = s->next)
++ wallDrawThumb (s);
++ break;
++
++ case WallDisplayOptionThumbHighlightGradientBaseColor:
++ case WallDisplayOptionThumbHighlightGradientShadowColor:
++ for (s = display->screens; s; s = s->next)
++ wallDrawHighlight (s);
++ break;
++
++ case WallDisplayOptionArrowBaseColor:
++ case WallDisplayOptionArrowShadowColor:
++ for (s = display->screens; s; s = s->next)
++ wallDrawArrow (s);
++ break;
++
++ case WallDisplayOptionNoSlideMatch:
++ for (s = display->screens; s; s = s->next)
++ {
++ CompWindow *w;
++
++ for (w = s->windows; w; w = w->next)
++ {
++ WALL_WINDOW (w);
++ ww->isSliding = !matchEval (wallGetNoSlideMatch (display), w);
++ }
++ }
++ break;
++
++ default:
++ break;
++ }
++}
++
++static Bool
++wallSetOptionForPlugin (CompObject *o,
++ const char *plugin,
++ const char *name,
++ CompOptionValue *value)
++{
++ Bool status;
++
++ WALL_CORE (&core);
++
++ UNWRAP (wc, &core, setOptionForPlugin);
++ status = (*core.setOptionForPlugin) (o, plugin, name, value);
++ WRAP (wc, &core, setOptionForPlugin, wallSetOptionForPlugin);
++
++ if (status && o->type == COMP_OBJECT_TYPE_SCREEN)
++ {
++ if (strcmp (plugin, "core") == 0)
++ if (strcmp (name, "hsize") == 0 || strcmp (name, "vsize") == 0)
++ {
++ CompScreen *s = (CompScreen *) o;
++
++ wallCreateCairoContexts (s, FALSE);
++ }
++ }
++
++ return status;
++}
++
++static void
++wallMatchExpHandlerChanged (CompDisplay *d)
++{
++ CompScreen *s;
++
++ WALL_DISPLAY (d);
++
++ UNWRAP (wd, d, matchExpHandlerChanged);
++ (*d->matchExpHandlerChanged) (d);
++ WRAP (wd, d, matchExpHandlerChanged, wallMatchExpHandlerChanged);
++
++ for (s = d->screens; s; s = s->next)
++ {
++ CompWindow *w;
++
++ for (w = s->windows; w; w = w->next)
++ {
++ WALL_WINDOW (w);
++
++ ww->isSliding = !matchEval (wallGetNoSlideMatch (d), w);
++ }
++ }
++}
++
++static void
++wallMatchPropertyChanged (CompDisplay *d,
++ CompWindow *w)
++{
++ WALL_DISPLAY (d);
++ WALL_WINDOW (w);
++
++ UNWRAP (wd, d, matchPropertyChanged);
++ (*d->matchPropertyChanged) (d, w);
++ WRAP (wd, d, matchPropertyChanged, wallMatchPropertyChanged);
++
++ ww->isSliding = !matchEval (wallGetNoSlideMatch (d), w);
++}
++
++static void
++wallWindowAdd (CompScreen *s,
++ CompWindow *w)
++{
++ WALL_WINDOW (w);
++
++ ww->isSliding = !matchEval (wallGetNoSlideMatch (s->display), w);
++}
++
++static void
++wallObjectAdd (CompObject *parent,
++ CompObject *object)
++{
++ static ObjectAddProc dispTab[] = {
++ (ObjectAddProc) 0, /* CoreAdd */
++ (ObjectAddProc) 0, /* DisplayAdd */
++ (ObjectAddProc) 0, /* ScreenAdd */
++ (ObjectAddProc) wallWindowAdd
++ };
++
++ WALL_CORE (&core);
++
++ UNWRAP (wc, &core, objectAdd);
++ (*core.objectAdd) (parent, object);
++ WRAP (wc, &core, objectAdd, wallObjectAdd);
++
++ DISPATCH (object, dispTab, ARRAY_SIZE (dispTab), (parent, object));
++}
++
++static Bool
++wallInitCore (CompPlugin *p,
++ CompCore *c)
++{
++ WallCore *wc;
++
++ if (!checkPluginABI ("core", CORE_ABIVERSION))
++ return FALSE;
++
++ wc = malloc (sizeof (WallCore));
++ if (!wc)
++ return FALSE;
++
++ WallDisplayPrivateIndex = allocateDisplayPrivateIndex ();
++ if (WallDisplayPrivateIndex < 0)
++ {
++ free (wc);
++ return FALSE;
++ }
++
++ WRAP (wc, c, setOptionForPlugin, wallSetOptionForPlugin);
++ WRAP (wc, c, objectAdd, wallObjectAdd);
++
++ c->base.privates[WallCorePrivateIndex].ptr = wc;
++
++ return TRUE;
++}
++
++static void
++wallFiniCore (CompPlugin *p,
++ CompCore *c)
++{
++ WALL_CORE (c);
++
++ UNWRAP (wc, c, setOptionForPlugin);
++ UNWRAP (wc, c, objectAdd);
++
++ freeDisplayPrivateIndex (WallDisplayPrivateIndex);
++
++ free (wc);
++}
++
++static Bool
++wallInitDisplay (CompPlugin *p,
++ CompDisplay *d)
++{
++ WallDisplay *wd;
++
++ wd = malloc (sizeof (WallDisplay));
++ if (!wd)
++ return FALSE;
++
++ wd->screenPrivateIndex = allocateScreenPrivateIndex (d);
++ if (wd->screenPrivateIndex < 0)
++ {
++ free (wd);
++ return FALSE;
++ }
++
++ wallSetLeftKeyInitiate (d, wallLeft);
++ wallSetLeftKeyTerminate (d, wallTerminate);
++ wallSetRightKeyInitiate (d, wallRight);
++ wallSetRightKeyTerminate (d, wallTerminate);
++ wallSetUpKeyInitiate (d, wallUp);
++ wallSetUpKeyTerminate (d, wallTerminate);
++ wallSetDownKeyInitiate (d, wallDown);
++ wallSetDownKeyTerminate (d, wallTerminate);
++ wallSetNextKeyInitiate (d, wallNext);
++ wallSetNextKeyTerminate (d, wallTerminate);
++ wallSetPrevKeyInitiate (d, wallPrev);
++ wallSetPrevKeyTerminate (d, wallTerminate);
++ wallSetLeftButtonInitiate (d, wallLeft);
++ wallSetLeftButtonTerminate (d, wallTerminate);
++ wallSetRightButtonInitiate (d, wallRight);
++ wallSetRightButtonTerminate (d, wallTerminate);
++ wallSetUpButtonInitiate (d, wallUp);
++ wallSetUpButtonTerminate (d, wallTerminate);
++ wallSetDownButtonInitiate (d, wallDown);
++ wallSetDownButtonTerminate (d, wallTerminate);
++ wallSetNextButtonInitiate (d, wallNext);
++ wallSetNextButtonTerminate (d, wallTerminate);
++ wallSetPrevButtonInitiate (d, wallPrev);
++ wallSetPrevButtonTerminate (d, wallTerminate);
++ wallSetLeftWindowKeyInitiate (d, wallLeftWithWindow);
++ wallSetLeftWindowKeyTerminate (d, wallTerminate);
++ wallSetRightWindowKeyInitiate (d, wallRightWithWindow);
++ wallSetRightWindowKeyTerminate (d, wallTerminate);
++ wallSetUpWindowKeyInitiate (d, wallUpWithWindow);
++ wallSetUpWindowKeyTerminate (d, wallTerminate);
++ wallSetDownWindowKeyInitiate (d, wallDownWithWindow);
++ wallSetDownWindowKeyTerminate (d, wallTerminate);
++ wallSetFlipLeftEdgeInitiate (d, wallFlipLeft);
++ wallSetFlipRightEdgeInitiate (d, wallFlipRight);
++ wallSetFlipUpEdgeInitiate (d, wallFlipUp);
++ wallSetFlipDownEdgeInitiate (d, wallFlipDown);
++
++ wallSetEdgeRadiusNotify (d, wallDisplayOptionChanged);
++ wallSetBorderWidthNotify (d, wallDisplayOptionChanged);
++ wallSetPreviewScaleNotify (d, wallDisplayOptionChanged);
++ wallSetOutlineColorNotify (d, wallDisplayOptionChanged);
++ wallSetBackgroundGradientBaseColorNotify (d, wallDisplayOptionChanged);
++ wallSetBackgroundGradientHighlightColorNotify (d, wallDisplayOptionChanged);
++ wallSetBackgroundGradientShadowColorNotify (d, wallDisplayOptionChanged);
++ wallSetThumbGradientBaseColorNotify (d, wallDisplayOptionChanged);
++ wallSetThumbGradientHighlightColorNotify (d, wallDisplayOptionChanged);
++ wallSetThumbHighlightGradientBaseColorNotify (d, wallDisplayOptionChanged);
++ wallSetThumbHighlightGradientShadowColorNotify (d,
++ wallDisplayOptionChanged);
++ wallSetArrowBaseColorNotify (d, wallDisplayOptionChanged);
++ wallSetArrowShadowColorNotify (d, wallDisplayOptionChanged);
++ wallSetNoSlideMatchNotify (d, wallDisplayOptionChanged);
++
++ WRAP (wd, d, handleEvent, wallHandleEvent);
++ WRAP (wd, d, matchExpHandlerChanged, wallMatchExpHandlerChanged);
++ WRAP (wd, d, matchPropertyChanged, wallMatchPropertyChanged);
++
++ d->base.privates[WallDisplayPrivateIndex].ptr = wd;
++
++ return TRUE;
++}
++
++static void
++wallFiniDisplay (CompPlugin *p,
++ CompDisplay *d)
++{
++ WALL_DISPLAY (d);
++
++ UNWRAP (wd, d, handleEvent);
++ UNWRAP (wd, d, matchExpHandlerChanged);
++ UNWRAP (wd, d, matchPropertyChanged);
++
++ freeScreenPrivateIndex (d, wd->screenPrivateIndex);
++ free (wd);
++}
++
++static Bool
++wallInitScreen (CompPlugin *p,
++ CompScreen *s)
++{
++ WallScreen *ws;
++
++ WALL_DISPLAY (s->display);
++
++ ws = malloc (sizeof (WallScreen));
++ if (!ws)
++ return FALSE;
++
++ ws->windowPrivateIndex = allocateWindowPrivateIndex (s);
++ if (ws->windowPrivateIndex < 0)
++ {
++ free (ws);
++ return FALSE;
++ }
++
++ ws->timer = 0;
++ ws->boxTimeout = 0;
++ ws->grabIndex = 0;
++
++ ws->moving = FALSE;
++ ws->showPreview = FALSE;
++ ws->focusDefault = TRUE;
++ ws->moveWindow = None;
++
++ ws->transform = NoTransformation;
++ ws->direction = -1;
++
++ memset (&ws->switcherContext, 0, sizeof (WallCairoContext));
++ memset (&ws->thumbContext, 0, sizeof (WallCairoContext));
++ memset (&ws->highlightContext, 0, sizeof (WallCairoContext));
++ memset (&ws->arrowContext, 0, sizeof (WallCairoContext));
++
++ WRAP (ws, s, paintScreen, wallPaintScreen);
++ WRAP (ws, s, paintOutput, wallPaintOutput);
++ WRAP (ws, s, donePaintScreen, wallDonePaintScreen);
++ WRAP (ws, s, paintTransformedOutput, wallPaintTransformedOutput);
++ WRAP (ws, s, preparePaintScreen, wallPreparePaintScreen);
++ WRAP (ws, s, paintWindow, wallPaintWindow);
++ WRAP (ws, s, activateWindow, wallActivateWindow);
++
++ s->base.privates[wd->screenPrivateIndex].ptr = ws;
++
++ wallCreateCairoContexts (s, TRUE);
++
++ return TRUE;
++}
++
++static void
++wallFiniScreen (CompPlugin *p,
++ CompScreen *s)
++{
++ WALL_SCREEN (s);
++
++ if (ws->grabIndex)
++ removeScreenGrab (s, ws->grabIndex, NULL);
++
++ wallDestroyCairoContext (s, &ws->switcherContext);
++ wallDestroyCairoContext (s, &ws->thumbContext);
++ wallDestroyCairoContext (s, &ws->highlightContext);
++ wallDestroyCairoContext (s, &ws->arrowContext);
++
++ UNWRAP (ws, s, paintScreen);
++ UNWRAP (ws, s, paintOutput);
++ UNWRAP (ws, s, donePaintScreen);
++ UNWRAP (ws, s, paintTransformedOutput);
++ UNWRAP (ws, s, preparePaintScreen);
++ UNWRAP (ws, s, paintWindow);
++ UNWRAP (ws, s, activateWindow);
++
++ freeWindowPrivateIndex (s, ws->windowPrivateIndex);
++
++ free(ws);
++}
++
++static CompBool
++wallInitWindow (CompPlugin *p,
++ CompWindow *w)
++{
++ WallWindow *ww;
++
++ WALL_SCREEN (w->screen);
++
++ ww = malloc (sizeof (WallWindow));
++ if (!ww)
++ return FALSE;
++
++ ww->isSliding = TRUE;
++
++ w->base.privates[ws->windowPrivateIndex].ptr = ww;
++
++ return TRUE;
++}
++
++static void
++wallFiniWindow (CompPlugin *p,
++ CompWindow *w)
++{
++ WALL_WINDOW (w);
++
++ free (ww);
++}
++
++static CompBool
++wallInitObject (CompPlugin *p,
++ CompObject *o)
++{
++ static InitPluginObjectProc dispTab[] = {
++ (InitPluginObjectProc) wallInitCore,
++ (InitPluginObjectProc) wallInitDisplay,
++ (InitPluginObjectProc) wallInitScreen,
++ (InitPluginObjectProc) wallInitWindow
++ };
++
++ RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
++}
++
++static void
++wallFiniObject (CompPlugin *p,
++ CompObject *o)
++{
++ static FiniPluginObjectProc dispTab[] = {
++ (FiniPluginObjectProc) wallFiniCore,
++ (FiniPluginObjectProc) wallFiniDisplay,
++ (FiniPluginObjectProc) wallFiniScreen,
++ (FiniPluginObjectProc) wallFiniWindow
++ };
++
++ DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
++}
++
++static Bool
++wallInit (CompPlugin *p)
++{
++ WallCorePrivateIndex = allocateCorePrivateIndex ();
++ if (WallCorePrivateIndex < 0)
++ return FALSE;
++
++ return TRUE;
++}
++
++static void
++wallFini (CompPlugin *p)
++{
++ freeCorePrivateIndex (WallCorePrivateIndex);
++}
++
++CompPluginVTable wallVTable = {
++ "wall",
++ 0,
++ wallInit,
++ wallFini,
++ wallInitObject,
++ wallFiniObject,
++ 0,
++ 0
++};
++
++CompPluginVTable*
++getCompPluginInfo (void)
++{
++ return &wallVTable;
++}
+diff -upNr compiz-0.8.2.orign/src/wall_options.c compiz-0.8.2/src/wall_options.c
+--- compiz-0.8.2.orign/src/wall_options.c 1970-01-01 01:00:00.000000000 +0100
++++ compiz-0.8.2/src/wall_options.c 2009-07-10 23:02:20.185497000 +0200
+@@ -0,0 +1,1936 @@
++/*
++ * This file is autogenerated with bcop:
++ * The Compiz option code generator
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ */
++
++#include
++#include
++#include
++
++#include
++
++#include "wall_options.h"
++
++static int WallOptionsDisplayPrivateIndex;
++
++static CompMetadata wallOptionsMetadata;
++
++static CompPluginVTable *wallPluginVTable = NULL;
++CompPluginVTable wallOptionsVTable;
++
++#define WALL_OPTIONS_DISPLAY(d) PLUGIN_DISPLAY(d, WallOptions, o)
++#define WALL_OPTIONS_SCREEN(s) PLUGIN_SCREEN(s, WallOptions, o)
++
++typedef struct _WallOptionsDisplay
++{
++ int screenPrivateIndex;
++
++ CompOption opt[WallDisplayOptionNum];
++ wallDisplayOptionChangeNotifyProc notify[WallDisplayOptionNum];
++} WallOptionsDisplay;
++
++typedef struct _WallOptionsScreen
++{
++ CompOption opt[WallScreenOptionNum];
++ wallScreenOptionChangeNotifyProc notify[WallScreenOptionNum];
++} WallOptionsScreen;
++
++Bool wallGetShowSwitcher (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionShowSwitcher].value.b;
++}
++
++CompOption * wallGetShowSwitcherOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionShowSwitcher];
++}
++
++void wallSetShowSwitcherNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionShowSwitcher] = notify;
++}
++
++Bool wallGetMiniscreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionMiniscreen].value.b;
++}
++
++CompOption * wallGetMiniscreenOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionMiniscreen];
++}
++
++void wallSetMiniscreenNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionMiniscreen] = notify;
++}
++
++float wallGetPreviewTimeout (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionPreviewTimeout].value.f;
++}
++
++CompOption * wallGetPreviewTimeoutOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPreviewTimeout];
++}
++
++void wallSetPreviewTimeoutNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionPreviewTimeout] = notify;
++}
++
++int wallGetPreviewScale (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionPreviewScale].value.i;
++}
++
++CompOption * wallGetPreviewScaleOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPreviewScale];
++}
++
++void wallSetPreviewScaleNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionPreviewScale] = notify;
++}
++
++int wallGetEdgeRadius (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionEdgeRadius].value.i;
++}
++
++CompOption * wallGetEdgeRadiusOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionEdgeRadius];
++}
++
++void wallSetEdgeRadiusNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionEdgeRadius] = notify;
++}
++
++int wallGetBorderWidth (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBorderWidth].value.i;
++}
++
++CompOption * wallGetBorderWidthOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionBorderWidth];
++}
++
++void wallSetBorderWidthNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionBorderWidth] = notify;
++}
++
++unsigned short * wallGetOutlineColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionOutlineColor].value.c;
++}
++
++unsigned short wallGetOutlineColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionOutlineColor].value.c[0];
++}
++
++unsigned short wallGetOutlineColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionOutlineColor].value.c[1];
++}
++
++unsigned short wallGetOutlineColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionOutlineColor].value.c[2];
++}
++
++unsigned short wallGetOutlineColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionOutlineColor].value.c[3];
++}
++
++CompOption * wallGetOutlineColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionOutlineColor];
++}
++
++void wallSetOutlineColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionOutlineColor] = notify;
++}
++
++unsigned short * wallGetBackgroundGradientBaseColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientBaseColor].value.c;
++}
++
++unsigned short wallGetBackgroundGradientBaseColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientBaseColor].value.c[0];
++}
++
++unsigned short wallGetBackgroundGradientBaseColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientBaseColor].value.c[1];
++}
++
++unsigned short wallGetBackgroundGradientBaseColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientBaseColor].value.c[2];
++}
++
++unsigned short wallGetBackgroundGradientBaseColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientBaseColor].value.c[3];
++}
++
++CompOption * wallGetBackgroundGradientBaseColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionBackgroundGradientBaseColor];
++}
++
++void wallSetBackgroundGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionBackgroundGradientBaseColor] = notify;
++}
++
++unsigned short * wallGetBackgroundGradientHighlightColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientHighlightColor].value.c;
++}
++
++unsigned short wallGetBackgroundGradientHighlightColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientHighlightColor].value.c[0];
++}
++
++unsigned short wallGetBackgroundGradientHighlightColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientHighlightColor].value.c[1];
++}
++
++unsigned short wallGetBackgroundGradientHighlightColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientHighlightColor].value.c[2];
++}
++
++unsigned short wallGetBackgroundGradientHighlightColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientHighlightColor].value.c[3];
++}
++
++CompOption * wallGetBackgroundGradientHighlightColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionBackgroundGradientHighlightColor];
++}
++
++void wallSetBackgroundGradientHighlightColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionBackgroundGradientHighlightColor] = notify;
++}
++
++unsigned short * wallGetBackgroundGradientShadowColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientShadowColor].value.c;
++}
++
++unsigned short wallGetBackgroundGradientShadowColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientShadowColor].value.c[0];
++}
++
++unsigned short wallGetBackgroundGradientShadowColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientShadowColor].value.c[1];
++}
++
++unsigned short wallGetBackgroundGradientShadowColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientShadowColor].value.c[2];
++}
++
++unsigned short wallGetBackgroundGradientShadowColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionBackgroundGradientShadowColor].value.c[3];
++}
++
++CompOption * wallGetBackgroundGradientShadowColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionBackgroundGradientShadowColor];
++}
++
++void wallSetBackgroundGradientShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionBackgroundGradientShadowColor] = notify;
++}
++
++unsigned short * wallGetThumbGradientBaseColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientBaseColor].value.c;
++}
++
++unsigned short wallGetThumbGradientBaseColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientBaseColor].value.c[0];
++}
++
++unsigned short wallGetThumbGradientBaseColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientBaseColor].value.c[1];
++}
++
++unsigned short wallGetThumbGradientBaseColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientBaseColor].value.c[2];
++}
++
++unsigned short wallGetThumbGradientBaseColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientBaseColor].value.c[3];
++}
++
++CompOption * wallGetThumbGradientBaseColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionThumbGradientBaseColor];
++}
++
++void wallSetThumbGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionThumbGradientBaseColor] = notify;
++}
++
++unsigned short * wallGetThumbGradientHighlightColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientHighlightColor].value.c;
++}
++
++unsigned short wallGetThumbGradientHighlightColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientHighlightColor].value.c[0];
++}
++
++unsigned short wallGetThumbGradientHighlightColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientHighlightColor].value.c[1];
++}
++
++unsigned short wallGetThumbGradientHighlightColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientHighlightColor].value.c[2];
++}
++
++unsigned short wallGetThumbGradientHighlightColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbGradientHighlightColor].value.c[3];
++}
++
++CompOption * wallGetThumbGradientHighlightColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionThumbGradientHighlightColor];
++}
++
++void wallSetThumbGradientHighlightColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionThumbGradientHighlightColor] = notify;
++}
++
++unsigned short * wallGetThumbHighlightGradientBaseColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientBaseColor].value.c;
++}
++
++unsigned short wallGetThumbHighlightGradientBaseColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientBaseColor].value.c[0];
++}
++
++unsigned short wallGetThumbHighlightGradientBaseColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientBaseColor].value.c[1];
++}
++
++unsigned short wallGetThumbHighlightGradientBaseColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientBaseColor].value.c[2];
++}
++
++unsigned short wallGetThumbHighlightGradientBaseColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientBaseColor].value.c[3];
++}
++
++CompOption * wallGetThumbHighlightGradientBaseColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionThumbHighlightGradientBaseColor];
++}
++
++void wallSetThumbHighlightGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionThumbHighlightGradientBaseColor] = notify;
++}
++
++unsigned short * wallGetThumbHighlightGradientShadowColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientShadowColor].value.c;
++}
++
++unsigned short wallGetThumbHighlightGradientShadowColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientShadowColor].value.c[0];
++}
++
++unsigned short wallGetThumbHighlightGradientShadowColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientShadowColor].value.c[1];
++}
++
++unsigned short wallGetThumbHighlightGradientShadowColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientShadowColor].value.c[2];
++}
++
++unsigned short wallGetThumbHighlightGradientShadowColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionThumbHighlightGradientShadowColor].value.c[3];
++}
++
++CompOption * wallGetThumbHighlightGradientShadowColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionThumbHighlightGradientShadowColor];
++}
++
++void wallSetThumbHighlightGradientShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionThumbHighlightGradientShadowColor] = notify;
++}
++
++unsigned short * wallGetArrowBaseColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowBaseColor].value.c;
++}
++
++unsigned short wallGetArrowBaseColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowBaseColor].value.c[0];
++}
++
++unsigned short wallGetArrowBaseColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowBaseColor].value.c[1];
++}
++
++unsigned short wallGetArrowBaseColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowBaseColor].value.c[2];
++}
++
++unsigned short wallGetArrowBaseColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowBaseColor].value.c[3];
++}
++
++CompOption * wallGetArrowBaseColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionArrowBaseColor];
++}
++
++void wallSetArrowBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionArrowBaseColor] = notify;
++}
++
++unsigned short * wallGetArrowShadowColor (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowShadowColor].value.c;
++}
++
++unsigned short wallGetArrowShadowColorRed (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowShadowColor].value.c[0];
++}
++
++unsigned short wallGetArrowShadowColorGreen (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowShadowColor].value.c[1];
++}
++
++unsigned short wallGetArrowShadowColorBlue (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowShadowColor].value.c[2];
++}
++
++unsigned short wallGetArrowShadowColorAlpha (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionArrowShadowColor].value.c[3];
++}
++
++CompOption * wallGetArrowShadowColorOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionArrowShadowColor];
++}
++
++void wallSetArrowShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionArrowShadowColor] = notify;
++}
++
++Bool wallGetAllowWraparound (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionAllowWraparound].value.b;
++}
++
++CompOption * wallGetAllowWraparoundOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionAllowWraparound];
++}
++
++void wallSetAllowWraparoundNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionAllowWraparound] = notify;
++}
++
++float wallGetSlideDuration (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return od->opt[WallDisplayOptionSlideDuration].value.f;
++}
++
++CompOption * wallGetSlideDurationOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionSlideDuration];
++}
++
++void wallSetSlideDurationNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionSlideDuration] = notify;
++}
++
++CompMatch * wallGetNoSlideMatch (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNoSlideMatch].value.match;
++}
++
++CompOption * wallGetNoSlideMatchOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNoSlideMatch];
++}
++
++void wallSetNoSlideMatchNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionNoSlideMatch] = notify;
++}
++
++CompAction * wallGetLeftKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftKey].value.action;
++}
++
++void wallSetLeftKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftKey].value.action.initiate = init;
++}
++
++void wallSetLeftKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftKey].value.action.terminate = term;
++}
++
++CompOption * wallGetLeftKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftKey];
++}
++
++void wallSetLeftKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionLeftKey] = notify;
++}
++
++CompAction * wallGetLeftButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftButton].value.action;
++}
++
++void wallSetLeftButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftButton].value.action.initiate = init;
++}
++
++void wallSetLeftButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftButton].value.action.terminate = term;
++}
++
++CompOption * wallGetLeftButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftButton];
++}
++
++void wallSetLeftButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionLeftButton] = notify;
++}
++
++CompAction * wallGetRightKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightKey].value.action;
++}
++
++void wallSetRightKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightKey].value.action.initiate = init;
++}
++
++void wallSetRightKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightKey].value.action.terminate = term;
++}
++
++CompOption * wallGetRightKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightKey];
++}
++
++void wallSetRightKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionRightKey] = notify;
++}
++
++CompAction * wallGetRightButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightButton].value.action;
++}
++
++void wallSetRightButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightButton].value.action.initiate = init;
++}
++
++void wallSetRightButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightButton].value.action.terminate = term;
++}
++
++CompOption * wallGetRightButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightButton];
++}
++
++void wallSetRightButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionRightButton] = notify;
++}
++
++CompAction * wallGetUpKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpKey].value.action;
++}
++
++void wallSetUpKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpKey].value.action.initiate = init;
++}
++
++void wallSetUpKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpKey].value.action.terminate = term;
++}
++
++CompOption * wallGetUpKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpKey];
++}
++
++void wallSetUpKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionUpKey] = notify;
++}
++
++CompAction * wallGetUpButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpButton].value.action;
++}
++
++void wallSetUpButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpButton].value.action.initiate = init;
++}
++
++void wallSetUpButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpButton].value.action.terminate = term;
++}
++
++CompOption * wallGetUpButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpButton];
++}
++
++void wallSetUpButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionUpButton] = notify;
++}
++
++CompAction * wallGetDownKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownKey].value.action;
++}
++
++void wallSetDownKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownKey].value.action.initiate = init;
++}
++
++void wallSetDownKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownKey].value.action.terminate = term;
++}
++
++CompOption * wallGetDownKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownKey];
++}
++
++void wallSetDownKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionDownKey] = notify;
++}
++
++CompAction * wallGetDownButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownButton].value.action;
++}
++
++void wallSetDownButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownButton].value.action.initiate = init;
++}
++
++void wallSetDownButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownButton].value.action.terminate = term;
++}
++
++CompOption * wallGetDownButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownButton];
++}
++
++void wallSetDownButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionDownButton] = notify;
++}
++
++CompAction * wallGetNextKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNextKey].value.action;
++}
++
++void wallSetNextKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionNextKey].value.action.initiate = init;
++}
++
++void wallSetNextKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionNextKey].value.action.terminate = term;
++}
++
++CompOption * wallGetNextKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNextKey];
++}
++
++void wallSetNextKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionNextKey] = notify;
++}
++
++CompAction * wallGetNextButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNextButton].value.action;
++}
++
++void wallSetNextButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionNextButton].value.action.initiate = init;
++}
++
++void wallSetNextButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionNextButton].value.action.terminate = term;
++}
++
++CompOption * wallGetNextButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionNextButton];
++}
++
++void wallSetNextButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionNextButton] = notify;
++}
++
++CompAction * wallGetPrevKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPrevKey].value.action;
++}
++
++void wallSetPrevKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionPrevKey].value.action.initiate = init;
++}
++
++void wallSetPrevKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionPrevKey].value.action.terminate = term;
++}
++
++CompOption * wallGetPrevKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPrevKey];
++}
++
++void wallSetPrevKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionPrevKey] = notify;
++}
++
++CompAction * wallGetPrevButton (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPrevButton].value.action;
++}
++
++void wallSetPrevButtonInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionPrevButton].value.action.initiate = init;
++}
++
++void wallSetPrevButtonTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionPrevButton].value.action.terminate = term;
++}
++
++CompOption * wallGetPrevButtonOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionPrevButton];
++}
++
++void wallSetPrevButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionPrevButton] = notify;
++}
++
++CompAction * wallGetLeftWindowKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftWindowKey].value.action;
++}
++
++void wallSetLeftWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftWindowKey].value.action.initiate = init;
++}
++
++void wallSetLeftWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionLeftWindowKey].value.action.terminate = term;
++}
++
++CompOption * wallGetLeftWindowKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionLeftWindowKey];
++}
++
++void wallSetLeftWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionLeftWindowKey] = notify;
++}
++
++CompAction * wallGetRightWindowKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightWindowKey].value.action;
++}
++
++void wallSetRightWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightWindowKey].value.action.initiate = init;
++}
++
++void wallSetRightWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionRightWindowKey].value.action.terminate = term;
++}
++
++CompOption * wallGetRightWindowKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionRightWindowKey];
++}
++
++void wallSetRightWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionRightWindowKey] = notify;
++}
++
++CompAction * wallGetUpWindowKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpWindowKey].value.action;
++}
++
++void wallSetUpWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpWindowKey].value.action.initiate = init;
++}
++
++void wallSetUpWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionUpWindowKey].value.action.terminate = term;
++}
++
++CompOption * wallGetUpWindowKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionUpWindowKey];
++}
++
++void wallSetUpWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionUpWindowKey] = notify;
++}
++
++CompAction * wallGetDownWindowKey (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownWindowKey].value.action;
++}
++
++void wallSetDownWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownWindowKey].value.action.initiate = init;
++}
++
++void wallSetDownWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionDownWindowKey].value.action.terminate = term;
++}
++
++CompOption * wallGetDownWindowKeyOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionDownWindowKey];
++}
++
++void wallSetDownWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionDownWindowKey] = notify;
++}
++
++CompAction * wallGetFlipLeftEdge (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipLeftEdge].value.action;
++}
++
++void wallSetFlipLeftEdgeInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipLeftEdge].value.action.initiate = init;
++}
++
++void wallSetFlipLeftEdgeTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipLeftEdge].value.action.terminate = term;
++}
++
++CompOption * wallGetFlipLeftEdgeOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipLeftEdge];
++}
++
++void wallSetFlipLeftEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionFlipLeftEdge] = notify;
++}
++
++CompAction * wallGetFlipRightEdge (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipRightEdge].value.action;
++}
++
++void wallSetFlipRightEdgeInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipRightEdge].value.action.initiate = init;
++}
++
++void wallSetFlipRightEdgeTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipRightEdge].value.action.terminate = term;
++}
++
++CompOption * wallGetFlipRightEdgeOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipRightEdge];
++}
++
++void wallSetFlipRightEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionFlipRightEdge] = notify;
++}
++
++CompAction * wallGetFlipUpEdge (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipUpEdge].value.action;
++}
++
++void wallSetFlipUpEdgeInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipUpEdge].value.action.initiate = init;
++}
++
++void wallSetFlipUpEdgeTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipUpEdge].value.action.terminate = term;
++}
++
++CompOption * wallGetFlipUpEdgeOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipUpEdge];
++}
++
++void wallSetFlipUpEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionFlipUpEdge] = notify;
++}
++
++CompAction * wallGetFlipDownEdge (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipDownEdge].value.action;
++}
++
++void wallSetFlipDownEdgeInitiate (CompDisplay *d, CompActionCallBackProc init)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipDownEdge].value.action.initiate = init;
++}
++
++void wallSetFlipDownEdgeTerminate (CompDisplay *d, CompActionCallBackProc term)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->opt[WallDisplayOptionFlipDownEdge].value.action.terminate = term;
++}
++
++CompOption * wallGetFlipDownEdgeOption (CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[WallDisplayOptionFlipDownEdge];
++}
++
++void wallSetFlipDownEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ od->notify[WallDisplayOptionFlipDownEdge] = notify;
++}
++
++int wallGetMmmode (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return os->opt[WallScreenOptionMmmode].value.i;
++}
++
++CompOption * wallGetMmmodeOption (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return &os->opt[WallScreenOptionMmmode];
++}
++
++void wallSetMmmodeNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_SCREEN(s);
++ os->notify[WallScreenOptionMmmode] = notify;
++}
++
++Bool wallGetEdgeflipPointer (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return os->opt[WallScreenOptionEdgeflipPointer].value.b;
++}
++
++CompOption * wallGetEdgeflipPointerOption (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return &os->opt[WallScreenOptionEdgeflipPointer];
++}
++
++void wallSetEdgeflipPointerNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_SCREEN(s);
++ os->notify[WallScreenOptionEdgeflipPointer] = notify;
++}
++
++Bool wallGetEdgeflipMove (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return os->opt[WallScreenOptionEdgeflipMove].value.b;
++}
++
++CompOption * wallGetEdgeflipMoveOption (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return &os->opt[WallScreenOptionEdgeflipMove];
++}
++
++void wallSetEdgeflipMoveNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_SCREEN(s);
++ os->notify[WallScreenOptionEdgeflipMove] = notify;
++}
++
++Bool wallGetEdgeflipDnd (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return os->opt[WallScreenOptionEdgeflipDnd].value.b;
++}
++
++CompOption * wallGetEdgeflipDndOption (CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return &os->opt[WallScreenOptionEdgeflipDnd];
++}
++
++void wallSetEdgeflipDndNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify)
++{
++ WALL_OPTIONS_SCREEN(s);
++ os->notify[WallScreenOptionEdgeflipDnd] = notify;
++}
++
++CompOption * wallGetDisplayOption (CompDisplay *d, WallDisplayOptions num)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ return &od->opt[num];
++}
++
++CompOption * wallGetScreenOption (CompScreen *s, WallScreenOptions num)
++{
++ WALL_OPTIONS_SCREEN(s);
++ return &os->opt[num];
++}
++
++static const CompMetadataOptionInfo wallOptionsDisplayOptionInfo[] = {
++ { "show_switcher", "bool", 0, 0, 0 },
++ { "miniscreen", "bool", 0, 0, 0 },
++ { "preview_timeout", "float", "0.02.0", 0, 0 },
++ { "preview_scale", "int", "0400", 0, 0 },
++ { "edge_radius", "int", "020", 0, 0 },
++ { "border_width", "int", "030", 0, 0 },
++ { "outline_color", "color", 0, 0, 0 },
++ { "background_gradient_base_color", "color", 0, 0, 0 },
++ { "background_gradient_highlight_color", "color", 0, 0, 0 },
++ { "background_gradient_shadow_color", "color", 0, 0, 0 },
++ { "thumb_gradient_base_color", "color", 0, 0, 0 },
++ { "thumb_gradient_highlight_color", "color", 0, 0, 0 },
++ { "thumb_highlight_gradient_base_color", "color", 0, 0, 0 },
++ { "thumb_highlight_gradient_shadow_color", "color", 0, 0, 0 },
++ { "arrow_base_color", "color", 0, 0, 0 },
++ { "arrow_shadow_color", "color", 0, 0, 0 },
++ { "allow_wraparound", "bool", 0, 0, 0 },
++ { "slide_duration", "float", "0.05.0", 0, 0 },
++ { "no_slide_match", "match", 0, 0, 0 },
++ { "left_key", "key", 0, 0, 0 },
++ { "left_button", "button", 0, 0, 0 },
++ { "right_key", "key", 0, 0, 0 },
++ { "right_button", "button", 0, 0, 0 },
++ { "up_key", "key", 0, 0, 0 },
++ { "up_button", "button", 0, 0, 0 },
++ { "down_key", "key", 0, 0, 0 },
++ { "down_button", "button", 0, 0, 0 },
++ { "next_key", "key", 0, 0, 0 },
++ { "next_button", "button", 0, 0, 0 },
++ { "prev_key", "key", 0, 0, 0 },
++ { "prev_button", "button", 0, 0, 0 },
++ { "left_window_key", "key", 0, 0, 0 },
++ { "right_window_key", "key", 0, 0, 0 },
++ { "up_window_key", "key", 0, 0, 0 },
++ { "down_window_key", "key", 0, 0, 0 },
++ { "flip_left_edge", "edge", 0, 0, 0 },
++ { "flip_right_edge", "edge", 0, 0, 0 },
++ { "flip_up_edge", "edge", 0, 0, 0 },
++ { "flip_down_edge", "edge", 0, 0, 0 },
++};
++
++static Bool wallOptionsSetDisplayOption (CompPlugin *plugin, CompDisplay *d, const char *name, CompOptionValue *value)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ CompOption *o;
++ int index;
++
++ o = compFindOption (od->opt, WallDisplayOptionNum, name, &index);
++
++ if (!o)
++ return FALSE;
++
++ switch (index)
++ {
++ case WallDisplayOptionShowSwitcher:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionShowSwitcher])
++ (*od->notify[WallDisplayOptionShowSwitcher]) (d, o, WallDisplayOptionShowSwitcher);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionMiniscreen:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionMiniscreen])
++ (*od->notify[WallDisplayOptionMiniscreen]) (d, o, WallDisplayOptionMiniscreen);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionPreviewTimeout:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionPreviewTimeout])
++ (*od->notify[WallDisplayOptionPreviewTimeout]) (d, o, WallDisplayOptionPreviewTimeout);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionPreviewScale:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionPreviewScale])
++ (*od->notify[WallDisplayOptionPreviewScale]) (d, o, WallDisplayOptionPreviewScale);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionEdgeRadius:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionEdgeRadius])
++ (*od->notify[WallDisplayOptionEdgeRadius]) (d, o, WallDisplayOptionEdgeRadius);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionBorderWidth:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionBorderWidth])
++ (*od->notify[WallDisplayOptionBorderWidth]) (d, o, WallDisplayOptionBorderWidth);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionOutlineColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionOutlineColor])
++ (*od->notify[WallDisplayOptionOutlineColor]) (d, o, WallDisplayOptionOutlineColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionBackgroundGradientBaseColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionBackgroundGradientBaseColor])
++ (*od->notify[WallDisplayOptionBackgroundGradientBaseColor]) (d, o, WallDisplayOptionBackgroundGradientBaseColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionBackgroundGradientHighlightColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionBackgroundGradientHighlightColor])
++ (*od->notify[WallDisplayOptionBackgroundGradientHighlightColor]) (d, o, WallDisplayOptionBackgroundGradientHighlightColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionBackgroundGradientShadowColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionBackgroundGradientShadowColor])
++ (*od->notify[WallDisplayOptionBackgroundGradientShadowColor]) (d, o, WallDisplayOptionBackgroundGradientShadowColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionThumbGradientBaseColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionThumbGradientBaseColor])
++ (*od->notify[WallDisplayOptionThumbGradientBaseColor]) (d, o, WallDisplayOptionThumbGradientBaseColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionThumbGradientHighlightColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionThumbGradientHighlightColor])
++ (*od->notify[WallDisplayOptionThumbGradientHighlightColor]) (d, o, WallDisplayOptionThumbGradientHighlightColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionThumbHighlightGradientBaseColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionThumbHighlightGradientBaseColor])
++ (*od->notify[WallDisplayOptionThumbHighlightGradientBaseColor]) (d, o, WallDisplayOptionThumbHighlightGradientBaseColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionThumbHighlightGradientShadowColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionThumbHighlightGradientShadowColor])
++ (*od->notify[WallDisplayOptionThumbHighlightGradientShadowColor]) (d, o, WallDisplayOptionThumbHighlightGradientShadowColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionArrowBaseColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionArrowBaseColor])
++ (*od->notify[WallDisplayOptionArrowBaseColor]) (d, o, WallDisplayOptionArrowBaseColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionArrowShadowColor:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionArrowShadowColor])
++ (*od->notify[WallDisplayOptionArrowShadowColor]) (d, o, WallDisplayOptionArrowShadowColor);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionAllowWraparound:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionAllowWraparound])
++ (*od->notify[WallDisplayOptionAllowWraparound]) (d, o, WallDisplayOptionAllowWraparound);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionSlideDuration:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionSlideDuration])
++ (*od->notify[WallDisplayOptionSlideDuration]) (d, o, WallDisplayOptionSlideDuration);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionNoSlideMatch:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionNoSlideMatch])
++ (*od->notify[WallDisplayOptionNoSlideMatch]) (d, o, WallDisplayOptionNoSlideMatch);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionLeftKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionLeftKey])
++ (*od->notify[WallDisplayOptionLeftKey]) (d, o, WallDisplayOptionLeftKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionLeftButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionLeftButton])
++ (*od->notify[WallDisplayOptionLeftButton]) (d, o, WallDisplayOptionLeftButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionRightKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionRightKey])
++ (*od->notify[WallDisplayOptionRightKey]) (d, o, WallDisplayOptionRightKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionRightButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionRightButton])
++ (*od->notify[WallDisplayOptionRightButton]) (d, o, WallDisplayOptionRightButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionUpKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionUpKey])
++ (*od->notify[WallDisplayOptionUpKey]) (d, o, WallDisplayOptionUpKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionUpButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionUpButton])
++ (*od->notify[WallDisplayOptionUpButton]) (d, o, WallDisplayOptionUpButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionDownKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionDownKey])
++ (*od->notify[WallDisplayOptionDownKey]) (d, o, WallDisplayOptionDownKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionDownButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionDownButton])
++ (*od->notify[WallDisplayOptionDownButton]) (d, o, WallDisplayOptionDownButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionNextKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionNextKey])
++ (*od->notify[WallDisplayOptionNextKey]) (d, o, WallDisplayOptionNextKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionNextButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionNextButton])
++ (*od->notify[WallDisplayOptionNextButton]) (d, o, WallDisplayOptionNextButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionPrevKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionPrevKey])
++ (*od->notify[WallDisplayOptionPrevKey]) (d, o, WallDisplayOptionPrevKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionPrevButton:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionPrevButton])
++ (*od->notify[WallDisplayOptionPrevButton]) (d, o, WallDisplayOptionPrevButton);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionLeftWindowKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionLeftWindowKey])
++ (*od->notify[WallDisplayOptionLeftWindowKey]) (d, o, WallDisplayOptionLeftWindowKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionRightWindowKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionRightWindowKey])
++ (*od->notify[WallDisplayOptionRightWindowKey]) (d, o, WallDisplayOptionRightWindowKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionUpWindowKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionUpWindowKey])
++ (*od->notify[WallDisplayOptionUpWindowKey]) (d, o, WallDisplayOptionUpWindowKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionDownWindowKey:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionDownWindowKey])
++ (*od->notify[WallDisplayOptionDownWindowKey]) (d, o, WallDisplayOptionDownWindowKey);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionFlipLeftEdge:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionFlipLeftEdge])
++ (*od->notify[WallDisplayOptionFlipLeftEdge]) (d, o, WallDisplayOptionFlipLeftEdge);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionFlipRightEdge:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionFlipRightEdge])
++ (*od->notify[WallDisplayOptionFlipRightEdge]) (d, o, WallDisplayOptionFlipRightEdge);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionFlipUpEdge:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionFlipUpEdge])
++ (*od->notify[WallDisplayOptionFlipUpEdge]) (d, o, WallDisplayOptionFlipUpEdge);
++ return TRUE;
++ }
++ break;
++ case WallDisplayOptionFlipDownEdge:
++ if (compSetDisplayOption (d, o, value))
++ {
++ if (od->notify[WallDisplayOptionFlipDownEdge])
++ (*od->notify[WallDisplayOptionFlipDownEdge]) (d, o, WallDisplayOptionFlipDownEdge);
++ return TRUE;
++ }
++ break;
++ default:
++ break;
++ }
++ return FALSE;
++}
++
++static CompOption * wallOptionsGetDisplayOptions (CompPlugin *plugin, CompDisplay *d, int *count)
++{
++ WALL_OPTIONS_DISPLAY(d);
++ *count = WallDisplayOptionNum;
++ return od->opt;
++}
++
++static const CompMetadataOptionInfo wallOptionsScreenOptionInfo[] = {
++ { "mmmode", "int", "01", 0, 0 },
++ { "edgeflip_pointer", "bool", 0, 0, 0 },
++ { "edgeflip_move", "bool", 0, 0, 0 },
++ { "edgeflip_dnd", "bool", 0, 0, 0 },
++};
++
++static Bool wallOptionsSetScreenOption (CompPlugin *plugin, CompScreen *s, const char *name, CompOptionValue *value)
++{
++ WALL_OPTIONS_SCREEN(s);
++ CompOption *o;
++ int index;
++
++ o = compFindOption (os->opt, WallScreenOptionNum, name, &index);
++
++ if (!o)
++ return FALSE;
++
++ switch (index)
++ {
++ case WallScreenOptionMmmode:
++ if (compSetScreenOption (s, o, value))
++ {
++ if (os->notify[WallScreenOptionMmmode])
++ (*os->notify[WallScreenOptionMmmode]) (s, o, WallScreenOptionMmmode);
++ return TRUE;
++ }
++ break;
++ case WallScreenOptionEdgeflipPointer:
++ if (compSetScreenOption (s, o, value))
++ {
++ if (os->notify[WallScreenOptionEdgeflipPointer])
++ (*os->notify[WallScreenOptionEdgeflipPointer]) (s, o, WallScreenOptionEdgeflipPointer);
++ return TRUE;
++ }
++ break;
++ case WallScreenOptionEdgeflipMove:
++ if (compSetScreenOption (s, o, value))
++ {
++ if (os->notify[WallScreenOptionEdgeflipMove])
++ (*os->notify[WallScreenOptionEdgeflipMove]) (s, o, WallScreenOptionEdgeflipMove);
++ return TRUE;
++ }
++ break;
++ case WallScreenOptionEdgeflipDnd:
++ if (compSetScreenOption (s, o, value))
++ {
++ if (os->notify[WallScreenOptionEdgeflipDnd])
++ (*os->notify[WallScreenOptionEdgeflipDnd]) (s, o, WallScreenOptionEdgeflipDnd);
++ return TRUE;
++ }
++ break;
++ default:
++ break;
++ }
++ return FALSE;
++}
++
++static CompOption * wallOptionsGetScreenOptions (CompPlugin *plugin, CompScreen *s, int *count)
++{
++ WALL_OPTIONS_SCREEN(s);
++ *count = WallScreenOptionNum;
++ return os->opt;
++}
++
++static Bool wallOptionsInitScreen (CompPlugin *p, CompScreen *s)
++{
++ WallOptionsScreen *os;
++
++ WALL_OPTIONS_DISPLAY (s->display);
++
++ os = calloc (1, sizeof(WallOptionsScreen));
++ if (!os)
++ return FALSE;
++
++ s->base.privates[od->screenPrivateIndex].ptr = os;
++
++ if (!compInitScreenOptionsFromMetadata (s, &wallOptionsMetadata, wallOptionsScreenOptionInfo, os->opt, WallScreenOptionNum))
++ {
++ free (os);
++ return FALSE;
++ }
++
++ return TRUE;
++}
++
++static void wallOptionsFiniScreen (CompPlugin *p, CompScreen *s)
++{
++ WALL_OPTIONS_SCREEN (s);
++
++
++ compFiniScreenOptions (s, os->opt, WallScreenOptionNum);
++
++ free (os);
++}
++
++static Bool wallOptionsInitDisplay (CompPlugin *p, CompDisplay *d)
++{
++ WallOptionsDisplay *od;
++
++
++ od = calloc (1, sizeof(WallOptionsDisplay));
++ if (!od)
++ return FALSE;
++
++ od->screenPrivateIndex = allocateScreenPrivateIndex(d);
++ if (od->screenPrivateIndex < 0)
++ {
++ free(od);
++ return FALSE;
++ }
++
++ d->base.privates[WallOptionsDisplayPrivateIndex].ptr = od;
++
++ if (!compInitDisplayOptionsFromMetadata (d, &wallOptionsMetadata, wallOptionsDisplayOptionInfo, od->opt, WallDisplayOptionNum))
++ {
++ free (od);
++ return FALSE;
++ }
++
++ return TRUE;
++}
++
++static void wallOptionsFiniDisplay (CompPlugin *p, CompDisplay *d)
++{
++ WALL_OPTIONS_DISPLAY (d);
++
++ freeScreenPrivateIndex(d, od->screenPrivateIndex);
++
++ compFiniDisplayOptions (d, od->opt, WallDisplayOptionNum);
++
++ free (od);
++}
++
++static Bool wallOptionsInit (CompPlugin *p)
++{
++ WallOptionsDisplayPrivateIndex = allocateDisplayPrivateIndex();
++ if (WallOptionsDisplayPrivateIndex < 0)
++ return FALSE;
++
++ if (!compInitPluginMetadataFromInfo (&wallOptionsMetadata, "wall",wallOptionsDisplayOptionInfo, WallDisplayOptionNum, wallOptionsScreenOptionInfo, WallScreenOptionNum))
++ return FALSE;
++
++ compAddMetadataFromFile (&wallOptionsMetadata, "wall");
++ if (wallPluginVTable && wallPluginVTable->init)
++ return wallPluginVTable->init (p);
++ return TRUE;
++}
++
++static void wallOptionsFini (CompPlugin *p)
++{
++ if (wallPluginVTable && wallPluginVTable->fini)
++ wallPluginVTable->fini (p);
++
++ if (WallOptionsDisplayPrivateIndex >= 0)
++ freeDisplayPrivateIndex (WallOptionsDisplayPrivateIndex);
++
++ compFiniMetadata (&wallOptionsMetadata);
++}
++
++static CompBool wallOptionsInitObject (CompPlugin *p, CompObject *o)
++{
++ static InitPluginObjectProc dispTab[] = {
++ (InitPluginObjectProc) 0,
++ (InitPluginObjectProc) wallOptionsInitDisplay,
++ (InitPluginObjectProc) wallOptionsInitScreen
++ };
++
++ RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), TRUE, (p, o));
++}
++
++static void wallOptionsFiniObject (CompPlugin *p, CompObject *o)
++{
++ static FiniPluginObjectProc dispTab[] = {
++ (FiniPluginObjectProc) 0,
++ (FiniPluginObjectProc) wallOptionsFiniDisplay,
++ (FiniPluginObjectProc) wallOptionsFiniScreen
++ };
++
++ DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), (p, o));
++}
++
++static CompBool wallOptionsInitObjectWrapper (CompPlugin *p, CompObject *o)
++{
++ CompBool rv = TRUE;
++ rv = wallOptionsInitObject (p, o);
++ if (wallPluginVTable->initObject)
++ rv &= wallPluginVTable->initObject (p, o);
++ return rv;
++}
++
++static void wallOptionsFiniObjectWrapper (CompPlugin *p, CompObject *o)
++{
++ if (wallPluginVTable->finiObject)
++ wallPluginVTable->finiObject (p, o);
++ wallOptionsFiniObject (p, o);
++}
++
++static CompOption * wallOptionsGetObjectOptions (CompPlugin *p, CompObject *o, int *count)
++{
++ static GetPluginObjectOptionsProc dispTab[] = {
++ (GetPluginObjectOptionsProc) 0,
++ (GetPluginObjectOptionsProc) wallOptionsGetDisplayOptions,
++ (GetPluginObjectOptionsProc) wallOptionsGetScreenOptions
++ };
++
++ *count = 0;
++ RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab),
++ NULL, (p, o, count));
++}
++
++static CompBool wallOptionsSetObjectOption (CompPlugin *p, CompObject *o, const char *name, CompOptionValue *value)
++{
++ static SetPluginObjectOptionProc dispTab[] = {
++ (SetPluginObjectOptionProc) 0,
++ (SetPluginObjectOptionProc) wallOptionsSetDisplayOption,
++ (SetPluginObjectOptionProc) wallOptionsSetScreenOption
++ };
++
++ RETURN_DISPATCH (o, dispTab, ARRAY_SIZE (dispTab), FALSE,
++ (p, o, name, value));
++}
++
++static CompMetadata *
++wallOptionsGetMetadata (CompPlugin *plugin)
++{
++ return &wallOptionsMetadata;
++}
++
++CompPluginVTable *getCompPluginInfo20070830 (void)
++{
++ if (!wallPluginVTable)
++ {
++ wallPluginVTable = getCompPluginInfo ();
++ memcpy(&wallOptionsVTable, wallPluginVTable, sizeof(CompPluginVTable));
++ wallOptionsVTable.getMetadata = wallOptionsGetMetadata;
++ wallOptionsVTable.init = wallOptionsInit;
++ wallOptionsVTable.fini = wallOptionsFini;
++ wallOptionsVTable.initObject = wallOptionsInitObjectWrapper;
++ wallOptionsVTable.finiObject = wallOptionsFiniObjectWrapper;
++ wallOptionsVTable.getObjectOptions = wallOptionsGetObjectOptions;
++ wallOptionsVTable.setObjectOption = wallOptionsSetObjectOption;
++
++ }
++ return &wallOptionsVTable;
++}
++
+diff -upNr compiz-0.8.2.orign/src/wall_options.h compiz-0.8.2/src/wall_options.h
+--- compiz-0.8.2.orign/src/wall_options.h 1970-01-01 01:00:00.000000000 +0100
++++ compiz-0.8.2/src/wall_options.h 2009-07-10 23:02:18.076511000 +0200
+@@ -0,0 +1,375 @@
++/*
++ * This file is autogenerated with bcop:
++ * The Compiz option code generator
++ *
++ * This program is distributed in the hope that it will be useful,
++ * but WITHOUT ANY WARRANTY; without even the implied warranty of
++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
++ * GNU General Public License for more details.
++ *
++ */
++
++#ifndef _WALL_OPTIONS_H
++#define _WALL_OPTIONS_H
++
++#include
++
++COMPIZ_BEGIN_DECLS
++
++CompPluginVTable * getCompPluginInfo (void);
++
++typedef enum
++{
++ WallDisplayOptionShowSwitcher,
++ WallDisplayOptionMiniscreen,
++ WallDisplayOptionPreviewTimeout,
++ WallDisplayOptionPreviewScale,
++ WallDisplayOptionEdgeRadius,
++ WallDisplayOptionBorderWidth,
++ WallDisplayOptionOutlineColor,
++ WallDisplayOptionBackgroundGradientBaseColor,
++ WallDisplayOptionBackgroundGradientHighlightColor,
++ WallDisplayOptionBackgroundGradientShadowColor,
++ WallDisplayOptionThumbGradientBaseColor,
++ WallDisplayOptionThumbGradientHighlightColor,
++ WallDisplayOptionThumbHighlightGradientBaseColor,
++ WallDisplayOptionThumbHighlightGradientShadowColor,
++ WallDisplayOptionArrowBaseColor,
++ WallDisplayOptionArrowShadowColor,
++ WallDisplayOptionAllowWraparound,
++ WallDisplayOptionSlideDuration,
++ WallDisplayOptionNoSlideMatch,
++ WallDisplayOptionLeftKey,
++ WallDisplayOptionLeftButton,
++ WallDisplayOptionRightKey,
++ WallDisplayOptionRightButton,
++ WallDisplayOptionUpKey,
++ WallDisplayOptionUpButton,
++ WallDisplayOptionDownKey,
++ WallDisplayOptionDownButton,
++ WallDisplayOptionNextKey,
++ WallDisplayOptionNextButton,
++ WallDisplayOptionPrevKey,
++ WallDisplayOptionPrevButton,
++ WallDisplayOptionLeftWindowKey,
++ WallDisplayOptionRightWindowKey,
++ WallDisplayOptionUpWindowKey,
++ WallDisplayOptionDownWindowKey,
++ WallDisplayOptionFlipLeftEdge,
++ WallDisplayOptionFlipRightEdge,
++ WallDisplayOptionFlipUpEdge,
++ WallDisplayOptionFlipDownEdge,
++ WallDisplayOptionNum
++} WallDisplayOptions;
++
++typedef void (*wallDisplayOptionChangeNotifyProc) (CompDisplay *display, CompOption *opt, WallDisplayOptions num);
++
++CompOption *wallGetDisplayOption (CompDisplay *d, WallDisplayOptions num);
++
++typedef enum
++{
++ WallScreenOptionMmmode,
++ WallScreenOptionEdgeflipPointer,
++ WallScreenOptionEdgeflipMove,
++ WallScreenOptionEdgeflipDnd,
++ WallScreenOptionNum
++} WallScreenOptions;
++
++typedef void (*wallScreenOptionChangeNotifyProc) (CompScreen *screen, CompOption *opt, WallScreenOptions num);
++
++CompOption *wallGetScreenOption (CompScreen *s, WallScreenOptions num);
++
++typedef enum
++{
++ MmmodeSwitchAll = 0,
++ MmmodeSwitchSeparately = 1,
++} WallMmmodeEnum;
++
++Bool wallGetShowSwitcher (CompDisplay *d);
++CompOption * wallGetShowSwitcherOption (CompDisplay *d);
++void wallSetShowSwitcherNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++Bool wallGetMiniscreen (CompDisplay *d);
++CompOption * wallGetMiniscreenOption (CompDisplay *d);
++void wallSetMiniscreenNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++float wallGetPreviewTimeout (CompDisplay *d);
++CompOption * wallGetPreviewTimeoutOption (CompDisplay *d);
++void wallSetPreviewTimeoutNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++int wallGetPreviewScale (CompDisplay *d);
++CompOption * wallGetPreviewScaleOption (CompDisplay *d);
++void wallSetPreviewScaleNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++int wallGetEdgeRadius (CompDisplay *d);
++CompOption * wallGetEdgeRadiusOption (CompDisplay *d);
++void wallSetEdgeRadiusNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++int wallGetBorderWidth (CompDisplay *d);
++CompOption * wallGetBorderWidthOption (CompDisplay *d);
++void wallSetBorderWidthNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetOutlineColor (CompDisplay *d);
++unsigned short wallGetOutlineColorRed (CompDisplay *d);
++unsigned short wallGetOutlineColorGreen (CompDisplay *d);
++unsigned short wallGetOutlineColorBlue (CompDisplay *d);
++unsigned short wallGetOutlineColorAlpha (CompDisplay *d);
++CompOption * wallGetOutlineColorOption (CompDisplay *d);
++void wallSetOutlineColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetBackgroundGradientBaseColor (CompDisplay *d);
++unsigned short wallGetBackgroundGradientBaseColorRed (CompDisplay *d);
++unsigned short wallGetBackgroundGradientBaseColorGreen (CompDisplay *d);
++unsigned short wallGetBackgroundGradientBaseColorBlue (CompDisplay *d);
++unsigned short wallGetBackgroundGradientBaseColorAlpha (CompDisplay *d);
++CompOption * wallGetBackgroundGradientBaseColorOption (CompDisplay *d);
++void wallSetBackgroundGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetBackgroundGradientHighlightColor (CompDisplay *d);
++unsigned short wallGetBackgroundGradientHighlightColorRed (CompDisplay *d);
++unsigned short wallGetBackgroundGradientHighlightColorGreen (CompDisplay *d);
++unsigned short wallGetBackgroundGradientHighlightColorBlue (CompDisplay *d);
++unsigned short wallGetBackgroundGradientHighlightColorAlpha (CompDisplay *d);
++CompOption * wallGetBackgroundGradientHighlightColorOption (CompDisplay *d);
++void wallSetBackgroundGradientHighlightColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetBackgroundGradientShadowColor (CompDisplay *d);
++unsigned short wallGetBackgroundGradientShadowColorRed (CompDisplay *d);
++unsigned short wallGetBackgroundGradientShadowColorGreen (CompDisplay *d);
++unsigned short wallGetBackgroundGradientShadowColorBlue (CompDisplay *d);
++unsigned short wallGetBackgroundGradientShadowColorAlpha (CompDisplay *d);
++CompOption * wallGetBackgroundGradientShadowColorOption (CompDisplay *d);
++void wallSetBackgroundGradientShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetThumbGradientBaseColor (CompDisplay *d);
++unsigned short wallGetThumbGradientBaseColorRed (CompDisplay *d);
++unsigned short wallGetThumbGradientBaseColorGreen (CompDisplay *d);
++unsigned short wallGetThumbGradientBaseColorBlue (CompDisplay *d);
++unsigned short wallGetThumbGradientBaseColorAlpha (CompDisplay *d);
++CompOption * wallGetThumbGradientBaseColorOption (CompDisplay *d);
++void wallSetThumbGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetThumbGradientHighlightColor (CompDisplay *d);
++unsigned short wallGetThumbGradientHighlightColorRed (CompDisplay *d);
++unsigned short wallGetThumbGradientHighlightColorGreen (CompDisplay *d);
++unsigned short wallGetThumbGradientHighlightColorBlue (CompDisplay *d);
++unsigned short wallGetThumbGradientHighlightColorAlpha (CompDisplay *d);
++CompOption * wallGetThumbGradientHighlightColorOption (CompDisplay *d);
++void wallSetThumbGradientHighlightColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetThumbHighlightGradientBaseColor (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientBaseColorRed (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientBaseColorGreen (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientBaseColorBlue (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientBaseColorAlpha (CompDisplay *d);
++CompOption * wallGetThumbHighlightGradientBaseColorOption (CompDisplay *d);
++void wallSetThumbHighlightGradientBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetThumbHighlightGradientShadowColor (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientShadowColorRed (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientShadowColorGreen (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientShadowColorBlue (CompDisplay *d);
++unsigned short wallGetThumbHighlightGradientShadowColorAlpha (CompDisplay *d);
++CompOption * wallGetThumbHighlightGradientShadowColorOption (CompDisplay *d);
++void wallSetThumbHighlightGradientShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetArrowBaseColor (CompDisplay *d);
++unsigned short wallGetArrowBaseColorRed (CompDisplay *d);
++unsigned short wallGetArrowBaseColorGreen (CompDisplay *d);
++unsigned short wallGetArrowBaseColorBlue (CompDisplay *d);
++unsigned short wallGetArrowBaseColorAlpha (CompDisplay *d);
++CompOption * wallGetArrowBaseColorOption (CompDisplay *d);
++void wallSetArrowBaseColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++unsigned short * wallGetArrowShadowColor (CompDisplay *d);
++unsigned short wallGetArrowShadowColorRed (CompDisplay *d);
++unsigned short wallGetArrowShadowColorGreen (CompDisplay *d);
++unsigned short wallGetArrowShadowColorBlue (CompDisplay *d);
++unsigned short wallGetArrowShadowColorAlpha (CompDisplay *d);
++CompOption * wallGetArrowShadowColorOption (CompDisplay *d);
++void wallSetArrowShadowColorNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++Bool wallGetAllowWraparound (CompDisplay *d);
++CompOption * wallGetAllowWraparoundOption (CompDisplay *d);
++void wallSetAllowWraparoundNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++float wallGetSlideDuration (CompDisplay *d);
++CompOption * wallGetSlideDurationOption (CompDisplay *d);
++void wallSetSlideDurationNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompMatch * wallGetNoSlideMatch (CompDisplay *d);
++CompOption * wallGetNoSlideMatchOption (CompDisplay *d);
++void wallSetNoSlideMatchNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetLeftKey (CompDisplay *d);
++void wallSetLeftKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetLeftKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetLeftKeyOption (CompDisplay *d);
++void wallSetLeftKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetLeftButton (CompDisplay *d);
++void wallSetLeftButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetLeftButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetLeftButtonOption (CompDisplay *d);
++void wallSetLeftButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetRightKey (CompDisplay *d);
++void wallSetRightKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetRightKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetRightKeyOption (CompDisplay *d);
++void wallSetRightKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetRightButton (CompDisplay *d);
++void wallSetRightButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetRightButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetRightButtonOption (CompDisplay *d);
++void wallSetRightButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetUpKey (CompDisplay *d);
++void wallSetUpKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetUpKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetUpKeyOption (CompDisplay *d);
++void wallSetUpKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetUpButton (CompDisplay *d);
++void wallSetUpButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetUpButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetUpButtonOption (CompDisplay *d);
++void wallSetUpButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetDownKey (CompDisplay *d);
++void wallSetDownKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetDownKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetDownKeyOption (CompDisplay *d);
++void wallSetDownKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetDownButton (CompDisplay *d);
++void wallSetDownButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetDownButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetDownButtonOption (CompDisplay *d);
++void wallSetDownButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetNextKey (CompDisplay *d);
++void wallSetNextKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetNextKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetNextKeyOption (CompDisplay *d);
++void wallSetNextKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetNextButton (CompDisplay *d);
++void wallSetNextButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetNextButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetNextButtonOption (CompDisplay *d);
++void wallSetNextButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetPrevKey (CompDisplay *d);
++void wallSetPrevKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetPrevKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetPrevKeyOption (CompDisplay *d);
++void wallSetPrevKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetPrevButton (CompDisplay *d);
++void wallSetPrevButtonInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetPrevButtonTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetPrevButtonOption (CompDisplay *d);
++void wallSetPrevButtonNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetLeftWindowKey (CompDisplay *d);
++void wallSetLeftWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetLeftWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetLeftWindowKeyOption (CompDisplay *d);
++void wallSetLeftWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetRightWindowKey (CompDisplay *d);
++void wallSetRightWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetRightWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetRightWindowKeyOption (CompDisplay *d);
++void wallSetRightWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetUpWindowKey (CompDisplay *d);
++void wallSetUpWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetUpWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetUpWindowKeyOption (CompDisplay *d);
++void wallSetUpWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetDownWindowKey (CompDisplay *d);
++void wallSetDownWindowKeyInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetDownWindowKeyTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetDownWindowKeyOption (CompDisplay *d);
++void wallSetDownWindowKeyNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetFlipLeftEdge (CompDisplay *d);
++void wallSetFlipLeftEdgeInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetFlipLeftEdgeTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetFlipLeftEdgeOption (CompDisplay *d);
++void wallSetFlipLeftEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetFlipRightEdge (CompDisplay *d);
++void wallSetFlipRightEdgeInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetFlipRightEdgeTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetFlipRightEdgeOption (CompDisplay *d);
++void wallSetFlipRightEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetFlipUpEdge (CompDisplay *d);
++void wallSetFlipUpEdgeInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetFlipUpEdgeTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetFlipUpEdgeOption (CompDisplay *d);
++void wallSetFlipUpEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++CompAction * wallGetFlipDownEdge (CompDisplay *d);
++void wallSetFlipDownEdgeInitiate (CompDisplay *d, CompActionCallBackProc init);
++void wallSetFlipDownEdgeTerminate (CompDisplay *d, CompActionCallBackProc term);
++CompOption * wallGetFlipDownEdgeOption (CompDisplay *d);
++void wallSetFlipDownEdgeNotify (CompDisplay *d, wallDisplayOptionChangeNotifyProc notify);
++
++int wallGetMmmode (CompScreen *s);
++CompOption * wallGetMmmodeOption (CompScreen *s);
++void wallSetMmmodeNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify);
++
++Bool wallGetEdgeflipPointer (CompScreen *s);
++CompOption * wallGetEdgeflipPointerOption (CompScreen *s);
++void wallSetEdgeflipPointerNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify);
++
++Bool wallGetEdgeflipMove (CompScreen *s);
++CompOption * wallGetEdgeflipMoveOption (CompScreen *s);
++void wallSetEdgeflipMoveNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify);
++
++Bool wallGetEdgeflipDnd (CompScreen *s);
++CompOption * wallGetEdgeflipDndOption (CompScreen *s);
++void wallSetEdgeflipDndNotify (CompScreen *s, wallScreenOptionChangeNotifyProc notify);
++
++#ifndef GENERIC_PRIVATE_DEFINES
++#define GENERIC_PRIVATE_DEFINES
++
++#define GET_PLUGIN_CORE(object, plugin) \
++ ((plugin##Core *) (object)->base.privates[plugin##CorePrivateIndex].ptr)
++#define PLUGIN_CORE(object, plugin, prefix) \
++ plugin##Core * prefix##c = GET_PLUGIN_CORE (object, plugin)
++
++#define GET_PLUGIN_DISPLAY(object, plugin) \
++ ((plugin##Display *) \
++ (object)->base.privates[plugin##DisplayPrivateIndex].ptr)
++#define PLUGIN_DISPLAY(object, plugin, prefix) \
++ plugin##Display * prefix##d = GET_PLUGIN_DISPLAY (object, plugin)
++
++#define GET_PLUGIN_SCREEN(object, parent, plugin) \
++ ((plugin##Screen *) \
++ (object)->base.privates[(parent)->screenPrivateIndex].ptr)
++#define PLUGIN_SCREEN(object, plugin, prefix) \
++ plugin##Screen * prefix##s = \
++ GET_PLUGIN_SCREEN (object, \
++ GET_PLUGIN_DISPLAY ((object)->display, plugin), plugin)
++
++#define GET_PLUGIN_WINDOW(object, parent, plugin) \
++ ((plugin##Window *) \
++ (object)->base.privates[(parent)->windowPrivateIndex].ptr)
++#define PLUGIN_WINDOW(object, plugin, prefix) \
++ plugin##Window * prefix##w = \
++ GET_PLUGIN_WINDOW (object, \
++ GET_PLUGIN_SCREEN ((object)->screen, \
++ GET_PLUGIN_DISPLAY ((object)->screen->display, plugin), plugin), plugin)
++
++#endif
++
++COMPIZ_END_DECLS
++
++#endif
diff --git a/compiz.spec b/compiz.spec
index 928ea14..87d9eeb 100644
--- a/compiz.spec
+++ b/compiz.spec
@@ -1,7 +1,7 @@
%define dialogversion 0.7.18
%define kde_dialogversion 0.0.5
-%define core_plugins blur clone cube dbus decoration fade ini inotify minimize move place png regex resize rotate scale screenshot switcher video water wobbly zoom fs obs commands
+%define core_plugins blur clone cube dbus decoration fade ini inotify minimize move place png regex resize rotate scale screenshot switcher video water wobbly zoom fs obs commands wall
%define gnome_plugins annotate gconf glib svg gnomecompat