Merge lp:~compiz-team/compiz-expo-plugin/oneiric.actual_polish into lp:~compiz-team/compiz-expo-plugin/oneiric

[Sam Spilsbury]

Center the spread as per design

Bug 837545

[Robert Carr (robertcarr)]

+1. Looks like there might be something wrong with...merging the group plugin though ?!?!

review: Approve

[Jason Smith (jassmith)]

Looks fine, dupes some code but we dont care since we dont use the group plugin.

review: Approve

=== modified file 'expo.xml.in'
--- expo.xml.in	2011-09-01 14:33:30 +0000
+++ expo.xml.in	2011-09-15 12:36:24 +0000
@@ -17,6 +17,7 @@
 		<plugin>wobbly</plugin>
 		<plugin>animation</plugin>
 		<plugin>wallpaper</plugin>
+		<plugin>imgpng</plugin>
 	    </relation>
 	</deps>
 	<options>
@@ -133,7 +134,7 @@
 		    <_long> Left Side screen space of expo in pixels</_long>
 		    <min>-1680</min>
 		    <max>1680</max>
-		    <default>36</default>
+		    <default>64</default>
                 </option>
 		<option name="y_offset" type="int">
 		    <_short>Y Space</_short>
@@ -145,7 +146,7 @@
 		<option name="distance" type="float">
 		    <_short>Distance</_short>
 		    <_long>Distance of the expo wall</_long>
-		    <default>0.0</default>
+		    <default>0.005</default>
 		    <min>0.0</min>
 		    <max>1.0</max>
 		    <precision>0.01</precision>
@@ -204,7 +205,7 @@
 		    <option name="vp_brightness" type="float">
 			<_short>Brightness</_short>
 			<_long>Inactive viewport brightness.</_long>
-			<default>80.0</default>
+			<default>40.0</default>
 			<min>0.0</min>
 			<max>100.0</max>
 			<precision>0.1</precision>
@@ -212,11 +213,21 @@
 		    <option name="vp_saturation" type="float">
 			<_short>Saturation</_short>
 			<_long>Inactive viewport saturation.</_long>
-			<default>100.0</default>
+			<default>40.0</default>
 			<min>0.0</min>
 			<max>100.0</max>
 			<precision>0.1</precision>
 		    </option>
+		    <option name="selected_color" type="color">
+			<_short>Selected Color</_short>
+			<_long>Color to use when highlighting the selected viewport</_long>
+			<default>
+			    <red>0xfbfb</red>
+			    <green>0x8b8b</green>
+			    <blue>0x0</blue>
+			    <alpha>0xffff</alpha>
+			</default>
+		    </option>
 		</subgroup>
 		<subgroup>
 		    <short>Reflection</short>
 
=== added directory 'images'
=== added file 'images/glow_outline.png'
 Binary files images/glow_outline.png	1970-01-01 00:00:00 +0000 and images/glow_outline.png	2011-09-15 12:36:24 +0000 differ
=== added file 'images/texture_tile.png'
 Binary files images/texture_tile.png	1970-01-01 00:00:00 +0000 and images/texture_tile.png	2011-09-15 12:36:24 +0000 differ
=== modified file 'src/expo.cpp'
--- src/expo.cpp	2011-09-01 14:33:30 +0000
+++ src/expo.cpp	2011-09-15 12:36:24 +0000
@@ -26,6 +26,7 @@
 #include "expo.h"
 #include <math.h>
 #include <GL/glu.h>
+#include <X11/cursorfont.h>
 
 COMPIZ_PLUGIN_20090315 (expo, ExpoPluginVTable);
 
@@ -67,11 +68,10 @@
 
     if (dndState == DnDDuring || dndState == DnDStart)
     {
-	if (dndWindow)
+	if (dndWindows.size ())
 	    finishWindowMovement ();
 
 	dndState  = DnDNone;
-	dndWindow = NULL;
 
 	action->setState (action->state () & CompAction::StateInitButton);
 	cScreen->damageScreen ();
@@ -107,7 +107,6 @@
 	clickTime   = 0;
 
 	dndState  = DnDNone;
-	dndWindow = NULL;
 
 	selectedVp = screen->vp ();
 	origVp     = screen->vp ();
@@ -150,7 +149,6 @@
 	vpUpdateMode = VPUpdateMouseOver;
 
     dndState  = DnDNone;
-    dndWindow = NULL;
 
     screen->removeAction (&optionGetDndButton ());
     screen->removeAction (&optionGetExitButton ());
@@ -263,53 +261,39 @@
 void
 ExpoScreen::finishWindowMovement ()
 {
-    dndWindow->syncPosition ();
-    dndWindow->ungrabNotify ();
-
-    screen->moveViewport (screen->vp ().x () - selectedVp.x (),
-			  screen->vp ().y () - selectedVp.y (), true);
-
-    /* update saved window attributes in case we moved the
-       window to a new viewport */
-    if (dndWindow->saveMask () & CWX)
-    {
-	dndWindow->saveWc ().x = dndWindow->saveWc ().x % screen->width ();
-	if (dndWindow->saveWc ().x < 0)
-	    dndWindow->saveWc ().x += screen->width ();
-    }
-    if (dndWindow->saveMask () & CWY)
-    {
-	dndWindow->saveWc ().y = dndWindow->saveWc ().y % screen->height ();
-	if (dndWindow->saveWc ().y < 0)
-	    dndWindow->saveWc ().y += screen->height ();
-    }
-
-    /* update window attibutes to make sure a moved maximized window
-       is properly snapped to the work area */
-    if (dndWindow->state () & MAXIMIZE_STATE)
-	dndWindow->updateAttributes (CompStackingUpdateModeNone);
-
-#if 0 /* FIXME: obsolete in the meantime? */
-    {
-	int lastOutput;
-	int centerX, centerY;
-
-	/* make sure we snap to the correct output */
-	lastOutput = s->currentOutputDev;
-	centerX = (WIN_X (w) + WIN_W (w) / 2) % s->width;
-	if (centerX < 0)
-	    centerX += s->width;
-	centerY = (WIN_Y (w) + WIN_H (w) / 2) % s->height;
-	if (centerY < 0)
-	    centerY += s->height;
-
-	s->currentOutputDev = outputDeviceForPoint (s, centerX, centerY);
-
-	updateWindowAttributes (w, CompStackingUpdateModeNone);
-
-	s->currentOutputDev = lastOutput;
-    }
-#endif
+    foreach (CompWindow *dndWindow, dndWindows)
+    {
+	if (dndWindow->grabbed ())
+	{
+	    dndWindow->syncPosition ();
+	    dndWindow->ungrabNotify ();
+
+	    screen->updateGrab (grabIndex, None);
+
+	    screen->moveViewport (screen->vp ().x () - selectedVp.x (),
+				  screen->vp ().y () - selectedVp.y (), true);
+
+	    /* update saved window attributes in case we moved the
+    window to a new viewport */
+	    if (dndWindow->saveMask () & CWX)
+	    {
+		dndWindow->saveWc ().x = dndWindow->saveWc ().x % screen->width ();
+		if (dndWindow->saveWc ().x < 0)
+		    dndWindow->saveWc ().x += screen->width ();
+	    }
+	    if (dndWindow->saveMask () & CWY)
+	    {
+		dndWindow->saveWc ().y = dndWindow->saveWc ().y % screen->height ();
+		if (dndWindow->saveWc ().y < 0)
+		    dndWindow->saveWc ().y += screen->height ();
+	    }
+
+	    /* update window attibutes to make sure a moved maximized window
+	   is properly snapped to the work area */
+	    if (dndWindow->state () & MAXIMIZE_STATE)
+		dndWindow->updateAttributes (CompStackingUpdateModeNone);
+	}
+    }
 }
 
 void
@@ -380,6 +364,26 @@
     screen->handleEvent (event);
 }
 
