Merge lp:~gala-dev/gala/expose-natural into lp:gala

[Tom Beckmann]

This replaces the old expose branch with a new one using the algorithm found in the natural-window-placement Gnome Shell extension (which is a copy of the one in KWin)

This adds the long requested expose feature as alternative to alt-tab window switching. It's default shortcut right now is super+e and it can be chosen as hotcorner action.
At the moment, it isnt integrated to the workspace view and as said earlier only supports choosing the active window for simplicity and stability reasons, anything else would have created too much work, that way there are no corner cases to be handled, just simple expose.

[Cassidy James Blaede (cassidyjames)]

I'd like to start calling this "Window Overview" rather than "expose" if
possible. 1. Expose doesn't really mean anything, 2. It's super close to
"Exposé," which is Apple's term for a similar feature, 3. I think "Window
Overview" makes more sense and is consistent with "Window Switcher,"
"Workspace Switcher," and "Workspace Overview."

Also, from what I saw in Tom's YouTube video, the placement needs work. It
feels a bit awkward right now (especially when there are more and more
windows).

Thanks,
Cassidy James

On Thu, Aug 23, 2012 at 10:33 AM, Rico Tzschichholz <email address hidden>wrote:

> The proposal to merge lp:~gala-dev/gala/expose-natural into lp:gala has
> been updated.
>
> Description changed to:
>
> This replaces the old expose branch with a new one using the algorithm
> found in the natural-window-placement Gnome Shell extension (which is a
> copy of the one in KWin)
>
> This adds the long requested expose feature as alternative to alt-tab
> window switching. It's default shortcut right now is super+e and it can be
> chosen as hotcorner action.
> At the moment, it isnt integrated to the workspace view and as said
> earlier only supports choosing the active window for simplicity and
> stability reasons, anything else would have created too much work, that way
> there are no corner cases to be handled, just simple expose.
>
> For more details, see:
> https://code.launchpad.net/~gala-dev/gala/expose-natural/+merge/121001
> --
> https://code.launchpad.net/~gala-dev/gala/expose-natural/+merge/121001
> Your team Gala developers is requested to review the proposed merge of
> lp:~gala-dev/gala/expose-natural into lp:gala.
>

[Rico Tzschichholz (ricotz)]

> I'd like to start calling this "Window Overview" rather than "expose" if
> possible. 1. Expose doesn't really mean anything, 2. It's super close to
> "Exposé," which is Apple's term for a similar feature, 3. I think "Window
> Overview" makes more sense and is consistent with "Window Switcher,"
> "Workspace Switcher," and "Workspace Overview."

+1

review: Needs Fixing

[lp:~gala-dev/gala/expose-natural]

194. By Tom Beckmann on 2012-08-24

Improve animations

195. By Tom Beckmann on 2012-08-24

Darken background while being in expose

196. By Tom Beckmann on 2012-08-24

Add a second, grid based algorithm, make this one the default one and add options in dconf to switch it

[Tom Beckmann (tombeckmann)]

Should this renaming happen code intern as well? Or just on the user front?

[lp:~gala-dev/gala/expose-natural]

197. By Tom Beckmann on 2012-08-24

Cleanup natural_placement

198. By Tom Beckmann on 2012-08-24

Replace Expo with WindowOverview

199. By Tom Beckmann on 2012-08-24

Fix problem with natural algo after cleanup

200. By Tom Beckmann on 2012-08-25

Cleanup grid_placement

201. By Tom Beckmann on 2012-08-25

Move code to better places, math related stuff to Utils namespace, some minor changes

202. By Tom Beckmann on 2012-08-25

Sort windows by monitor

203. By Rico Tzschichholz on 2012-08-25

Some minor fixes

204. By Rico Tzschichholz on 2012-08-25

Remove some useless methods

205. By Rico Tzschichholz on 2012-08-25

Use arrays instead of lists in natural-placement

206. By Tom Beckmann on 2012-08-25

Port the enlarging part for the natural placement algorithm

207. By Tom Beckmann on 2012-08-25

Some more cleanups for natural placement

208. By Rico Tzschichholz on 2012-08-25

Optimize a bit with the cost of behaviour change

209. By Tom Beckmann on 2012-08-26

Simplify area calculation

210. By Tom Beckmann on 2012-08-26

Rename ExposedWindow to WindowThumb

[Rico Tzschichholz (ricotz)]

review: Approve

[lp:~gala-dev/gala/expose-natural]

211. By Rico Tzschichholz on 2012-08-27

