Merge lp:~3v1n0/unity/swcenter-icon-fixes into lp:unity

[Marco Trevisan (Treviño)]

ApplicationLauncherIcon: make sure we unstick an icon, update its URI and resave it in order

Also improving a lot the SoftwareCenterLauncherIcon code and the install behaviour.

Improvements to glib::Variant, LauncherDragWindow, ApplicationLauncherIcon and SoftwareCenterLauncherIcon.
Added nicer animation when installing applications from SW center: now a new empty space is created on the launcher as soon as the icon starts to fly to that position, that then is filled only once the animation is completed.

As always, added new tests.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3497
http://jenkins.qa.ubuntu.com/job/unity-ci/324/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/213
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/211
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/212

Click here to trigger a rebuild:
http://s-jenkins:8080/job/unity-ci/324/rebuild

review: Approve (continuous-integration)

[Christopher Townsend (townsend)]

Sweet! This looks good.

I do see something that may or may not be a problem.

When installing an application from the Dash, the icon immediately shows up on the Launcher and shows the progress inside the icon. However, when installing from the Software Center, the icon does not show up until the application is fully installed.

Also, another difference between Dash vs. Software Center is that after the application is installed, when installing via Dash, the icon is urgent, but when installing via Software Center, it is not.

I'm not sure if these are bugs or intended behavior or should even be addressed in the MP.

Otherwise, this looks really good and works quite well.

review: Needs Information

[Marco Trevisan (Treviño) (3v1n0)]

That behavior is different only due to the clients you're using (sw center and the lens).

They had this different behavior, but now (you need to use lp:software-center trunk) they're quite similar. So, give a try with that if you prefer.

[Christopher Townsend (townsend)]

Since the behavior I was questioning is part of the Software Center, then I'm approving this.

review: Approve

=== modified file 'UnityCore/Variant.cpp'
--- UnityCore/Variant.cpp	2013-07-10 16:34:55 +0000
+++ UnityCore/Variant.cpp	2013-08-29 17:07:13 +0000
@@ -70,6 +70,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetString();
+
     LOG_ERROR(logger) << "You're trying to extract a String from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -94,6 +98,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetInt32();
+
     LOG_ERROR(logger) << "You're trying to extract an Int32 from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -118,6 +126,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetUInt32();
+
     LOG_ERROR(logger) << "You're trying to extract an UInt32 from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -141,6 +153,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetInt64();
+
     LOG_ERROR(logger) << "You're trying to extract an Int64 from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -165,6 +181,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetUInt64();
+
     LOG_ERROR(logger) << "You're trying to extract an UInt64 from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -189,6 +209,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetBool();
+
     LOG_ERROR(logger) << "You're trying to extract a Boolean from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -213,6 +237,10 @@
   }
   else
   {
+    auto const& variant = GetVariant();
+    if (variant)
+      return variant.GetDouble();
+
     LOG_ERROR(logger) << "You're trying to extract a Double from a variant which is of type "
                       << g_variant_type_peek_string(g_variant_get_type(variant_));
   }
@@ -225,6 +253,30 @@
   return static_cast<float>(GetDouble());
 }
 
+Variant Variant::GetVariant() const
+{
+  Variant value;
+
+  if (!variant_)
+    return value;
+
+  if (g_variant_is_of_type(variant_, G_VARIANT_TYPE_VARIANT))
+  {
+    value = Variant(g_variant_get_variant(variant_), StealRef());
+  }
+  else if (g_variant_is_of_type(variant_, G_VARIANT_TYPE("(v)")))
+  {
+    g_variant_get(variant_, "(v)", &value);
+  }
+  else
+  {
+    LOG_ERROR(logger) << "You're trying to extract a Variant from a variant which is of type "
+                      << g_variant_type_peek_string(g_variant_get_type(variant_));
+  }
+
+  return value;
+}
+
 bool Variant::ASVToHints(HintsMap& hints) const
 {
   GVariantIter* hints_iter;

=== modified file 'UnityCore/Variant.h'
--- UnityCore/Variant.h	2013-05-17 22:53:57 +0000
+++ UnityCore/Variant.h	2013-08-29 17:07:13 +0000
@@ -56,6 +56,7 @@
   bool GetBool() const;
   double GetDouble() const;
   float GetFloat() const;
+  Variant GetVariant() const;
 
   bool ASVToHints(HintsMap& hints) const;
   static Variant FromHints(HintsMap const& hints);

=== modified file 'launcher/ApplicationLauncherIcon.cpp'
--- launcher/ApplicationLauncherIcon.cpp	2013-08-07 16:43:38 +0000
+++ launcher/ApplicationLauncherIcon.cpp	2013-08-29 17:07:13 +0000
@@ -111,11 +111,11 @@
   }
 
   signals_conn_.Clear();
+  app_ = app;
 
   if (!app)
     return;
 
-  app_ = app;
   app_->seen = true;
   SetupApplicationSignalsConnections();
 
@@ -545,12 +545,6 @@
           break;
       }
     });
-
-    if (app_->sticky() && old_uri != new_uri)
-    {
-      UnStick();
-      Stick();
-    }
   }
   else if (app_->sticky())
   {
@@ -558,7 +552,17 @@
   }
 
   if (old_uri != new_uri)
+  {
+    bool update_saved_uri = (!filename.empty() && app_->sticky());
+
+    if (update_saved_uri)
+      SimpleLauncherIcon::UnStick();
+
     uri_changed.emit(new_uri);
+
+    if (update_saved_uri)
+      SimpleLauncherIcon::Stick();
+  }
 }
 
 std::string ApplicationLauncherIcon::DesktopFile() const
@@ -725,7 +729,6 @@
   // any or they're filtered for the environment we're in
   const gchar** nicks = indicator_desktop_shortcuts_get_nicks(_desktop_shortcuts);
 