+bool
+ExpoScreen::windowsOnVp (CompPoint &p)
+{
+    foreach (CompWindow *w, screen->clientList (true))
+    {
+	CompPoint viewport;
+
+	screen->viewportForGeometry (w->geometry (), viewport);
+
+	if (viewport == p&&
+	    w->type () != CompWindowTypeDesktopMask &&
+	    w->type () != CompWindowTypeDockMask)
+	{
+	    return true;
+	}
+    }
+
+    return false;
+}
+
 void
 ExpoScreen::preparePaint (int msSinceLastPaint)
 {
@@ -390,6 +394,29 @@
     else
 	expoCam = MAX (0.0, expoCam - val);
 
+    if (dndState == DnDDuring)
+    {
+	foreach (CompWindow *w, dndWindows)
+	    ExpoWindow::get (w)->dndOpacity = MIN (1.0, ExpoWindow::get (w)->dndOpacity + val);
+    }
+    else if (dndState == DnDNone)
+    {
+	CompWindowList::iterator it = dndWindows.begin ();
+
+	while (it != dndWindows.end ())
+	{
+	    ExpoWindow::get ((*it))->dndOpacity = MAX (0.0, ExpoWindow::get ((*it))->dndOpacity - val);
+
+	    if (ExpoWindow::get ((*it))->dndOpacity <= 0.0f)
+	    {
+		dndWindows.erase (it);
+		it = dndWindows.begin ();
+	    }
+	    else
+		it++;
+	}
+    }
+
     if (expoCam)
     {
 	unsigned int i, j, vp;
@@ -408,8 +435,9 @@
 	    for (j = 0; j < (unsigned int) screen->vpSize ().height (); j++)
 	    {
 		vp = (j * screen->vpSize ().width ()) + i;
+		CompPoint vpPos = CompPoint (i, j);
 
-		if (CompPoint (i, j) == selectedVp)
+		if (windowsOnVp (vpPos))
 		    vpActivity[vp] = MIN (1.0, vpActivity[vp] + val);
 		else
 		    vpActivity[vp] = MAX (0.0, vpActivity[vp] - val);
@@ -437,6 +465,7 @@
     screen->handleEventSetEnabled (this, enable);
     cScreen->preparePaintSetEnabled (this, enable);
     cScreen->paintSetEnabled (this, enable);
+    cScreen->getWindowPaintListSetEnabled (this, false);
     cScreen->donePaintSetEnabled (this, enable);
     gScreen->glPaintOutputSetEnabled (this, enable);
     gScreen->glPaintTransformedOutputSetEnabled (this, enable);
@@ -516,6 +545,11 @@
 	foreach (float& vp, vpActivity)
 	    if (vp != 0.0 && vp != 1.0)
 		cScreen->damageScreen ();
+
+	foreach (CompWindow *w, dndWindows)
+	    if (ExpoWindow::get (w)->dndOpacity != 0.0f &&
+		ExpoWindow::get (w)->dndOpacity != 1.0f)
+		cScreen->damageScreen ();
     }
 
     if (grabIndex && expoCam <= 0.0f && !expoMode)
@@ -530,10 +564,18 @@
     switch (dndState) {
     case DnDDuring:
 	{
-	    if (dndWindow)
-		dndWindow->move (newCursor.x () - prevCursor.x (),
-				 newCursor.y () - prevCursor.y (),
-				 optionGetExpoImmediateMove ());
+	    if (dndWindows.size ())
+	    {
+		foreach (CompWindow *dndWindow, dndWindows)
+		{
+		    if (dndWindow->grabbed ())
+		    {
+			dndWindow->move (newCursor.x () - prevCursor.x (),
+					 newCursor.y () - prevCursor.y (),
+					 optionGetExpoImmediateMove ());
+		    }
+		}
+	    }
 
 	    prevCursor = newCursor;
 	    cScreen->damageScreen ();
@@ -598,12 +640,14 @@
 		    break;
 
 		dndState  = DnDDuring;
-		dndWindow = w;
+		dndWindows.push_back (w);
 
 		w->grabNotify (nx, ny, 0,
 			       CompWindowGrabMoveMask |
 			       CompWindowGrabButtonMask);
 
+		screen->updateGrab (grabIndex, mMoveCursor);
+
 		w->raise ();
 		w->moveInputFocusTo ();
 		break;
@@ -689,6 +733,121 @@
 }
 
 void
+ExpoScreen::paintViewport (const GLScreenPaintAttrib& attrib,
+			   const GLMatrix&            transform,
+			   const CompRegion&          region,
+			   CompOutput                 *output,
+			   unsigned int               mask,
+			   CompPoint                  vpPos,
+			   GLVector                   &vpCamPos,
+			   bool                       reflection)
+{
+    GLMatrix     sTransform (transform);
+    GLMatrix     sTransform2, sTransform3;
+    float        sx = (float) screen->width () / output->width ();
+    float        sy = (float) screen->height () / output->height ();
+    float        vpp;
+    float        progress = sigmoidProgress (expoCam);
+    unsigned int vp;
+    CompPoint    vpSize (screen->vpSize ().width (), screen->vpSize ().height ());
+
+    const float gapY = optionGetVpDistance () * 0.1f * expoCam;
+    const float gapX = optionGetVpDistance () * 0.1f * screen->height () /
+		       screen->width () * expoCam;
+
+    /* not sure this will work with different resolutions */
+    sTransform.translate (0.0, MAX (0, vpPos.y ()) * -(sy + gapY), 0.0f);
+
+    sTransform2 = sTransform;
+
+    /* not sure this will work with different resolutions */
+    if (optionGetDeform () != DeformCurve)
+	sTransform2.translate (MAX (0, vpPos.x ()) * (sx + gapX), 0.0f, 0.0);
+
+
+    if (optionGetExpoAnimation () == ExpoAnimationVortex)
+	sTransform2.rotate (360 * expoCam,
+			    0.0f, 1.0f, 2.0f * expoCam);
+
+    sTransform3 = sTransform2;
+
+    sTransform3.translate (output->x () / output->width (),
+			   -output->y () / output->height (), 0.0);
+
+    cScreen->setWindowPaintOffset ((screen->vp ().x () - vpPos.x ()) *
+				   screen->width (),
+				   (screen->vp ().y () - vpPos.y ()) *
+				   screen->height ());
+
+    vp = (vpPos.y () * vpSize.x ()) + vpPos.x ();
+
+    vpp = (expoCam * vpActivity[vp]) + (1 - expoCam);
+    vpp = sigmoidProgress (vpp);
+
+    vpBrightness = vpp + ((1.0 - vpp) *
+			  optionGetVpBrightness () / 100.0);
+    vpSaturation = vpp + ((1.0 - vpp) *
+			  optionGetVpSaturation () / 100.0);
+
+    paintingVp = vpPos;
+
+    if (optionGetDeform () == DeformCurve)
+    {
+	float rotateX;
+
+	sTransform3.translate (-vpCamPos[GLVector::x], 0.0f,
+			       curveDistance - DEFAULT_Z_CAMERA);
+
+	rotateX = -vpPos.x () + interpolate (((float) vpSize.x () / 2.0) - 0.5,
+				    screen->vp ().x (), progress);
+
+	sTransform3.rotate (curveAngle * rotateX, 0.0, 1.0, 0.0);
+
+	sTransform3.translate (vpCamPos[GLVector::x], 0.0f,
+			       DEFAULT_Z_CAMERA - curveDistance);
+    }
+
+    cScreen->getWindowPaintListSetEnabled (this, paintingDndWindow);
+
+    gScreen->glPaintTransformedOutput (attrib, sTransform3,
+				       screen->region (), output,
+				       mask);
+
+    cScreen->getWindowPaintListSetEnabled (this, !paintingDndWindow);
+
+    if (!reflection && !paintingDndWindow)
+    {
+	int cursor[2] = { pointerX, pointerY };
+
+	invertTransformedVertex (attrib, sTransform3,
+				 output, cursor);
+
+	if ((cursor[0] > 0) && (cursor[0] < (int) screen->width ()) &&
+		(cursor[1] > 0) && (cursor[1] < (int) screen->height ()))
+	{
+	    newCursor.setX (vpPos.x () * screen->width () + cursor[0]);
+	    newCursor.setY (vpPos.y () * screen->height () + cursor[1]);
+
+	    if (anyClick || dndState != DnDNone)
+	    {
+		/* Used to save last viewport interaction was in */
+		selectedVp = vpPos;
+		anyClick = false;
+	    }
+	}
+    }
+
+    /* Calculate the current viewport size */
+    int tl[2] = { 0, 0 };
+    int br[2] = { screen->width (), screen->height () };
+
+    invertTransformedVertex (attrib, sTransform3, output, tl);
+    invertTransformedVertex (attrib, sTransform3, output, br);
+
+    viewport_size = CompSize (br[0] - tl[0], br[1] - tl[1]);
+}
+
+void
 ExpoScreen::paintWall (const GLScreenPaintAttrib& attrib,
 		       const GLMatrix&            transform,
 		       const CompRegion&          region,
@@ -697,13 +856,11 @@
 		       bool                       reflection)
 {
     GLMatrix sTransformW, sTransform (transform);
-    int      i, j, vp;
     GLenum   oldFilter = gScreen->textureFilter ();
-
-    float     sx = (float) screen->width () / output->width ();
-    float     sy = (float) screen->height () / output->height ();
+    float        sx = (float) screen->width () / output->width ();
+    float        sy = (float) screen->height () / output->height ();
     float     biasZ;
-    float     oScale, rotation = 0.0f, progress, vpp;
+    float     oScale, rotation = 0.0f, progress;
     float     aspectX = 1.0f, aspectY = 1.0f;
     GLVector  cam;
     CompPoint vpSize (screen->vpSize ().width (), screen->vpSize ().height ());
@@ -833,10 +990,23 @@
     sTransform.rotate (rotation, 0.0f, 1.0f, 0.0f);
     sTransform.scale (aspectX, aspectY, 1.0);
 
-    float xoffset = ((vpSize.x () * sx) / ((float) screen->width ()) * optionGetXOffset ()) * sigmoidProgress (expoCam);
-    float yoffset = ((vpSize.y () * sy) / ((float) screen->height ()) * optionGetYOffset ()) * sigmoidProgress (expoCam);
-    float xadjs = 1.0f - ((float) optionGetXOffset () / (float) screen->width ()) * sigmoidProgress (expoCam);
-    float yadjs = 1.0f - ((float) optionGetYOffset () / (float) screen->height ()) * sigmoidProgress (expoCam);
+    float xoffset = 0.0;
+    float yoffset = 0.0;
+    float xadjs = 1.0f;
+    float yadjs = 1.0f;
+
+    if (output->left () == 0)
+    {
+        xoffset = ((vpSize.x () * sx) / ((float) output->width ()) * (optionGetXOffset ()) * sigmoidProgress (expoCam));
+	xadjs = 1.0f - ((float) (optionGetXOffset ()) / (float) (output->width ())) * sigmoidProgress (expoCam);
+    }
+
+    if (output->top () == 0)
+    {
+	yoffset = ((vpSize.y () * sy) / ((float) output->height ()) * (optionGetYOffset ()) * sigmoidProgress (expoCam));
+
+	yadjs = 1.0f - ((float) (optionGetYOffset ()) / (float) output->height ()) * sigmoidProgress (expoCam);
+    }
 
     /* translate expo to center */
     sTransform.translate (vpSize.x () * sx * -0.5 + xoffset,
@@ -865,89 +1035,29 @@
 
     expoActive = true;
 
-    for (j = 0; j < vpSize.y (); j++)
+    for (int j = 0; j < screen->vpSize ().height (); j++)
+	for (int i = 0; i < screen->vpSize().width (); i++)
+	    paintViewport (attrib, sTransform, region, output, mask, CompPoint (i, j), vpCamPos, reflection);
+
+    paintingDndWindow = true;
+
+    foreach (CompWindow *dndWindow, dndWindows)
     {
-	GLMatrix sTransform2 (sTransform), sTransform3;
-
-	for (i = 0; i < vpSize.x (); i++)
-	{
-	    if (optionGetExpoAnimation () == ExpoAnimationVortex)
-		sTransform2.rotate (360 * expoCam,
-				    0.0f, 1.0f, 2.0f * expoCam);
-
-	    sTransform3 = sTransform2;
-
-	    sTransform3.translate (output->x () / output->width (),
-				   -output->y () / output->height (), 0.0);
-
-	    cScreen->setWindowPaintOffset ((screen->vp ().x () - i) *
-					   screen->width (),
-					   (screen->vp ().y () - j) *
-					   screen->height ());
-
-	    vp = (j * vpSize.x ()) + i;
-
-	    vpp = (expoCam * vpActivity[vp]) + (1 - expoCam);
-	    vpp = sigmoidProgress (vpp);
-
-	    vpBrightness = vpp + ((1.0 - vpp) *
-				  optionGetVpBrightness () / 100.0);
-	    vpSaturation = vpp + ((1.0 - vpp) *
-				  optionGetVpSaturation () / 100.0);
-
-	    paintingVp.set (i, j);
-
-	    if (optionGetDeform () == DeformCurve)
-	    {
-		float rotateX;
-
-		sTransform3.translate (-vpCamPos[GLVector::x], 0.0f,
-				       curveDistance - DEFAULT_Z_CAMERA);
-
-		rotateX = -i + interpolate (((float) vpSize.x () / 2.0) - 0.5,
-					    screen->vp ().x (), progress);
-
-		sTransform3.rotate (curveAngle * rotateX, 0.0, 1.0, 0.0);
-
-		sTransform3.translate (vpCamPos[GLVector::x], 0.0f,
-				       DEFAULT_Z_CAMERA - curveDistance);
-	    }
-
-	    gScreen->glPaintTransformedOutput (attrib, sTransform3,
-					       screen->region (), output,
-					       mask);
-
-	    if (!reflection)
-	    {
-		int cursor[2] = { pointerX, pointerY };
-
-		invertTransformedVertex (attrib, sTransform3,
-					 output, cursor);
-
-		if ((cursor[0] > 0) && (cursor[0] < (int) screen->width ()) &&
-		    (cursor[1] > 0) && (cursor[1] < (int) screen->height ()))
-		{
-		    newCursor.setX (i * screen->width () + cursor[0]);
-		    newCursor.setY (j * screen->height () + cursor[1]);
-
-		    if (anyClick || dndState != DnDNone)
-		    {
-			/* Used to save last viewport interaction was in */
-			selectedVp.set (i, j);
-			anyClick = false;
-		    }
-		}
-	    }
-
-	    /* not sure this will work with different resolutions */
-	    if (optionGetDeform () != DeformCurve)
-		sTransform2.translate (sx + gapX, 0.0f, 0.0);
-	}
-
-	/* not sure this will work with different resolutions */
-	sTransform.translate (0.0, -(sy + gapY), 0.0f);
+	CompPoint vp;
+
+	screen->viewportForGeometry (dndWindow->geometry (), vp);
+
+	while (vp.x () < 0)
+	    vp.setX (screen->vpSize ().width () + vp.x ());
+
+	while (vp.y () < 0)
+	    vp.setY (screen->vpSize ().height () + vp.y ());
+
+	paintViewport (attrib, sTransform, infiniteRegion, output, mask, vp, vpCamPos, reflection);
     }
 
+    paintingDndWindow = false;
+
     glNormal3f (0.0, 0.0, -1.0);
 
     if (reflection)
@@ -1025,6 +1135,12 @@
     gScreen->setTextureFilter (oldFilter);
 }
 
+const CompWindowList &
+ExpoScreen::getWindowPaintList ()
+{
+    return dndWindows;
+}
+
 bool
 ExpoScreen::glPaintOutput (const GLScreenPaintAttrib& attrib,
 			   const GLMatrix&            transform,
@@ -1079,6 +1195,11 @@
 		    const CompRegion&   region,
 		    unsigned int        mask)
 {
+    GLMatrix wTransform (transform);
+    CompPoint vp;
+
+    screen->viewportForGeometry (window->geometry (), vp);
+
     if (eScreen->expoCam == 0.0f)
 	return gWindow->glDraw (transform, fragment, region, mask);
 
@@ -1107,8 +1228,11 @@
 	    }
 	}
 
-	fA.setBrightness (fragment.getBrightness () * eScreen->vpBrightness);
-	fA.setSaturation (fragment.getSaturation () * eScreen->vpSaturation);
+	if (vp == eScreen->paintingVp || window->onAllViewports ())
+	{
+	    fA.setBrightness (fragment.getBrightness () * eScreen->vpBrightness);
+	    fA.setSaturation (fragment.getSaturation () * eScreen->vpSaturation);
+	}
     }
     else
     {
@@ -1119,7 +1243,82 @@
 			      (1 - sigmoidProgress (eScreen->expoCam)));
     }
 
-    return gWindow->glDraw (transform, fA, region, mask);
+    bool status = gWindow->glDraw (wTransform, fA, region, mask);
+
+    if (window->type () & CompWindowTypeDesktopMask)
+    {
+	/* We want to set the geometry of the polka dots to the window
+	 * region */
+	CompRegion reg = CompRegion (0, 0, window->width (), window->height ());
+
+	foreach(GLTexture * tex, eScreen->polkadots_texture)
+	{
+	    GLTexture::MatrixList matl;
+	    GLTexture::Matrix     mat = tex->matrix();
+	    CompRegion            paintRegion(region);
+
+	    /* We can reset the window geometry since it will be
+	     * re-added later */
+	    gWindow->geometry().reset();
+
+	    float xScale = screen->width () / (float) eScreen->viewport_size.width ();
+	    float yScale = screen->height () / (float) eScreen->viewport_size.height ();
+
+	    mat.xx *= xScale;
+	    mat.yy *= yScale;
+
+	    /* Not sure what this does, but it is necessary
+	     * (adjusts for scale?) */
+	    mat.x0 -= mat.xx * reg.boundingRect().x1();
+	    mat.y0 -= mat.yy * reg.boundingRect().y1();
+
+	    matl.push_back(mat);
+
+	    if (mask & PAINT_WINDOW_TRANSFORMED_MASK)
+		paintRegion = infiniteRegion;
+
+	    /* Now allow plugins to mess with the geometry of our
+	     * dim (so we get a nice render for things like
+	     * wobbly etc etc */
+	    gWindow->glAddGeometry(matl, reg, paintRegion);
+
+	    /* Did it succeed? */
+	    if (gWindow->geometry().vertices)
+	    {
+		unsigned int glDrawTextureIndex = gWindow->glDrawTextureGetCurrentIndex();
+		fA.setOpacity (fragment.getOpacity () * (((1.0 - eScreen->vpBrightness) + (1.0 - eScreen->vpSaturation) / 2.0)));
+		/* Texture rendering set-up */
+		eScreen->gScreen->setTexEnvMode(GL_MODULATE);
+		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+		/* Draw the dim texture with all of it's modified
+		 * geometry glory */
+		gWindow->glDrawTextureSetCurrentIndex(MAXSHORT);
+		gWindow->glDrawTexture(tex, fA, mask | PAINT_WINDOW_BLEND_MASK
+				       | PAINT_WINDOW_TRANSLUCENT_MASK |
+				       PAINT_WINDOW_TRANSFORMED_MASK);
+		gWindow->glDrawTextureSetCurrentIndex(glDrawTextureIndex);
+		/* Texture rendering tear-down */
+		glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+		eScreen->gScreen->setTexEnvMode(GL_REPLACE);
+	    }
+	}
+
+	/* Paint the outline */
+	if (mGlowQuads && eScreen->paintingVp == eScreen->selectedVp)
+	{
+	    if (region.numRects ())
+	    {
+		/* reset geometry and paint */
+		gWindow->geometry ().reset ();
+
+		paintGlow (fragment, infiniteRegion, mask);
+	    }
+	}
+
+  }
+
+  return status;
+
 }
 
 #define EXPO_GRID_SIZE 100
