Merge lp:~ricotz/plank/animate-add-remove into lp:plank

[Rico Tzschichholz]

[lp:~ricotz/plank/animate-add-remove]

1161. By Rico Tzschichholz on 2015-01-20

Fix broken virtual LauncherEntry-items

Regression of r1057

1162. By Rico Tzschichholz on 2015-01-20

positionmanager: Alignment should have same meaning for dock and items

START and END were treated differently resulting in a contradicting
settings-behaviour of Aligment and ItemsAlignment

1163. By Rico Tzschichholz on 2015-01-20

build: Request gee-0.8 without an automatic fallback to gee-1.0

1164. By Rico Tzschichholz on 2015-01-21

build: Compatibility for BSD, use replacement for sys/prctl.h

1165. By Rico Tzschichholz on 2015-01-21

Make use of Gdk.EVENT_PROPAGATE and Gdk.EVENT_STOP

1166. By Rico Tzschichholz on 2015-01-25

po: Update translations

1167. By Rico Tzschichholz on 2015-01-25

Prepare 0.8.1 release

1168. By Rico Tzschichholz on 2015-01-25

Back to development

1169. By Rico Tzschichholz on 2015-01-26

dockitem: Fix warning while building non-HiDPI

1170. By Rico Tzschichholz on 2015-01-21

renderer: Redo final drawing to untangle the different layers

Adds additional drawing operations and therefore slows things down a bit.

1171. By Rico Tzschichholz on 2015-01-22

drawing: Add standard set of easing-functions

1172. By Rico Tzschichholz on 2015-01-26

Add add/remove animations for dock-items

1173. By Rico Tzschichholz on 2015-01-26

theme: Increase default ItemMoveTime to 450ms

=== modified file 'data/themes/Default/dock.theme'
--- data/themes/Default/dock.theme	2013-10-01 14:44:00 +0000
+++ data/themes/Default/dock.theme	2015-01-26 20:17:08 +0000
@@ -59,4 +59,4 @@
 #The hue-shift (-180 to 180) of the urgent indicator color.
 UrgentHueShift=150
 #The time (in ms) to move an item to its new position.
-ItemMoveTime=150
+ItemMoveTime=450

=== modified file 'docs/Makefile.am'
--- docs/Makefile.am	2014-10-10 07:01:51 +0000
+++ docs/Makefile.am	2015-01-26 20:17:08 +0000
@@ -34,6 +34,7 @@
 	$(top_srcdir)/lib/Drawing/DrawingService.vala \
 	$(top_srcdir)/lib/Drawing/DockSurface.vala \
 	$(top_srcdir)/lib/Drawing/DockTheme.vala \
+	$(top_srcdir)/lib/Drawing/Easing.vala \
 	$(top_srcdir)/lib/Drawing/Theme.vala \
 	$(top_srcdir)/lib/Factories/AbstractMain.vala \
 	$(top_srcdir)/lib/Factories/Factory.vala \

=== modified file 'lib/DockController.vala'
--- lib/DockController.vala	2014-11-04 09:54:12 +0000
+++ lib/DockController.vala	2015-01-26 20:17:08 +0000
@@ -225,6 +225,10 @@
 			if (provider == default_provider)
 				serialize_item_positions ();
 			