grid-placement: avoid empty window-slot which would make it look weird

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2012-08-23 10:03:20 +0000
+++ CMakeLists.txt	2012-08-27 21:04:19 +0000
@@ -54,7 +54,9 @@
     src/TextShadowEffect.vala
     src/Utils.vala
     src/Widgets/AppIcon.vala
+    src/Widgets/WindowOverview.vala
     src/Widgets/WindowSwitcher.vala
+    src/Widgets/WindowThumb.vala
     src/Widgets/WorkspaceThumb.vala
     src/Widgets/WorkspaceView.vala
     ${CMAKE_BINARY_DIR}/src/Config.vala

=== modified file 'data/org.pantheon.desktop.gala.gschema.xml'
--- data/org.pantheon.desktop.gala.gschema.xml	2012-07-28 06:40:12 +0000
+++ data/org.pantheon.desktop.gala.gschema.xml	2012-08-27 21:04:19 +0000
@@ -7,6 +7,11 @@
 		<value nick="minimize-current" value="3" />
 		<value nick="open-launcher" value="4" />
 		<value nick="custom-command" value="5" />
+		<value nick="window-overview" value="6" />
+	</enum>
+	<enum id="GalaWindowOverviewType">
+		<value nick='grid' value='0'/>
+		<value nick='natural' value='1'/>
 	</enum>
 	
 	<schema path="/org/pantheon/desktop/gala/behavior/" id="org.pantheon.desktop.gala.behavior" gettext-domain="gala">
@@ -15,6 +20,11 @@
 			<summary>Action for the top left corner</summary>
 			<description></description>
 		</key>
+		<key enum="GalaWindowOverviewType" name="window-overview-type">
+			<default>'grid'</default>
+			<summary>Algorithm for window overview layout</summary>
+			<description>Choose the algorithm used for exposing the windows</description>
+		</key>
 		<key enum="GalaActionType" name="hotcorner-topright">
 			<default>'none'</default>
 			<summary>Action for the top right corner</summary>
@@ -65,6 +75,11 @@
 			<summary>Shortcut to move to last workspace</summary>
 			<description></description>
 		</key>
+		<key type="as" name="expose-windows">
+			<default><![CDATA[['<Super>e']]]></default>
+			<summary>Shortcut to move to last workspace</summary>
+			<description></description>
+		</key>
 	</schema>
 	
 	<schema path="/org/pantheon/desktop/gala/appearance/" id="org.pantheon.desktop.gala.appearance" gettext-domain="gala">

=== modified file 'src/Plugin.vala'
--- src/Plugin.vala	2012-08-24 19:39:01 +0000
+++ src/Plugin.vala	2012-08-27 21:04:19 +0000
@@ -26,7 +26,8 @@
 		MAXIMIZE_CURRENT,
 		MINIMIZE_CURRENT,
 		OPEN_LAUNCHER,