@@ -1261,6 +1460,12 @@
 		     const CompRegion&          region,
 		     unsigned int               mask)
 {
+    GLMatrix            wTransform (transform);
+    GLWindowPaintAttrib wAttrib (attrib);
+    CompPoint           vp;
+
+    screen->viewportForGeometry (window->geometry (), vp);
+
     if (eScreen->expoActive)
     {
 	float opacity = 1.0;
@@ -1294,9 +1499,52 @@
 
 	if (opacity <= 0)
 	    mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
-    }
-
-    return gWindow->glPaint (attrib, transform, region, mask);
+	else
+	    wAttrib.opacity = wAttrib.opacity * opacity;
+    }
+
+    /* Stretch maximized windows a little so that you don't
+     * have an awkward gap */
+    if (window->state () & MAXIMIZE_STATE)
+    {
+	CompOutput *o = &screen->outputDevs ()[screen->outputDeviceForGeometry(window->geometry())];
+	float yS = 1.0 + ((o->height () / (float) window->height ()) - 1.0f) * sigmoidProgress (eScreen->expoCam);
+	wTransform.translate (window->x () + window->width () / 2,
+			      window->y () + window->height (),
+			      0.0f);
+	wTransform.scale (1.0f, yS, 1.0f);
+	wTransform.translate (-(window->x () + window->width () / 2),
+			      -(window->y () + window->height ()),
+			      0.0f);
+
+	if (eScreen->paintingVp != vp)
+	    mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
+
+	mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+    }
+
+    if (std::find (eScreen->dndWindows.begin(), eScreen->dndWindows.end (), window) != eScreen->dndWindows.end ())
+    {
+	if (!eScreen->paintingDndWindow)
+	{
+	    if ((1.0f - dndOpacity) <= 0.0f || (eScreen->paintingVp == vp &&
+						eScreen->dndState != ExpoScreen::DnDNone))
+		mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
+	    else if (!window->region ().subtracted (screen->region ()).isEmpty () &&
+		     eScreen->paintingVp != vp)
+		wAttrib.opacity = wAttrib.opacity * (1.0f - dndOpacity);
+	}
+	else
+	{
+	    mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+	    if (!window->region ().subtracted (screen->region ()).isEmpty ())
+		wAttrib.opacity = wAttrib.opacity * dndOpacity;
+	}
+    }
+
+    bool status = gWindow->glPaint (wAttrib, wTransform, region, mask);
+
+    return status;
 }
 
 bool