-  
   for (int index = 0; nicks[index]; ++index)
   {
     // Build a dbusmenu item for each nick that is the desktop
@@ -856,7 +859,7 @@
     return;
 
   SimpleLauncherIcon::UnStick();
-  SetQuirk(Quirk::VISIBLE, app_->running());
+  SetQuirk(Quirk::VISIBLE, app_->visible());
   app_->sticky = false;
 
   if (!app_->running())

=== modified file 'launcher/Launcher.cpp'
--- launcher/Launcher.cpp	2013-07-17 21:48:22 +0000
+++ launcher/Launcher.cpp	2013-08-29 17:07:13 +0000
@@ -2099,11 +2099,9 @@
   _drag_icon_position = _model->IconIndex(icon);
 
   HideDragWindow();
-  _offscreen_drag_texture = nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(GetWidth(), GetWidth(), 1, nux::BITFMT_R8G8B8A8);
-  _drag_window = new LauncherDragWindow(_offscreen_drag_texture,
-                                        std::bind(&Launcher::RenderIconToTexture, this,
-                                                  _1,
-                                                  _drag_icon, _offscreen_drag_texture));
+
+  auto cb = std::bind(&Launcher::RenderIconToTexture, this, _1, _2, _drag_icon);
+  _drag_window = new LauncherDragWindow(GetWidth(), cb);
   ShowDragWindow();
 
   ubus_.SendMessage(UBUS_LAUNCHER_ICON_START_DND);
@@ -2135,10 +2133,9 @@
         _model->Save();
       }
 
-      _drag_window->on_anim_completed_conn_ = _drag_window->anim_completed.connect(sigc::mem_fun(this, &Launcher::OnDragWindowAnimCompleted));
-
       auto const& icon_center = _drag_icon->GetCenter(monitor);
-      _drag_window->SetAnimationTarget(icon_center.x, icon_center.y),
+      _drag_window->SetAnimationTarget(icon_center.x, icon_center.y);
+      _drag_window->anim_completed.connect(sigc::mem_fun(this, &Launcher::OnDragWindowAnimCompleted));
       _drag_window->StartQuickAnimation();
     }
   }
@@ -2571,7 +2568,7 @@
   return AbstractLauncherIcon::Ptr();
 }
 
-void Launcher::RenderIconToTexture(nux::GraphicsEngine& GfxContext, AbstractLauncherIcon::Ptr const& icon, nux::ObjectPtr<nux::IOpenGLBaseTexture> texture)
+void Launcher::RenderIconToTexture(nux::GraphicsEngine& GfxContext, nux::ObjectPtr<nux::IOpenGLBaseTexture> const& texture, AbstractLauncherIcon::Ptr const& icon)
 {
   RenderArg arg;
   struct timespec current;
@@ -2596,11 +2593,8 @@
   GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
   GfxContext.GetRenderStates().SetBlend(false);
 
-  GfxContext.QRP_Color(0,
-                      0,
-                      texture->GetWidth(),
-                      texture->GetHeight(),
-                      nux::Color(0.0f, 0.0f, 0.0f, 0.0f));
+  GfxContext.QRP_Color(0, 0, texture->GetWidth(), texture->GetHeight(),
+                       nux::color::Transparent);
 
   GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
 

=== modified file 'launcher/Launcher.h'
--- launcher/Launcher.h	2013-07-01 21:20:51 +0000
+++ launcher/Launcher.h	2013-08-29 17:07:13 +0000
@@ -107,7 +107,7 @@
   };
 
   nux::ObjectPtr<nux::View> const& GetActiveTooltip() const;
-  nux::ObjectPtr<LauncherDragWindow> const& GetDraggedIcon() const;
+  LauncherDragWindow::Ptr const& GetDraggedIcon() const;
 
   virtual void RecvMouseUp(int x, int y, unsigned long button_flags, unsigned long key_flags);
   virtual void RecvMouseDown(int x, int y, unsigned long button_flags, unsigned long key_flags);
@@ -153,7 +153,7 @@
 
   static const int ANIM_DURATION_SHORT;
 
-  void RenderIconToTexture(nux::GraphicsEngine& GfxContext, AbstractLauncherIcon::Ptr const& icon, nux::ObjectPtr<nux::IOpenGLBaseTexture> texture);
+  void RenderIconToTexture(nux::GraphicsEngine&, nux::ObjectPtr<nux::IOpenGLBaseTexture> const&, AbstractLauncherIcon::Ptr const&);
 
 #ifdef NUX_GESTURES_SUPPORT
   virtual nux::GestureDeliveryRequest GestureEvent(const nux::GestureEvent &event);
@@ -393,8 +393,7 @@
   float _last_reveal_progress;
 
   nux::Point2 _mouse_position;
-  nux::ObjectPtr<nux::IOpenGLBaseTexture> _offscreen_drag_texture;
-  nux::ObjectPtr<LauncherDragWindow> _drag_window;
+  LauncherDragWindow::Ptr _drag_window;
   LauncherHideMachine _hide_machine;
   LauncherHoverMachine _hover_machine;
   TooltipManager tooltip_manager_;

=== modified file 'launcher/LauncherController.cpp'
--- launcher/LauncherController.cpp	2013-08-07 19:47:00 +0000
+++ launcher/LauncherController.cpp	2013-08-29 17:07:13 +0000
@@ -528,8 +528,7 @@
       // This will ensure that the center of the new icon is set, so that
       // the animation could be done properly.
       sources_.AddIdle([this, icon_x, icon_y, result] {
-        result->Animate(CurrentLauncher(), icon_x, icon_y);
-        return false;
+        return !result->Animate(CurrentLauncher(), icon_x, icon_y);
       });
     }
     else

=== modified file 'launcher/LauncherDragWindow.cpp'
--- launcher/LauncherDragWindow.cpp	2013-08-09 12:09:34 +0000
+++ launcher/LauncherDragWindow.cpp	2013-08-29 17:07:13 +0000
@@ -41,16 +41,16 @@
 
 NUX_IMPLEMENT_OBJECT_TYPE(LauncherDragWindow);
 
-LauncherDragWindow::LauncherDragWindow(nux::ObjectPtr<nux::IOpenGLBaseTexture> texture,
-                                       std::function<void(nux::GraphicsEngine &)> const &deferred_icon_render_func)
+LauncherDragWindow::LauncherDragWindow(unsigned size, DeferredIconRenderer const& renderer_func)
   : nux::BaseWindow("")
   , icon_rendered_(false)
-  , deferred_icon_render_func_(deferred_icon_render_func)
+  , renderer_func_(renderer_func)
   , animation_speed_(QUICK_ANIMATION_SPEED)
   , cancelled_(false)