+			// Schedule added/removed items for special animations
+			renderer.animate_items (added);
+			renderer.animate_items (removed);
+			
 			update_visible_items ();
 			
 			if (prefs.Alignment != Gtk.Align.FILL

=== modified file 'lib/DockRenderer.vala'
--- lib/DockRenderer.vala	2015-01-05 10:54:40 +0000
+++ lib/DockRenderer.vala	2015-01-26 20:17:08 +0000
@@ -43,11 +43,14 @@
 		[CCode (notify = false)]
 		double opacity { get; private set; }
 
+		DockSurface? main_buffer = null;
+		DockSurface? fade_buffer = null;
+		DockSurface? item_buffer = null;
+		DockSurface? shadow_buffer = null;
+		
 		DockSurface? background_buffer = null;
 		Gdk.Rectangle background_rect;
-		DockSurface? main_buffer = null;
 		DockSurface? indicator_buffer = null;
-		DockSurface? shadow_buffer = null;
 		DockSurface? urgent_indicator_buffer = null;
 		DockSurface? urgent_glow_buffer = null;
 		
@@ -61,6 +64,9 @@
 		
 		ulong gtk_theme_name_changed_id = 0;
 		
+		double dynamic_animation_offset = 0.0;
+		
+		Gee.HashSet<DockItem> transient_items;
 #if BENCHMARK
 		Gee.ArrayList<string> benchmark;
 #endif
@@ -78,6 +84,7 @@
 		
 		construct
 		{
+			transient_items = new Gee.HashSet<DockItem> ();
 #if BENCHMARK
 			benchmark = new Gee.ArrayList<string> ();
 #endif
@@ -187,9 +194,12 @@
 			Logger.verbose ("DockRenderer.reset_buffers ()");
 			
 			main_buffer = null;
+			fade_buffer = null;
+			item_buffer = null;
+			shadow_buffer = null;
+			
 			background_buffer = null;
 			indicator_buffer = null;
-			shadow_buffer = null;
 			urgent_indicator_buffer = null;
 			urgent_glow_buffer = null;
 			
@@ -213,6 +223,7 @@
 		{
 			frame_time = GLib.get_monotonic_time ();
 			screen_is_composited = controller.position_manager.screen_is_composited;
+			dynamic_animation_offset = 0.0;
 			
 			var fade_opacity = theme.FadeOpacity;
 			
@@ -258,6 +269,13 @@
 #endif
 			}
 			
+			if (item_buffer == null) {
+				item_buffer = new DockSurface.with_surface (win_rect.width, win_rect.height, cr.get_target ());
+#if HAVE_HIDPI
+				cairo_surface_set_device_scale (item_buffer.Internal, window_scale_factor, window_scale_factor);
+#endif
+			}
+			
 			if (shadow_buffer == null) {
 				shadow_buffer = new DockSurface.with_surface (win_rect.width, win_rect.height, cr.get_target ());
 #if HAVE_HIDPI
@@ -282,60 +300,179 @@
 				return;
 			}
 
+			if (opacity < 1.0 && fade_buffer == null) {
+				fade_buffer = new DockSurface.with_surface (win_rect.width, win_rect.height, cr.get_target ());
+#if HAVE_HIDPI
+				cairo_surface_set_device_scale (fade_buffer.Internal, window_scale_factor, window_scale_factor);
+#endif
+			}
+			
 #if BENCHMARK
+			DateTime start, start2, end, end2;
 			benchmark.clear ();
-			var start = new DateTime.now_local ();
+			start = new DateTime.now_local ();
 #endif
 			
 			main_buffer.clear ();
+			item_buffer.clear ();
 			shadow_buffer.clear ();
-			
-#if BENCHMARK
-			var start2 = new DateTime.now_local ();
-#endif
-			draw_dock_background ();
-#if BENCHMARK
-			var end2 = new DateTime.now_local ();
+			unowned Cairo.Context item_cr = item_buffer.Context;
+			
+			// draw transient items onto the dock buffer and calculate the resulting
+			// dynamic-animation-offset used to animate the background-resize
+			if (screen_is_composited) {
+				var add_time = 0LL;
+				var remove_time = 0LL;
+				var move_time = 0LL;
+				var move_duration = theme.ItemMoveTime * 1000;
+				
+				var transient_items_it = transient_items.iterator ();
+				while (transient_items_it.next ()) {
+					var item = transient_items_it.get ();
+					add_time = item.AddTime;
+					remove_time = item.RemoveTime;
+					
+					if (add_time > remove_time) {
+						move_time = frame_time - add_time;
+						if (move_time < move_duration) {
+							var move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_OUT_QUINT, move_time, move_duration);
+							dynamic_animation_offset -= move_animation_progress * (position_manager.IconSize + position_manager.ItemPadding);
+						} else {
+							transient_items_it.remove ();
+						}
+					} else if (remove_time > 0) {
+						move_time = frame_time - remove_time;
+						if (move_time < move_duration) {
+							var move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_IN_QUINT, move_time, move_duration);
+							dynamic_animation_offset += move_animation_progress * (position_manager.IconSize + position_manager.ItemPadding);
+						} else {
+							transient_items_it.remove ();
+						}
+					} else {
+						continue;
+					}
+#if BENCHMARK
+					start2 = new DateTime.now_local ();
+#endif
+					// Do not draw the currently dragged item or items which are suppose to be drawn later
+					if (move_time < move_duration && dragged_item != item && !items.contains (item))
+						draw_item (item_cr, item);
+#if BENCHMARK
+					end2 = new DateTime.now_local ();
+					benchmark.add ("item render time - %f ms".printf (end2.difference (start2) / 1000.0));
+#endif
+				}
+			} else {
+				transient_items.clear ();
+			}
+
+			background_rect = position_manager.get_background_region ();
+			
+			// calculate drawing offset
+			var x_offset = 0, y_offset = 0;
+			if (opacity == 1.0)
+				position_manager.get_dock_draw_position (out x_offset, out y_offset);
+			
+			// calculate drawing animation-offset
+			var x_animation_offset = 0, y_animation_offset = 0;
+			switch (controller.prefs.Alignment) {
+			default:
+			case Gtk.Align.CENTER:
+				if (position_manager.is_horizontal_dock ())
+					x_animation_offset -= (int) Math.round (dynamic_animation_offset / 2.0);
+				else
+					y_animation_offset -= (int) Math.round (dynamic_animation_offset / 2.0);
+				background_rect = { background_rect.x + x_animation_offset, background_rect.y + y_animation_offset,
+					background_rect.width -2 * x_animation_offset, background_rect.height -2 * y_animation_offset };
+				break;
+			case Gtk.Align.START:
+				if (position_manager.is_horizontal_dock ())
+					background_rect = { background_rect.x, background_rect.y,
+						background_rect.width + (int) Math.round (dynamic_animation_offset), background_rect.height };
+				else
+					background_rect = { background_rect.x, background_rect.y,
+						background_rect.width, background_rect.height + (int) Math.round (dynamic_animation_offset) };
+				break;
+			case Gtk.Align.END:
+				if (position_manager.is_horizontal_dock ())
+					x_animation_offset -= (int) Math.round (dynamic_animation_offset);
+				else
+					y_animation_offset -= (int) Math.round (dynamic_animation_offset);
+				background_rect = { background_rect.x + x_animation_offset, background_rect.y + y_animation_offset,
+					background_rect.width - x_animation_offset, background_rect.height - y_animation_offset };
+				break;
+			case Gtk.Align.FILL:
+				switch (controller.prefs.ItemsAlignment) {
+				default:
+				case Gtk.Align.FILL:
+				case Gtk.Align.CENTER:
+					if (position_manager.is_horizontal_dock ())
+						x_animation_offset -= (int) Math.round (dynamic_animation_offset / 2.0);
+					else
+						y_animation_offset -= (int) Math.round (dynamic_animation_offset / 2.0);
+					break;
+				case Gtk.Align.START:
+					break;
+				case Gtk.Align.END:
+					if (position_manager.is_horizontal_dock ())
+						x_animation_offset -= (int) Math.round (dynamic_animation_offset);
+					else
+						y_animation_offset -= (int) Math.round (dynamic_animation_offset);
+					break;
+				}
+				break;
+			}
+			
+			// composite dock layers and make sure to draw onto the window's context with one operation
+			main_buffer.clear ();
+			unowned Cairo.Context main_cr = main_buffer.Context;
+			main_cr.set_operator (Cairo.Operator.OVER);
+			
+			// draw items-shadow-layer
+			main_cr.set_source_surface (shadow_buffer.Internal, x_animation_offset, y_animation_offset);
+			main_cr.paint ();
+			
+#if BENCHMARK
+			start2 = new DateTime.now_local ();
+#endif
+			// draw background-layer
+			draw_dock_background (main_cr, background_rect);
+#if BENCHMARK
+			end2 = new DateTime.now_local ();
 			benchmark.add ("background render time - %f ms".printf (end2.difference (start2) / 1000.0));
 #endif
 			