@@ -1325,20 +1573,29 @@
     expoActive (false),
     expoMode (false),
     dndState (DnDNone),
-    dndWindow (NULL),
+    dndWindows (0),
     origVp (s->vp ()),
     selectedVp (s->vp ()),
     vpUpdateMode (VPUpdateNone),
     clickTime (0),
     doubleClick (false),
     vpNormals (360 * 3),
-    grabIndex (0)
+    grabIndex (0),
+    paintingDndWindow (false),
+    mGlowTextureProperties (&glowTextureProperties)
 {
+    CompString fname;
+    CompString pname = "expo";
+    CompSize   size;
+
+
     leftKey  = XKeysymToKeycode (s->dpy (), XStringToKeysym ("Left"));
     rightKey = XKeysymToKeycode (s->dpy (), XStringToKeysym ("Right"));
     upKey    = XKeysymToKeycode (s->dpy (), XStringToKeysym ("Up"));
     downKey  = XKeysymToKeycode (s->dpy (), XStringToKeysym ("Down"));
 
+    mMoveCursor = XCreateFontCursor (screen->dpy (), XC_fleur);
+
     EXPOINITBIND (ExpoKey, doExpo);
     EXPOTERMBIND (ExpoKey, termExpo);
     EXPOINITBIND (ExpoButton, doExpo);
@@ -1355,6 +1612,47 @@
     ScreenInterface::setHandler (screen, false);
     CompositeScreenInterface::setHandler (cScreen, false);
     GLScreenInterface::setHandler (gScreen, false);
+
+    outline_texture = GLTexture::imageDataToTexture (mGlowTextureProperties->textureData,
+						     CompSize (mGlowTextureProperties->textureSize,
+							       mGlowTextureProperties->textureSize),
+						     GL_RGBA, GL_UNSIGNED_BYTE);
+    fname = "texture_tile.png";
+    polkadots_texture = GLTexture::readImageToTexture (fname, pname, polkadots_texture_size);
+
+    if (polkadots_texture.empty ())
+	compLogMessage ("expo", CompLogLevelWarn, "failed to bind image to texture");
+    else
+    {
+	foreach (GLTexture *tex, polkadots_texture)
+	{
+	    tex->enable (GLTexture::Good);
+	    glTexParameteri (tex->target (), GL_TEXTURE_WRAP_S, GL_REPEAT);
+	    glTexParameteri (tex->target (), GL_TEXTURE_WRAP_T, GL_REPEAT);
+	    tex->disable ();
+	}
+    }
+}
+
+ExpoScreen::~ExpoScreen ()
+{
+    if (mMoveCursor)
+	XFreeCursor (screen->dpy (), mMoveCursor);
+}
+
+void
+ExpoWindow::resizeNotify(int dx, int dy, int dw, int dh)
+{
+    window->resizeNotify (dx, dy, dw, dh);
+
+    /* mGlowQuads contains positional info, so we need to recalc that */
+    if (mGlowQuads)
+    {
+	/* FIXME: we need to find a more multitexture friendly way
+	 * of doing this */
+	GLTexture::Matrix tMat = eScreen->outline_texture.at (0)->matrix ();
+	computeGlowQuads (&tMat);
+    }
 }
 
 ExpoWindow::ExpoWindow (CompWindow *w) :
@@ -1362,10 +1660,28 @@
     window (w),
     cWindow (CompositeWindow::get (w)),
     gWindow (GLWindow::get (w)),
