Rewrote tile's operation logic:

- Don't base the logic on viewports. This logic breaks whenever a tiled window is moved to another viewport.
- Get rid of linked lists to manage tiled windows.
- Clean ups.

1 files changed, 650 insertions, 848 deletions

diff --git a/src/tile.c b/src/tile.c
index a64a621..953e1c7 100644
--- a/src/tile.c
+++ b/src/tile.c
@@ -36,383 +36,334 @@
 #include <compiz.h>
 #include "tile_options.h"
 
-#define GET_TILE_DISPLAY(d) ((TileDisplay *) (d)->privates[displayPrivateIndex].ptr)
-#define TILE_DISPLAY(d) TileDisplay *td = GET_TILE_DISPLAY (d)
-
-#define GET_TILE_SCREEN(s, td) ((TileScreen *) (s)->privates[(td)->screenPrivateIndex].ptr)
-#define TILE_SCREEN(s) TileScreen *ts = GET_TILE_SCREEN (s, GET_TILE_DISPLAY (s->display))
-
-#define GET_TILE_WINDOW(w, ts) ((TileWindow *) (w)->privates[(ts)->windowPrivateIndex].ptr)
-#define TILE_WINDOW(w) TileWindow *tw = GET_TILE_WINDOW (w, GET_TILE_SCREEN (w->screen, GET_TILE_DISPLAY (w->screen->display)))
-
-#define THIS_VIEWPORT(s) (ts->viewports[(((s)->hsize * (s)->y) + (s)->x)])
-
-// Minimal width and height under which the window cant be resized
-#define MINIMUM_WIDTH 														25
-#define MINIMUM_HEIGHT														10
-
 static int displayPrivateIndex = 0;
 
+typedef enum {
+    NoAnimation = 0,
+    Animating,
+    AnimationDone
+} WindowAnimationType;
+
 typedef struct _TileDisplay {
-	int screenPrivateIndex;
+    int screenPrivateIndex;
 } TileDisplay;
 
-typedef struct _TileViewport {
-	TileTileToggleTypeEnum currentTileType; // which kind of tiling is applied to windows on viewport
-	int tiledCount; // number of windows
-	CompWindow *firstTiled; // pointer to first tiled window
-} TileViewport;
-
 typedef struct _TileScreen {
-	TileViewport *viewports;
-	Bool isResizing; // whether there any windows on screen being resized
-	int oneDuration; // duration of animation for one window
-	int msResizing; // number of ms elapsed from start of resizing animation
-
-	PaintWindowProc paintWindow;
-	WindowResizeNotifyProc windowResizeNotify;
-	PreparePaintScreenProc preparePaintScreen;
-	DonePaintScreenProc donePaintScreen;
-	PaintScreenProc paintScreen;
-	SetScreenOptionProc setScreenOption;
-
-	int windowPrivateIndex;
+    int windowPrivateIndex;
+
+    Bool isAnimating; 
+    int oneDuration; // duration of animation for one window
+    int msResizing; // number of ms elapsed from start of resizing animation
+    TileTileToggleTypeEnum tileType;
+
+    PaintWindowProc paintWindow;
+    WindowResizeNotifyProc windowResizeNotify;
+    PreparePaintScreenProc preparePaintScreen;
+    DonePaintScreenProc donePaintScreen;
+    PaintScreenProc paintScreen;
 } TileScreen;
 
 typedef struct _TileWindow {
-	CompWindow *next; // next window for tiling
-	CompWindow *prev; // previous window for tiling
+    Bool isTiled; 
 
-	Bool resizedAlready; // whether the animation already resized the window
+    XRectangle savedCoords;
+    XRectangle prevCoords;
+    XRectangle newCoords;
+    unsigned int savedMaxState;
+    Bool savedValid;
 
-	// coords used in animation, before last resize
-	int previousX;
-	int previousY;
-	int previousWidth;
-	int previousHeight;
+    Bool alreadyResized;
 
-	// coords used when configuring window in middle of animation
-	int futureX;
-	int futureY;
-	int futureWidth;
-	int futureHeight;
+    WindowAnimationType animationType;
+    unsigned int animationNum;
 
-	Bool isResizing; // tells if the window is being resized
+    GLushort outlineColor[3];
+} TileWindow;
 
-	GLushort outlineColor[3];
-	int prevState;
+#define GET_TILE_DISPLAY(d) ((TileDisplay *) (d)->privates[displayPrivateIndex].ptr)
+#define TILE_DISPLAY(d) TileDisplay *td = GET_TILE_DISPLAY (d)
 
-	// coords before whole tiling
-	int originalX;
-	int originalY;
-	int originalWidth;
-	int originalHeight;
-} TileWindow;
+#define GET_TILE_SCREEN(s, td) ((TileScreen *) (s)->privates[(td)->screenPrivateIndex].ptr)
+#define TILE_SCREEN(s) TileScreen *ts = GET_TILE_SCREEN (s, GET_TILE_DISPLAY (s->display))
 
-static Bool placeWindow(CompWindow *w, int x, int y, int width, int height);
-static Bool isTileWindow(CompWindow *w);
-static Bool setWindowFutureSize(CompWindow *w);
+#define GET_TILE_WINDOW(w, ts) ((TileWindow *) (w)->privates[(ts)->windowPrivateIndex].ptr)
+#define TILE_WINDOW(w) TileWindow *tw = GET_TILE_WINDOW (w, GET_TILE_SCREEN (w->screen, GET_TILE_DISPLAY (w->screen->display)))
 