-			
 			// draw each item onto the dock buffer
-			foreach (var item in items)
-			{
+			foreach (var item in items) {
 #if BENCHMARK
 				start2 = new DateTime.now_local ();
 #endif
 				// Do not draw the currently dragged item
 				if (dragged_item != item)
-					draw_item (item);
+					draw_item (item_cr, item);
 #if BENCHMARK
 				end2 = new DateTime.now_local ();
 				benchmark.add ("item render time - %f ms".printf (end2.difference (start2) / 1000.0));
 #endif
 			}
 			
-			// calculate drawing offset
-			var x_offset = 0, y_offset = 0;
-			if (opacity == 1.0)
-				position_manager.get_dock_draw_position (out x_offset, out y_offset);
-			
-			// composite dock layers and make sure to draw onto the window's context with one operation
-			unowned Cairo.Context composite_cr = shadow_buffer.Context;
-			composite_cr.set_operator (Cairo.Operator.OVER);
-			composite_cr.set_source_surface (main_buffer.Internal, 0, 0);
-			composite_cr.paint ();
-			
-			// fade the dock if need be
+			// draw items-layer
+			main_cr.set_source_surface (item_buffer.Internal, x_animation_offset, y_animation_offset);
+			main_cr.paint ();
+			
+			// draw the dock on the window and fade it if need be
+			cr.set_operator (Cairo.Operator.SOURCE);
 			if (opacity < 1.0) {
-				composite_cr.set_operator (Cairo.Operator.SOURCE);
-				composite_cr.set_source_rgba (0, 0, 0, 0);
-				composite_cr.paint_with_alpha (1 - opacity);
+				fade_buffer.clear ();
+				unowned Cairo.Context fade_cr = fade_buffer.Context;
+				fade_cr.set_operator (Cairo.Operator.OVER);
+				fade_cr.set_source_surface (main_buffer.Internal, 0, 0);
+				fade_cr.paint_with_alpha (opacity);
+				
+				cr.set_source_surface (fade_buffer.Internal, x_offset, y_offset);
+			} else {
+				cr.set_source_surface (main_buffer.Internal, x_offset, y_offset);
 			}
-			
-			// draw the dock on the window
-			cr.set_operator (Cairo.Operator.SOURCE);
-			cr.set_source_surface (shadow_buffer.Internal, x_offset, y_offset);
 			cr.paint ();
 			
 			// draw urgent-glow if dock is completely hidden
@@ -345,7 +482,7 @@
 			}
 			
 #if BENCHMARK
-			var end = new DateTime.now_local ();
+			end = new DateTime.now_local ();
 			var diff = end.difference (start) / 1000.0;
 			if (diff > 5.0)
 				foreach (var s in benchmark)
@@ -356,12 +493,10 @@
 			is_first_frame = false;
 		}
 		
