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