-int current = 0;
+
+static Bool placeWindow(CompWindow *w, int x, int y, int width, int height);
+static Bool tileSetNewWindowSize(CompWindow *w);
 
 // window painting function, draws animation
 static Bool tilePaintWindow(CompWindow * w, 
-							const WindowPaintAttrib * attrib,
-							const CompTransform * transform, 
-							Region region, unsigned int mask)
+			    const WindowPaintAttrib * attrib,
+			    const CompTransform * transform, 
+			    Region region, unsigned int mask)
 {
-	CompScreen *s = w->screen;
-	Bool status;
-	Bool dontDraw = FALSE;
+    CompScreen *s = w->screen;
+    Bool status;
+    Bool dontDraw = FALSE;
 
-	TILE_WINDOW(w);
-	TILE_SCREEN(s);
+    TILE_WINDOW(w);
+    TILE_SCREEN(s);
 		
-	if (tw->isResizing)
+    if (tw->animationType != NoAnimation)
+    {
+	WindowPaintAttrib wAttrib = *attrib;
+	CompTransform wTransform = *transform;
+	float animationDuration = tileGetAnimationDuration(s->display);
+
+	switch (tileGetAnimateType(s->display))
 	{
-		WindowPaintAttrib wAttrib = *attrib;
-		CompTransform wTransform = *transform;
-		float animationDuration = tileGetAnimationDuration(s->display);
+	    /*
+	       Drop animation
+	       */
+	    case AnimateTypeDrop:
+		matrixRotate(&wTransform,
+			     100.0f / animationDuration * ts->msResizing - 100, 
+			     0.0f, 0.0f, 1.0f);
+		mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+		break;
+
+	    /*
+	       Zoom animation
+	       */
+	    case AnimateTypeZoom:
+		matrixTranslate(&wTransform, 0, 0, 
+				-1 + ts->msResizing / animationDuration);
+		mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+		break;
+
+	    /*
+    	       Slide animation
+	       */
+	    case AnimateTypeSlide:
+		if (ts->msResizing < 0.75 * animationDuration)
+		    wAttrib.opacity = OPAQUE / 2;
+		else
+		    wAttrib.opacity = OPAQUE / 2 + OPAQUE / 2 * 
+			(ts->msResizing - 0.75 * animationDuration) /
+			(0.25 * animationDuration);
 
-		switch (tileGetAnimateType(s->display))
+		if (ts->msResizing > tw->animationNum * ts->oneDuration) 
 		{
-			/*
-				Drop animation
-			*/
-			case AnimateTypeDrop:
-				matrixRotate(&wTransform,
-							 100.0f / animationDuration * ts->msResizing - 100, 
-							 0.0f, 0.0f, 1.0f);
-				mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				break;
-
-			/*
-				Zoom animation
-			*/
-			case AnimateTypeZoom:
-				matrixTranslate(&wTransform, 0, 0, 
-								-1 + ts->msResizing / animationDuration);
-				mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				break;
-
-			/*
-				Slide animation
-			*/
-			case AnimateTypeSlide:
-				if (ts->msResizing < 0.75 * animationDuration)
-					wAttrib.opacity = OPAQUE / 2;
-				else
-					wAttrib.opacity = OPAQUE / 2 + OPAQUE / 2 * 
-						(ts->msResizing - 0.75 * animationDuration) /
-						(0.25 * animationDuration);
-			
-				if (ts->msResizing > current * ts->oneDuration) 
-					// windows that have animation finished already
-				{
-					mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				}
-				else if (ts->msResizing > (current-1)*ts->oneDuration && ts->msResizing < current*ts->oneDuration) 
-					// animation in progress
-				{
-					int thisDur; // ms spent animating this window
-					for(thisDur = ts->msResizing;thisDur > ts->oneDuration;thisDur -= ts->oneDuration);
-
-					if (current % 2)
-						matrixTranslate(&wTransform, -s->width + 
-								s->width * (float)thisDur / ts->oneDuration, 
-								0, 0);
-					else
-						matrixTranslate(&wTransform, s->width - 
-								s->width * (float)thisDur / ts->oneDuration, 
-								0, 0);
-
-					mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				}
-				else
-					dontDraw = TRUE;
-			break;
-
-			/*
-				Outline animation
-			*/
-			case AnimateTypeOutline:
-				dontDraw = TRUE;
-				break;
-
-			/*
-				Fade animation
-			*/
-			case AnimateTypeFade:
-				// first half of the animation, fade out
-				if (ts->msResizing < 0.40f * animationDuration)
-				{
-					wAttrib.opacity = OPAQUE - OPAQUE * 
-						ts->msResizing / (0.40f * animationDuration);
-					mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				}
-				else if (ts->msResizing > 0.40f * animationDuration && !tw->resizedAlready) 
-				{
-					// resize window right after first half
-					setWindowFutureSize(w);
-					dontDraw = TRUE;
-				}
-				else if (ts->msResizing > 0.60f * animationDuration) 
-					// second half of animation, fade in
-				{
-					wAttrib.opacity = OPAQUE * 
-						(ts->msResizing - 0.60f * animationDuration) / 
-						(0.40f * animationDuration);
-					mask |= PAINT_WINDOW_TRANSFORMED_MASK;
-				}
-				break;
-
-			default:
-				break;
+		    /* animation finished */
+		    tw->animationType = AnimationDone; 
+		}
+		else if (ts->msResizing > (tw->animationNum - 1) * ts->oneDuration)
+		{
+		    int thisDur; // ms spent animating this window
+		    thisDur = ts->msResizing % ts->oneDuration;
+
+		    if (tw->animationNum % 2)
+			matrixTranslate(&wTransform, s->width - 
+					s->width * (float)thisDur / ts->oneDuration, 
+					0, 0);
+		    else
+			matrixTranslate(&wTransform, -s->width + 
+					s->width * (float)thisDur / ts->oneDuration, 
+					0, 0);
+
+		    mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+		}
+		else
+		    dontDraw = TRUE;
+		break;
+	    /*
+    	       Outline animation
+	       */
+	    case AnimateTypeOutline:
+		dontDraw = TRUE;
+		break;
+
+	    /*
+    	       Fade animation
+	       */
+	    case AnimateTypeFade:
+		// first half of the animation, fade out
+		if (ts->msResizing < 0.40f * animationDuration)
+		{
+		    wAttrib.opacity = OPAQUE - OPAQUE * 
+			ts->msResizing / (0.40f * animationDuration);
+		    mask |= PAINT_WINDOW_TRANSFORMED_MASK;
+		}
+		else if (ts->msResizing > 0.40f * animationDuration && !tw->alreadyResized) 
+		{
+		    // resize window right after first half
+		    tileSetNewWindowSize(w);
+		    dontDraw = TRUE;
+		}
+		else if (ts->msResizing > 0.60f * animationDuration) 
+    		    // second half of animation, fade in
+		{
+		    wAttrib.opacity = OPAQUE * 
+			(ts->msResizing - 0.60f * animationDuration) / 
+			(0.40f * animationDuration);
+		    mask |= PAINT_WINDOW_TRANSFORMED_MASK;
 		}
+		break;
 
-		if (dontDraw)
-			mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
+    	    default:
+		break;
+	}
 
-		UNWRAP(ts, s, paintWindow);
-		status = (*s->paintWindow) (w, &wAttrib, &wTransform, region, mask);
-		WRAP(ts, s, paintWindow, tilePaintWindow);
+	if (dontDraw)
+	    mask |= PAINT_WINDOW_NO_CORE_INSTANCE_MASK;
 
-		current -= 1;
-	}
-	else // paint window as always
-	{
-		UNWRAP(ts, s, paintWindow);
-		status = (*s->paintWindow) (w, attrib, transform, region, mask);
-		WRAP(ts, s, paintWindow, tilePaintWindow);
-	}
+	UNWRAP(ts, s, paintWindow);
+	status = (*s->paintWindow) (w, &wAttrib, &wTransform, region, mask);
+	WRAP(ts, s, paintWindow, tilePaintWindow);
+    }
+    else // paint window as always
+    {
+	UNWRAP(ts, s, paintWindow);
+	status = (*s->paintWindow) (w, attrib, transform, region, mask);
+	WRAP(ts, s, paintWindow, tilePaintWindow);
+    }
 