-		void draw_dock_background ()
+		void draw_dock_background (Cairo.Context cr, Gdk.Rectangle background_rect)
 		{
 			unowned PositionManager position_manager = controller.position_manager;
 			
-			background_rect = position_manager.get_background_region ();
-			
 			if (background_rect.width <= 0 || background_rect.height <= 0) {
 				background_buffer = null;
 				return;
@@ -372,28 +507,28 @@
 				background_buffer = theme.create_background (background_rect.width, background_rect.height,
 					position_manager.Position, main_buffer);
 			
-			unowned Cairo.Context cr = main_buffer.Context;
 			cr.set_source_surface (background_buffer.Internal, background_rect.x, background_rect.y);
 			cr.paint ();
 		}
 		
-		void draw_item (DockItem item)
+		void draw_item (Cairo.Context cr, DockItem item)
 		{
 			unowned PositionManager position_manager = controller.position_manager;
 			unowned DockItem hovered_item = controller.window.HoveredItem;
 			unowned DragManager drag_manager = controller.drag_manager;
 			
-			unowned Cairo.Context main_cr = main_buffer.Context;
 			unowned Cairo.Context shadow_cr = shadow_buffer.Context;
 			var icon_size = position_manager.IconSize;
 			var shadow_size = position_manager.IconShadowSize;
 			var position = position_manager.Position;
+			var show_indicator = true;
+			var item_opacity = 1.0;
 			
 			// load the icon
 #if BENCHMARK
 			var start = new DateTime.now_local ();
 #endif
-			var icon_surface = item.get_surface_copy (icon_size * window_scale_factor, icon_size * window_scale_factor, main_buffer);
+			var icon_surface = item.get_surface_copy (icon_size * window_scale_factor, icon_size * window_scale_factor, item_buffer);
 			unowned Cairo.Context icon_cr = icon_surface.Context;
 			
 			DockSurface? icon_shadow_surface = null;
@@ -471,9 +606,9 @@
 			if (hover_time < max_hover_time) {
 				var hover_animation_progress = 0.0;
 				if (hovered_item == item) {
-					hover_animation_progress = double.min (1.0, hover_time / (double) max_hover_time);
+					hover_animation_progress = Drawing.easing_for_mode (AnimationMode.LINEAR, hover_time, max_hover_time);
 				} else {
-					hover_animation_progress = double.max (0.0, 1.0 - hover_time / (double) max_hover_time);
+					hover_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.LINEAR, hover_time, max_hover_time);
 				}
 				
 				switch (item.HoveredAnimation) {
@@ -524,23 +659,55 @@
 			
 			// animate icon movement on move state
 			if ((item.State & ItemState.MOVE) != 0) {
+				var move_duration = theme.ItemMoveTime * 1000;
 				var move_time = frame_time - item.LastMove;
-				var move_animation_progress = move_time / (double) (theme.ItemMoveTime * 1000);
-				if (move_animation_progress < 1.0) {
-					var change = (1.0 - move_animation_progress) * (icon_size + position_manager.ItemPadding);
+				if (move_time < move_duration) {
+					var move_animation_progress = 0.0;
+					if (transient_items.size > 0) {
+						if (dynamic_animation_offset > 0)
+							move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_IN_QUINT, move_time, move_duration);
+						else
+							move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_OUT_QUINT, move_time, move_duration);
+					} else {
+						move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_OUT_CIRC, move_time, move_duration);
+					}
+					var change = move_animation_progress * (icon_size + position_manager.ItemPadding);
 					draw_value.move_right (position, (item.Position < item.LastPosition ? change : -change));
 				} else {
 					item.unset_move_state ();
 				}
 			}
-
+			
+			// animate addition/removal
+			if (screen_is_composited && item.AddTime > item.RemoveTime) {
+				var move_duration = theme.ItemMoveTime * 1000;
+				var move_time = frame_time - item.AddTime;
+				if (move_time < move_duration) {
+					var move_animation_progress = 1.0 - Drawing.easing_for_mode (AnimationMode.LINEAR, move_time, move_duration);
+					item_opacity = Drawing.easing_for_mode (AnimationMode.EASE_IN_EXPO, move_time, move_duration);
+					var change = move_animation_progress * (icon_size + position_manager.BottomPadding);
+					draw_value.move_in (position, -change);
+					show_indicator = false;
+				}
+			} else if (screen_is_composited && item.RemoveTime > 0) {
+				var move_duration = theme.ItemMoveTime * 1000;
+				var move_time = frame_time - item.RemoveTime;
+				if (move_time < move_duration) {
+					var move_animation_progress = Drawing.easing_for_mode (AnimationMode.LINEAR, move_time, move_duration);
+					item_opacity = 1.0 - Drawing.easing_for_mode (AnimationMode.EASE_OUT_EXPO, move_time, move_duration);
+					var change = move_animation_progress * (icon_size + position_manager.BottomPadding);
+					draw_value.move_in (position, -change);
+					show_indicator = false;
+				}
+			}
+			
 			// draw active glow
 			var active_time = frame_time - item.LastActive;
 			var opacity = double.min (1, active_time / (double) (theme.ActiveTime * 1000));
 			if ((item.State & ItemState.ACTIVE) == 0)
 				opacity = 1 - opacity;
 			if (opacity > 0) {
-				theme.draw_active_glow (main_buffer, background_rect, draw_value.background_region, item.AverageIconColor, opacity, position);
+				theme.draw_active_glow (item_buffer, background_rect, draw_value.background_region, item.AverageIconColor, opacity, position);
 			}
 			
 			// draw the icon shadow
@@ -551,23 +718,29 @@
 				}
 				shadow_cr.set_operator (Cairo.Operator.OVER);
 				shadow_cr.set_source_surface (icon_shadow_surface.Internal, (draw_value.draw_region.x - shadow_size) * window_scale_factor, (draw_value.draw_region.y - shadow_size) * window_scale_factor);
-				shadow_cr.paint ();
+				if (item_opacity < 1.0)
+					shadow_cr.paint_with_alpha (item_opacity);
+				else
+					shadow_cr.paint ();
 				if (window_scale_factor > 1)
 					shadow_cr.restore ();
 			}
 
 			// draw the icon
 			if (window_scale_factor > 1) {
-				main_cr.save ();
-				main_cr.scale (1.0 / window_scale_factor, 1.0 / window_scale_factor);
+				cr.save ();
+				cr.scale (1.0 / window_scale_factor, 1.0 / window_scale_factor);
 			}
-			main_cr.set_source_surface (icon_surface.Internal, draw_value.draw_region.x * window_scale_factor, draw_value.draw_region.y * window_scale_factor);
-			main_cr.paint ();
+			cr.set_source_surface (icon_surface.Internal, draw_value.draw_region.x * window_scale_factor, draw_value.draw_region.y * window_scale_factor);
+			if (item_opacity < 1.0)
+				cr.paint_with_alpha (item_opacity);
+			else
+				cr.paint ();
 			if (window_scale_factor > 1)
-				main_cr.restore ();
+				cr.restore ();
 			
 			// draw indicators
-			if (item.Indicator != IndicatorState.NONE)
+			if (show_indicator && item.Indicator != IndicatorState.NONE)
 				draw_indicator_state (draw_value.hover_region, item.Indicator, item.State);
 		}
 		
@@ -648,24 +821,24 @@
 			if (indicator_buffer == null) {
 				var indicator_color = get_styled_color ();
 				indicator_color.set_min_sat (0.4);
-				indicator_buffer = theme.create_indicator (position_manager.IndicatorSize, indicator_color, main_buffer);
+				indicator_buffer = theme.create_indicator (position_manager.IndicatorSize, indicator_color, item_buffer);
 			}
 			if (urgent_indicator_buffer == null) {
 				var urgent_indicator_color = get_styled_color ();
 				urgent_indicator_color.add_hue (theme.UrgentHueShift);
 				urgent_indicator_color.set_sat (1.0);
-				urgent_indicator_buffer = theme.create_indicator (position_manager.IndicatorSize, urgent_indicator_color, main_buffer);
+				urgent_indicator_buffer = theme.create_indicator (position_manager.IndicatorSize, urgent_indicator_color, item_buffer);
 			}
 			
 			unowned DockSurface indicator_surface = (item_state & ItemState.URGENT) != 0 ? urgent_indicator_buffer : indicator_buffer;