-  , texture_(texture)
+  , texture_(nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(
+             size, size, 1, nux::BITFMT_R8G8B8A8))
 {
-  SetBaseSize(texture_->GetWidth(), texture_->GetHeight());
+  SetBaseSize(size, size);
 
   key_down.connect([this] (unsigned long, unsigned long keysym, unsigned long, const char*, unsigned short) {
     if (keysym == NUX_VK_ESCAPE)
@@ -158,7 +158,7 @@
   // Render the icon if we haven't already
   if (!icon_rendered_)
   {
-    deferred_icon_render_func_ (GfxContext);
+    renderer_func_(GfxContext, texture_);
     icon_rendered_ = true;
   }
 

=== modified file 'launcher/LauncherDragWindow.h'
--- launcher/LauncherDragWindow.h	2013-07-01 21:20:51 +0000
+++ launcher/LauncherDragWindow.h	2013-08-29 17:07:13 +0000
@@ -38,12 +38,12 @@
 {
   NUX_DECLARE_OBJECT_TYPE(LauncherDragWindow, nux::BaseWindow);
 public:
-  LauncherDragWindow(nux::ObjectPtr<nux::IOpenGLBaseTexture> texture,
-                     std::function<void(nux::GraphicsEngine &)> const &deferred_icon_render_func);
+  typedef nux::ObjectPtr<LauncherDragWindow> Ptr;
+  typedef std::function<void(nux::GraphicsEngine&, nux::ObjectPtr<nux::IOpenGLBaseTexture> const&)> DeferredIconRenderer;
+
+  LauncherDragWindow(unsigned size, DeferredIconRenderer const&);
   ~LauncherDragWindow();
 
-  void DrawContent(nux::GraphicsEngine& gfxContext, bool forceDraw);
-
   void SetAnimationTarget(int x, int y);
   void StartQuickAnimation();
   void StartSlowAnimation();
@@ -53,21 +53,20 @@
 
   sigc::signal<void> anim_completed;
   sigc::signal<void> drag_cancel_request;
-  connection::Wrapper on_anim_completed_conn_;
 
 protected:
+  void DrawContent(nux::GraphicsEngine& gfxContext, bool forceDraw);
   bool InspectKeyEvent(unsigned int event_type, unsigned int keysym, const char* character);
   bool AcceptKeyNavFocus();
-
   virtual bool DrawContentOnNuxLayer() const;
 
 private:
   void StartAnimation();
   bool OnAnimationTimeout();
   void CancelDrag();
-  
+
   bool icon_rendered_;
-  std::function<void(nux::GraphicsEngine &)> deferred_icon_render_func_;
+  DeferredIconRenderer renderer_func_;
 
   float animation_speed_;
   bool cancelled_;

=== modified file 'launcher/SoftwareCenterLauncherIcon.cpp'
--- launcher/SoftwareCenterLauncherIcon.cpp	2013-08-07 16:44:38 +0000
+++ launcher/SoftwareCenterLauncherIcon.cpp	2013-08-29 17:07:13 +0000
@@ -31,6 +31,7 @@
 #include "LauncherDragWindow.h"
 #include "LauncherModel.h"
 #include "DesktopUtilities.h"
+#include "MultiMonitor.h"
 
 namespace unity
 {
@@ -39,29 +40,31 @@
 
 namespace
 {
-const std::string SOURCE_SHOW_TOOLTIP = "ShowTooltip";
-const std::string SOURCE_HIDE_TOOLTIP = "HideTooltip";
 const int INSTALL_TIP_DURATION = 1500;
 }
 
 NUX_IMPLEMENT_OBJECT_TYPE(SoftwareCenterLauncherIcon);
-
 SoftwareCenterLauncherIcon::SoftwareCenterLauncherIcon(ApplicationPtr const& app,
                                                        std::string const& aptdaemon_trans_id,
                                                        std::string const& icon_path)
   : ApplicationLauncherIcon(app)
-  , aptdaemon_trans_("org.debian.apt",
-                     aptdaemon_trans_id,
-                     "org.debian.apt.transaction",
-                     G_BUS_TYPE_SYSTEM,
-                     G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START)
-  , finished_(true)
+  , aptdaemon_trans_(std::make_shared<glib::DBusProxy>("org.debian.apt",
+                                                       aptdaemon_trans_id,
+                                                       "org.debian.apt.transaction",
+                                                       G_BUS_TYPE_SYSTEM,
+                                                       G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START))
+  , finished_(false)
   , needs_urgent_(false)
   , aptdaemon_trans_id_(aptdaemon_trans_id)
 {
   SetQuirk(Quirk::VISIBLE, false);
-  aptdaemon_trans_.Connect("PropertyChanged", sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnPropertyChanged));
-  aptdaemon_trans_.Connect("Finished", sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnFinished));
+  aptdaemon_trans_->Connect("PropertyChanged", sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnPropertyChanged));
+  aptdaemon_trans_->Connect("Finished", sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnFinished));
+  aptdaemon_trans_->GetProperty("Progress", [this] (GVariant *value) {
+    int32_t progress = glib::Variant(value).GetInt32();
+    SetProgress(progress/100.0f);
+    SetQuirk(Quirk::PROGRESS, (progress > 0));
+  });
 
   if (!icon_path.empty())
     icon_name = icon_path;
@@ -70,51 +73,57 @@
     tooltip_text = _("Waiting to install");
 }
 
-void SoftwareCenterLauncherIcon::Animate(nux::ObjectPtr<Launcher> const& launcher, int start_x, int start_y)
+bool SoftwareCenterLauncherIcon::Animate(nux::ObjectPtr<Launcher> const& launcher, int start_x, int start_y)
 {
   using namespace std::placeholders;
 
-  launcher_ = launcher;
-
-  // FIXME: this needs testing, if there is no useful coordinates 
-  //        then do not animate
   if (start_x <= 0 && start_y <= 0)
   {
     SetQuirk(Quirk::VISIBLE, true);
-    return;
+    return true;
   }
 
-  icon_texture_ = nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(
-    launcher->GetWidth(),
-    launcher->GetWidth(),
-    1,
-    nux::BITFMT_R8G8B8A8);
-
-  drag_window_ = new LauncherDragWindow(icon_texture_,
-                                        std::bind (&Launcher::RenderIconToTexture,
-                                                   launcher.GetPointer(),
-                                                   _1,
-                                                   AbstractLauncherIcon::Ptr(this),
-                                                   icon_texture_));
+  int monitor = launcher->monitor();
+  auto const& icon_center = GetCenter(monitor);
+
+  if (icon_center.x == 0 && icon_center.y == 0)
+    return false;
+
+  auto* floating_icon = new SimpleLauncherIcon(GetIconType());
+  AbstractLauncherIcon::Ptr floating_icon_ptr(floating_icon);
+  floating_icon->icon_name = icon_name();
+
+  // Transform this in a spacer-icon and make it visible only on launcher's monitor
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+    SetVisibleOnMonitor(i, static_cast<int>(i) == monitor);
+
+  icon_name = "";
+  SetQuirk(Quirk::VISIBLE, true);
+
+  auto rcb = std::bind(&Launcher::RenderIconToTexture, launcher.GetPointer(), _1, _2, floating_icon_ptr);
+  drag_window_ = new LauncherDragWindow(launcher->GetWidth(), rcb);
+  drag_window_->SetBaseXY(start_x, start_y);
+  drag_window_->SetAnimationTarget(icon_center.x, icon_center.y + (launcher->GetIconSize() / 2));
 
   launcher->ForceReveal(true);
-
-  auto const& icon_center = GetCenter(launcher->monitor());
-  drag_window_->SetBaseXY(start_x, start_y);
   drag_window_->ShowWindow(true);
-  drag_window_->SetAnimationTarget(icon_center.x, icon_center.y + (launcher->GetIconSize() / 2));
-  drag_window_->on_anim_completed_conn_ = drag_window_->anim_completed.connect(sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnDragAnimationFinished));
+
+  auto cb = sigc::bind(sigc::mem_fun(this, &SoftwareCenterLauncherIcon::OnDragAnimationFinished), launcher, floating_icon->icon_name());
+  drag_window_->anim_completed.connect(cb);
   drag_window_->StartSlowAnimation();
+
+  return true;
 }
 