-	return status;
+    return status;
 }
 
 static void tilePreparePaintScreen(CompScreen * s, int msSinceLastPaint)
 {
-	TILE_SCREEN(s);
-	current = THIS_VIEWPORT(s).tiledCount;
+    TILE_SCREEN(s);
 
-	// add spent time
-	if (ts->isResizing)
-		ts->msResizing += msSinceLastPaint;
+    // add spent time
+    if (ts->isAnimating)
+	ts->msResizing += msSinceLastPaint;
 	
-	// Check if the animation hasnt finished yet
-	if (ts->isResizing && ts->msResizing > tileGetAnimationDuration(s->display))
+    // Check if the animation hasnt finished yet
+    if (ts->isAnimating && ts->msResizing > tileGetAnimationDuration(s->display))
+    {
+	CompWindow *w;
+	for (w = s->windows; w; w = w->next)
 	{
-		CompWindow *w = THIS_VIEWPORT(s).firstTiled;
-		while (w)
-		{
-			TILE_WINDOW(w);
-			if (tw->isResizing)
-				tw->isResizing = FALSE;
-
-			w = tw->next;
-		}
-		ts->isResizing = FALSE;
-		ts->msResizing = 0;
+	    TILE_WINDOW(w);
+	    tw->animationType = NoAnimation;
 	}
 
-	UNWRAP(ts, s, preparePaintScreen);
-	(*s->preparePaintScreen) (s, msSinceLastPaint);
-	WRAP(ts, s, preparePaintScreen, tilePreparePaintScreen);
+	ts->isAnimating = FALSE;
+	ts->msResizing = 0;
+    }
+
+    UNWRAP(ts, s, preparePaintScreen);
+    (*s->preparePaintScreen) (s, msSinceLastPaint);
+    WRAP(ts, s, preparePaintScreen, tilePreparePaintScreen);
 }
 
 static void tileDonePaintScreen(CompScreen * s)
 {
-	TILE_SCREEN(s);
+    TILE_SCREEN(s);
 
-	if (ts->isResizing)
-		damageScreen(s);
+    if (ts->isAnimating)
+	damageScreen(s);
 
-	UNWRAP(ts, s, donePaintScreen);
-	(*s->donePaintScreen) (s);
-	WRAP(ts, s, donePaintScreen, tileDonePaintScreen);
+    UNWRAP(ts, s, donePaintScreen);
+    (*s->donePaintScreen) (s);
+    WRAP(ts, s, donePaintScreen, tileDonePaintScreen);
 }
 
 static Bool tilePaintScreen(CompScreen * s,
-							const ScreenPaintAttrib * sa,
-							const CompTransform		* transform,
-							Region region, int output, unsigned int mask)
+			    const ScreenPaintAttrib * sa,
+			    const CompTransform		* transform,
+			    Region region, int output, unsigned int mask)
 {
-	Bool status;
-	CompTransform sTransform = *transform;
+    Bool status;
+    CompTransform sTransform = *transform;
 
-	TILE_SCREEN(s);
+    TILE_SCREEN(s);
 
-	if (ts->isResizing)
-		mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
+    if (ts->isAnimating)
+	mask |= PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_MASK;
 
-	UNWRAP(ts, s, paintScreen);
-	status = (*s->paintScreen) (s, sa, transform, region, output, mask);
-	WRAP(ts, s, paintScreen, tilePaintScreen);
+    UNWRAP(ts, s, paintScreen);
+    status = (*s->paintScreen) (s, sa, transform, region, output, mask);
+    WRAP(ts, s, paintScreen, tilePaintScreen);
 
-	// Check if animation is enabled, there is resizing on screen and only outline should be drawn
+    // Check if animation is enabled, there is resizing on screen and only outline should be drawn
 
-	if (ts->isResizing && (tileGetAnimateType(s->display) == AnimateTypeOutline))
-	{
-		transformToScreenSpace(s, output, -DEFAULT_Z_CAMERA, &sTransform);
-		glPushMatrix();
-		glLoadMatrixf(sTransform.m);
-
-		glLineWidth(4.0f);
+    if (ts->isAnimating && (tileGetAnimateType(s->display) == AnimateTypeOutline))
+    {
+	CompWindow *w;
+	float animationDuration = tileGetAnimationDuration(s->display);
 
-		CompWindow *w = THIS_VIEWPORT(s).firstTiled;
-		float animationDuration = tileGetAnimationDuration(s->display);
+	transformToScreenSpace(s, output, -DEFAULT_Z_CAMERA, &sTransform);
+	glPushMatrix();
+	glLoadMatrixf(sTransform.m);
 
-		while (w && isTileWindow(w))
-		{
-			TILE_WINDOW(w);
+	glLineWidth(4.0f);
 
-			if (tw->isResizing)
-			{
-				// Coordinate = start +            speed          * elapsedTime
-				// Coordinate = start + (target - start)/interval * elapsedTime
-				// Draw outline
-
-				int x = tw->previousX - w->input.left +
-					    (((float)(w->attrib.x - tw->previousX)) * ts->msResizing / animationDuration);
-				int y = tw->previousY - w->input.top +
-					    (((float)(w->attrib.y - tw->previousY)) * ts->msResizing / animationDuration);
-				int width = tw->previousWidth + w->input.left + w->input.right +
-				        (((float)(w->attrib.width - tw->previousWidth)) * ts->msResizing / animationDuration);
-				int height = tw->previousHeight + w->input.top + w->input.bottom +
-				        (((float)(w->attrib.height - tw->previousHeight)) * ts->msResizing / animationDuration);
-
-				glColor3us(tw->outlineColor[0] * 0.66, tw->outlineColor[1] * 0.66, 
-						   tw->outlineColor[2]*0.66);
-				glRecti(x, y + height, x + width, y);
-
-				glColor3usv(tw->outlineColor);
-
-				glBegin(GL_LINE_LOOP);
-				glVertex3f(x, y, 0.0f);
-				glVertex3f(x + width, y, 0.0f);
-				glVertex3f(x + width, y + height, 0.0f);
-				glVertex3f(x, y + height, 0.0f);
-				glEnd();
-
-				glColor4usv(defaultColor);
-			}
-
-			w = tw->next;
-		}
+	for (w = s->windows; w; w = w->next)
+	{
+	    TILE_WINDOW(w);
+
+	    if (tw->animationType == Animating)
+	    {
+		// Coordinate = start +            speed          * elapsedTime
+		// Coordinate = start + (target - start)/interval * elapsedTime
+		// Draw outline
+
+		int x = tw->prevCoords.x - w->input.left +
+		    (((float)(w->attrib.x - tw->prevCoords.x)) * ts->msResizing / animationDuration);
+		int y = tw->prevCoords.y - w->input.top +
+		    (((float)(w->attrib.y - tw->prevCoords.y)) * ts->msResizing / animationDuration);
+		int width = tw->prevCoords.width + w->input.left + w->input.right +
+		    (((float)(w->attrib.width - tw->prevCoords.width)) * ts->msResizing / animationDuration);
+		int height = tw->prevCoords.height + w->input.top + w->input.bottom +
+		    (((float)(w->attrib.height - tw->prevCoords.height)) * ts->msResizing / animationDuration);
+
+		glColor3us(tw->outlineColor[0] * 0.66, tw->outlineColor[1] * 0.66, 
+			   tw->outlineColor[2]*0.66);
+		glRecti(x, y + height, x + width, y);
+
+		glColor3usv(tw->outlineColor);
+
+		glBegin(GL_LINE_LOOP);
+		glVertex3f(x, y, 0.0f);
+		glVertex3f(x + width, y, 0.0f);
+		glVertex3f(x + width, y + height, 0.0f);
+		glVertex3f(x, y + height, 0.0f);
+		glEnd();
 
-		glPopMatrix();
 		glColor4usv(defaultColor);
-		glLineWidth(1.0f);
+	    }
 	}
 
-	return status;
-}
-
-static Bool tileSetCoreScreenOption(CompScreen *s, char *name, CompOptionValue *value)
-{
-	TILE_SCREEN(s);
-	Bool status;
-
-	UNWRAP(ts, s, setScreenOption);
-	status = (*s->setScreenOption) (s, name, value);
-	WRAP(ts, s, setScreenOption, tileSetCoreScreenOption);
+	glPopMatrix();
+	glColor4usv(defaultColor);
+	glLineWidth(1.0f);
+    }
 
-	if (status && ((strcmp(name, "size") == 0) || (strcmp(name, "vsize") == 0)))
-	{
-		ts->viewports = realloc(ts->viewports, sizeof(TileViewport) *
-								(s->hsize * s->vsize));
-	}
-
-	return status;
+    return status;
 }
 
 // Resize notify used when windows are tiled horizontally or vertically
 static void tileResizeNotify(CompWindow * w, int dx, int dy, int dwidth, int dheight)
 {
-	TILE_SCREEN(w->screen);
-	TILE_WINDOW(w);
-
-	UNWRAP(ts, w->screen, windowResizeNotify);
-	(*w->screen->windowResizeNotify) (w, dx, dy, dwidth, dheight);
-	WRAP(ts, w->screen, windowResizeNotify, tileResizeNotify);
-
-	if (!tw->resizedAlready)
-	{
-		tw->resizedAlready = True; // window is resized now
-		return;
-	}
-
-	// Dont do anything if joining is disabled or windows are being resized
-	if (!tileGetTileJoin(w->screen->display) || ts->isResizing)
-		return;
-
-	switch (THIS_VIEWPORT(w->screen).currentTileType)
-	{
-		case TileToggleTypeTile:
-			if (tw->prev)
-				placeWindow(tw->prev, 
-							tw->prev->attrib.x, tw->prev->attrib.y, 
-							w->attrib.x - tw->prev->attrib.x - w->input.left - tw->prev->input.right, 
-							tw->prev->height);
+    TILE_SCREEN(w->screen);
+    TILE_WINDOW(w);
+
+    UNWRAP(ts, w->screen, windowResizeNotify);
+    (*w->screen->windowResizeNotify) (w, dx, dy, dwidth, dheight);
+    WRAP(ts, w->screen, windowResizeNotify, tileResizeNotify);
+
+    if (!tw->alreadyResized)
+    {
+	tw->alreadyResized = TRUE;
+	return;
+    }
+
+    // Dont do anything if joining is disabled or windows are being resized
+    if (!tileGetTileJoin(w->screen->display) || ts->isAnimating)
+	return;
+#if 0
+    switch (ts->tileType)
+    {
+	case TileToggleTypeTile:
+	    if (tw->prev)
+		placeWindow(tw->prev, 
+			    tw->prev->attrib.x, tw->prev->attrib.y, 
+			    w->attrib.x - tw->prev->attrib.x - w->input.left - tw->prev->input.right, 
+			    tw->prev->height);
 
 			if (tw->next)
 			{
@@ -504,6 +455,7 @@ static void tileResizeNotify(CompWindow * w, int dx, int dy, int dwidth, int dhe
 		default:
 			break;
 	}
+#endif
 }
 
 static Bool tileInitScreen(CompPlugin * p, CompScreen * s)
@@ -522,22 +474,16 @@ static Bool tileInitScreen(CompPlugin * p, CompScreen * s)
 
 	s->privates[td->screenPrivateIndex].ptr = ts;
 
-	ts->isResizing = FALSE;
+	ts->isAnimating = FALSE;
 	ts->msResizing = 0;
 	ts->oneDuration = 0;
 
-	ts->viewports = calloc(s->hsize * s->vsize, sizeof(TileViewport));
-	int i;
-	for(i = 0;i < (s->hsize * s->vsize); i++)
-		ts->viewports[i].currentTileType = TileToggleTypeNum;
-
 	// Wrap plugin functions
 	WRAP(ts, s, paintScreen, tilePaintScreen);
 	WRAP(ts, s, preparePaintScreen, tilePreparePaintScreen);
 	WRAP(ts, s, donePaintScreen, tileDonePaintScreen);
 	WRAP(ts, s, windowResizeNotify, tileResizeNotify);
 	WRAP(ts, s, paintWindow, tilePaintWindow);
-	WRAP(ts, s, setScreenOption, tileSetCoreScreenOption);
 
 	return TRUE;
 }
@@ -547,7 +493,6 @@ static void tileFiniScreen(CompPlugin * p, CompScreen * s)
 	TILE_SCREEN(s);
 
 	freeWindowPrivateIndex(s, ts->windowPrivateIndex);
-	free(ts->viewports);
 
 	//Restore the original function
 	UNWRAP(ts, s, paintScreen);
@@ -555,7 +500,6 @@ static void tileFiniScreen(CompPlugin * p, CompScreen * s)
 	UNWRAP(ts, s, donePaintScreen);
 	UNWRAP(ts, s, windowResizeNotify);
 	UNWRAP(ts, s, paintWindow);
-	UNWRAP(ts, s, setScreenOption);
 
 	//Free the pointer
 	free(ts);
@@ -606,672 +550,530 @@ static void constrainMinMax(CompWindow * w, int width, int height, int *newWidth
 // Moves window to [x,y] and resizes to width x height if no animation or starts animation
 static Bool placeWindow(CompWindow *w, int x, int y, int width, int height)
 {
-	// window existence check
-	if (!w)
-		return FALSE;
-
-	// this checks if the window isnt smaller than minimum size it has defined
-	constrainMinMax(w, width, height, &width, &height);
-
-	// check if the window isnt already where its going to be
-	if (x == w->attrib.x && y == w->attrib.y && width == w->attrib.width && height == w->attrib.height)
-		return TRUE;
-
-	TILE_WINDOW(w);
-	TILE_SCREEN(w->screen);
-
-	// set previous coordinates for animation
-	tw->previousX = w->attrib.x;
-	tw->previousY = w->attrib.y;
-	tw->previousWidth = w->attrib.width;
-	tw->previousHeight = w->attrib.height;
-
-	// set future coordinates for animation
-	tw->futureX = x;
-	tw->futureY = y;
-	tw->futureWidth = width;
-	tw->futureHeight = height;
-
-	tw->resizedAlready = False; // window is not resized now
+    // window existence check
+    if (!w)
+	return FALSE;
 
-	switch (tileGetAnimateType(w->screen->display))
-	{
-		case AnimateTypeNone:
-			setWindowFutureSize(w);
-			break;
-		case AnimateTypeOutline:
-		case AnimateTypeSlide:
-		case AnimateTypeZoom:
-		case AnimateTypeDrop:
-			setWindowFutureSize(w);
-			/* fall-through */
-		case AnimateTypeFade:
-			ts->isResizing = TRUE;
-			tw->isResizing = TRUE;
-			ts->msResizing = 0;
-			ts->oneDuration = tileGetAnimationDuration(w->screen->display) / 
-				              THIS_VIEWPORT(w->screen).tiledCount;
-			break;
-		default:
-			break;
-	}
+    // this checks if the window isnt smaller than minimum size it has defined
+    constrainMinMax(w, width, height, &width, &height);
 
+    // check if the window isnt already where its going to be
+    if (x == w->attrib.x && y == w->attrib.y && width == w->attrib.width && height == w->attrib.height)
 	return TRUE;
+
+    TILE_WINDOW(w);
+    TILE_SCREEN(w->screen);
+
+    // set previous coordinates for animation
+    tw->prevCoords.x = w->attrib.x;
+    tw->prevCoords.y = w->attrib.y;
+    tw->prevCoords.width = w->attrib.width;
+    tw->prevCoords.height = w->attrib.height;
+
+    // set future coordinates for animation
+    tw->newCoords.x = x;
+    tw->newCoords.y = y;
+    tw->newCoords.width = width;
+    tw->newCoords.height = height;
+
+    tw->alreadyResized = FALSE; // window is not resized now
+
+    switch (tileGetAnimateType(w->screen->display))
+    {
+	case AnimateTypeNone:
+	    tileSetNewWindowSize(w);
+	    break;
+	case AnimateTypeOutline:
+	case AnimateTypeSlide:
+	case AnimateTypeZoom:
+	case AnimateTypeDrop:
+	    tileSetNewWindowSize(w);
+	    /* fall-through */
+	case AnimateTypeFade:
+    	    ts->isAnimating = TRUE;
+	    tw->animationType = Animating;
+	    ts->msResizing = 0;
+	    break;
+	default:
+	    break;
+    }
+
+    return TRUE;
 }
 
-static Bool setWindowFutureSize(CompWindow *w)
+static Bool tileSetNewWindowSize(CompWindow *w)
 {
 	TILE_WINDOW(w);
 	TILE_SCREEN(w->screen);
 	XWindowChanges xwc;
 
-	xwc.x = tw->futureX;
-	xwc.y = tw->futureY;
-	xwc.width = tw->futureWidth;
-	xwc.height = tw->futureHeight;
+	xwc.x = tw->newCoords.x;
+	xwc.y = tw->newCoords.y;
+	xwc.width = tw->newCoords.width;
+	xwc.height = tw->newCoords.height;
 
-	if (THIS_VIEWPORT(w->screen).currentTileType == TileToggleTypeNum)
-		maximizeWindow(w, tw->prevState);
-	else
-		maximizeWindow(w, 0);
-
-	// FIXME
-	// restack window where it should be, under next window because maximization/restoration breaks it somehow
-	if (tw->prevState & MAXIMIZE_STATE && tw->next)
-		restackWindowBelow(w, tw->next);
-
-	/* TODO */
-#if 0	
-	// if after restoring the window is maximized, then restore "restore data" :P
-	if ((w->state & MAXIMIZE_STATE) && THIS_VIEWPORT(w->screen).currentTileType == none)
-		saveWindowGeometry(w, &xwc, CWX | CWY | CWWidth | CWHeight);
+	if (ts->tileType == TileToggleTypeNum)
+	{
+	    if (tw->savedValid)
+		maximizeWindow(w, tw->savedMaxState);
+	}
 	else
-		configureXWindow (w, CWX | CWY | CWWidth | CWHeight, &xwc);
-#endif
+    	    maximizeWindow(w, 0);
+
+	configureXWindow (w, CWX | CWY | CWWidth | CWHeight, &xwc);
+
 	return TRUE;
 }
 
 // Heavily inspired by windowIs3D and isSDWindow, returns TRUE if the window is usable for tiling
 static Bool isTileWindow(CompWindow * w)
 {
-	if (matchEval(tileGetExcludeMatch(w->screen->display), w))
-		return FALSE;
-
-	if (w->attrib.override_redirect)
-		return FALSE;
-
-	if (w->wmType & (CompWindowTypeDockMask | CompWindowTypeDesktopMask))
-		return FALSE;
-
-	if (w->state & CompWindowStateSkipPagerMask)
-		return FALSE;
-
-	// Normal window
-	if ((w->type & CompWindowTypeNormalMask)==CompWindowTypeNormalMask && !w->minimized && w->placed)
-		return TRUE;
-
+    if (matchEval(tileGetExcludeMatch(w->screen->display), w))
 	return FALSE;
-}
-
-// Finds windows on desktop that are to be tiled
-static Bool loadTiledWindows(CompScreen *s)
-{
-	TILE_SCREEN(s);
 
-	int count = 0;
-	CompWindow *first = 0, *previous = 0;
-
-	CompWindow *w;
-	if (THIS_VIEWPORT(s).currentTileType != TileToggleTypeNum)
-	for (w = s->windows; w; w = w->next)
-	{
-		int x,y;
-		defaultViewportForWindow(w, &x, &y);
-		if (isTileWindow(w) && (x == s->x) && (y == s->y))
-		{
-			if (previous)
-			{
-				TILE_WINDOW(previous);
-				tw->next = w;
-			}
-
-			TILE_WINDOW(w);
-			if (!first)
-				first = w;
+    if (w->attrib.override_redirect)
+	return FALSE;
 
-			tw->prev = previous;
-			previous = w;
-			tw->next = 0;
-			count++;
-		}
-	}
-	else // when reloading windows for restoration, in case window order was changed since last tiling
-	for (w = s->windows; w; w = w->next)
-	{
-		TILE_WINDOW(w);
-		int x,y;
-		defaultViewportForWindow(w,&x,&y);
-		if ((tw->originalWidth || tw->originalHeight) && (x == s->x) && (y == s->y))
-		{
-			if (previous)
-			{
-				TILE_WINDOW(previous);
-				tw->next = w;
-			}
+    if (!((*w->screen->focusWindow)(w)))
+	return FALSE;
 
-			if (!first)
-				first = w;
+    if (w->wmType & (CompWindowTypeDockMask | CompWindowTypeDesktopMask))
+	return FALSE;
 
-			tw->prev = previous;
-			previous = w;
-			tw->next = 0;
-			count++;
-		}
-	}
+    if (w->state & CompWindowStateSkipPagerMask)
+	return FALSE;
 
-	THIS_VIEWPORT(s).firstTiled = first;
-	THIS_VIEWPORT(s).tiledCount = count;
+    if (w->minimized || !w->placed)
+	return FALSE;
 
-	return TRUE;
+    return TRUE;
 }
 
 // save window coordinates to use for restore
-static Bool saveCoords(CompWindow *w)
+static void saveCoords(CompWindow *w)
 {
 	TILE_WINDOW(w);
 
-	// if the window was maximized save "restore data" for later restoring
-	if (w->state & MAXIMIZE_STATE)
-	{
-		if (w->saveMask & CWX)
-			tw->originalX = w->saveWc.x;
-		else
-			tw->originalX = w->serverX;
-
-		if (w->saveMask & CWY)
-			tw->originalY = w->saveWc.y;
-		else
-			tw->originalY = w->serverY;
+	if (tw->savedValid)
+	    return;
 
-		if (w->saveMask & CWWidth)
-			tw->originalWidth = w->saveWc.width;
-		else
-			tw->originalWidth = w->serverWidth;
+	tw->savedCoords.x = w->serverX;
+	tw->savedCoords.y = w->serverY;
+	tw->savedCoords.width = w->serverWidth;
+	tw->savedCoords.height = w->serverHeight;
 
-		if (w->saveMask & CWHeight)
-			tw->originalHeight = w->saveWc.height;
-		else
-			tw->originalHeight = w->serverHeight;
-	}
-	else
-	{
-		tw->originalX = w->serverX;
-		tw->originalY = w->serverY;
-		tw->originalWidth = w->serverWidth;
-		tw->originalHeight = w->serverHeight;
-	}
+	tw->savedMaxState = w->state & MAXIMIZE_STATE;
 
-	// save state
-	tw->prevState = w->state;
+	tw->savedValid = TRUE;
 
-	return TRUE;
+	return;
 }
 
 // Applies tiling/restoring
 static Bool applyTiling(CompScreen *s)
 {
-	TILE_SCREEN(s);
-
-	if (ts->isResizing)
-		return FALSE;
-
-	loadTiledWindows(s);
-	if (THIS_VIEWPORT(s).tiledCount > 1)
-	{
-		int i = 0;
-		XRectangle workArea;
-		CompWindow *w;
-		CompWindowExtents border;
-
-		memset(&border, 0, sizeof(CompWindowExtents));
-		/* first get the largest border of the windows on this
-		   screen - some of the windows in our list might be 
-		   maximized now and not be maximized later, so 
-		   their border information may be inaccurate */
-		for (w = s->windows; w; w = w->next)
-		{
-			if (w->input.left > border.left)
-				border.left = w->input.left;
-			if (w->input.right > border.right)
-				border.right = w->input.right;
-			if (w->input.top > border.top)
-				border.top = w->input.top;
-			if (w->input.bottom > border.bottom)
-				border.bottom = w->input.bottom;
-		}
-
-		w = THIS_VIEWPORT(s).firstTiled;
-
-		/* FIXME */
-		getWorkareaForOutput(s, s->currentOutputDev, &workArea);
-
-		switch(THIS_VIEWPORT(s).currentTileType)
-		{
-			/*
-				Tile into grid
-			*/
-			case TileToggleTypeTile :
-			{
-				int countX = ceil(sqrt(THIS_VIEWPORT(s).tiledCount));
-				int countY = ceil((float)THIS_VIEWPORT(s).tiledCount / countX);
-
-				int currentX = workArea.x;
-				int currentY = workArea.y;
-
-				int winWidth = workArea.width / countX;
-				int winHeight = workArea.height / countY;
-
-				while (w)
-				{
-					TILE_WINDOW(w);
-					if (!tw->originalWidth || !tw->originalHeight)
-						saveCoords(w);
-
-					placeWindow(w, currentX + border.left, 
-								currentY + border.top, 
-								winWidth - (border.left + border.right),
-								winHeight - (border.top + border.bottom));
-					i++;
-
-					if (!(i % countX))
-					{
-						currentX = workArea.x;
-						currentY += winHeight;
-					}
-					else
-						currentX += winWidth;
-
-					w = tw->next;
-				}
-			}
-			break;
+    TILE_SCREEN(s);
 
-			/*
-				Tile left
-			*/
-			case TileToggleTypeLeft:
-			{
-				int x = 0, y = 0, winWidth = 0, winHeight = 0;
-				int height = workArea.height / (THIS_VIEWPORT(s).tiledCount - 1);
-				int occupancy = tileGetTileLeftOccupancy(s->display);
+    if (ts->isAnimating)
+	return FALSE;
 
-				while (w)
-				{
-					TILE_WINDOW(w);
-					if (!tw->next) // this is the last window in the list - the active/topmost window
-					{
-						x = workArea.x;
-						y = workArea.y;
-						winWidth = workArea.width * occupancy / 100;
-						winHeight = workArea.height;
-					}
-					else
-					{
-						x = workArea.x + (workArea.width * occupancy / 100);
-						y = workArea.y + (i * height);
-						winWidth = (workArea.width * (100 - occupancy) / 100);
-						winHeight = height;
-					}
-					if (!tw->originalWidth || !tw->originalHeight)
-						saveCoords(w);
-
-					placeWindow(w, x + border.left, y + border.top, 
-								winWidth - (border.left + border.right),
-								winHeight - (border.top + border.bottom));
-					i++;
-					w = tw->next;
-				}
-			}
-			break;
+    int count = 0;
+    CompWindow *w;
 
-			/*
-			Tile vertically
-			*/
-			case TileToggleTypeVertical:
-			{
-				int winWidth = workArea.width / THIS_VIEWPORT(s).tiledCount;
-				int winHeight = workArea.height;
-				int y = workArea.y;
+    for (w = s->windows; w; w = w->next)
+    {
+	if (isTileWindow(w))
+	    count++;
+    }
 
-				while (w)
-				{
-					TILE_WINDOW(w);
+    ts->oneDuration = tileGetAnimationDuration(s->display) / MAX(count, 1);
 
-					int x = workArea.x + (winWidth * i);
-					if (!tw->originalWidth || !tw->originalHeight)
-						saveCoords(w);
+    if (count > 1)
+    {
+	int i = 0;
+	XRectangle workArea;
+	CompWindowExtents border;
 
-					placeWindow(w, x + border.left, y + border.top, 
-								winWidth - (border.left + border.right),
-								winHeight - (border.top + border.bottom));
-					i++;
-					w = tw->next;
-				}
-			}
-			break;
-
-			/*
-				Tile horizontally
-			*/
-			case TileToggleTypeHorizontal:
-			{
-				int winWidth = workArea.width;
-				int winHeight = workArea.height / THIS_VIEWPORT(s).tiledCount;
-				int x = workArea.x;
+	memset(&border, 0, sizeof(CompWindowExtents));
+	/* first get the largest border of the windows on this
+	   screen - some of the windows in our list might be 
+	   maximized now and not be maximized later, so 
+	   their border information may be inaccurate */
+	for (w = s->windows; w; w = w->next)
+	{
+	    if (w->input.left > border.left)
+		border.left = w->input.left;
+	    if (w->input.right > border.right)
+		border.right = w->input.right;
+	    if (w->input.top > border.top)
+		border.top = w->input.top;
+	    if (w->input.bottom > border.bottom)
+		border.bottom = w->input.bottom;
+	}
 
-				while (w)
-				{
-					TILE_WINDOW(w);
+    	int countX = 0, countY = 0;
+	int currentX = 0, currentY = 0;
+	int winWidth = 0, winHeight = 0;
+	int x = 0, y = 0;
+	int height = 0, occupancy = 0, delta = 0;
+	Bool first = TRUE;
 
-					int y = workArea.y + (winHeight * i);
-					if (!tw->originalWidth || !tw->originalHeight)
-						saveCoords(w);
+	workArea = s->workArea;
 
-					placeWindow(w, x + border.left, y + border.top, 
-								winWidth - (border.left + border.right),
-								winHeight - (border.top + border.bottom));
-					i++;
-					w = tw->next;
-				}
-			}
-			break;
+    	switch (ts->tileType)
+	{
+	    case TileToggleTypeTile:
+		countX = ceil(sqrt(count));
+		countY = ceil((float)count / countX);
+	    	currentX = workArea.x;
+    		currentY = workArea.y;
+		winWidth = workArea.width / countX;
+		winHeight = workArea.height / countY;
+		break;
+	    case TileToggleTypeLeft:
+		height = workArea.height / (count - 1);
+		occupancy = tileGetTileLeftOccupancy(s->display);
+		break;
+	    case TileToggleTypeVertical:
+		winWidth = workArea.width / count;
+		winHeight = workArea.height;
+		y = workArea.y;
+		break;
+	    case TileToggleTypeHorizontal:
+		winWidth = workArea.width;
+		winHeight = workArea.height / count;
+		x = workArea.x;
+		break;
+	    case TileToggleTypeCascade:
+		delta = tileGetTileDelta(s->display);
+		currentX = workArea.x;
+		currentY = workArea.y;
+		winHeight = workArea.height - delta * (count - 1);
+		winWidth = workArea.width - delta * (count - 1);
+		break;
+	    default:
+		break;
+	}
 
-			/*
-				Cascade
-			*/
-			case TileToggleTypeCascade:
-			{
-				int delta = tileGetTileDelta(s->display);
-				int currentX = workArea.x;
-				int currentY = workArea.y;
-				int winHeight = workArea.height - delta * (THIS_VIEWPORT(s).tiledCount - 1);
-				int winWidth = workArea.width - delta * (THIS_VIEWPORT(s).tiledCount - 1);
+	for (w = s->windows; w; w = w->next)
+	{
+	    if (!isTileWindow(w))
+		continue;
 
-				while (w)
-				{
-					TILE_WINDOW(w);
-					if (!tw->originalWidth || !tw->originalHeight)
-						saveCoords(w);
-
-					placeWindow(w, currentX + border.left, 
-								currentY + border.top, 
-								winWidth - (border.left + border.right),
-								winHeight - (border.top + border.bottom));
-
-					currentX += delta;
-					currentY += delta;
-					w = tw->next;
-				}
-			}
-			break;
+    	    TILE_WINDOW(w);
 
-			/*
-				Restore
-			*/
-			case TileToggleTypeNum:
-			{
-				while (w)
-				{
-					TILE_WINDOW(w);
+	    if (!tw->savedValid)
+		saveCoords(w);
 
-					placeWindow(w, tw->originalX, tw->originalY, tw->originalWidth, tw->originalHeight);
+	    switch (ts->tileType)
+	    {
+		case TileToggleTypeTile:
+		    placeWindow(w, currentX + border.left, 
+				currentY + border.top, 
+				winWidth - (border.left + border.right),
+				winHeight - (border.top + border.bottom));
+		    tw->isTiled = TRUE;
+		    break;
+		case TileToggleTypeLeft:
+		    if (first) 
+		    {
+			x = workArea.x;
+			y = workArea.y;
+			winWidth = workArea.width * occupancy / 100;
+			winHeight = workArea.height;
+			first = FALSE;
+		    }
+		    else
+		    {
+			x = workArea.x + (workArea.width * occupancy / 100);
+			y = workArea.y + (i * height);
+			winWidth = (workArea.width * (100 - occupancy) / 100);
+			winHeight = height;
+		    }
+
+	    	    placeWindow(w, x + border.left, y + border.top, 
+    				winWidth - (border.left + border.right),
+				winHeight - (border.top + border.bottom));
+		    tw->isTiled = TRUE;
+		    break;
+		case TileToggleTypeVertical:
+		    x = workArea.x + (winWidth * i);
+		    placeWindow(w, x + border.left, y + border.top, 
+				winWidth - (border.left + border.right),
+				winHeight - (border.top + border.bottom));
+		    tw->isTiled = TRUE;
+		    break;
+		case TileToggleTypeHorizontal:
+		    y = workArea.y + (winHeight * i);
+		    placeWindow(w, x + border.left, y + border.top, 
+				winWidth - (border.left + border.right),
+				winHeight - (border.top + border.bottom));
+		    tw->isTiled = TRUE;
+		    break;
+		case TileToggleTypeCascade:
+		    placeWindow(w, currentX + border.left, 
+				currentY + border.top, 
+				winWidth - (border.left + border.right),
+				winHeight - (border.top + border.bottom));
+		    tw->isTiled = TRUE;
+		    break;
+		case TileToggleTypeNum:
+		    if (tw->isTiled)
+		    {
+			placeWindow(w, tw->savedCoords.x, tw->savedCoords.y,
+			    	    tw->savedCoords.width, tw->savedCoords.height);
+			tw->savedValid = FALSE;
+			tw->isTiled = FALSE;
+		    }
+		    break;
+		default:
+		    break;
+	    }
 
-					tw->originalX = 0;
-					tw->originalY = 0;
-					tw->originalWidth = 0;
-					tw->originalHeight = 0;
+    	    i++;
+	    tw->animationNum = i;
 
-					w = tw->next;
-				}
-			}
-			break;
-		}
+	    switch (ts->tileType)
+	    {
+		case TileToggleTypeTile:
+		    if (!(i % countX))
+		    {
+			currentX = workArea.x;
+			currentY += winHeight;
+		    }
+		    else
+			currentX += winWidth;
+		    break;
+		case TileToggleTypeCascade:
+		    currentX += delta;
+		    currentY += delta;
+		default:
+		    break;
+	    }
 	}
+    }
 
-	return TRUE;
+    return TRUE;
 }
 
 static Bool tileTile(CompDisplay * d, CompAction * ac, CompActionState state, CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		THIS_VIEWPORT(s).currentTileType = TileToggleTypeTile;
-		applyTiling(s);
-	}
-	return FALSE;
+    if (s) {
+	TILE_SCREEN(s);
+	ts->tileType = TileToggleTypeTile;
+	applyTiling(s);
+    }
+
+    return FALSE;
 }
 
 static Bool tileVertically(CompDisplay * d, CompAction * ac, CompActionState state,CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		THIS_VIEWPORT(s).currentTileType = TileToggleTypeVertical;
-		applyTiling(s);
-	}
-	return FALSE;
+    if (s) {
+	TILE_SCREEN(s);
+	ts->tileType = TileToggleTypeVertical;
+	applyTiling(s);
+    }
+
+    return FALSE;
 }
 
 static Bool tileHorizontally(CompDisplay * d, CompAction * ac, CompActionState state, CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		THIS_VIEWPORT(s).currentTileType = TileToggleTypeHorizontal;
-		applyTiling(s);
-	}
-	return FALSE;
+    if (s) {
+	TILE_SCREEN(s);
+	ts->tileType = TileToggleTypeHorizontal;
+	applyTiling(s);
+    }
+
+    return FALSE;
 }
 
 static Bool tileCascade(CompDisplay * d, CompAction * ac, CompActionState state, CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		THIS_VIEWPORT(s).currentTileType = TileToggleTypeCascade;
-		applyTiling(s);
-	}
-	return FALSE;
+    if (s) {
+	TILE_SCREEN(s);
+	ts->tileType = TileToggleTypeCascade;
+	applyTiling(s);
+    }
+
+    return FALSE;
 }
 
 static Bool tileRestore(CompDisplay * d, CompAction * ac, CompActionState state, CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		if(THIS_VIEWPORT(s).currentTileType != TileToggleTypeNum)
-		{
-			THIS_VIEWPORT(s).currentTileType = TileToggleTypeNum;
-			applyTiling(s);
-		}
-	}
-	return FALSE;
+    if (s) {
+	TILE_SCREEN(s);
+	ts->tileType = TileToggleTypeNum;
+	applyTiling(s);
+    }
+
+    return FALSE;
 }
 
 static Bool tileToggle(CompDisplay * d, CompAction * ac, CompActionState state, CompOption * option, int nOption)
 {
-	CompScreen *s;
-	s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
+    CompScreen *s;
+    s = findScreenAtDisplay(d, getIntOptionNamed(option, nOption, "root", 0));
 
-	if (s) {
-		TILE_SCREEN(s);
-		if(THIS_VIEWPORT(s).currentTileType != TileToggleTypeNum)
-		{
-			THIS_VIEWPORT(s).currentTileType = TileToggleTypeNum;
-			applyTiling(s);
-		}
-		else
-		{
-			THIS_VIEWPORT(s).currentTileType = tileGetTileToggleType(d);
-			applyTiling(s);
-		}
+    if (s) {
+	CompWindow *w;
+	TILE_SCREEN(s);
+
+	for (w = s->windows; w; w = w->next)
+	{
+	    TILE_WINDOW(w);
+	    if (tw->isTiled)
+		break;
 	}
 
-	return FALSE;
+	if (w)
+	{
+	    ts->tileType = TileToggleTypeNum;
+	    applyTiling(s);
+	}
+	else
+	{
+	    ts->tileType = tileGetTileToggleType(d);
+	    applyTiling(s);
+	}
+    }
+
+    return FALSE;
 }
 
 static Bool tileInitDisplay(CompPlugin * p, CompDisplay * d)
 {
-	//Generate a tile display
-	TileDisplay *td = (TileDisplay *) malloc(sizeof(TileDisplay));
-	//Allocate a private index
-	td->screenPrivateIndex = allocateScreenPrivateIndex(d);
-
-	//Check if its valid
-	if (td->screenPrivateIndex < 0) {
-		free(td);
-		return FALSE;
-	}
+    //Generate a tile display
+    TileDisplay *td = (TileDisplay *) malloc(sizeof(TileDisplay));
+    //Allocate a private index
+    td->screenPrivateIndex = allocateScreenPrivateIndex(d);
+
+    //Check if its valid
+    if (td->screenPrivateIndex < 0) {
+	free(td);
+	return FALSE;
+    }
 
-	tileSetTileVerticallyInitiate(d, tileVertically);
-	tileSetTileHorizontallyInitiate(d, tileHorizontally);
-	tileSetTileTileInitiate(d, tileTile);
-	tileSetTileCascadeInitiate(d, tileCascade);
-	tileSetTileRestoreInitiate(d, tileRestore);
-	tileSetTileToggleInitiate(d, tileToggle);
+    tileSetTileVerticallyInitiate(d, tileVertically);
+    tileSetTileHorizontallyInitiate(d, tileHorizontally);
+    tileSetTileTileInitiate(d, tileTile);
+    tileSetTileCascadeInitiate(d, tileCascade);
+    tileSetTileRestoreInitiate(d, tileRestore);
+    tileSetTileToggleInitiate(d, tileToggle);
 
-	//Record the display
-	d->privates[displayPrivateIndex].ptr = td;
+    //Record the display
+    d->privates[displayPrivateIndex].ptr = td;
 
-	return TRUE;
+    return TRUE;
 }
 
 static void tileFiniDisplay(CompPlugin * p, CompDisplay * d)
 {
-	TILE_DISPLAY(d);
+    TILE_DISPLAY(d);
 
-	//Free the private index
-	freeScreenPrivateIndex(d, td->screenPrivateIndex);
-	//Free the pointer
-	free(td);
+    //Free the private index
+    freeScreenPrivateIndex(d, td->screenPrivateIndex);
+    //Free the pointer
+    free(td);
 }
 
 static Bool tileInitWindow(CompPlugin * p, CompWindow * w)
 {
-	TileWindow *tw;
+    TileWindow *tw;
 
-	TILE_SCREEN(w->screen);
-
-	tw = malloc(sizeof(TileWindow));
-	if (!tw)
-		return FALSE;
+    TILE_SCREEN(w->screen);
 
-	tw->next = 0;
-	tw->prev = 0;
+    tw = malloc(sizeof(TileWindow));
+    if (!tw)
+	return FALSE;
 
-	tw->originalX = 0;
-	tw->originalY = 0;
-	tw->originalWidth = 0;
-	tw->originalHeight = 0;
+    memset(&tw->newCoords, 0, sizeof(XRectangle));
+    memset(&tw->prevCoords, 0, sizeof(XRectangle));
+    memset(&tw->savedCoords, 0, sizeof(XRectangle));
 
-	tw->previousX = 0;
-	tw->previousY = 0;
-	tw->previousWidth = 0;
-	tw->previousHeight = 0;
-	tw->isResizing = FALSE;
-	tw->prevState = 0;
+    tw->savedValid = FALSE;
+    tw->animationType = NoAnimation;
+    tw->savedMaxState = 0;
+    tw->isTiled = FALSE;
 	
-	// random color, from group.c thanks to the author for doing it
-	tw->outlineColor[0] = rand() % 0xFFFF;
-	tw->outlineColor[1] = rand() % 0xFFFF;
-	tw->outlineColor[2] = rand() % 0xFFFF;
+    // random color, from group.c thanks to the author for doing it
+    tw->outlineColor[0] = rand() % 0xFFFF;
+    tw->outlineColor[1] = rand() % 0xFFFF;
+    tw->outlineColor[2] = rand() % 0xFFFF;
 
-	w->privates[ts->windowPrivateIndex].ptr = tw;
+    w->privates[ts->windowPrivateIndex].ptr = tw;
 
-	return TRUE;
+    return TRUE;
 }
 
 static void tileFiniWindow(CompPlugin * p, CompWindow * w)
 {
-	TILE_WINDOW(w);
-	TILE_SCREEN(w->screen);
+    TILE_WINDOW(w);
 
-	if (tw->originalWidth && tw->originalHeight)
-	{
-		// when one window is destroyed, join the linked list
-		CompWindow *prev = tw->prev;
-		CompWindow *next = tw->next;
-
-		if (prev)
-		{
-			TileWindow *twprev = GET_TILE_WINDOW(prev, GET_TILE_SCREEN (prev->screen, GET_TILE_DISPLAY (prev->screen->display)));
-			twprev->next = next;
-		}
-		else
-		{
-			THIS_VIEWPORT(w->screen).firstTiled = next;
-		}
-	}
-
-	free(tw);
+    free(tw);
 }
 
 static Bool tileInit(CompPlugin * p)
 {
-	displayPrivateIndex = allocateDisplayPrivateIndex();
+    displayPrivateIndex = allocateDisplayPrivateIndex();
 
-	if (displayPrivateIndex < 0)
-		return FALSE;
+    if (displayPrivateIndex < 0)
+	return FALSE;
 
-	return TRUE;
+    return TRUE;
 }
 
 static void tileFini(CompPlugin * p)
 {
-	if (displayPrivateIndex >= 0)
-		freeDisplayPrivateIndex(displayPrivateIndex);
+    if (displayPrivateIndex >= 0)
+	freeDisplayPrivateIndex(displayPrivateIndex);
 }
 
 static int tileGetVersion(CompPlugin *p, int version)
 {
-	return ABIVERSION;
+    return ABIVERSION;
 }
 
 CompPluginVTable tileVTable = {
-	"tile",
-	N_("Tile"),
-	N_("Tile windows"),
-	tileGetVersion,
-	tileInit,
-	tileFini,
-	tileInitDisplay,
-	tileFiniDisplay,
-	tileInitScreen,
-	tileFiniScreen,
-	tileInitWindow,
-	tileFiniWindow,
-	0,
-	0,
-	0,			/*tileGetScreenOptions */
-	0,			/*tileSetScreenOption */
-	0,
-	0,
-	0,
-	0
+    "tile",
+    N_("Tile"),
+    N_("Tile windows"),
+    tileGetVersion,
+    tileInit,
+    tileFini,
+    tileInitDisplay,
+    tileFiniDisplay,
+    tileInitScreen,
+    tileFiniScreen,
+    tileInitWindow,
+    tileFiniWindow,
+    0,
+    0,
+    0,			/*tileGetScreenOptions */
+    0,			/*tileSetScreenOption */
+    0,
+    0,
+    0,
+    0
 };
 
 CompPluginVTable *getCompPluginInfo(void)
 {
-	return &tileVTable;
+    return &tileVTable;
 }