-    eScreen (ExpoScreen::get (screen))
+    eScreen (ExpoScreen::get (screen)),
+    dndOpacity (0.0f),
+    mGlowQuads (NULL)
 {
     CompositeWindowInterface::setHandler (cWindow, false);
     GLWindowInterface::setHandler (gWindow, false);
+    WindowInterface::setHandler (window, true);
+
+    if (window->type () & CompWindowTypeDesktopMask)
+    {
+	foreach (GLTexture *tex, eScreen->outline_texture)
+	{
+	    GLTexture::Matrix mat = tex->matrix ();
+	    computeGlowQuads (&mat);
+	}
+    }
+}
+
+ExpoWindow::~ExpoWindow ()
+{
+    eScreen->dndWindows.remove (window);
+    computeGlowQuads (NULL);
 }
 
 bool
 
=== modified file 'src/expo.h'
--- src/expo.h	2011-09-01 14:33:30 +0000
+++ src/expo.h	2011-09-15 12:36:24 +0000
@@ -25,11 +25,21 @@
 
 #include <core/core.h>
 #include <core/pluginclasshandler.h>
+#include <cairo.h>
+#include <cairo-xlib-xrender.h>
 
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 
 #include "expo_options.h"
+#include "glow.h"
+
+#define WIN_REAL_X(w) (w->x () - w->border ().left)
+#define WIN_REAL_Y(w) (w->y () - w->border ().top)
+#define WIN_REAL_WIDTH(w) (w->width () + 2 * w->geometry ().border () + \
+			   w->border ().left + w->border ().right)
+#define WIN_REAL_HEIGHT(w) (w->height () + 2 * w->geometry ().border () + \
+			    w->border ().top + w->border ().bottom)
 
 class ExpoScreen :
     public ScreenInterface,
@@ -40,6 +50,7 @@
 {
     public:
 	ExpoScreen (CompScreen *);
+	~ExpoScreen ();
 
 	void handleEvent (XEvent *);
 
@@ -53,6 +64,8 @@
 				       const GLMatrix&, const CompRegion&,
 				       CompOutput *, unsigned int);
 
+	const CompWindowList & getWindowPaintList ();
+
 	bool dndInit (CompAction *, CompAction::State, CompOption::Vector&);
 	bool dndFini (CompAction *, CompAction::State, CompOption::Vector&);
 	bool doExpo (CompAction *, CompAction::State, CompOption::Vector&);
@@ -61,6 +74,8 @@
 	bool nextVp (CompAction *, CompAction::State, CompOption::Vector&);
 	bool prevVp (CompAction *, CompAction::State, CompOption::Vector&);
 
+	CompPoint currentViewport ();
+
 	typedef enum {
 	    DnDNone,
 	    DnDDuring,
@@ -81,7 +96,7 @@
 	bool  expoMode;
 
 	DnDState   dndState;
-	CompWindow *dndWindow;
+	CompWindowList dndWindows;
 
 	CompPoint prevCursor;
 	CompPoint newCursor;
@@ -111,6 +126,17 @@
 
 	CompScreen::GrabHandle grabIndex;
 
+	GLTexture::List polkadots_texture;
+	CompSize        polkadots_texture_size;
+	CompSize        viewport_size;
+
+	GLTexture::List outline_texture;
+	CompSize        outline_texture_size;
+
+	bool paintingDndWindow;
+
+	const GlowTextureProperties *mGlowTextureProperties;
+
     private:
 	void moveFocusViewport (int, int);
 	void finishWindowMovement ();
@@ -121,22 +147,39 @@
 	void paintWall (const GLScreenPaintAttrib&, const GLMatrix&,
 			const CompRegion&, CompOutput *, unsigned int, bool);
 
+	void paintViewport (const GLScreenPaintAttrib& attrib,
+			    const GLMatrix&            transform,
+			    const CompRegion&          region,
+			    CompOutput                 *output,
+			    unsigned int               mask,
+			    CompPoint                  vpPos,
+			    GLVector                   &vpCamPos,
+			    bool                       reflection);
+
+	bool windowsOnVp (CompPoint &p);
+
 	KeyCode leftKey;
 	KeyCode rightKey;
 	KeyCode upKey;
 	KeyCode downKey;
+
+	Cursor  mMoveCursor;
 };
 
 class ExpoWindow :
     public CompositeWindowInterface,
     public GLWindowInterface,
