Merge lp:~dbarth/compiz/reworked-fix-744104 into lp:~unity-team/compiz/trunk

[David Barth]

Re-worked version of sam's original patch, to make it apply to the current trunk

=== modified file 'plugins/grid/grid.xml.in'
--- plugins/grid/grid.xml.in	2011-04-05 13:32:45 +0000
+++ plugins/grid/grid.xml.in	2011-04-06 14:53:28 +0000
@@ -556,6 +556,37 @@
 			    <alpha>0x4f4f</alpha>
 			</default>
 		</option>
+		<option name="indicator_direction" type="int">
+			<_short>Indicator direction</_short>
+			<_long>Where the indicator should come from on-screen</_long>
+			<default>0</default>
+			<min>0</min>
+			<max>1</max>
+			<desc>
+			    <value>0</value>
+			    <_name>From Window</_name>
+			</desc>
+			<desc>
+			    <value>1</value>
+			    <_name>From Edge</_name>
+			</desc>
+		</option>
+		<option name="indicator_type" type="int">
+			<_short>Indicator type</_short>
+			<_long>Appearance of the indicator</_long>
+			<default>0</default>
+			<min>0</min>
+			<max>0</max>
+			<desc>
+			    <value>0</value>
+			    <_name>Outline</_name>
+			</desc>
+		</option>
+		<option name="behind_window" type="bool">
+			<_short>Behind window</_short>
+			<_long>Draw indicator behind window</_long>
+			<default>true</default>
+		</option>
 	    </group>
 	</options>
     </plugin>

=== modified file 'plugins/grid/src/grid.cpp'
--- plugins/grid/src/grid.cpp	2011-04-05 13:32:45 +0000
+++ plugins/grid/src/grid.cpp	2011-04-06 14:53:28 +0000
@@ -127,7 +127,7 @@
     if (edgeToGridType () != GridUnknown && optionGetDrawIndicator () &&
 	gw->allowGrid (edgeToGridType ()))
     {
-	cRect = gw->constrainSize (desiredSlot);
+	cRect = gw->constrainSize (*desiredSlot);
     }
     else
 	cRect.setGeometry (0, 0, 0, 0);
@@ -146,7 +146,17 @@
     xid = CompOption::getIntOptionNamed (option, "window");
     cw  = screen->findWindow (xid);
 
-    if (where == GridUnknown || screen->otherGrabExist ("move", NULL))
+    if (where == GridUnknown)
+    {
+	if (desiredSlot)
+	{
+	    delete desiredSlot;
+	    desiredSlot = NULL;
+	}
+
+	return false;
+    }
+    else if (screen->otherGrabExist ("move", NULL))
 	return false;
 
     if (cw)
@@ -155,6 +165,9 @@
 
 	GRID_WINDOW (cw);
 
+	if (!gw->allowGrid (where))
+	    return false;
+
 	if (gw->lastTarget != where)
 	    gw->resizeCount = 0;
 
@@ -199,6 +212,41 @@
 	    return true;
 	}
 
+        /* Should really be three different types here, but not enough time
+         * to implement that one FIXME */
+        if (!desiredSlot)
+        {
+            if (resize)
+            {
+                desiredSlot = new PaintableAnimatedGridRectangle ();
+ 
+                if (!desiredSlot)
+                    return false;
+            }
+            else
+            {
+                CompRect sbr = cw->serverBorderRect ();
+                if (compositingActive)
+                {
+                    CompRect sbr = cw->serverBorderRect ();
+                    desiredSlot = new PaintableAnimatedGridRectangle ();
+ 
+                    if (!desiredSlot)
+                        return false;
+                }
+                else
+                {
+                    desiredSlot = new PaintableAnimatedGridRectangle ();
+ 
+                    if (!desiredSlot)
+                        return false;
+                }
+ 
+                ((AnimatedGridRectangle *) desiredSlot)->setFrom (sbr);
+            }
+        }
+
+
 	/* Convention:
 	 * xxxSlot include decorations (it's the screen area occupied)
 	 * xxxRect are undecorated (it's the constrained position
@@ -206,15 +254,15 @@
 	 */
 
 	/* slice and dice to get desired slot - including decorations */