-void SoftwareCenterLauncherIcon::OnDragAnimationFinished()
+void SoftwareCenterLauncherIcon::OnDragAnimationFinished(nux::ObjectPtr<Launcher> const& launcher, std::string const& final_icon)
 {
+  icon_name = final_icon;
   drag_window_->ShowWindow(false);
-  drag_window_ = nullptr;
-  launcher_->ForceReveal(false);
-  launcher_ = nullptr;
-  icon_texture_ = nullptr;
-  SetQuirk(Quirk::VISIBLE, true);
+  drag_window_.Release();
+  launcher->ForceReveal(false);
+
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+    SetVisibleOnMonitor(i, true);
 }
 
 void SoftwareCenterLauncherIcon::ActivateLauncherIcon(ActionArg arg)
@@ -142,8 +151,8 @@
   // app-install-data points to the "wrong" one in /usr/share/app-install
   //
   // So:
-  // - if there is a desktop file already and it startswith 
-  //   /usr/share/app-install/desktop, then transform to 
+  // - if there is a desktop file already and it startswith
+  //   /usr/share/app-install/desktop, then transform to
   //   /usr/share/application
   // - if there is a desktop file with prefix /tmp/software-center-agent:
   //   transform to /usr/share/application
@@ -168,10 +177,10 @@
     }
     filename = DesktopUtilities::GetDesktopPathById(filename);
     return filename;
-  } 
+  }
   else if (desktop_file.find("/tmp/software-center-agent:") == 0)
   {
-    // by convention the software-center-agent uses 
+    // by convention the software-center-agent uses
     //   /usr/share/applications/$pkgname.desktop
     // or
     //   /usr/share/applications/extras-$pkgname.desktop
@@ -197,10 +206,7 @@
 
 void SoftwareCenterLauncherIcon::OnFinished(GVariant *params)
 {
-  glib::String exit_state;
-  g_variant_get_child(params, 0, "s", &exit_state);
-
-  if (exit_state.Str() == "exit-success")
+  if (glib::Variant(params).GetString() == "exit-success")
   {
     SetQuirk(Quirk::PROGRESS, false);
     SetQuirk(Quirk::URGENT, true);
@@ -223,39 +229,34 @@
       _source_manager.AddTimeout(INSTALL_TIP_DURATION, [this] {
         HideTooltip();
         return false;
-      }, SOURCE_HIDE_TOOLTIP);
+      });
       return false;
-    }, SOURCE_SHOW_TOOLTIP);
+    });
   }
   else
   {
     // failure condition, remove icon again
     UnStick();
   }
+
+  aptdaemon_trans_.reset();
 };
 
 void SoftwareCenterLauncherIcon::OnPropertyChanged(GVariant* params)
 {
-  gint32 progress;
-  glib::String property_name;
-
-  g_variant_get_child(params, 0, "s", &property_name);
-
-  if (property_name.Str() == "Progress")
+  glib::Variant property_name(g_variant_get_child_value(params, 0), glib::StealRef());
+
+  if (property_name.GetString() == "Progress")
   {
-    GVariant* property_value = nullptr;
-    g_variant_get_child(params, 1, "v", &property_value);
-    g_variant_get(property_value, "i", &progress);
+    int32_t progress = glib::Variant(g_variant_get_child_value(params, 1), glib::StealRef()).GetInt32();
 
     if (progress < 100)
     {
       SetQuirk(Quirk::PROGRESS, true);
-      finished_ = false;
-      tooltip_text = _("Installing…"); 
+      tooltip_text = _("Installing…");
     }
 
     SetProgress(progress/100.0f);
-    g_variant_unref(property_value);
   }
 }
 

=== modified file 'launcher/SoftwareCenterLauncherIcon.h'
--- launcher/SoftwareCenterLauncherIcon.h	2013-08-05 08:01:45 +0000
+++ launcher/SoftwareCenterLauncherIcon.h	2013-08-29 17:07:13 +0000
@@ -42,27 +42,25 @@
                              std::string const& aptdaemon_trans_id,
                              std::string const& icon_path);
 
-  void Animate(nux::ObjectPtr<Launcher> const& launcher, int start_x, int start_y);
+  bool Animate(nux::ObjectPtr<Launcher> const& launcher, int start_x, int start_y);
 