+    public WindowInterface,
     public PluginClassHandler<ExpoWindow, CompWindow>
 {
     public:
 	ExpoWindow (CompWindow *);
+	~ExpoWindow ();
 
 	bool damageRect (bool, const CompRect&);
 
+	void resizeNotify (int dx, int dy, int dw, int dh);
+
 	bool glDraw (const GLMatrix&, GLFragment::Attrib&,
 		     const CompRegion&, unsigned int);
 	bool glPaint (const GLWindowPaintAttrib&, const GLMatrix&,
@@ -147,10 +190,22 @@
 	void glDrawTexture (GLTexture *, GLFragment::Attrib& attrib,
 			    unsigned int);
 
+	void
+	paintGlow (GLFragment::Attrib        &attrib,
+		   const CompRegion	     &paintRegion,
+		   unsigned int		     mask);
+
+	void
+	computeGlowQuads (GLTexture::Matrix *matrix);
+
 	CompWindow      *window;
 	CompositeWindow *cWindow;
 	GLWindow        *gWindow;
 	ExpoScreen      *eScreen;
+
+	float           dndOpacity;
+
+	GlowQuad *mGlowQuads;
 };
 
 class ExpoPluginVTable :
 
=== added file 'src/glow.cpp'
--- src/glow.cpp	1970-01-01 00:00:00 +0000
+++ src/glow.cpp	2011-09-15 12:36:24 +0000
@@ -0,0 +1,428 @@
+/**
+ *
+ * Compiz group plugin
+ *
+ * glow.cpp
+ *
+ * Copyright : (C) 2006-2010 by Patrick Niklaus, Roi Cohen,
+ * 				Danny Baumann, Sam Spilsbury
+ * Authors: Patrick Niklaus <[e-mail]>
+ *          Roi Cohen       <[e-mail]>
+ *          Danny Baumann   <[e-mail]>
+ * 	    Sam Spilsbury   <[e-mail]>
+ *
+ *
+ * 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 "expo.h"
+#include "group_glow.h"
+
+const GlowTextureProperties glowTextureProperties = {
+    /* GlowTextureRectangular */
+    glowTexRect, 32, 21
+};
+
+/*
+ * GroupWindow::paintGlow
+ *
+ * Takes our glow texture, stretches the appropriate positions in the glow texture,
+ * adds those geometries (so plugins like wobby and deform this texture correctly)
+ * and then draws the glow texture with this geometry (plugins like wobbly and friends
+ * will automatically deform the texture based on our set geometry)
+ */
+
+void
+ExpoWindow::paintGlow (GLFragment::Attrib        &attrib,
+		       const CompRegion	         &paintRegion,
+		       unsigned int		  mask)
+{
+    CompRegion reg;
+    int    i;
+
+    /* There are 8 glow parts of the glow texture which we wish to paint
+     * separately with different transformations
+     */
+    for (i = 0; i < NUM_GLOWQUADS; i++)
+    {
+	/* Using precalculated quads here */
+	reg = CompRegion (mGlowQuads[i].mBox);
+
+	if (reg.boundingRect ().x1 () < reg.boundingRect ().x2 () &&
+	    reg.boundingRect ().y1 () < reg.boundingRect ().y2 ())
+	{
+	    GLTexture::MatrixList matl;
+	    reg = CompRegion (reg.boundingRect ().x1 (),
+			      reg.boundingRect ().y1 (),
+			      reg.boundingRect ().width (),
+			      reg.boundingRect ().height ());
+
+	    matl.push_back (mGlowQuads[i].mMatrix);
+	    gWindow->glAddGeometry (matl, reg, paintRegion);
+	}
+    }
+
+    /* If the geometry add succeeded */
+    if (gWindow->geometry ().vertices)
+    {
+	GLFragment::Attrib fAttrib (attrib);
+	GLushort       average;
+	GLushort       color[3] = {MAXSHORT,
+				   MAXSHORT,
+				   MAXSHORT};
+
+	float alpha = (float) ExpoScreen::get (screen)->optionGetSelectedColorAlpha ()  / 65535.0f;
+
+	GLScreen::get (screen)->setTexEnvMode (GL_MODULATE);
+	glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+	glColor4f (((float) ExpoScreen::get (screen)->optionGetSelectedColorRed () / 65535.0f) * alpha,
+		   ((float) ExpoScreen::get (screen)->optionGetSelectedColorGreen () / 65535.0f) * alpha,
+		   ((float) ExpoScreen::get (screen)->optionGetSelectedColorBlue () / 65535.0f) * alpha,
+		   alpha);
+
+	/* we use PAINT_WINDOW_TRANSFORMED_MASK here to force
+	   the usage of a good texture filter */
+	foreach (GLTexture *tex, ExpoScreen::get (screen)->outline_texture)
+	{
+	    gWindow->glDrawTexture (tex, fAttrib, mask | 
+					PAINT_WINDOW_BLEND_MASK       |
+					PAINT_WINDOW_TRANSLUCENT_MASK |
+					PAINT_WINDOW_TRANSFORMED_MASK);
+	}
+
+	glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+	GLScreen::get (screen)->setTexEnvMode (GL_REPLACE);
+	glColor4usv (defaultColor);
+    }
+}
+
+/*
+ * ExpoWindow::computeGlowQuads
+ *
+ * This function computures the matrix transformation required for each
+ * part of the glow texture which we wish to stretch to some rectangular
+ * dimentions
+ *
+ * There are eight quads different parts of the texture which we wish to
+ * paint here, the 4 sides and four corners, eg:
+ *
+ *		     ------------------
+ *		     | 1 |   4    | 6 |
+ * -------------     ------------------
+ * | 1 | 4 | 6 |     |   |        |   |
+ * -------------     |   |	  |   |
+ * | 2 | n | 7 | ->  | 2 |   n    | 7 |
+ * -------------     |   |        |   |
+ * | 3 | 5 | 8 |     |   |        |   |
+ * -------------     ------------------
+ *		     | 3 |   5    | 8 |
+ *		     ------------------
+ *
+ * In this example here, 2, 4, 5 and 7 are stretched, and the matrices for
+ * each quad rect adjusted accordingly for it's size compared to the original
+ * texture size.
+ *
+ * When we are adjusting the matrices here, the initial size of each corner has
+ * a size of of "1.0f", so according to 2x2 matrix rules,
+ * the scale factor is the inverse of the size of the glow (which explains
+ * while you will see here that matrix->xx is (1 / glowSize)
+ * where glowSize is the size the user specifies they want their glow to extend.
+ * (likewise, matrix->yy is adjusted similarly for corners and for top/bottom)
+ *
+ * matrix->x0 and matrix->y0 here are set to be the top left edge of the rect
+ * adjusted by the matrix scale factor (matrix->xx and matrix->yy)
+ *
+ */
+void
+ExpoWindow::computeGlowQuads (GLTexture::Matrix *matrix)
+{
+    CompRect	      *box;
+    int		      x1, x2, y1, y2;
+    GLTexture::Matrix *quadMatrix;
+    int               glowSize, glowOffset;
+    CompWindow	      *w = window;
+
+    /* Passing NULL to this function frees the glow quads
+     * (so the window is not painted with glow) */
+
+    if (matrix)
+    {
+	if (!mGlowQuads)
+	    mGlowQuads = new GlowQuad[NUM_GLOWQUADS];
+	if (!mGlowQuads)
+	    return;
+    }
+    else
+    {
+	if (mGlowQuads)
+	{
+	    delete[] mGlowQuads;
+	    mGlowQuads = NULL;
+	}
+	return;
+    }
+
+    glowSize = 48;
+    glowOffset = (glowSize * ExpoScreen::get (screen)->mGlowTextureProperties->glowOffset /
+		  ExpoScreen::get (screen)->mGlowTextureProperties->textureSize) + 1;
+
+    /* Top left corner */
+    box = &mGlowQuads[GLOWQUAD_TOPLEFT].mBox;
+    mGlowQuads[GLOWQUAD_TOPLEFT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_TOPLEFT].mMatrix;
+
+    /* Set the desired rect dimentions
+     * for the part of the glow we are painting */
+
+    x1 = WIN_REAL_X (w) - glowSize + glowOffset;
+    y1 = WIN_REAL_Y (w) - glowSize + glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * Scaling both parts of the texture in a positive direction
+     * here (left to right top to bottom)
+     *
+     * The base position (x0 and y0) here requires us to move backwards
+     * on the x and y dimentions by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = 1.0f / glowSize;
+    quadMatrix->yy = 1.0f / (glowSize);
+    quadMatrix->x0 = -(x1 * quadMatrix->xx);
+    quadMatrix->y0 = -(y1 * quadMatrix->yy);
+
+    x2 = MIN (WIN_REAL_X (w) + glowOffset,
+	      WIN_REAL_X (w) + (WIN_REAL_WIDTH (w) / 2));
+    y2 = MIN (WIN_REAL_Y (w) + glowOffset,
+	      WIN_REAL_Y (w) + (WIN_REAL_HEIGHT (w) / 2));
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Top right corner */
+    box = &mGlowQuads[GLOWQUAD_TOPRIGHT].mBox;
+    mGlowQuads[GLOWQUAD_TOPRIGHT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_TOPRIGHT].mMatrix;
+
+    /* Set the desired rect dimentions
+     * for the part of the glow we are painting */
+
+    x1 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset;
+    y1 = WIN_REAL_Y (w) - glowSize + glowOffset;
+    x2 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) + glowSize - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * Scaling the y part of the texture in a positive direction
+     * and the x part in a negative direction here
+     * (right to left top to bottom)
+     *
+     * The base position (x0 and y0) here requires us to move backwards
+     * on the y dimention and forwards on x by the calculated rect dimentions
+     * multiplied by the scale factors (since we are moving forward on x we
+     * need the inverse of that which is 1 - x1 * xx
+     */
+
+    quadMatrix->xx = -1.0f / glowSize;
+    quadMatrix->yy = 1.0f / glowSize;
+    quadMatrix->x0 = 1.0 - (x1 * quadMatrix->xx);
+    quadMatrix->y0 = -(y1 * quadMatrix->yy);
+
+    x1 = MAX (WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset,
+	      WIN_REAL_X (w) + (WIN_REAL_WIDTH (w) / 2));
+    y2 = MIN (WIN_REAL_Y (w) + glowOffset,
+	      WIN_REAL_Y (w) + (WIN_REAL_HEIGHT (w) / 2));
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Bottom left corner */
+    box = &mGlowQuads[GLOWQUAD_BOTTOMLEFT].mBox;
+    mGlowQuads[GLOWQUAD_BOTTOMLEFT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_BOTTOMLEFT].mMatrix;
+
+    x1 = WIN_REAL_X (w) - glowSize + glowOffset;
+    y1 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset;
+    x2 = WIN_REAL_X (w) + glowOffset;
+    y2 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) + glowSize - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * Scaling the x part of the texture in a positive direction
+     * and the y part in a negative direction here
+     * (left to right bottom to top)
+     *
+     * The base position (x0 and y0) here requires us to move backwards
+     * on the x dimention and forwards on y by the calculated rect dimentions
+     * multiplied by the scale factors (since we are moving forward on x we
+     * need the inverse of that which is 1 - y1 * yy
+     */
+
+    quadMatrix->xx = 1.0f / glowSize;
+    quadMatrix->yy = -1.0f / glowSize;
+    quadMatrix->x0 = -(x1 * quadMatrix->xx);
+    quadMatrix->y0 = 1.0f - (y1 * quadMatrix->yy);
+
+    y1 = MAX (WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset,
+	      WIN_REAL_Y (w) + (WIN_REAL_HEIGHT (w) / 2));
+    x2 = MIN (WIN_REAL_X (w) + glowOffset,
+	      WIN_REAL_X (w) + (WIN_REAL_WIDTH (w) / 2));
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Bottom right corner */
+    box = &mGlowQuads[GLOWQUAD_BOTTOMRIGHT].mBox;
+    mGlowQuads[GLOWQUAD_BOTTOMRIGHT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_BOTTOMRIGHT].mMatrix;
+
+    x1 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset;
+    y1 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset;
+    x2 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) + glowSize - glowOffset;
+    y2 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) + glowSize - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * Scaling the both parts of the texture in a negative direction
+     * (right to left bottom to top)
+     *
+     * The base position (x0 and y0) here requires us to move forwards
+     * on both dimentions by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = -1.0f / glowSize;
+    quadMatrix->yy = -1.0f / glowSize;
+    quadMatrix->x0 = 1.0 - (x1 * quadMatrix->xx);
+    quadMatrix->y0 = 1.0 - (y1 * quadMatrix->yy);
+
+    x1 = MAX (WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset,
+	      WIN_REAL_X (w) + (WIN_REAL_WIDTH (w) / 2));
+    y1 = MAX (WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset,
+	      WIN_REAL_Y (w) + (WIN_REAL_HEIGHT (w) / 2));
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Top edge */
+    box = &mGlowQuads[GLOWQUAD_TOP].mBox;
+    mGlowQuads[GLOWQUAD_TOP].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_TOP].mMatrix;
+
+    x1 = WIN_REAL_X (w) + glowOffset;
+    y1 = WIN_REAL_Y (w) - glowSize + glowOffset;
+    x2 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset;
+    y2 = WIN_REAL_Y (w) + glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * No need to scale the x part of the texture here, but we
+     * are scaling on the y part in a positive direciton
+     *
+     * The base position (y0) here requires us to move backwards
+     * on the x dimention and forwards on y by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = 0.0f;
+    quadMatrix->yy = 1.0f / glowSize;
+    quadMatrix->x0 = 1.0;
+    quadMatrix->y0 = -(y1 * quadMatrix->yy);
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Bottom edge */
+    box = &mGlowQuads[GLOWQUAD_BOTTOM].mBox;
+    mGlowQuads[GLOWQUAD_BOTTOM].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_BOTTOM].mMatrix;
+
+    x1 = WIN_REAL_X (w) + glowOffset;
+    y1 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset;
+    x2 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset;
+    y2 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) + glowSize - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * No need to scale the x part of the texture here, but we
+     * are scaling on the y part in a negative direciton
+     *
+     * The base position (y0) here requires us to move forwards
+     * on y by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = 0.0f;
+    quadMatrix->yy = -1.0f / glowSize;
+    quadMatrix->x0 = 1.0;
+    quadMatrix->y0 = 1.0 - (y1 * quadMatrix->yy);
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Left edge */
+    box = &mGlowQuads[GLOWQUAD_LEFT].mBox;
+    mGlowQuads[GLOWQUAD_LEFT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_LEFT].mMatrix;
+
+    x1 = WIN_REAL_X (w) - glowSize + glowOffset;
+    y1 = WIN_REAL_Y (w) + glowOffset;
+    x2 = WIN_REAL_X (w) + glowOffset;
+    y2 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * No need to scale the y part of the texture here, but we
+     * are scaling on the x part in a positive direciton
+     *
+     * The base position (x0) here requires us to move backwards
+     * on x by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = 1.0f / glowSize;
+    quadMatrix->yy = 0.0f;
+    quadMatrix->x0 = -(x1 * quadMatrix->xx);
+    quadMatrix->y0 = 1.0;
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+
+    /* Right edge */
+    box = &mGlowQuads[GLOWQUAD_RIGHT].mBox;
+    mGlowQuads[GLOWQUAD_RIGHT].mMatrix = *matrix;
+    quadMatrix = &mGlowQuads[GLOWQUAD_RIGHT].mMatrix;
+
+    x1 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) - glowOffset;
+    y1 = WIN_REAL_Y (w) + glowOffset;
+    x2 = WIN_REAL_X (w) + WIN_REAL_WIDTH (w) + glowSize - glowOffset;
+    y2 = WIN_REAL_Y (w) + WIN_REAL_HEIGHT (w) - glowOffset;
+
+    /* 2x2 Matrix here, adjust both x and y scale factors
+     * and the x and y position
+     *
+     * No need to scale the y part of the texture here, but we
+     * are scaling on the x part in a negative direciton
+     *
+     * The base position (x0) here requires us to move forwards
+     * on x by the calculated rect dimentions
+     * multiplied by the scale factors
+     */
+
+    quadMatrix->xx = -1.0f / glowSize;
+    quadMatrix->yy = 0.0f;
+    quadMatrix->x0 = 1.0 - (x1 * quadMatrix->xx);
+    quadMatrix->y0 = 1.0;
+
+    *box = CompRect (x1, y1, x2 - x1, y2 - y1);
+}
 