-			unowned Cairo.Context main_cr = main_buffer.Context;
+			unowned Cairo.Context cr = item_buffer.Context;
 			
 			var x = 0.0, y = 0.0;
 			switch (position_manager.Position) {
 			default:
 			case Gtk.PositionType.BOTTOM:
 				x = item_rect.x + item_rect.width / 2.0 - indicator_surface.Width / 2.0;
-				y = main_buffer.Height - indicator_surface.Height / 2.0 - 2.0 * theme.get_bottom_offset () - indicator_surface.Height / 24.0;
+				y = item_buffer.Height - indicator_surface.Height / 2.0 - 2.0 * theme.get_bottom_offset () - indicator_surface.Height / 24.0;
 				break;
 			case Gtk.PositionType.TOP:
 				x = item_rect.x + item_rect.width / 2.0 - indicator_surface.Width / 2.0;
@@ -676,14 +849,14 @@
 				y = item_rect.y + item_rect.height / 2.0 - indicator_surface.Height / 2.0;
 				break;
 			case Gtk.PositionType.RIGHT:
-				x = main_buffer.Width - indicator_surface.Width / 2.0 - 2.0 * theme.get_bottom_offset () - indicator_surface.Width / 24.0;
+				x = item_buffer.Width - indicator_surface.Width / 2.0 - 2.0 * theme.get_bottom_offset () - indicator_surface.Width / 24.0;
 				y = item_rect.y + item_rect.height / 2.0 - indicator_surface.Height / 2.0;
 				break;
 			}
 			
 			if (indicator == IndicatorState.SINGLE) {
-				main_cr.set_source_surface (indicator_surface.Internal, x, y);
-				main_cr.paint ();
+				cr.set_source_surface (indicator_surface.Internal, x, y);
+				cr.paint ();
 			} else {
 				var x_offset = 0.0, y_offset = 0.0;
 				if (position_manager.is_horizontal_dock ())
@@ -691,10 +864,10 @@
 				else
 					y_offset = position_manager.IconSize / 16.0;
 				
-				main_cr.set_source_surface (indicator_surface.Internal, x - x_offset, y - y_offset);
-				main_cr.paint ();
-				main_cr.set_source_surface (indicator_surface.Internal, x + x_offset, y + y_offset);
-				main_cr.paint ();
+				cr.set_source_surface (indicator_surface.Internal, x - x_offset, y - y_offset);
+				cr.paint ();
+				cr.set_source_surface (indicator_surface.Internal, x + x_offset, y + y_offset);
+				cr.paint ();
 			}
 		}
 		
@@ -754,6 +927,20 @@
 			animated_draw ();
 		}
 		
+		public void animate_items (Gee.List<DockElement> elements)
+		{
+			if (!screen_is_composited)
+				return;
+			
+			foreach (var element in elements) {
+				DockItem? item = (element as DockItem);
+				if (item != null)
+					transient_items.add (item);
+			}
+			
+			animated_draw ();
+		}
+		
 		/**
 		 * {@inheritDoc}
 		 */
@@ -767,6 +954,9 @@
 					return true;
 			}
 			
+			if (transient_items.size > 0)
+				return true;
+			
 			foreach (var item in controller.Items) {
 				if (item.ClickedAnimation != Animation.NONE
 					&& render_time - item.LastClicked <= (item.ClickedAnimation == Animation.BOUNCE ? theme.LaunchBounceTime : theme.ClickTime) * 1000)
@@ -783,6 +973,10 @@
 					return true;
 				if (render_time - item.LastMove <= theme.ItemMoveTime * 1000)
 					return true;
+				if (render_time - item.AddTime <= theme.ItemMoveTime * 1000)
+					return true;
+				if (render_time - item.RemoveTime <= theme.ItemMoveTime * 1000)
+					return true;
 			}
 				
 			return false;

=== modified file 'lib/Drawing/DockTheme.vala'
--- lib/Drawing/DockTheme.vala	2014-11-20 08:05:10 +0000
+++ lib/Drawing/DockTheme.vala	2015-01-26 20:17:08 +0000
@@ -133,7 +133,7 @@
 			GlowTime = 10000;
 			GlowPulseTime = 2000;
 			UrgentHueShift = 150;