+protected:
   std::string GetName() const;
+  void ActivateLauncherIcon(ActionArg arg);
 
-protected:
+private:
   std::string GetActualDesktopFileAfterInstall();
-  void ActivateLauncherIcon(ActionArg arg);
   void OnFinished(GVariant *params);
   void OnPropertyChanged(GVariant* params);
-
-private:
-  void OnDragAnimationFinished();
-
-  glib::DBusProxy aptdaemon_trans_;
-
-  nux::ObjectPtr<nux::IOpenGLBaseTexture> icon_texture_;
-  nux::ObjectPtr<LauncherDragWindow> drag_window_;
-  nux::ObjectPtr<Launcher> launcher_;
+  void OnDragAnimationFinished(nux::ObjectPtr<Launcher> const&, std::string const&);
+
+  glib::DBusProxy::Ptr aptdaemon_trans_;
+  LauncherDragWindow::Ptr drag_window_;
   bool finished_;
   bool needs_urgent_;
   std::string aptdaemon_trans_id_;
+
+  friend class TestSoftwareCenterLauncherIcon;
 };
 
 }

=== modified file 'tests/mock-application.h'
--- tests/mock-application.h	2013-08-07 16:44:38 +0000
+++ tests/mock-application.h	2013-08-29 17:07:13 +0000
@@ -175,8 +175,19 @@
   }
 
   void SetRunState(bool state) {
+    if (running_ == state)
+      return;
+
     running_ = state;
-    running.changed.emit(state);
+    running.changed.emit(running_);
+  }
+
+  void SetVisibility(bool state) {
+    if (visible_ == state)
+      return;
+
+    visible_ = state;
+    visible.changed.emit(visible_);
   }
 
   bool SetSeen(bool const& param) {

=== modified file 'tests/test_application_launcher_icon.cpp'
--- tests/test_application_launcher_icon.cpp	2013-08-07 16:44:38 +0000
+++ tests/test_application_launcher_icon.cpp	2013-08-29 17:07:13 +0000
@@ -280,9 +280,13 @@
 
 TEST_F(TestApplicationLauncherIcon, UnstickNotRunning)
 {
+  usc_app->SetRunState(false);
+  usc_app->SetVisibility(true);
+
   bool forgot = false;
-  usc_app->running_ = false;
+  bool removed = false;
   usc_icon->position_forgot.connect([&forgot] {forgot = true;});
+  usc_icon->remove.connect([&removed] (AbstractLauncherIcon::Ptr const&) { removed = true; });
 
   usc_icon->Stick();
   usc_icon->UnStick();
@@ -290,13 +294,18 @@
   EXPECT_FALSE(usc_icon->IsSticky());
   EXPECT_FALSE(usc_icon->IsVisible());
   EXPECT_TRUE(forgot);
+  EXPECT_TRUE(removed);
 }
 
 TEST_F(TestApplicationLauncherIcon, UnstickRunning)
 {
+  usc_app->SetRunState(true);
+  usc_app->SetVisibility(true);
+
   bool forgot = false;
-  usc_app->running_ = true;
+  bool removed = false;
   usc_icon->position_forgot.connect([&forgot] {forgot = true;});
+  usc_icon->remove.connect([&removed] (AbstractLauncherIcon::Ptr const&) { removed = true; });
 
   usc_icon->Stick();
   usc_icon->UnStick();
@@ -304,6 +313,7 @@
   EXPECT_FALSE(usc_icon->IsSticky());
   EXPECT_TRUE(usc_icon->IsVisible());
   EXPECT_TRUE(forgot);
+  EXPECT_FALSE(removed);
 }
 
 TEST_F(TestApplicationLauncherIcon, VisibleChanged)
@@ -390,6 +400,34 @@
   EXPECT_TRUE(forgot);
 }
 
+TEST_F(TestApplicationLauncherIcon, UpdateDesktopEmptyForgetsIconPositionAndUpdatesUri)
+{
+  usc_icon->Stick(true);
+
+  bool forgot = false;
+  bool uri_updated = false;
+  bool saved = false;
+
+  usc_icon->position_forgot.connect([&forgot, &uri_updated] {
+    ASSERT_FALSE(uri_updated);
+    forgot = true;
+  });
+  usc_icon->uri_changed.connect([&forgot, &uri_updated] (std::string const&) {
+    ASSERT_TRUE(forgot);
+    uri_updated = true;
+  });
+  usc_icon->position_saved.connect([&saved] { saved = false; });
+
+  usc_app->desktop_file_ = "";
+  usc_app->desktop_file.changed.emit(usc_app->desktop_file_);
+
+  EXPECT_FALSE(usc_app->sticky());
+  EXPECT_FALSE(usc_icon->IsSticky());
+  EXPECT_TRUE(forgot);
+  EXPECT_TRUE(uri_updated);
+  EXPECT_FALSE(saved);
+}
+
 TEST_F(TestApplicationLauncherIcon, UpdateDesktopUpdatesIconUri)
 {
   bool updated = false;
@@ -408,16 +446,52 @@
   EXPECT_TRUE(updated);
 }
 
-
 TEST_F(TestApplicationLauncherIcon, UpdateDesktopDoesntUpdatesIconUri)
 {
   bool updated = false;
-  usc_icon->uri_changed.connect([&updated] (std::string const& new_uri) { updated = true; });
+  usc_icon->uri_changed.connect([&updated] (std::string const&) { updated = true; });
   usc_app->desktop_file.changed.emit(usc_app->desktop_file_);
 
   EXPECT_FALSE(updated);
 }
 