=== added file 'src/glow.h'
--- src/glow.h	1970-01-01 00:00:00 +0000
+++ src/glow.h	2011-09-15 12:36:24 +0000
@@ -0,0 +1,66 @@
+/**
+ *
+ * Compiz group plugin
+ *
+ * glow.h
+ *
+ * Copyright : (C) 2006-2010 by Patrick Niklaus, Roi Cohen,
+ * 				Danny Baumann, Sam Spilsbury
+ * Authors: Patrick Niklaus <[e-mail]>
+ *          Roi Cohen       <[e-mail]>
+ *          Danny Baumann   <[e-mail]>
+ * 	    Sam Spilsbury   <[e-mail]>
+ *
+ *
+ * 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.
+ *
+ **/
+ 
+#ifndef _EXPO_GLOW_H
+#define _EXPO_GLOW_H
+ 
+#define GLOWQUAD_TOPLEFT	 0
+#define GLOWQUAD_TOPRIGHT	 1
+#define GLOWQUAD_BOTTOMLEFT	 2
+#define GLOWQUAD_BOTTOMRIGHT     3
+#define GLOWQUAD_TOP		 4
+#define GLOWQUAD_BOTTOM		 5
+#define GLOWQUAD_LEFT		 6
+#define GLOWQUAD_RIGHT		 7
+#define NUM_GLOWQUADS		 8
+
+/* Represents a particular glow texture, so here
+ * we have hardcoded in the texture data, the offset
+ * and the size of the texture
+ */
+
+typedef struct _GlowTextureProperties {
+    char *textureData;
+    int  textureSize;
+    int  glowOffset;
+} GlowTextureProperties;
+
+/* Each glow quad contains a 2x2 scale + positional matrix
+ * (the 3rd column is not used since that is for matrix skew
+ *  operations which we do not care about)
+ * and also a CompRect which describes the size and position of
+ * the quad on the glow
+ */
+
+class GlowQuad {
+    public:
+	CompRect	  mBox;
+	GLTexture::Matrix mMatrix;
+};
+
+extern const GlowTextureProperties glowTextureProperties;
+
+#endif
 