-			ItemMoveTime = 150;
+			ItemMoveTime = 450;
 		}
 		
 		/**

=== added file 'lib/Drawing/Easing.vala'
--- lib/Drawing/Easing.vala	1970-01-01 00:00:00 +0000
+++ lib/Drawing/Easing.vala	2015-01-26 20:17:08 +0000
@@ -0,0 +1,548 @@
+//
+//  Copyright (C) 2015 Rico Tzschichholz
+//
+//  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/>.
+//
+
+namespace Plank.Drawing
+{
+	/**
+	 * Utility functions to calculate progress of transitions.
+	 * Initially ported from clutter's clutter-enums.h and clutter-easing.c
+	 */
+
+	/**
+	 * The available animation modes
+	 */
+	public enum AnimationMode
+	{
+		CUSTOM = 0,
+
+		/**
+		 * linear tweening
+		 */
+		LINEAR,
+
+		/**
+		 * quadratic tweening
+		 */
+		EASE_IN_QUAD,
+		/**
+		 * quadratic tweening, inverse of EASE_IN_QUAD
+		 */
+		EASE_OUT_QUAD,
+		/**
+		 * quadratic tweening, combininig EASE_IN_QUAD and EASE_OUT_QUAD
+		 */
+		EASE_IN_OUT_QUAD,
+
+		/**
+		 * cubic tweening
+		 */
+		EASE_IN_CUBIC,
+		/**
+		 * cubic tweening, invers of EASE_IN_CUBIC
+		 */
+		EASE_OUT_CUBIC,
+		/**
+		 * cubic tweening, combining EASE_IN_CUBIC and EASE_OUT_CUBIC
+		 */
+		EASE_IN_OUT_CUBIC,
+
+		/**
+		 * quartic tweening
+		 */
+		EASE_IN_QUART,
+		/**
+		 * quartic tweening, inverse of EASE_IN_QUART
+		 */
+		EASE_OUT_QUART,
+		/**
+		 * quartic tweening, combining EASE_IN_QUART and EASE_OUT_QUART
+		 */
+		EASE_IN_OUT_QUART,
+
+		/**
+		 * quintic tweening
+		 */
+		EASE_IN_QUINT,
+		/**
+		 * quintic tweening, inverse of EASE_IN_QUINT
+		 */
+		EASE_OUT_QUINT,
+		/**
+		 * fifth power tweening, combining EASE_IN_QUINT and EASE_OUT_QUINT
+		 */
+		EASE_IN_OUT_QUINT,
+
+		/**
+		 * sinusoidal tweening
+		 */
+		EASE_IN_SINE,
+		/**
+		 * sinusoidal tweening, inverse of EASE_IN_SINE
+		 */
+		EASE_OUT_SINE,
+		/**
+		 * sine wave tweening, combining EASE_IN_SINE and EASE_OUT_SINE
+		 */
+		EASE_IN_OUT_SINE,
+
+		/**
+		 * exponential tweening
+		 */
+		EASE_IN_EXPO,
+		/**
+		 * exponential tweening, inverse of EASE_IN_EXPO
+		 */
+		EASE_OUT_EXPO,
+		/**
+		 * exponential tweening, combining EASE_IN_EXPO and EASE_OUT_EXPO
+		 */
+		EASE_IN_OUT_EXPO,
+
+		/**
+		 * circular tweening
+		 */
+		EASE_IN_CIRC,
+		/**
+		 * circular tweening, inverse of EASE_IN_CIRC
+		 */
+		EASE_OUT_CIRC,
+		/**
+		 * circular tweening, combining EASE_IN_CIRC and EASE_OUT_CIRC
+		 */
+		EASE_IN_OUT_CIRC,
+
+		/**
+		 * elastic tweening, with offshoot on start
+		 */
+		EASE_IN_ELASTIC,
+		/**
+		 * elastic tweening, with offshoot on end
+		 */
+		EASE_OUT_ELASTIC,
+		/**
+		 * elastic tweening with offshoot on both ends
+		 */
+		EASE_IN_OUT_ELASTIC,
+
+		/**
+		 * overshooting cubic tweening, with backtracking on start
+		 */
+		EASE_IN_BACK,
+		/**
+		 * overshooting cubic tweening, with backtracking on end
+		 */
+		EASE_OUT_BACK,
+		/**
+		 * overshooting cubic tweening, with backtracking on both ends
+		 */
+		EASE_IN_OUT_BACK,
+
+		/**
+		 * exponentially decaying parabolic (bounce) tweening, with bounce on start
+		 */
+		EASE_IN_BOUNCE,
+		/**
+		 * exponentially decaying parabolic (bounce) tweening, with bounce on end
+		 */
+		EASE_OUT_BOUNCE,
+		/**
+		 * exponentially decaying parabolic (bounce) tweening, with bounce on both ends
+		 */
+		EASE_IN_OUT_BOUNCE,
+
+		/* guard, before registered alpha functions */
+		LAST
+	}
+
+	/**
+	 * Internal type for the easing functions.
+	 *
+	 * @param t elapsed time
+	 * @param d total duration
+	 * @return the interpolated value, between -1.0 and 2.0
+	 */
+	[CCode (has_target = false)]
+	delegate double EasingFunc (double t, double d);
+	
+	struct AnimationModeMapping
+	{
+		AnimationMode mode;
+		EasingFunc func;
+		string name;
+	}
+
+	const AnimationModeMapping[] animation_modes = {
+		{ AnimationMode.CUSTOM,              null, "custom" },
+
+		{ AnimationMode.LINEAR,              linear, "linear" },
+		{ AnimationMode.EASE_IN_QUAD,        ease_in_quad, "easeInQuad" },
+		{ AnimationMode.EASE_OUT_QUAD,       ease_out_quad, "easeOutQuad" },
+		{ AnimationMode.EASE_IN_OUT_QUAD,    ease_in_out_quad, "easeInOutQuad" },
+		{ AnimationMode.EASE_IN_CUBIC,       ease_in_cubic, "easeInCubic" },
+		{ AnimationMode.EASE_OUT_CUBIC,      ease_out_cubic, "easeOutCubic" },
+		{ AnimationMode.EASE_IN_OUT_CUBIC,   ease_in_out_cubic, "easeInOutCubic" },
+		{ AnimationMode.EASE_IN_QUART,       ease_in_quart, "easeInQuart" },
+		{ AnimationMode.EASE_OUT_QUART,      ease_out_quart, "easeOutQuart" },
+		{ AnimationMode.EASE_IN_OUT_QUART,   ease_in_out_quart, "easeInOutQuart" },
+		{ AnimationMode.EASE_IN_QUINT,       ease_in_quint, "easeInQuint" },
+		{ AnimationMode.EASE_OUT_QUINT,      ease_out_quint, "easeOutQuint" },
+		{ AnimationMode.EASE_IN_OUT_QUINT,   ease_in_out_quint, "easeInOutQuint" },
+		{ AnimationMode.EASE_IN_SINE,        ease_in_sine, "easeInSine" },
+		{ AnimationMode.EASE_OUT_SINE,       ease_out_sine, "easeOutSine" },
+		{ AnimationMode.EASE_IN_OUT_SINE,    ease_in_out_sine, "easeInOutSine" },
+		{ AnimationMode.EASE_IN_EXPO,        ease_in_expo, "easeInExpo" },
+		{ AnimationMode.EASE_OUT_EXPO,       ease_out_expo, "easeOutExpo" },
+		{ AnimationMode.EASE_IN_OUT_EXPO,    ease_in_out_expo, "easeInOutExpo" },
+		{ AnimationMode.EASE_IN_CIRC,        ease_in_circ, "easeInCirc" },
+		{ AnimationMode.EASE_OUT_CIRC,       ease_out_circ, "easeOutCirc" },
+		{ AnimationMode.EASE_IN_OUT_CIRC,    ease_in_out_circ, "easeInOutCirc" },
+		{ AnimationMode.EASE_IN_ELASTIC,     ease_in_elastic, "easeInElastic" },
+		{ AnimationMode.EASE_OUT_ELASTIC,    ease_out_elastic, "easeOutElastic" },
+		{ AnimationMode.EASE_IN_OUT_ELASTIC, ease_in_out_elastic, "easeInOutElastic" },
+		{ AnimationMode.EASE_IN_BACK,        ease_in_back, "easeInBack" },
+		{ AnimationMode.EASE_OUT_BACK,       ease_out_back, "easeOutBack" },
+		{ AnimationMode.EASE_IN_OUT_BACK,    ease_in_out_back, "easeInOutBack" },
+		{ AnimationMode.EASE_IN_BOUNCE,      ease_in_bounce, "easeInBounce" },
+		{ AnimationMode.EASE_OUT_BOUNCE,     ease_out_bounce, "easeOutBounce" },
+		{ AnimationMode.EASE_IN_OUT_BOUNCE,  ease_in_out_bounce, "easeInOutBounce" },
+
+		{ AnimationMode.LAST,                null, "sentinel" }
+	};
+
+	EasingFunc easing_func_for_mode (AnimationMode mode)
+	{
+		assert (animation_modes[mode].mode == mode);
+		assert (animation_modes[mode].func != null);
+		
+		return animation_modes[mode].func;
+	}
+
+	unowned string easing_name_for_mode (AnimationMode mode)
+	{
+		assert (animation_modes[mode].mode == mode);
+		assert (animation_modes[mode].func != null);
+		
+		return animation_modes[mode].name;
+	}
+
+	public double easing_for_mode (AnimationMode mode, double t, double d)
+	{
+		assert (animation_modes[mode].mode == mode);
+		assert (animation_modes[mode].func != null);
+		
+		return animation_modes[mode].func (t, d);
+	}
+	
+	double linear (double t, double d)
+	{
+		return t / d;
+	}
+
+	double ease_in_quad (double t, double d)
+	{
+		double p = t / d;
+
+		return p * p;
+	}
+
+	double ease_out_quad (double t, double d)
+	{
+		double p = t / d;
+
+		return -1.0 * p * (p - 2);
+	}
+
+	double ease_in_out_quad (double t, double d)
+	{
+		double p = t / (d / 2);
+
+		if (p < 1)
+			return 0.5 * p * p;
+
+		p -= 1;
+
+		return -0.5 * (p * (p - 2) - 1);
+	}
+
+	double ease_in_cubic (double t, double d)
+	{
+		double p = t / d;
+
+		return p * p * p;
+	}
+
+	double ease_out_cubic (double t, double d)
+	{
+		double p = t / d - 1;
+
+		return p * p * p + 1;
+	}
+
+	double ease_in_out_cubic (double t, double d)
+	{
+		double p = t / (d / 2);
+
+		if (p < 1)
+			return 0.5 * p * p * p;
+
+		p -= 2;
+
+		return 0.5 * (p * p * p + 2);
+	}
+
+	double ease_in_quart (double t, double d)
+	{
+		double p = t / d;
+
+		return p * p * p * p;
+	}
+
+	double ease_out_quart (double t, double d)
+	{
+		double p = t / d - 1;
+
+		return -1.0 * (p * p * p * p - 1);
+	}
+
+	double ease_in_out_quart (double t, double d)
+	{
+		double p = t / (d / 2);
+
+		if (p < 1)
+			return 0.5 * p * p * p * p;
+
+		p -= 2;
+
+		return -0.5 * (p * p * p * p - 2);
+	}
+
+	double ease_in_quint (double t, double d)
+	 {
+		double p = t / d;
+
+		return p * p * p * p * p;
+	}
+
+	double ease_out_quint (double t, double d)
+	{
+		double p = t / d - 1;
+
+		return p * p * p * p * p + 1;
+	}
+
+	double ease_in_out_quint (double t, double d)
+	{
+		double p = t / (d / 2);
+
+		if (p < 1)
+			return 0.5 * p * p * p * p * p;
+
+		p -= 2;
+
+		return 0.5 * (p * p * p * p * p + 2);
+	}
+
+	double ease_in_sine (double t, double d)
+	{
+		return -1.0 * Math.cos (t / d * Math.PI_2) + 1.0;
+	}
+
+	double ease_out_sine (double t, double d)
+	{
+		return Math.sin (t / d * Math.PI_2);
+	}
+
+	double ease_in_out_sine (double t, double d)
+	{
+		return -0.5 * (Math.cos (Math.PI * t / d) - 1);
+	}
+
+	double ease_in_expo (double t, double d)
+	{
+		return (t == 0) ? 0.0 : Math.pow (2, 10 * (t / d - 1));
+	}
+
+	double ease_out_expo (double t, double d)
+	{
+		return (t == d) ? 1.0 : -Math.pow (2, -10 * t / d) + 1;
+	}
+
+	double ease_in_out_expo (double t, double d)
+	{
+		double p;
+
+		if (t == 0)
+			return 0.0;
+
+		if (t == d)
+			return 1.0;
+
+		p = t / (d / 2);
+
+		if (p < 1)
+			return 0.5 * Math.pow (2, 10 * (p - 1));
+
+		p -= 1;
+
+		return 0.5 * (-Math.pow (2, -10 * p) + 2);
+	}
+
+	double ease_in_circ (double t, double d)
+	{
+		double p = t / d;
+
+		return -1.0 * (Math.sqrt (1 - p * p) - 1);
+	}
+
+	double ease_out_circ (double t, double d)
+	{
+		double p = t / d - 1;
+
+		return Math.sqrt (1 - p * p);
+	}
+
+	double ease_in_out_circ (double t, double d)
+	{
+		double p = t / (d / 2);
+
+		if (p < 1)
+			return -0.5 * (Math.sqrt (1 - p * p) - 1);
+
+		p -= 2;
+
+		return 0.5 * (Math.sqrt (1 - p * p) + 1);
+	}
+
+	double ease_in_elastic (double t, double d)
+	{
+		double p = d * 0.3;
+		double s = p / 4;
+		double q = t / d;
+
+		if (q == 1)
+			return 1.0;
+
+		q -= 1;
+
+		return -(Math.pow (2, 10 * q) * Math.sin ((q * d - s) * (2 * Math.PI) / p));
+	}
+
+	double ease_out_elastic (double t, double d)
+	{
+		double p = d * 0.3;
+		double s = p / 4;
+		double q = t / d;
+
+		if (q == 1)
+			return 1.0;
+
+		return Math.pow (2, -10 * q) * Math.sin ((q * d - s) * (2 * Math.PI) / p) + 1.0;
+	}
+
+	double ease_in_out_elastic (double t, double d)
+	{
+		double p = d * (0.3 * 1.5);
+		double s = p / 4;
+		double q = t / (d / 2);
+
+		if (q == 2)
+			return 1.0;
+
+		if (q < 1) {
+			q -= 1;
+
+			return -0.5 * (Math.pow (2, 10 * q) * Math.sin ((q * d - s) * (2 * Math.PI) / p));
+		} else {
+			q -= 1;
+
+			return Math.pow (2, -10 * q)
+				 * Math.sin ((q * d - s) * (2 * Math.PI) / p)
+				 * 0.5 + 1.0;
+		}
+	}
+
+	double ease_in_back (double t, double d)
+	{
+		double p = t / d;
+
+		return p * p * ((1.70158 + 1) * p - 1.70158);
+	}
+
+	double ease_out_back (double t, double d)
+	{
+		double p = t / d - 1;
+
+		return p * p * ((1.70158 + 1) * p + 1.70158) + 1;
+	}
+
+	double ease_in_out_back (double t, double d)
+	{
+		double p = t / (d / 2);
+		double s = 1.70158 * 1.525;
+
+		if (p < 1)
+			return 0.5 * (p * p * ((s + 1) * p - s));
+
+		p -= 2;
+
+		return 0.5 * (p * p * ((s + 1) * p + s) + 2);
+	}
+
+	static inline double ease_out_bounce_internal (double t, double d)
+	{
+		double p = t / d;
+
+		if (p < (1 / 2.75)) {
+			return 7.5625 * p * p;
+		} else if (p < (2 / 2.75)) {
+			p -= (1.5 / 2.75);
+
+			return 7.5625 * p * p + 0.75;
+		} else if (p < (2.5 / 2.75)) {
+			p -= (2.25 / 2.75);
+
+			return 7.5625 * p * p + 0.9375;
+		} else {
+			p -= (2.625 / 2.75);
+
+			return 7.5625 * p * p + 0.984375;
+		}
+	}
+
+	static inline double ease_in_bounce_internal (double t, double d)
+	{
+		return 1.0 - ease_out_bounce_internal (d - t, d);
+	}
+
+	double ease_in_bounce (double t, double d)
+	{
+		return ease_in_bounce_internal (t, d);
+	}
+
+	double ease_out_bounce (double t, double d)
+	{
+		return ease_out_bounce_internal (t, d);
+	}
+
+	double ease_in_out_bounce (double t, double d)
+	{
+		if (t < d / 2)
+			return ease_in_bounce_internal (t * 2, d) * 0.5;
+		else
+			return ease_out_bounce_internal (t * 2 - d, d) * 0.5 + 1.0 * 0.5;
+	}
+}