-		CUSTOM_COMMAND
+		CUSTOM_COMMAND,
+		WINDOW_OVERVIEW
 	}
 	
 	public enum InputArea {
@@ -39,6 +40,7 @@
 	{
 		WindowSwitcher winswitcher;
 		WorkspaceView workspace_view;
+		WindowOverview window_overview;
 		
 		Window? moving; //place for the window that is being moved over
 		
@@ -77,11 +79,17 @@
 			
 			winswitcher = new WindowSwitcher (this);
 			
+			window_overview = new WindowOverview (this);
+			
 			stage.add_child (workspace_view);
 			stage.add_child (winswitcher);
+			stage.add_child (window_overview);
 			
 			/*keybindings*/
 			
+			screen.get_display ().add_keybinding ("expose-windows", BehaviorSettings.get_default ().schema, 0, () => {
+				window_overview.open (true);
+			});
 			screen.get_display ().add_keybinding ("move-to-workspace-first", BehaviorSettings.get_default ().schema, 0, () => {
 				screen.get_workspace_by_index (0).activate (screen.get_display ().get_current_time ());
 			});
@@ -280,6 +288,9 @@
 						warning (e.message);
 					}
 					break;
+				case ActionType.WINDOW_OVERVIEW:
+					window_overview.open (true);
+					break;
 				default:
 					warning ("Trying to run unknown action");
 					break;

=== modified file 'src/Settings.vala'
--- src/Settings.vala	2012-07-26 12:54:56 +0000
+++ src/Settings.vala	2012-08-27 21:04:19 +0000
@@ -25,6 +25,8 @@
 		public string overlay_action { get; set; }
 		public string hotcorner_custom_command { get; set; }
 		
+		public WindowOverviewType window_overview_type { get; set; }
+		
 		public ActionType hotcorner_topleft { get; set; }
 		public ActionType hotcorner_topright { get; set; }
 		public ActionType hotcorner_bottomleft { get; set; }

=== added file 'src/Widgets/WindowOverview.vala'
--- src/Widgets/WindowOverview.vala	1970-01-01 00:00:00 +0000
+++ src/Widgets/WindowOverview.vala	2012-08-27 21:04:19 +0000
@@ -0,0 +1,597 @@
+//  
+//  Copyright (C) 2012 Tom Beckmann
+// 
+//  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 3 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.
+// 
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+// 
+
+using Meta;
+using Clutter;
+
+namespace Gala
+{
+	
+	public enum WindowOverviewType
+	{
+		GRID = 0,
+		NATURAL
+	}
+	
+	public class WindowOverview : Actor
+	{
+		Plugin plugin;
+		Screen screen;
+		
+		bool ready;
+		
+		static const int PADDING = 50;
+		
+		public WindowOverview (Plugin _plugin)
+		{
+			plugin = _plugin;
+			screen = plugin.get_screen ();
+			
+			screen.workspace_switched.connect (() => close (false));
+			
+			visible = false;
+			ready = true;
+		}
+		
+		public override bool key_press_event (Clutter.KeyEvent event)
+		{
+			//FIXME need to figure out the actual keycombo, for now leave it by 
+			// default and others will close it by selecting a window!
+			if (event.keyval == Clutter.Key.e || event.keyval == Clutter.Key.Escape) {
+				close (true);
+				
+				return true;
+			}
+			
+			return false;
+		}
+		
+		public override void key_focus_out ()
+		{
+			close (false);
+		}
+		
+		/**
+		 * Code ported from KWin present windows effect
+		 * https://projects.kde.org/projects/kde/kde-workspace/repository/revisions/master/entry/kwin/effects/presentwindows/presentwindows.cpp
+		 **/
+		
+		//constants, mainly for natural expo
+		const int GAPS = 10;
+		const int MAX_TRANSLATIONS = 100000;
+		const int ACCURACY = 20;
+		const int BORDER = 10;
+		const int TOP_GAP = 20;
+		const int BOTTOM_GAP = 100;
+		
+		//some math utilities
+		int squared_distance (Gdk.Point a, Gdk.Point b)
+		{
+			var k1 = b.x - a.x;
+			var k2 = b.y - a.y;
+			
+			return k1*k1 + k2*k2;
+		}
+		
+		bool rect_is_overlapping_any (Meta.Rectangle rect, Meta.Rectangle[] rects, Meta.Rectangle border)
+		{
+			if (!border.contains_rect (rect))
+				return true;
+			foreach (var comp in rects) {
+				if (comp == rect)
+					continue;
+				
+				if (rect.overlap (comp))
+					return true;
+			}
+			
+			return false;
+		}
+		
+		Meta.Rectangle rect_adjusted (Meta.Rectangle rect, int dx1, int dy1, int dx2, int dy2)
+		{
+			return {rect.x + dx1, rect.y + dy1, rect.width + (-dx1 + dx2), rect.height + (-dy1 + dy2)};
+		}
+		
+		Gdk.Point rect_center (Meta.Rectangle rect)
+		{
+			return {rect.x + rect.width / 2, rect.y + rect.height / 2};
+		}
+		
+		
+		void calculate_places (List<Actor> windows)
+		{
+			var clones = windows.copy ();
+			clones.sort ((a, b) => {
+				return (int)(a as WindowThumb).window.get_stable_sequence () - 
+				        (int)(b as WindowThumb).window.get_stable_sequence ();
+			});
+			
+			//sort windows by monitor
+			List<Actor>[] monitors = {};
+			monitors.resize (screen.get_n_monitors ());
+			
+			foreach (var clone in clones)
+				monitors[(clone as WindowThumb).window.get_monitor ()].append (clone);
+			
+			for (var i = 0; i < screen.get_n_monitors (); i++) {
+				if (monitors[i].length () == 0)
+					continue;
+				
+				// get the area used by the expo algorithms together
+				var geom = screen.get_monitor_geometry (i);
+				Meta.Rectangle area = {(int)Math.floorf (geom.x + BORDER), 
+				                       (int)Math.floorf (geom.y + TOP_GAP), 
+				                       (int)Math.floorf (geom.width - BORDER * 2), 
+				                       (int)Math.floorf (geom.height - BOTTOM_GAP)};
+				
+				if (BehaviorSettings.get_default ().schema.get_enum ("window-overview-type") == WindowOverviewType.GRID)
+					grid_placement (area, monitors[i]);
+				else
+					natural_placement (area, monitors[i]);
+			}
+		}
+		
+		void grid_placement (Meta.Rectangle area, List<Actor> clones)
+		{
+			int columns = (int)Math.ceil (Math.sqrt (clones.length ()));
+			int rows = (int)Math.ceil (clones.length () / (double)columns);
+			
+			// Assign slots
+			int slot_width = area.width / columns;
+			int slot_height = area.height / rows;
+			
+			WindowThumb[] taken_slots = {};
+			taken_slots.resize (rows * columns);
+			
+			// precalculate all slot centers
+			Gdk.Point[] slot_centers = {};
+			slot_centers.resize (rows * columns);
+			for (int x = 0; x < columns; x++) {
+				for (int y = 0; y < rows; y++) {
+					slot_centers[x + y * columns] = {area.x + slot_width  * x + slot_width  / 2,
+					                                 area.y + slot_height * y + slot_height / 2};
+				}
+			}
+			
+			// Assign each window to the closest available slot
+			var tmplist = clones.copy ();
+			var window_count = tmplist.length ();
+			while (tmplist.length () > 0) {
+				var window = tmplist.nth_data (0) as WindowThumb;
+				var rect = window.window.get_outer_rect ();
+				
+				var slot_candidate = -1;
+				var slot_candidate_distance = int.MAX;
+				var pos = rect_center (rect);
+				
+				// all slots
+				for (int i = 0; i < columns * rows; i++) {
+					if (i > window_count - 1)
+						break;
+					
+					var dist = squared_distance (pos, slot_centers[i]);
+					
+					if (dist < slot_candidate_distance) {
+						// window is interested in this slot
+						WindowThumb occupier = taken_slots[i];
+						if (occupier == window)
+							continue;
+						
+						if (occupier == null || dist < squared_distance (rect_center (occupier.window.get_outer_rect ()), slot_centers[i])) {
+							// either nobody lives here, or we're better - takeover the slot if it's our best
+							slot_candidate = i;
+							slot_candidate_distance = dist;
+						}
+					}
+				}
+				
+				if (slot_candidate == -1)
+					continue;
+				
+				if (taken_slots[slot_candidate] != null)
+					tmplist.prepend (taken_slots[slot_candidate]);
+				
+				tmplist.remove_all (window);
+				taken_slots[slot_candidate] = window;
+			}
+			
+			for (int slot = 0; slot < columns * rows; slot++) {
+				var window = taken_slots[slot];
+				// some slots might be empty
+				if (window == null)
+					continue;
+				
+				var rect = window.window.get_outer_rect ();
+				
+				// Work out where the slot is
+				Meta.Rectangle target = {area.x + (slot % columns) * slot_width,
+				                         area.y + (slot / columns) * slot_height,
+				                         slot_width, 
+				                         slot_height};
+				target = rect_adjusted (target, 10, 10, -10, -10);
+				
+				float scale;
+				if (target.width / (double)rect.width < target.height / (double)rect.height) {
+					// Center vertically
+					scale = target.width / (float)rect.width;
+					target.y += (target.height - (int)(rect.height * scale)) / 2;
+					target.height = (int)Math.floorf (rect.height * scale);
+				} else {
+					// Center horizontally
+					scale = target.height / (float)window.height;
+					target.x += (target.width - (int)(rect.width * scale)) / 2;
+					target.width = (int)Math.floorf (rect.width * scale);
+				}
+				
+				// Don't scale the windows too much
+				if (scale > 2.0 || (scale > 1.0 && (rect.width > 300 || rect.height > 300))) {
+					scale = (rect.width > 300 || rect.height > 300) ? 1.0f : 2.0f;
+					target = {rect_center (target).x - (int)Math.floorf (rect.width * scale) / 2,
+					          rect_center (target).y - (int)Math.floorf (rect.height * scale) / 2,
+					          (int)Math.floorf (scale * rect.width), 
+					          (int)Math.floorf (scale * rect.height)};
+				}
+				
+				place_window (window, target);
+			}
+		}
+		
+		void natural_placement (Meta.Rectangle area, List<Actor> clones)
+		{
+			Meta.Rectangle bounds = {area.x, area.y, area.width, area.height};
+			
+			var direction = 0;
+			int[] directions = new int[clones.length ()];
+			Meta.Rectangle[] rects = new Meta.Rectangle[clones.length ()];
+			
+			for (int i = 0; i < clones.length (); i++) {
+				// save rectangles into 4-dimensional arrays representing two corners of the rectangular: [left_x, top_y, right_x, bottom_y]
+				var rect = (clones.nth_data (i) as WindowThumb).window.get_outer_rect ();
+				rect = rect_adjusted(rect, -GAPS, -GAPS, GAPS, GAPS);
+				rects[i] = rect;
+				bounds = bounds.union (rect);
+				
+				// This is used when the window is on the edge of the screen to try to use as much screen real estate as possible.
+				directions[i] = direction;
+				direction++;
+				if (direction == 4)
+					direction = 0;
+			}
+			
+			var loop_counter = 0;
+			var overlap = false;
+			do {
+				overlap = false;
+				for (var i = 0; i < rects.length; i++) {
+					for (var j = 0; j < rects.length; j++) {
+						if (i == j)
+							continue;
+						
+						var rect = rects[i];
+						var comp = rects[j];
+						
+						if (!rect.overlap (comp))
+							continue;
+						
+						loop_counter ++;
+						overlap = true;
+						
+						// Determine pushing direction
+						Gdk.Point i_center = rect_center (rect);
+						Gdk.Point j_center = rect_center (comp);
+						Gdk.Point diff = {j_center.x - i_center.x, j_center.y - i_center.y};
+						
+						// Prevent dividing by zero and non-movement
+						if (diff.x == 0 && diff.y == 0)
+							diff.x = 1;
+						
+						// Approximate a vector of between 10px and 20px in magnitude in the same direction
+						var length = Math.sqrtf (diff.x * diff.x + diff.y * diff.y);
+						diff.x = (int)Math.floorf (diff.x * ACCURACY / length);
+						diff.y = (int)Math.floorf (diff.y * ACCURACY / length);
+						// Move both windows apart
+						rect.x += -diff.x;
+						rect.y += -diff.y;
+						comp.x += diff.x;
+						comp.y += diff.y;
+						
+						// Try to keep the bounding rect the same aspect as the screen so that more
+						// screen real estate is utilised. We do this by splitting the screen into nine
+						// equal sections, if the window center is in any of the corner sections pull the
+						// window towards the outer corner. If it is in any of the other edge sections
+						// alternate between each corner on that edge. We don't want to determine it
+						// randomly as it will not produce consistant locations when using the filter.
+						// Only move one window so we don't cause large amounts of unnecessary zooming
+						// in some situations. We need to do this even when expanding later just in case
+						// all windows are the same size.
+						// (We are using an old bounding rect for this, hopefully it doesn't matter)
+						var x_section = (int)Math.roundf ((rect.x - bounds.x) / (bounds.width / 3.0f));
+						var y_section = (int)Math.roundf ((comp.y - bounds.y) / (bounds.height / 3.0f));
+						
+						i_center = rect_center (rect);
+						diff.x = 0;
+						diff.y = 0;
+						if (x_section != 1 || y_section != 1) { // Remove this if you want the center to pull as well
+							if (x_section == 1)
+								x_section = (directions[i] / 2 == 1 ? 2 : 0);
+							if (y_section == 1)
+								y_section = (directions[i] % 2 == 1 ? 2 : 0);
+						}
+						if (x_section == 0 && y_section == 0) {
+							diff.x = bounds.x - i_center.x;
+							diff.y = bounds.y - i_center.y;
+						}
+						if (x_section == 2 && y_section == 0) {
+							diff.x = bounds.x + bounds.width - i_center.x;
+							diff.y = bounds.y - i_center.y;
+						}
+						if (x_section == 2 && y_section == 2) {
+							diff.x = bounds.x + bounds.width - i_center.x;
+							diff.y = bounds.y + bounds.height - i_center.y;
+						}
+						if (x_section == 0 && y_section == 2) {
+							diff.x = bounds.x - i_center.x;
+							diff.y = bounds.y + bounds.height - i_center.y;
+						}
+						if (diff.x != 0 || diff.y != 0) {
+							length = Math.sqrtf (diff.x * diff.x + diff.y * diff.y);
+							diff.x *= (int)Math.floorf (ACCURACY / length / 2.0f);
+							diff.y *= (int)Math.floorf (ACCURACY / length / 2.0f);
+							rect.x += diff.x;
+							rect.y += diff.y;
+						}
+						
+						// Update bounding rect
+						bounds = bounds.union(rect);
+						bounds = bounds.union(comp);
+						
+						//we took copies from the rects from our list so we need to reassign them
+						rects[i] = rect;
+						rects[j] = comp;
+					}
+				}
+			} while (overlap && loop_counter < MAX_TRANSLATIONS);
+			
+			// Work out scaling by getting the most top-left and most bottom-right window coords.
+			float scale = Math.fminf (Math.fminf (area.width / (float)bounds.width, area.height / (float)bounds.height), 1.0f);
+			
+			// Make bounding rect fill the screen size for later steps
+			bounds.x = (int)Math.floorf (bounds.x - (area.width - bounds.width * scale) / 2);
+			bounds.y = (int)Math.floorf (bounds.y - (area.height - bounds.height * scale) / 2);
+			bounds.width = (int)Math.floorf (area.width / scale);
+			bounds.height = (int)Math.floorf (area.height / scale);
+			
+			// Move all windows back onto the screen and set their scale
+			var index = 0;
+			foreach (var rect in rects) {
+				rect = {(int)Math.floorf ((rect.x - bounds.x) * scale + area.x),
+				        (int)Math.floorf ((rect.y - bounds.y) * scale + area.y),
+				        (int)Math.floorf (rect.width * scale),
+				        (int)Math.floorf (rect.height * scale)};
+				
+				rects[index] = rect;
+				index++;
+			}
+			
+			// fill gaps by enlarging windows
+			bool moved = false;
+			Meta.Rectangle border = area;
+			do {
+				moved = false;
+				
+				index = 0;
+				foreach (var rect in rects) {
+					
+					int width_diff = ACCURACY;
+					int height_diff = (int)Math.floorf ((((rect.width + width_diff) - rect.height) / 
+					    (float)rect.width) * rect.height);
+					int x_diff = width_diff / 2;
+					int y_diff = height_diff / 2;
+					
+					//top right
+					Meta.Rectangle old = rect;
+					rect = {rect.x + x_diff, rect.y - y_diff - height_diff, rect.width + width_diff, rect.height + width_diff};
+					if (rect_is_overlapping_any (rect, rects, border))
+						rect = old;
+					else
+						moved = true;
+					
+					//bottom right
+					old = rect;
+					rect = {rect.x + x_diff, rect.y + y_diff, rect.width + width_diff, rect.height + width_diff};
+					if (rect_is_overlapping_any (rect, rects, border))
+						rect = old;
+					else
+						moved = true;
+					
+					//bottom left
+					old = rect;
+					rect = {rect.x - x_diff, rect.y + y_diff, rect.width + width_diff, rect.height + width_diff};
+					if (rect_is_overlapping_any (rect, rects, border))
+						rect = old;
+					else
+						moved = true;
+					
+					//top left
+					old = rect;
+					rect = {rect.x - x_diff, rect.y - y_diff - height_diff, rect.width + width_diff, rect.height + width_diff};
+					if (rect_is_overlapping_any (rect, rects, border))
+						rect = old;
+					else
+						moved = true;
+					
+					rects[index] = rect;
+					index++;
+				}
+			} while (moved);
+			
+			index = 0;
+			foreach (var rect in rects) {
+				var window = clones.nth_data (index) as WindowThumb;
+				var window_rect = window.window.get_outer_rect ();
+				
+				rect = rect_adjusted(rect, GAPS, GAPS, -GAPS, -GAPS);
+				scale = rect.width / (float)window_rect.width;
+				
+				if (scale > 2.0 || (scale > 1.0 && (window_rect.width > 300 || window_rect.height > 300))) {
+					scale = (window_rect.width > 300 || window_rect.height > 300) ? 1.0f : 2.0f;
+					rect = {rect_center (rect).x - (int)Math.floorf (window_rect.width * scale) / 2,
+					        rect_center (rect).y - (int)Math.floorf (window_rect.height * scale) / 2,
+					        (int)Math.floorf (window_rect.width * scale),
+					        (int)Math.floorf (window_rect.height * scale)};
+				}
+				
+				place_window (window, rect);
+				index++;
+			}
+		}
+		
+		// animate a window to the given position
+		void place_window (WindowThumb clone, Meta.Rectangle rect)
+		{
+			var fscale = rect.width / clone.width;
+			
+			//animate the windows and icons to the calculated positions
+			clone.icon.x = rect.x + Math.floorf (clone.width * fscale / 2.0f - clone.icon.width / 2.0f);
+			clone.icon.y = rect.y + Math.floorf (clone.height * fscale - 50.0f);
+			clone.icon.get_parent ().set_child_above_sibling (clone.icon, null);
+			
+			clone.close_button.x = rect.x - 10;
+			clone.close_button.y = rect.y - 10;
+			
+			clone.animate (Clutter.AnimationMode.EASE_OUT_CUBIC, 250, scale_x:fscale, scale_y:fscale, x:rect.x+0.0f, y:rect.y+0.0f)
+				.completed.connect (() => ready = true );
+			clone.icon.opacity = 0;
+			clone.icon.animate (Clutter.AnimationMode.EASE_OUT_CUBIC, 350, scale_x:1.0f, scale_y:1.0f, opacity:255);
+		}
+		
+		public void open (bool animate = true)
+		{
+			if (!ready)
+				return;
+			
+			if (visible) {
+				close (true);
+				return;
+			}
+			
+			ready = false;
+			
+			var used_windows = new SList<Window> ();
+			
+			foreach (var window in screen.get_active_workspace ().list_windows ()) {
+				if (window.window_type != WindowType.NORMAL && window.window_type != WindowType.DOCK) {
+					(window.get_compositor_private () as Actor).hide ();
+					continue;
+				}
+				if (window.window_type == WindowType.DOCK)
+					continue;
+				
+				used_windows.append (window);
+			}
+			
+			var n_windows = used_windows.length ();
+			if (n_windows == 0)
+				return;
+			
+			Compositor.get_background_actor_for_screen (screen).
+				animate (AnimationMode.EASE_OUT_QUAD, 1000, dim_factor : 0.4);
+			
+			// sort windows by stacking order
+			var windows = screen.get_display ().sort_windows_by_stacking (used_windows);
+			
+			grab_key_focus ();
+			
+			plugin.begin_modal ();
+			Utils.set_input_area (screen, InputArea.FULLSCREEN);
+			
+			visible = true;
+			
+			foreach (var window in windows) {
+				var actor = window.get_compositor_private () as WindowActor;
+				if (actor == null)
+					return;
+				actor.hide ();
+				
+				var clone = new WindowThumb (window);
+				clone.x = actor.x;
+				clone.y = actor.y;
+				
+				clone.selected.connect (selected);
+				clone.reposition.connect (reposition);
+				
+				add_child (clone);
+			}
+			
+			calculate_places (get_children ());
+		}
+		
+		//called when a window has been closed
+		void reposition (WindowThumb removed)
+		{
+				var children = get_children ().copy ();
+				children.remove (removed);
+				calculate_places (children);
+		}
+		
+		void selected (Window window)
+		{
+			window.activate (screen.get_display ().get_current_time ());
+			
+			close (true);
+		}
+		
+		void close (bool animate)
+		{
+			if (!visible || !ready)
+				return;
+			
+			ready = false;
+			
+			plugin.end_modal ();
+			plugin.update_input_area ();
+			
+			foreach (var child in get_children ()) {
+				var exposed = child as WindowThumb;
+				exposed.close (animate);
+				exposed.selected.disconnect (selected);
+			}
+			
+			Compositor.get_background_actor_for_screen (screen).
+				animate (AnimationMode.EASE_OUT_QUAD, 500, dim_factor : 1.0);
+			
+			if (animate) {
+				Timeout.add (300, () => {
+					visible = false;
+					ready = true;
+					
+					foreach (var window in screen.get_active_workspace ().list_windows ())
+						(window.get_compositor_private () as Actor).show ();
+					
+					return false;
+				});
+			} else {
+				ready = true;
+				visible = false;
+				
+				foreach (var window in screen.get_active_workspace ().list_windows ())
+					(window.get_compositor_private () as Actor).show ();
+			}
+		}
+	}
+}

=== added file 'src/Widgets/WindowThumb.vala'
--- src/Widgets/WindowThumb.vala	1970-01-01 00:00:00 +0000
+++ src/Widgets/WindowThumb.vala	2012-08-27 21:04:19 +0000
@@ -0,0 +1,167 @@
+//  
+//  Copyright (C) 2012 Tom Beckmann
+// 
+//  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 3 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.
+// 
+//  You should have received a copy of the GNU General Public License
+//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+// 
+
+using Meta;
+using Clutter;
+
+namespace Gala
+{
+	public class WindowThumb : Actor
+	{
+		public weak Window window;
+		Clone clone;
+		public GtkClutter.Texture icon;
+		public GtkClutter.Texture close_button;
+		
+		public signal void selected (Window window);
+		public signal void reposition ();
+		
+		public WindowThumb (Window _window)
+		{
+			window = _window;
+			
+			reactive = true;
+			
+			var actor = window.get_compositor_private () as WindowActor;
+			clone = new Clone (actor.get_texture ());
+			
+			icon = new GtkClutter.Texture ();
+			icon.scale_x = 0.0f;
+			icon.scale_y = 0.0f;
+			icon.scale_gravity = Gravity.CENTER;
+			
+			try {
+				icon.set_from_pixbuf (Utils.get_icon_for_window (window, 64));
+			} catch (Error e) { warning (e.message); }
+			
+			close_button = new GtkClutter.Texture ();
+			close_button.reactive = true;
+			close_button.visible = false;
+			close_button.scale_x = 0.0f;
+			close_button.scale_y = 0.0f;
+			close_button.scale_gravity = Gravity.CENTER;
+			close_button.button_press_event.connect (close_clicked);
+			close_button.leave_event.connect ((e) => leave_event (e));
+			
+			try {
+				close_button.set_from_pixbuf (Granite.Widgets.Utils.get_close_pixbuf ());
+			} catch (Error e) { warning (e.message); }
+			
+			add_child (clone);
+			
+			var stage = Compositor.get_stage_for_screen (window.get_screen ());
+			stage.add_child (icon);
+			stage.add_child (close_button);
+		}
+		
+		bool close_clicked (ButtonEvent event)
+		{
+			if (event.button != 1)
+				return false;
+			
+			//make sure we dont see a window closing animation in the background
+			(window.get_compositor_private () as Actor).opacity = 0;
+			get_parent ().set_child_below_sibling (this, null);
+			animate (AnimationMode.EASE_IN_CUBIC, 200, depth : -50.0f, opacity : 0).completed.connect (() => {
+				destroy ();
+				window.delete (window.get_screen ().get_display ().get_current_time ());
+			});
+			
+			close_button.destroy ();
+			icon.destroy ();
+			
+			reposition ();
+			
+			return true;
+		}
+		
+		public override bool enter_event (CrossingEvent event)
+		{
+			//if we're still animating don't show the close button
+			if (get_animation () != null)
+				return false;
+			
+			close_button.visible = true;
+			close_button.animate (AnimationMode.EASE_OUT_ELASTIC, 400, scale_x : 1.0f, scale_y : 1.0f);
+			
+			return true;
+		}
+		
+		public override bool motion_event (MotionEvent event)
+		{
+			if (get_animation () != null)
+				return false;
+			
+			close_button.visible = true;
+			close_button.animate (AnimationMode.EASE_OUT_ELASTIC, 400, scale_x : 1.0f, scale_y : 1.0f);
+			
+			return true;
+		}
+		
+		public override bool leave_event (CrossingEvent event)
+		{
+			if (event.related == close_button)
+				return false;
+			
+			close_button.animate (AnimationMode.EASE_IN_QUAD, 200, scale_x : 0.0f, scale_y : 0.0f)
+				.completed.connect (() => close_button.visible = false );
+			
+			return true;
+		}
+		
+		public override bool button_press_event (ButtonEvent event)
+		{
+			get_parent ().set_child_above_sibling (this, null);
+			selected (window);
+			
+			return true;
+		}
+		
+		public void close (bool do_animate=true)
+		{
+			unowned Meta.Rectangle rect = window.get_outer_rect ();
+			
+			//FIXME need to subtract 10 here to remove jump for most windows, but adds jump for maximized ones
+			float delta = window.maximized_horizontally || window.maximized_vertically ? 0 : 10;
+			
+			float dest_x = rect.x - delta;
+			float dest_y = rect.y - delta;
+			
+			//stop all running animations
+			detach_animation ();
+			icon.detach_animation ();
+			
+			if (do_animate) {
+				icon.animate (AnimationMode.EASE_IN_CUBIC, 100, scale_x:0.0f, scale_y:0.0f).completed.connect ( () => {
+					icon.destroy ();
+				});
+				
+				animate (AnimationMode.EASE_IN_OUT_CUBIC, 300, scale_x:1.0f, scale_y:1.0f, x:dest_x, y:dest_y).completed.connect (() => {
+					(window.get_compositor_private () as Actor).show ();
+					destroy ();
+				});
+			} else {
+				(window.get_compositor_private () as Actor).show ();
+				
+				destroy ();
+				icon.destroy ();
+			}
+			
+			close_button.destroy ();
+		}
+	}
+}

=== modified file 'src/Widgets/WorkspaceView.vala'
--- src/Widgets/WorkspaceView.vala	2012-08-09 15:20:04 +0000
+++ src/Widgets/WorkspaceView.vala	2012-08-27 21:04:19 +0000
@@ -320,12 +320,12 @@
 			
 			var screen = plugin.get_screen ();
 			
+			visible = true;
+			grab_key_focus ();
+			
 			Utils.set_input_area (screen, InputArea.FULLSCREEN);
 			plugin.begin_modal ();
 			
-			visible = true;
-			grab_key_focus ();
-			
 			if (wait) {
 				timeout = Timeout.add (1000, () => {
 					show_elements ();