=== added file 'src/group_glow.h'
--- src/group_glow.h	1970-01-01 00:00:00 +0000
+++ src/group_glow.h	2011-09-15 12:36:24 +0000
@@ -0,0 +1,197 @@
+#ifndef _GROUP_GLOWTEX_H
+#define _GROUP_GLOWTEX_H
+
+/**
+ *
+ * Compiz group plugin
+ *
+ * group_glow.h
+ *
+ * Copyright : (C) 2006-2010 by Patrick Niklaus, Roi Cohen,
+ * 				Danny Baumann, Sam Spilsbury
+ * Authors: Patrick Niklaus <[e-mail]>
+ *          Roi Cohen       <[e-mail]>
+ *          Danny Baumann   <[e-mail]>
+ * 	    Sam Spilsbury   <[e-mail]>
+ *
+ *
+ * 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.
+ *
+ **/
+
+/*
+ * glowTex
+ */
+
+static char glowTexRect[4097] = {
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377"
+  "\377\377\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377"
+  "\377\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\6\377\377\377\6\377\377"
+  "\377\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377"
+  "\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377\6"
+  "\377\377\377\14\377\377\377\14\377\377\377\14\377\377\377\14\377\377\377"
+  "\14\377\377\377\14\377\377\377\14\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\6\377\377\377\6\377\377\377\14"
+  "\377\377\377\14\377\377\377\22\377\377\377\22\377\377\377\22\377\377\377"
+  "\27\377\377\377\27\377\377\377\27\377\377\377\27\377\377\377\27\377\377\377"
+  "\27\377\377\377\27\377\377\377\27\377\377\377\27\377\377\377\27\377\377\377"
+  "\35\377\377\377\35\377\377\377\35\377\377\377\35\377\377\377\35\377\377\377"
+  "\35\377\377\377\35\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377"
+  "\377\6\377\377\377\6\377\377\377\14\377\377\377\22\377\377\377\27\377\377"
+  "\377\27\377\377\377\35\377\377\377#\377\377\377'\377\377\377'\377\377\377"
+  "+\377\377\377+\377\377\377+\377\377\377+\377\377\377+\377\377\377+\377\377"
+  "\377+\377\377\377+\377\377\377+\377\377\3771\377\377\3771\377\377\3771\377"
+  "\377\3771\377\377\3771\377\377\3771\377\377\3771\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\22\377\377\377"
+  "\27\377\377\377\35\377\377\377#\377\377\377+\377\377\3771\377\377\3776\377"
+  "\377\377<\377\377\377>\377\377\377C\377\377\377I\377\377\377I\377\377\377"
+  "I\377\377\377I\377\377\377I\377\377\377I\377\377\377I\377\377\377I\377\377"
+  "\377L\377\377\377L\377\377\377L\377\377\377L\377\377\377L\377\377\377L\377"
+  "\377\377L\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377"
+  "\377\377\22\377\377\377\27\377\377\377#\377\377\377+\377\377\3776\377\377"
+  "\377C\377\377\377L\377\377\377U\377\377\377]\377\377\377`\377\377\377d\377"
+  "\377\377h\377\377\377k\377\377\377k\377\377\377k\377\377\377k\377\377\377"
+  "k\377\377\377k\377\377\377k\377\377\377p\377\377\377p\377\377\377p\377\377"
+  "\377p\377\377\377p\377\377\377p\377\377\377p\0\0\0\0\0\0\0\0\0\0\0\0\377"
+  "\377\377\6\377\377\377\14\377\377\377\22\314\314\314\35\377\377\377'\377"
+  "\377\3771\377\377\377>\357\357\357P\377\377\377]\363\363\363k\365\365\365"
+  "v\365\365\365|\377\377\377\202\367\367\367\210\367\367\367\214\367\367\367"
+  "\216\367\367\367\221\367\367\367\221\367\367\367\221\367\367\367\221\367"
+  "\367\367\221\367\367\367\221\367\367\367\224\367\367\367\224\367\367\367"
+  "\224\367\367\367\224\367\367\367\224\367\367\367\224\367\367\367\224\0\0"
+  "\0\0\0\0\0\0\377\377\377\6\377\377\377\6\377\377\377\22\377\377\377\27\377"
+  "\377\377'\377\377\3776\377\377\377I\377\377\377Y\377\377\377k\376\376\376"
+  "y\377\377\377\210\377\377\377\224\377\377\377\235\377\377\377\245\377\377"
+  "\377\253\377\377\377\255\377\377\377\262\377\377\377\262\377\377\377\263"
+  "\377\377\377\263\377\377\377\263\377\377\377\263\377\377\377\263\377\377"
+  "\377\266\377\377\377\266\377\377\377\266\377\377\377\266\377\377\377\266"
+  "\377\377\377\266\377\377\377\266\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377"
+  "\14\377\377\377\27\377\377\377#\377\377\3771\377\377\377I\377\377\377]\377"
+  "\377\377r\377\377\377\205\377\377\377\231\377\377\377\247\377\377\377\263"
+  "\377\377\377\275\377\377\377\304\377\377\377\310\377\377\377\313\377\377"
+  "\377\316\377\377\377\320\377\377\377\320\377\377\377\320\377\377\377\320"
+  "\377\377\377\320\377\377\377\320\377\377\377\322\377\377\377\322\377\377"
+  "\377\322\377\377\377\322\377\377\377\322\377\377\377\322\377\377\377\322"
+  "\0\0\0\0\377\377\377\6\377\377\377\6\377\377\377\22\377\377\377\35\377\377"
+  "\377+\377\377\377>\377\377\377Y\377\377\377r\377\377\377\210\376\376\376"
+  "\237\377\377\377\262\377\377\377\302\377\377\377\313\377\377\377\324\377"
+  "\377\377\332\376\376\376\336\377\377\377\341\377\377\377\342\377\377\377"
+  "\344\377\377\377\344\377\377\377\344\377\377\377\344\377\377\377\344\377"
+  "\377\377\344\377\377\377\345\377\377\377\345\377\377\377\345\377\377\377"
+  "\345\377\377\377\345\377\377\377\345\377\377\377\345\0\0\0\0\377\377\377"
+  "\6\377\377\377\14\377\377\377\27\377\377\377#\377\377\3776\377\377\377P\377"
+  "\377\377k\377\377\377\205\376\376\376\237\372\372\372\266\377\377\377\307"
+  "\373\373\373\325\373\373\373\337\374\374\374\345\374\374\374\352\374\374"
+  "\374\355\374\374\374\357\374\374\374\360\374\374\374\361\374\374\374\361"
+  "\374\374\374\362\374\374\374\362\374\374\374\362\374\374\374\362\374\374"
+  "\374\362\374\374\374\362\374\374\374\362\374\374\374\362\374\374\374\362"
+  "\374\374\374\362\374\374\374\362\0\0\0\0\377\377\377\6\377\377\377\14\377"
+  "\377\377\35\377\377\377+\377\377\377C\377\377\377]\377\377\377|\377\377\377"
+  "\231\377\377\377\263\377\377\377\307\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377"
+  "\377\377\6\377\377\377\22\324\324\324#\377\377\3771\377\377\377L\363\363"
+  "\363k\377\377\377\210\377\377\377\247\377\377\377\302\377\377\377\325\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\22\377\377"
+  "\377#\377\377\377<\377\377\377U\377\377\377v\377\377\377\226\377\377\377"
+  "\263\377\377\377\315\377\377\377\337\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377"
+  "\6\377\377\377\14\377\377\377\27\377\377\377'\377\377\377>\377\377\377]\377"
+  "\377\377|\370\370\370\237\377\377\377\275\373\373\373\325\377\377\377\345"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\27\377"
+  "\377\377+\377\377\377C\377\377\377`\377\377\377\202\377\377\377\247\377\377"
+  "\377\304\377\377\377\332\377\377\377\352\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377"
+  "\377\6\377\377\377\14\377\377\377\27\377\377\377+\377\377\377C\377\377\377"
+  "d\377\377\377\210\377\377\377\253\377\377\377\310\376\376\376\336\374\374"
+  "\374\355\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377"
+  "\35\377\377\377+\377\377\377I\377\377\377h\377\377\377\214\377\377\377\260"
+  "\377\377\377\313\374\374\374\342\374\374\374\357\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\377\377\377\6\377\377\377\14\377\377\377\35\342\342\3421\377\377\377I\377"
+  "\377\377k\377\377\377\216\377\377\377\262\377\377\377\316\374\374\374\344"
+  "\377\377\377\360\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377"
+  "\377\377\35\377\377\3771\377\377\377L\377\377\377k\377\377\377\221\377\377"
+  "\377\263\377\377\377\320\377\377\377\344\377\377\377\361\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\35\377\377\3771\377\377"
+  "\377L\377\377\377k\377\377\377\221\377\377\377\263\377\377\377\320\377\377"
+  "\377\344\374\374\374\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377"
+  "\14\377\377\377\35\377\377\3771\377\377\377L\364\364\364p\377\377\377\221"
+  "\372\372\372\266\377\377\377\320\374\374\374\345\377\377\377\362\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\35\377\377\377"
+  "1\377\377\377L\377\377\377p\377\377\377\221\377\377\377\266\373\373\373\322"
+  "\377\377\377\345\377\377\377\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377"
+  "\377\377\14\377\377\377\35\377\377\3771\377\377\377L\377\377\377p\377\377"
+  "\377\221\377\377\377\266\373\373\373\322\377\377\377\345\377\377\377\362"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\35\377"
+  "\377\3771\377\377\377L\377\377\377p\377\377\377\221\377\377\377\266\373\373"
+  "\373\322\377\377\377\345\377\377\377\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377"
+  "\377\6\377\377\377\14\377\377\377\35\377\377\3771\377\377\377L\377\377\377"
+  "p\367\367\367\224\377\377\377\266\377\377\377\322\377\377\377\345\374\374"
+  "\374\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377"
+  "\35\377\377\3771\377\377\377L\377\377\377p\367\367\367\224\377\377\377\266"
+  "\377\377\377\322\377\377\377\345\374\374\374\362\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\377\377\377\6\377\377\377\14\377\377\377\35\377\377\3771\377\377\377L\377"
+  "\377\377p\367\367\367\224\377\377\377\266\377\377\377\322\377\377\377\345"
+  "\374\374\374\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377"
+  "\377\377\35\377\377\3771\377\377\377L\377\377\377p\367\367\367\224\377\377"
+  "\377\266\377\377\377\322\377\377\377\345\374\374\374\362\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\35\377\377\3771\377\377"
+  "\377L\377\377\377p\367\367\367\224\377\377\377\266\377\377\377\322\377\377"
+  "\377\345\374\374\374\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377"
+  "\14\377\377\377\35\377\377\3771\377\377\377L\377\377\377p\367\367\367\224"
+  "\377\377\377\266\377\377\377\322\377\377\377\345\374\374\374\362\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\377\377\377\6\377\377\377\14\377\377\377\35\377\377\377"
+  "1\377\377\377L\377\377\377p\367\367\367\224\377\377\377\266\377\377\377\322"
+  "\377\377\377\345\374\374\374\362\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"
+  "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
+};
+
+#endif