=== modified file 'lib/Items/DockItem.vala'
--- lib/Items/DockItem.vala	2014-11-19 14:06:10 +0000
+++ lib/Items/DockItem.vala	2015-01-26 20:17:08 +0000
@@ -396,14 +396,12 @@
 		 */
 		protected virtual void draw_icon (DockSurface surface)
 		{
-			double x_scale = 1.0, y_scale = 1.0;
-#if HAVE_HIDPI
-			cairo_surface_get_device_scale (surface.Internal, out x_scale, out y_scale);
-#endif
 			Cairo.Surface? icon = null;
 			Gdk.Pixbuf? pbuf = ForcePixbuf;
 			if (pbuf == null) {
 #if HAVE_HIDPI
+				double x_scale = 1.0, y_scale = 1.0;
+				cairo_surface_get_device_scale (surface.Internal, out x_scale, out y_scale);
 				icon = DrawingService.load_icon_for_scale (Icon, surface.Width, surface.Height, (int) double.max (x_scale, y_scale));
 				if (icon != null)
 					cairo_surface_set_device_scale (icon, 1.0, 1.0);

=== modified file 'lib/Makefile.am'
--- lib/Makefile.am	2015-01-06 12:58:35 +0000
+++ lib/Makefile.am	2015-01-26 20:17:08 +0000
@@ -72,6 +72,7 @@
 	Drawing/DrawingService.vala \
 	Drawing/DockSurface.vala \
 	Drawing/DockTheme.vala \
+	Drawing/Easing.vala \
 	Drawing/Theme.vala \
 	Factories/AbstractMain.vala \
 	Factories/Factory.vala \

=== modified file 'lib/libplank.symbols'
--- lib/libplank.symbols	2015-01-18 16:49:22 +0000
+++ lib/libplank.symbols	2015-01-26 20:17:08 +0000
@@ -82,6 +82,7 @@
 plank_drawing_animated_renderer_construct
 plank_drawing_animated_renderer_get_type
 plank_drawing_animated_renderer_get_widget
+plank_drawing_animation_mode_get_type
 plank_drawing_color_add_hue
 plank_drawing_color_brighten_val
 plank_drawing_color_darken_by_sat
@@ -185,6 +186,7 @@
 plank_drawing_drawing_service_load_icon
 plank_drawing_drawing_service_load_icon_for_scale
 plank_drawing_drawing_service_try_get_icon_file
+plank_drawing_easing_for_mode
 plank_drawing_theme_construct
 plank_drawing_theme_construct_with_name
 plank_drawing_theme_draw_background