+TEST_F(TestApplicationLauncherIcon, UpdateDesktopForgetsOldPositionUpdatesUriAndSavesAgain)
+{
+  usc_icon->Stick(true);
+
+  bool forgot = false;
+  bool uri_updated = false;
+  bool saved = false;
+  bool removed = false;
+
+  usc_icon->position_forgot.connect([&] {
+    ASSERT_FALSE(uri_updated);
+    ASSERT_FALSE(saved);
+    forgot = true;
+  });
+  usc_icon->uri_changed.connect([&] (std::string const&) {
+    ASSERT_FALSE(saved);
+    ASSERT_TRUE(forgot);
+    uri_updated = true;
+  });
+  usc_icon->position_saved.connect([&] {
+    ASSERT_TRUE(forgot);
+    ASSERT_TRUE(uri_updated);
+    saved = true;
+  });
+  usc_icon->remove.connect([&removed] (AbstractLauncherIcon::Ptr const&) { removed = true; });
+
+  usc_app->desktop_file_ = UM_DESKTOP;
+  usc_app->desktop_file.changed.emit(usc_app->desktop_file_);
+
+  ASSERT_FALSE(removed);
+  EXPECT_TRUE(usc_app->sticky());
+  EXPECT_TRUE(usc_icon->IsSticky());
+  EXPECT_TRUE(forgot);
+  EXPECT_TRUE(uri_updated);
+  EXPECT_TRUE(saved);
+}
+
 TEST_F(TestApplicationLauncherIcon, RemoteUri)
 {
   EXPECT_EQ(usc_icon->RemoteUri(), FavoriteStore::URI_PREFIX_APP + DesktopUtilities::GetDesktopID(USC_DESKTOP));

=== modified file 'tests/test_glib_variant.cpp'
--- tests/test_glib_variant.cpp	2013-07-10 16:32:43 +0000
+++ tests/test_glib_variant.cpp	2013-08-29 17:07:13 +0000
@@ -168,8 +168,8 @@
   EXPECT_EQ(hints["guint32-key"].GetUInt32(), (guint32)-2);
   EXPECT_EQ(hints["gint64-key"].GetInt64(), (gint64)-3);
   EXPECT_EQ(hints["guint64-key"].GetUInt64(), (guint64)-4);
-  EXPECT_EQ(hints["float-key"].GetFloat(), (float)1.1);
-  EXPECT_EQ(hints["double-key"].GetDouble(), (double)2.2);
+  EXPECT_FLOAT_EQ(hints["float-key"].GetFloat(), 1.1);
+  EXPECT_DOUBLE_EQ(hints["double-key"].GetDouble(), 2.2);
   EXPECT_EQ(hints["bool-key"].GetBool(), true);
 
   // throw away all references to the original variant
@@ -185,8 +185,8 @@
   EXPECT_EQ(hints["guint32-key"].GetUInt32(), (guint32)-2);
   EXPECT_EQ(hints["gint64-key"].GetInt64(), (gint64)-3);
   EXPECT_EQ(hints["guint64-key"].GetUInt64(), (guint64)-4);
-  EXPECT_EQ(hints["float-key"].GetFloat(), (float)1.1);
-  EXPECT_EQ(hints["double-key"].GetDouble(), (double)2.2);
+  EXPECT_FLOAT_EQ(hints["float-key"].GetFloat(), 1.1);
+  EXPECT_DOUBLE_EQ(hints["double-key"].GetDouble(), 2.2);
   EXPECT_EQ(hints["bool-key"].GetBool(), true);
 }
 
@@ -203,6 +203,9 @@
 
   Variant v4;
   EXPECT_EQ(v4.GetString(), "");
+
+  Variant v5(g_variant_new_variant(g_variant_new_string("Yeah!!!")));
+  EXPECT_EQ(v5.GetString(), "Yeah!!!");
 }
 
 TEST(TestGLibVariant, GetInt32)
@@ -220,6 +223,10 @@
 
   Variant v4;
   EXPECT_EQ(v4.GetInt32(), 0);
+
+  value = g_random_int_range(G_MININT, G_MAXINT);
+  Variant v5(g_variant_new_variant(g_variant_new_int32(value)));
+  EXPECT_EQ(v5.GetInt32(), value);
 }
 
 TEST(TestGLibVariant, GetUInt32)
@@ -237,6 +244,10 @@
 
   Variant v4;
   EXPECT_EQ(v4.GetUInt32(), 0);
+
+  value = g_random_int();
+  Variant v5(g_variant_new_variant(g_variant_new_uint32(value)));
+  EXPECT_EQ(v5.GetUInt32(), value);
 }
 
 TEST(TestGLibVariant, GetBool)
@@ -254,7 +265,29 @@
 
   Variant v4;
   EXPECT_EQ(v4.GetBool(), false);
-}
+
+  value = (g_random_int() % 2) ? TRUE : FALSE;
+  Variant v5(g_variant_new_variant(g_variant_new_boolean(value)));
+  EXPECT_EQ(v5.GetBool(), value);
+}
+
+TEST(TestGLibVariant, GetVariant)
+{
+  Variant value(g_variant_new_uint32(g_random_int()));
+  Variant v1(g_variant_new_variant(value));
+  EXPECT_TRUE(ValuesEqual(v1.GetVariant(), value));
+
+  value = g_variant_new_boolean((g_random_int() % 2) ? TRUE : FALSE);
+  Variant v2(g_variant_new("(v)", static_cast<GVariant*>(value)));
+  EXPECT_TRUE(ValuesEqual(v2.GetVariant(), value));
+
+  Variant v3(g_variant_new("(vs)", static_cast<GVariant*>(value), "fooostring"));
+  EXPECT_FALSE(v3.GetVariant());
+
+  Variant v4;
+  EXPECT_FALSE(v4.GetVariant());
+}
+
 
 
 } // Namespace