-	desiredSlot.setY (workarea.y () + props.gravityDown *
+	desiredSlot->setY (workarea.y () + props.gravityDown *
 			  (workarea.height () / props.numCellsY));
-	desiredSlot.setHeight (workarea.height () / props.numCellsY);
-	desiredSlot.setX (workarea.x () + props.gravityRight *
+	desiredSlot->setHeight (workarea.height () / props.numCellsY);
+	desiredSlot->setX (workarea.x () + props.gravityRight *
 			  (workarea.width () / props.numCellsX));
-	desiredSlot.setWidth (workarea.width () / props.numCellsX);
+	desiredSlot->setWidth (workarea.width () / props.numCellsX);
 
 	/* Adjust for constraints and decorations */
-	desiredRect = gw->constrainSize (desiredSlot).subtractBorders (cw);
+	desiredRect = gw->constrainSize (*desiredSlot).subtractBorders (cw);
 	/* Get current rect not including decorations */
 	currentRect.setGeometry (cw->serverX (), cw->serverY (),
 				 cw->serverWidth (),
@@ -243,8 +291,8 @@
 		switch (gw->resizeCount)
 		{
 		    case 1:
-			desiredSlot.setWidth (slotWidth66);
-			desiredSlot.setX (workarea.x () +
+			desiredSlot->setWidth (slotWidth66);
+			desiredSlot->setX (workarea.x () +
 					  props.gravityRight * slotWidth33);
 			gw->resizeCount++;
 			break;
@@ -252,20 +300,20 @@
 			gw->resizeCount++;
 			break;
 		    case 3:
-			desiredSlot.setWidth (slotWidth33);
-			desiredSlot.setX (workarea.x () +
+			desiredSlot->setWidth (slotWidth33);
+			desiredSlot->setX (workarea.x () +
 					  props.gravityRight * slotWidth66);
 			gw->resizeCount++;
 			break;
 		    case 4:
-			desiredSlot.setWidth (slotWidth25);
-			desiredSlot.setX (workarea.x () +
+			desiredSlot->setWidth (slotWidth25);
+			desiredSlot->setX (workarea.x () +
 					  props.gravityRight * slotWidth75);
 			gw->resizeCount++;
 			break;
 		    case 5:
-			desiredSlot.setWidth (slotWidth75);
-			desiredSlot.setX (workarea.x () +
+			desiredSlot->setWidth (slotWidth75);
+			desiredSlot->setX (workarea.x () +
 					  props.gravityRight * slotWidth25);
 			gw->resizeCount++;
 			break;
@@ -284,27 +332,27 @@
 		switch (gw->resizeCount)
 		{
 		    case 1:
-			desiredSlot.setWidth (workarea.width () -
+			desiredSlot->setWidth (workarea.width () -
 					     (slotWidth17 * 2));
-			desiredSlot.setX (workarea.x () + slotWidth17);
+			desiredSlot->setX (workarea.x () + slotWidth17);
 			gw->resizeCount++;
 			break;
 		    case 2:
-			desiredSlot.setWidth ((slotWidth25 * 2) +
+			desiredSlot->setWidth ((slotWidth25 * 2) +
 					      (slotWidth17 * 2));
-			desiredSlot.setX (workarea.x () +
+			desiredSlot->setX (workarea.x () +
 					 (slotWidth25 - slotWidth17));
 			gw->resizeCount++;
 			break;
 		    case 3:
-			desiredSlot.setWidth ((slotWidth25 * 2));
-			desiredSlot.setX (workarea.x () + slotWidth25);
+			desiredSlot->setWidth ((slotWidth25 * 2));
+			desiredSlot->setX (workarea.x () + slotWidth25);
 			gw->resizeCount++;
 			break;
 		    case 4:
-			desiredSlot.setWidth (slotWidth33 -
+			desiredSlot->setWidth (slotWidth33 -
 			    (cw->border ().left + cw->border ().right));
-			desiredSlot.setX (workarea.x () + slotWidth33);
+			desiredSlot->setX (workarea.x () + slotWidth33);
 			gw->resizeCount++;
 			break;
 		    case 5:
@@ -318,7 +366,7 @@
 	    if (gw->resizeCount == 6)
 		gw->resizeCount = 1;
 
-	    desiredRect = gw->constrainSize (desiredSlot).subtractBorders (cw);
+	    desiredRect = gw->constrainSize (*desiredSlot).subtractBorders (cw);
 	}
 
 	/* TODO: animate move+resize */
@@ -336,6 +384,9 @@
 	    if (cw->mapNum ())
 		cw->sendSyncRequest ();
 
+		delete desiredSlot;
+		desiredSlot = NULL;
+		
 	    cw->configureXWindow (flags, &xwc);
 	    gw->isGridResized = true;
 	    gw->isGridMaximized = false;
@@ -347,48 +398,102 @@
     return true;
 }
 
-void
-GridScreen::glPaintRectangle (const GLScreenPaintAttrib &sAttrib,
-			      const GLMatrix            &transform,
-			      CompOutput                *output)
-{
-    CompRect rect;
-    GLMatrix sTransform (transform);
-
-    getPaintRectangle (rect);
-
-    glPushMatrix ();
-
-    sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
-
-    glLoadMatrixf (sTransform.getMatrix ());
-
-    glDisableClientState (GL_TEXTURE_COORD_ARRAY);
-    glEnable (GL_BLEND);
-
-    /* fill rectangle */
-    glColor4usv (optionGetFillColor ());
-    glRecti (rect.x1 (), rect.y2 (), rect.x2 (), rect.y1 ());
-
-    /* Set outline rect smaller to avoid damage issues */
-    rect.setGeometry (rect.x () + 1, rect.y () + 1,
-		      rect.width () - 2, rect.height () - 2);
-
-    /* draw outline */
-    glColor4usv (optionGetOutlineColor ());
-    glLineWidth (2.0);
-    glBegin (GL_LINE_LOOP);
-    glVertex2i (rect.x1 (), rect.y1 ());
-    glVertex2i (rect.x2 (), rect.y1 ());
-    glVertex2i (rect.x2 (), rect.y2 ());
-    glVertex2i (rect.x1 (), rect.y2 ());
-    glEnd ();
-
-    /* clean up */
-    glColor4usv (defaultColor);
-    glDisable (GL_BLEND);
-    glEnableClientState (GL_TEXTURE_COORD_ARRAY);
-    glPopMatrix ();
+CompRect
+AnimatedGridRectangle::current ()
+{
+    /* Expand edges out to destination rect based on progress */
+ 
+    CompRect ret = mFrom;
+
+    ret.setTop (floor (mFrom.top () + (top () - mFrom.top ()) * mProgress));
+    ret.setLeft (floor (mFrom.left () + (left () - mFrom.left ()) * mProgress));
+    ret.setRight (floor (mFrom.right () + (right () - mFrom.right ()) * mProgress));
+    ret.setBottom (floor (mFrom.bottom () + (bottom () - mFrom.bottom ()) * mProgress));
+
+    return ret;
+}
+
+float
+AnimatedGridRectangle::progress ()
+{
+    return mProgress;
+}
+
+void
+AnimatedGridRectangle::setTime (unsigned int t)
+{
+    mTime = t;
+}
+
+void
+AnimatedGridRectangle::setFrom (CompRect &f)
+{
+    mFrom = f;
+}
+
+void
+AnimatedGridRectangle::setProgress (float p)
+{
+    mProgress = p;
+
+    if (mProgress >= 1.0f)
+	mProgress = 1.0f;
+    else if (mProgress <= 0.0f)
+	mProgress = 0.0f;
+}
+
+void
+AnimatedGridRectangle::reset ()
+{
+    mProgress = 0.0f;
+}
+
+void
+PaintableAnimatedGridRectangle::paint (const GLMatrix &mat)
+{
+    CompRect outline;
+    CompRect fill = current ();
+    GridScreen *gScreen = GridScreen::get (screen);
+ 
+    if (gScreen->optionGetIndicatorType () == GridOptions::IndicatorTypeOutline)
+    {
+	glPushMatrix ();
+
+	glLoadMatrixf (mat.getMatrix ());
+
+	glDisableClientState (GL_TEXTURE_COORD_ARRAY);
+	glEnable (GL_BLEND);
+
+	/* fill rectangle */
+	glColor4f ((float) gScreen->optionGetFillColorRed () / 65535.0f,
+		   (float) gScreen->optionGetFillColorGreen () / 65535.0f,
+		   (float) gScreen->optionGetFillColorBlue () / 65535.0f,
+		   ((float) gScreen->optionGetFillColorAlpha () / 65535.0f) * progress ());
+	glRecti (fill.x1 (), fill.y2 (), fill.x2 (), fill.y1 ());
+
+	/* Set outline rect smaller to avoid damage issues */
+	outline.setGeometry (fill.x () + 1, fill.y () + 1,
+			  fill.width () - 2,fill. height () - 2);
+
+	/* draw outline */
+	glColor4f ((float) gScreen->optionGetOutlineColorRed () / 65535.0f,
+		   (float) gScreen->optionGetOutlineColorGreen () / 65535.0f,
+		   (float) gScreen->optionGetOutlineColorBlue () / 65535.0f,
+		   ((float) gScreen->optionGetOutlineColorAlpha () / 65535.0f) * progress ());
+	glLineWidth (2.0);
+	glBegin (GL_LINE_LOOP);
+	glVertex2i (outline.x1 (), outline.y1 ());
+	glVertex2i (outline.x2 (), outline.y1 ());
+	glVertex2i (outline.x2 (), outline.y2 ());
+	glVertex2i (outline.x1 (), outline.y2 ());
+	glEnd ();
+
+	/* clean up */
+	glColor4usv (defaultColor);
+	glDisable (GL_BLEND);
+	glEnableClientState (GL_TEXTURE_COORD_ARRAY);
+	glPopMatrix ();
+    }
 }
 
 bool
@@ -398,11 +503,18 @@
 			   CompOutput                *output,
 			   unsigned int              mask)
 {
-    bool status;
-
-    status = glScreen->glPaintOutput (attrib, matrix, region, output, mask);
-
-    glPaintRectangle (attrib, matrix, output);
+    bool     status;
+
+    if (desiredSlot && optionGetDrawIndicator ())
+    {
+	GLMatrix sTransform (matrix);
+	status = glScreen->glPaintOutput (attrib, matrix, region, output, mask);
+
+	sTransform.toScreenSpace (output, -DEFAULT_Z_CAMERA);
+	((PaintableAnimatedGridRectangle *) desiredSlot)->paint (sTransform);
+    }
+    else
+	status = glScreen->glPaintOutput (attrib, matrix, region, output, mask);
 
     return status;
 }
@@ -452,6 +564,8 @@
     CompOutput	       out;
     CompOption::Vector opts;
     CompOption::Value  v = CompOption::Value ((int) mGrabWindow->id ());
+    CompRect	       *edgeBox = NULL;
+    float	           edgeDist; /* interpolated 0.0f -> 1.0f based on distance */
 
     screen->handleEvent (event);
 
@@ -469,31 +583,182 @@
     /* Bottom Left */
     if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold()) &&
         pointerX < out.x () + optionGetLeftEdgeThreshold())
+    {
+	float xd, yd;
+	unsigned int xptr = (out.x ()) + pointerX;
+	unsigned int yptr = (out.y () + out.height ()) - pointerY;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetBottomEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x (), out.y () + (out.height () - mGrabWindow->height ()),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = (xd + yd) / 2.0f;
 	edge = BottomLeft;
+    }
     /* Bottom Right */
     else if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold()) &&
              pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold()))
+    {
+	float xd, yd;
+	unsigned int xptr = (out.x () + out.width ()) - pointerX;
+	unsigned int yptr = (out.y () + out.height ()) - pointerY;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetRightEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetBottomEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
+				    out.y () + (out.height () - mGrabWindow->height ()),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = (xd + yd) / 2.0f;
 	edge = BottomRight;
+    }
     /* Top Left */
     else if (pointerY < optionGetTopEdgeThreshold() &&
 	    pointerX < optionGetLeftEdgeThreshold())
+    {
+	float xd, yd;
+	unsigned int xptr = (out.x ()) + pointerX;
+	unsigned int yptr = (out.y ()) + pointerY;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x (),
+				    out.y (),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = (xd + yd) / 2.0f;
 	edge = TopLeft;
+    }
     /* Top Right */
     else if (pointerY < out.y () + optionGetTopEdgeThreshold() &&
              pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold()))
+    {
+	float xd, yd;
+	unsigned int xptr = (out.x () + out.width ()) - pointerX;
+	unsigned int yptr = (out.y ()) + pointerY;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetRightEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
+				    out.y (),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = (xd + yd) / 2.0f;
 	edge = TopRight;
+    }
     /* Left */
     else if (pointerX < out.x () + optionGetLeftEdgeThreshold())
+    {
+	float xd;
+	unsigned int xptr = (out.x ()) + pointerX;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetLeftEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x (),
+				    out.y () + (out.height () / 2.0f) - mGrabWindow->height () / 2.0f,
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = xd;
 	edge = Left;
+    }
     /* Right */
     else if (pointerX > (out.x () + out.width () - optionGetRightEdgeThreshold()))
+    {
+	float xd;
+	unsigned int xptr = (out.x () + out.width ()) - pointerX;
+
+	if (xptr)
+	    xd = MIN (((float) xptr / (float) optionGetRightEdgeThreshold ()), 1.0f);
+	else
+	    xd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x () + (out.width () - mGrabWindow->width ()),
+				    out.y () + (out.height () / 2.0f) - mGrabWindow->height () / 2.0f,
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = xd;
 	edge = Right;
+    }
     /* Top */
     else if (pointerY < out.y () + optionGetTopEdgeThreshold())
+    {
+	float yd;
+	unsigned int yptr = (out.y ()) + pointerY;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetTopEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x () + (out.width () / 2.0f) - mGrabWindow->width () / 2.0f,
+				    out.y (),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = yd;
 	edge = Top;
+    }
     /* Bottom */
     else if (pointerY > (out.y () + out.height () - optionGetBottomEdgeThreshold()))
+    {
+	float yd;
+	unsigned int yptr = (out.y () + out.width ()) - pointerY;
+
+	if (yptr)
+	    yd = MIN (((float) yptr / (float) optionGetBottomEdgeThreshold ()), 1.0f);
+	else
+	    yd = 0.0f;
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromEdge)
+	    edgeBox = new CompRect (out.x () + (out.width () / 2.0f) - mGrabWindow->width () / 2.0f,
+				    out.y () + (out.height () - mGrabWindow->height ()),
+				    mGrabWindow->width (), mGrabWindow->height ());
+
+	edgeDist = yd;
 	edge = Bottom;
+    }
     /* No Edge */
     else
 	edge = NoEdge;
@@ -504,29 +769,71 @@
 			    (screen->outputDeviceForPoint (pointerX, pointerY));
     if (lastWorkarea != currentWorkarea)
     {
+	CompRect old;
+
+	if (desiredSlot)
+	    old = *desiredSlot;
+
 	lastWorkarea = currentWorkarea;
 
 	if (compositingActive && cScreen)
-	    cScreen->damageRegion (desiredSlot);
+	    cScreen->damageRegion (old);
 
 	initiateCommon (0, 0, opts, edgeToGridType (), false);
 
+	if (edgeBox && desiredSlot)
+	{
+	    desiredSlot->setFrom (*edgeBox);
+	    delete edgeBox;
+	}
+
 	if (compositingActive && cScreen)
-	    cScreen->damageRegion (desiredSlot);
+	    cScreen->damageRegion (desiredSlot ? *desiredSlot : old);
     }
 
     /* Detect edge region change */
     if (lastEdge != edge)
     {
+	CompRect old;
+
+	if (desiredSlot)
+	{
+	    ((AnimatedGridRectangle *) desiredSlot)->reset ();
+	    old = *desiredSlot;
+	}
+
 	lastEdge = edge;
 
 	if (compositingActive && cScreen)
-	    cScreen->damageRegion (desiredSlot);
+	    cScreen->damageRegion (old);
 
 	initiateCommon (0, 0, opts, edgeToGridType (), false);
 
+	if (edgeBox && desiredSlot)
+	{
+	    desiredSlot->setFrom (*edgeBox);
+	    delete edgeBox;
+	}
+
 	if (compositingActive && cScreen)
-	    cScreen->damageRegion (desiredSlot);
+	    cScreen->damageRegion (desiredSlot ? *desiredSlot : old);
+    }
+
+    /* The closer the user gets to the edge, the more progress should go up */
+    if (desiredSlot)
+    {
+	CompRect damage;
+	CompRect sbr = mGrabWindow->serverBorderRect ();
+
+	damage = ((AnimatedGridRectangle *) desiredSlot)->current ();
+	cScreen->damageRegion (damage);
+
+	if (optionGetIndicatorDirection () == GridOptions::IndicatorDirectionFromWindow)
+	    ((AnimatedGridRectangle *) desiredSlot)->setFrom (sbr);
+	((AnimatedGridRectangle *) desiredSlot)->setProgress (1.0f - edgeDist);
+
+	damage = ((AnimatedGridRectangle *) desiredSlot)->current ();
+	cScreen->damageRegion (damage);
     }
 
     GRID_WINDOW (mGrabWindow);
@@ -540,6 +847,24 @@
 	    restoreWindow (0, 0, opts);
 }
 
+bool
+GridWindow::glDraw (const GLMatrix            &transform,
+		    GLFragment::Attrib	      &fragment,
+		    const CompRegion          &region,
+		    unsigned int              mask)
+{
+    CompRegion nRegion = region;
+
+    if (gScreen->desiredSlot)
+    {
+	nRegion = nRegion.united (gScreen->desiredSlot->current ());
+
+	gScreen->desiredSlot->paint (transform);
+    }
+
+    return glWindow->glDraw (transform, fragment, nRegion, mask);
+ }
+
 void
 GridWindow::grabNotify (int          x,
 			int          y,
@@ -550,7 +875,12 @@
     {
 	screen->handleEventSetEnabled (gScreen, true);
 	if (compositingActive)
-	    gScreen->glScreen->glPaintOutputSetEnabled (gScreen, true);
+	{
+	    if (gScreen->optionGetBehindWindow ())
+		glWindow->glDrawSetEnabled (this, true);
+	    else
+		gScreen->glScreen->glPaintOutputSetEnabled (gScreen, true);
+	}
 	gScreen->mGrabWindow = window;
 	pointerBufDx = pointerBufDy = 0;
 
@@ -574,6 +904,7 @@
     if (window == gScreen->mGrabWindow)
     {
 	CompOption::Vector opts;
+    CompRect           damage = gScreen->desiredSlot ? *gScreen->desiredSlot : CompRect (0, 0, 0, 0);
 	CompOption::Value  v = CompOption::Value ((int) gScreen->mGrabWindow->id ());
 
 	opts.resize (1);
@@ -587,8 +918,11 @@
 
 	if (compositingActive)
 	{
-	    gScreen->glScreen->glPaintOutputSetEnabled (gScreen, false);
-	    gScreen->cScreen->damageRegion (gScreen->desiredSlot);
+	    if (gScreen->optionGetBehindWindow ())
+		glWindow->glDrawSetEnabled (this, false);
+	    else
+		gScreen->glScreen->glPaintOutputSetEnabled (gScreen, false);
+	    gScreen->cScreen->damageRegion (damage);
 	}
 
 	gScreen->mGrabWindow = NULL;
@@ -654,6 +988,7 @@
 
 GridScreen::GridScreen (CompScreen *screen) :
     PluginClassHandler<GridScreen, CompScreen> (screen),
+    desiredSlot (NULL),
     mGrabWindow (NULL)
 {
     if (compositingActive)
@@ -661,8 +996,7 @@
 	cScreen = CompositeScreen::get (screen);
 	glScreen = GLScreen::get (screen);
 
-	CompositeScreenInterface::setHandler (cScreen, false);
-	GLScreenInterface::setHandler (glScreen, false);
+	ScreenInterface::setHandler (screen, false);
     }
 
     ScreenInterface::setHandler (screen, false);
@@ -696,6 +1030,7 @@
 GridWindow::GridWindow (CompWindow *window) :
     PluginClassHandler <GridWindow, CompWindow> (window),
     window (window),
+    glWindow (GLWindow::get (window)),
     gScreen (GridScreen::get (screen)),
     isGridResized (false),
     isGridMaximized (false),
@@ -705,6 +1040,7 @@
     lastTarget (GridUnknown)
 {
     WindowInterface::setHandler (window);
+    GLWindowInterface::setHandler (glWindow, false);
 }
 
 /* Initial plugin init function called. Checks to see if we are ABI

=== modified file 'plugins/grid/src/grid.h'
--- plugins/grid/src/grid.h	2011-04-05 13:32:45 +0000
+++ plugins/grid/src/grid.h	2011-04-06 14:53:28 +0000
@@ -28,6 +28,8 @@
 #include <composite/composite.h>
 #include <opengl/opengl.h>
 
+#include <cmath>
+
 #include "grid_options.h"
 
 #define SNAPOFF_THRESHOLD 50
@@ -85,6 +87,89 @@
 	GridRectangle addBorders (CompWindow *w) const;
 };
 
+class Paintable
+{
+    public:
+
+	Paintable ()
+	{
+	};
+
+	virtual void paint (const GLMatrix &mat) = 0;
+};
+
+class AnimatedGridRectangle :
+    public GridRectangle
+{
+    public:
+
+	AnimatedGridRectangle () :
+	    GridRectangle::GridRectangle (),
+	    mFrom (CompRect (0, 0, 0, 0)),
+	    mProgress (0.0f),
+	    mTime (300)
+	{
+	};
+
+	AnimatedGridRectangle (const GridRectangle &r) :
+	    GridRectangle::GridRectangle (r),
+	    mFrom (CompRect (0, 0, 0, 0)),
+	    mProgress (0.0f),
+	    mTime (300)
+	{
+	};
+
+	AnimatedGridRectangle (const CompRect &r) :
+	    GridRectangle::GridRectangle (r),
+	    mFrom (CompRect (0, 0, 0, 0)),
+	    mProgress (0.0f),
+	    mTime (300)
+	{
+	};
+
+	CompRect current ();
+	float    progress ();
+
+	void setFrom (CompRect &);
+	void setProgress (float);
+	void reset ();
+	void setTime (unsigned int);
+
+    private:
+
+	CompRect mFrom;
+	float	 mProgress;
+
+	unsigned int mTime;
+};
+
+class PaintableAnimatedGridRectangle :
+    public Paintable,
+    public AnimatedGridRectangle
+{
+    public:
+
+	PaintableAnimatedGridRectangle () :
+	    Paintable::Paintable (),
+	    AnimatedGridRectangle::AnimatedGridRectangle ()
+	{
+	};
+
+	PaintableAnimatedGridRectangle (const GridRectangle &r) :
+	    Paintable::Paintable (),
+	    AnimatedGridRectangle::AnimatedGridRectangle (r)
+	{
+	};
+
+	PaintableAnimatedGridRectangle (const CompRect &r) :
+	    Paintable::Paintable (),
+	    AnimatedGridRectangle::AnimatedGridRectangle (r)
+	{
+	};
+
+	virtual void paint (const GLMatrix &mat);
+};
+
 class GridScreen :
     public ScreenInterface,
     public CompositeScreenInterface,
@@ -98,7 +183,7 @@
 	CompositeScreen *cScreen;
 	GLScreen        *glScreen;
 
-	GridRectangle desiredSlot;
+        PaintableAnimatedGridRectangle *desiredSlot;
 	CompRect workarea, currentRect,
 		 desiredRect, lastWorkarea, currentWorkarea;
 	GridProps props;
@@ -110,9 +195,6 @@
 	bool initiateCommon (CompAction*, CompAction::State,
 			     CompOption::Vector&, GridType, bool);
 
-	void glPaintRectangle (const GLScreenPaintAttrib&,
-			       const GLMatrix&, CompOutput *);
-
 	bool glPaintOutput (const GLScreenPaintAttrib &,
 			    const GLMatrix &, const CompRegion &,
 			    CompOutput *, unsigned int);
@@ -132,12 +214,14 @@
 
 class GridWindow :
     public WindowInterface,
+    public GLWindowInterface,
     public PluginClassHandler <GridWindow, CompWindow>
 {
     public:
 
 	GridWindow (CompWindow *);
 	CompWindow *window;
+	GLWindow   *glWindow;
 	GridScreen *gScreen;
 
 	bool isGridResized;
@@ -154,6 +238,12 @@
 	GridRectangle
 	constrainSize (const GridRectangle & slot);
 
+	bool
+	glDraw (const GLMatrix            &transform,
+		GLFragment::Attrib	  &fragment,
+		const CompRegion          &region,
+		unsigned int              mask);
+
 	void grabNotify (int, int, unsigned int, unsigned int);
 
 	void ungrabNotify ();