=== modified file 'tests/test_launcher_drag_window.cpp'
--- tests/test_launcher_drag_window.cpp	2013-05-15 04:40:36 +0000
+++ tests/test_launcher_drag_window.cpp	2013-08-29 17:07:13 +0000
@@ -29,91 +29,66 @@
 
 namespace
 {
-const int ICON_WIDTH = 10;
-const int ICON_HEIGHT = 15;
+const int ICON_SIZE = 15;
 }
 
 namespace unity
 {
 namespace launcher
 {
-class StubLauncherDragWindow : public LauncherDragWindow
-{
-  public:
-
-    StubLauncherDragWindow(nux::ObjectPtr<nux::IOpenGLBaseTexture> const &texture,
-                           std::function<void(nux::GraphicsEngine&)> const &callback)
-     : LauncherDragWindow(texture, callback)
-    {}
-
-  protected:
-
-    bool DrawContentOnNuxLayer() const { return false; }
+namespace
+{
+
+struct StubLauncherDragWindow : public LauncherDragWindow
+{
+  struct DrawCallback
+  {
+    MOCK_METHOD0(callback, void());
+  };
+
+  StubLauncherDragWindow()
+   : LauncherDragWindow(ICON_SIZE, std::bind(&DrawCallback::callback, &cb))
+  {}
+
+  bool DrawContentOnNuxLayer() const { return false; }
+  using LauncherDragWindow::DrawContent;
+
+  DrawCallback cb;
 };
 
 struct TestLauncherDragWindow : public testing::Test
 {
   TestLauncherDragWindow()
-    : texture(new nux::IOpenGLBaseTexture(nux::RTTEXTURE, ICON_WIDTH, ICON_HEIGHT, 24, 1, nux::BITFMT_R8G8B8A8))
-    , drag_window(new LauncherDragWindow(texture,
-                                         [](nux::GraphicsEngine &){
-                                         }))
+    : drag_window(new StubLauncherDragWindow())
   {}
 
-  nux::ObjectPtr<nux::IOpenGLBaseTexture> texture;
-  nux::ObjectPtr<LauncherDragWindow> drag_window;
-};
-
-class DrawCallback
-{
-  public:
-
-    MOCK_METHOD0(callback, void());
+  nux::ObjectPtr<StubLauncherDragWindow> drag_window;
 };
 }
 
 TEST_F(TestLauncherDragWindow, Construction)
 {
-  EXPECT_EQ(drag_window->GetBaseWidth(), ICON_WIDTH);
-  EXPECT_EQ(drag_window->GetBaseHeight(), ICON_HEIGHT);
+  EXPECT_EQ(drag_window->GetBaseWidth(), ICON_SIZE);
+  EXPECT_EQ(drag_window->GetBaseHeight(), ICON_SIZE);
   EXPECT_FALSE(drag_window->Animating());
   EXPECT_FALSE(drag_window->Cancelled());
 }
 
 TEST_F(TestLauncherDragWindow, NoDrawOnConstruction)
 {
-  DrawCallback cb;
-
-  EXPECT_CALL(cb, callback()).Times(0);
-
-  drag_window.Adopt(new StubLauncherDragWindow (texture,
-                                                std::bind(&DrawCallback::callback,
-                                                          &cb)));
+  EXPECT_CALL(drag_window->cb, callback()).Times(0);
+  drag_window = new StubLauncherDragWindow();
 }
 
 TEST_F(TestLauncherDragWindow, DrawOnFirstPaint)
 {
-  DrawCallback cb;
-
-  drag_window.Adopt(new StubLauncherDragWindow (texture,
-                                                std::bind(&DrawCallback::callback,
-                                                          &cb)));
-
-  EXPECT_CALL(cb, callback()).Times(1);
-
+  EXPECT_CALL(drag_window->cb, callback()).Times(1);
   drag_window->DrawContent(*(nux::GetGraphicsDisplay()->GetGraphicsEngine()), false);
 }
 
 TEST_F(TestLauncherDragWindow, NoDrawOnSecondPaint)
 {
-  DrawCallback cb;
-
-  drag_window.Adopt(new StubLauncherDragWindow (texture,
-                                                std::bind(&DrawCallback::callback,
-                                                          &cb)));
-
-  EXPECT_CALL(cb, callback()).Times(1);
-
+  EXPECT_CALL(drag_window->cb, callback()).Times(1);
   drag_window->DrawContent(*(nux::GetGraphicsDisplay()->GetGraphicsEngine()), false);
   drag_window->DrawContent(*(nux::GetGraphicsDisplay()->GetGraphicsEngine()), false);
 }
@@ -154,3 +129,4 @@
 }
 
 }
+}

=== modified file 'tests/test_software_center_launcher_icon.cpp'
--- tests/test_software_center_launcher_icon.cpp	2013-08-07 16:44:38 +0000
+++ tests/test_software_center_launcher_icon.cpp	2013-08-29 17:07:13 +0000
@@ -27,6 +27,7 @@
 
 #include "mock-application.h"
 #include "FavoriteStore.h"
+#include "MultiMonitor.h"
 #include "SoftwareCenterLauncherIcon.h"
 #include "Launcher.h"
 #include "PanelStyle.h"
@@ -41,32 +42,50 @@
 {
 namespace launcher
 {
+namespace
+{
+const std::string PRE_INSTALL_ICON = "sw-center-launcher-icon";
+const std::string FINAL_ICON = "softwarecenter";
+const std::string APP_NAME = "Ubuntu Software Center";
 const std::string LOCAL_DATA_DIR = BUILDDIR"/tests/data";
 const std::string USC_DESKTOP = LOCAL_DATA_DIR+"/applications/ubuntu-software-center.desktop";
 const std::string USC_APP_INSTALL_DESKTOP = "/usr/share/app-install/desktop/software-center:ubuntu-software-center.desktop";
-
-class MockSoftwareCenterLauncherIcon : public SoftwareCenterLauncherIcon
-{
-public:
-  MockSoftwareCenterLauncherIcon(ApplicationPtr const& app,
-                                std::string const& aptdaemon_trans_id,
-                                std::string const& icon_path)
-    : SoftwareCenterLauncherIcon(app, aptdaemon_trans_id, icon_path)
-  {}
-
-  using SoftwareCenterLauncherIcon::GetActualDesktopFileAfterInstall;
-  using SoftwareCenterLauncherIcon::GetRemoteUri;
-  using SoftwareCenterLauncherIcon::OnFinished;
-  using SoftwareCenterLauncherIcon::OnPropertyChanged;
-};
+}
 
 struct TestSoftwareCenterLauncherIcon : testing::Test
 {
   TestSoftwareCenterLauncherIcon()
-     : usc(std::make_shared<MockApplication::Nice>(USC_APP_INSTALL_DESKTOP, "softwarecenter", "Ubuntu Software Center"))
-     , icon(usc, "/com/canonical/unity/test/object/path", "")
+     : usc(std::make_shared<MockApplication::Nice>(USC_APP_INSTALL_DESKTOP, FINAL_ICON, APP_NAME))
+     , icon(usc, "/com/canonical/unity/test/object/path", PRE_INSTALL_ICON)
   {}
 
+  struct MockSoftwareCenterLauncherIcon : SoftwareCenterLauncherIcon
+  {
+    MockSoftwareCenterLauncherIcon(ApplicationPtr const& app,
+                                   std::string const& aptdaemon_trans_id,
+                                   std::string const& icon_path)
+      : SoftwareCenterLauncherIcon(app, aptdaemon_trans_id, icon_path)
+    {}
+
+    using SoftwareCenterLauncherIcon::GetActualDesktopFileAfterInstall;
+    using SoftwareCenterLauncherIcon::GetRemoteUri;
+    using SoftwareCenterLauncherIcon::OnFinished;
+    using SoftwareCenterLauncherIcon::OnPropertyChanged;
+    using SoftwareCenterLauncherIcon::drag_window_;
+  };
+
+  nux::ObjectPtr<Launcher> CreateLauncher()
+  {
+    launcher_win = new MockableBaseWindow("");
+    nux::ObjectPtr<Launcher> launcher(new Launcher(launcher_win.GetPointer()));
+    launcher->options = Options::Ptr(new Options);
+    launcher->SetModel(LauncherModel::Ptr(new LauncherModel));
+    return launcher;
+  }
+
+  Settings settings;
+  panel::Style panel;
+  nux::ObjectPtr<MockableBaseWindow> launcher_win;
   MockApplication::Ptr usc;
   MockSoftwareCenterLauncherIcon icon;
 };
@@ -74,8 +93,9 @@
 TEST_F(TestSoftwareCenterLauncherIcon, Construction)
 {
   EXPECT_FALSE(icon.IsVisible());
-  EXPECT_EQ(icon.position(), AbstractLauncherIcon::Position::FLOATING);
-  EXPECT_EQ(icon.tooltip_text(), "Waiting to install");
+  EXPECT_EQ(AbstractLauncherIcon::Position::FLOATING, icon.position());
+  EXPECT_EQ("Waiting to install", icon.tooltip_text());
+  EXPECT_EQ(PRE_INSTALL_ICON, icon.icon_name());
 }
 
 TEST_F(TestSoftwareCenterLauncherIcon, DesktopFileTransformTrivial)
@@ -169,35 +189,60 @@
 {
   icon.tooltip_text = "FooText";
   icon.OnFinished(glib::Variant(g_variant_new("(s)", "exit-success")));
-  EXPECT_EQ("Ubuntu Software Center", icon.tooltip_text());
+  EXPECT_EQ(icon.tooltip_text(), usc->title());
 }
 
 TEST_F(TestSoftwareCenterLauncherIcon, OnFinishedUpdatesIcon)
 {
   icon.icon_name = "foo-icon";
   icon.OnFinished(glib::Variant(g_variant_new("(s)", "exit-success")));
-  EXPECT_EQ("softwarecenter", icon.icon_name());
-}
-
-TEST_F(TestSoftwareCenterLauncherIcon, Animate)
-{
-  ASSERT_FALSE(icon.IsVisible());
-
-  Settings settings;
-  panel::Style panel;
-  nux::ObjectPtr<MockableBaseWindow> win(new MockableBaseWindow(""));
-  nux::ObjectPtr<Launcher> launcher(new Launcher(win.GetPointer()));
-  launcher->options = Options::Ptr(new Options);
-  launcher->SetModel(LauncherModel::Ptr(new LauncherModel));
-
-  icon.Animate(launcher, 1, 2);
-  Utils::WaitForTimeoutMSec(500);
-
-  EXPECT_TRUE(icon.IsVisible());
-}
-
-struct InstallProgress : TestSoftwareCenterLauncherIcon, testing::WithParamInterface<int> {};
-INSTANTIATE_TEST_CASE_P(TestSoftwareCenterLauncherIcon, InstallProgress, testing::Range<int>(0, 99, 10));
+  EXPECT_EQ(icon.icon_name(), usc->icon());
+}
+
+TEST_F(TestSoftwareCenterLauncherIcon, AnimateToInvalidPosition)
+{
+  EXPECT_FALSE(icon.Animate(CreateLauncher(), 1, 2));
+  EXPECT_FALSE(icon.IsVisible());
+  EXPECT_EQ(PRE_INSTALL_ICON, icon.icon_name());
+}
+
+TEST_F(TestSoftwareCenterLauncherIcon, AnimateFromInvalidPosition)
+{
+  EXPECT_TRUE(icon.Animate(CreateLauncher(), 0, 0));
+  EXPECT_TRUE(icon.IsVisible());
+  EXPECT_EQ(PRE_INSTALL_ICON, icon.icon_name());
+}
+
+struct MultiMonitor : TestSoftwareCenterLauncherIcon, WithParamInterface<unsigned> {};
+INSTANTIATE_TEST_CASE_P(TestSoftwareCenterLauncherIcon, MultiMonitor, Range<unsigned>(0, monitors::MAX, 1));
+
+TEST_P(/*TestSoftwareCenterLauncherIcon*/MultiMonitor, Animate)
+{
+  auto launcher = CreateLauncher();
+  launcher->monitor = GetParam();
+  icon.SetCenter({1, 1, 0}, launcher->monitor(), nux::Geometry());
+  EXPECT_TRUE(icon.Animate(launcher, 2, 2));
+  EXPECT_TRUE(icon.IsVisible());
+  EXPECT_EQ("", icon.icon_name());
+
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+    ASSERT_EQ(static_cast<int>(i) == launcher->monitor(), icon.IsVisibleOnMonitor(i));
+
+  bool animated = false;
+  ASSERT_TRUE(icon.drag_window_);
+  icon.drag_window_->anim_completed.connect([&animated] { animated = true; });
+  Utils::WaitUntilMSec(animated);
+  ASSERT_TRUE(animated);
+
+  EXPECT_EQ(PRE_INSTALL_ICON, icon.icon_name());
+  EXPECT_FALSE(icon.drag_window_);
+
+  for (unsigned i = 0; i < monitors::MAX; ++i)
+    ASSERT_TRUE(icon.IsVisibleOnMonitor(i));
+}
+
+struct InstallProgress : TestSoftwareCenterLauncherIcon, WithParamInterface<int> {};
+INSTANTIATE_TEST_CASE_P(TestSoftwareCenterLauncherIcon, InstallProgress, Range<int>(0, 99, 10));
 
 TEST_P(/*TestSoftwareCenterLauncherIcon*/InstallProgress, InstallEmblems)
 {