Merge lp:~canonical-dx-team/unity/unity.startup-notification into lp:unity

[Jason Smith]

[Neil J. Patel (njpatel)]

Looks good, some notes + questions:

- You need to add a dep for libstartup-notification-1.0 to CMakeLists.txt::UNITY_PLUGIN_DEPS

- The quirks, they seem to be all booleans, should they just be bit flags? I'm not sure how it'll impact API, though...

review: Needs Fixing

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2010-11-18 16:25:14 +0000
+++ CMakeLists.txt	2010-11-24 15:28:12 +0000
@@ -74,7 +74,7 @@
 #
 # src (Compiz Plugin)
 #
-set (UNITY_PLUGIN_DEPS "nux-0.9;libbamf;dbus-glib-1;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib;x11")
+set (UNITY_PLUGIN_DEPS "nux-0.9;libbamf;dbus-glib-1;dee-1.0;gio-2.0;gio-unix-2.0;dbusmenu-glib;x11;libstartup-notification-1.0")
 
 find_package (Compiz REQUIRED)
 include (CompizPlugin)

=== modified file 'src/BamfLauncherIcon.cpp'
--- src/BamfLauncherIcon.cpp	2010-11-18 14:00:53 +0000
+++ src/BamfLauncherIcon.cpp	2010-11-24 15:28:12 +0000
@@ -25,6 +25,9 @@
 
 #include <gio/gdesktopappinfo.h>
 
+#include <core/core.h>
+#include <core/atoms.h>
+
 BamfLauncherIcon::BamfLauncherIcon (Launcher* IconManager, BamfApplication *app, CompScreen *screen, NUX_FILE_LINE_DECL)
 :   SimpleLauncherIcon(IconManager)
 {
@@ -37,12 +40,12 @@
     SetIconType (LAUNCHER_ICON_TYPE_APPLICATION);
     
     if (bamf_view_is_sticky (BAMF_VIEW (m_App)))
-      SetVisible (true);
+      SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
     else
-      SetVisible (bamf_view_user_visible (BAMF_VIEW (m_App)));
+      SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, bamf_view_user_visible (BAMF_VIEW (m_App)));
     
-    SetActive (bamf_view_is_active (BAMF_VIEW (m_App)));
-    SetRunning (bamf_view_is_running (BAMF_VIEW (m_App)));
+    SetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE, bamf_view_is_active (BAMF_VIEW (m_App)));
+    SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, bamf_view_is_running (BAMF_VIEW (m_App)));
     
     g_free (icon_name);
     
@@ -84,6 +87,9 @@
       appInfo = g_desktop_app_info_new_from_filename (bamf_application_get_desktop_file (BAMF_APPLICATION (m_App)));
       g_app_info_launch (G_APP_INFO (appInfo), NULL, NULL, NULL);
       g_object_unref (appInfo);
+      
+      UpdateQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+      
       return;
     }
     
@@ -143,14 +149,14 @@
     BamfLauncherIcon *self = (BamfLauncherIcon *) data;
     
     if (!bamf_view_is_sticky (BAMF_VIEW (self->m_App)))
-      self->SetVisible (visible);
+      self->SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, visible);
 }
 
 void
 BamfLauncherIcon::OnRunningChanged (BamfView *view, gboolean running, gpointer data)
 {
     BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-    self->SetRunning (running);
+    self->SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, running);
     
     if (running)
       self->EnsureWindowState ();
@@ -160,14 +166,14 @@
 BamfLauncherIcon::OnActiveChanged (BamfView *view, gboolean active, gpointer data)
 {
     BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-    self->SetActive (active);
+    self->SetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE, active);
 }
 
 void
 BamfLauncherIcon::OnUrgentChanged (BamfView *view, gboolean urgent, gpointer data)
 {
     BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-    self->SetUrgent (urgent);
+    self->SetQuirk (LAUNCHER_ICON_QUIRK_URGENT, urgent);
 }
 
 void
@@ -220,3 +226,32 @@
     
     return result;
 }
+
+void 
+BamfLauncherIcon::OnCenterStabilized (nux::Point3 center)
+{
+    GList *children, *l;
+    BamfView *view;
+    long data[4];
+
+    data[0] = center.x - 24;
+    data[1] = center.y - 24;
+    data[2] = 48;
+    data[3] = 48;
+
+    children = bamf_view_get_children (BAMF_VIEW (m_App));
+
+    for (l = children; l; l = l->next)
+    {
+        view = (BamfView *) l->data;
+    
+        if (BAMF_IS_WINDOW (view))
+        {
+            guint32 xid = bamf_window_get_xid (BAMF_WINDOW (view));
+            
+            XChangeProperty (m_Screen->dpy (), xid, Atoms::wmIconGeometry,
+                             XA_CARDINAL, 32, PropModeReplace,
+                             (unsigned char *) data, 4);
+        }
+    }
+}

=== modified file 'src/BamfLauncherIcon.h'
--- src/BamfLauncherIcon.h	2010-11-10 18:56:19 +0000
+++ src/BamfLauncherIcon.h	2010-11-24 15:28:12 +0000
@@ -42,6 +42,8 @@
 protected:
     void OnMouseClick (int button);
     std::list<DbusmenuClient *> GetMenus ();
+    
+    void OnCenterStabilized (nux::Point3 center);
 
 private:
     BamfApplication *m_App;

=== modified file 'src/Launcher.cpp'
--- src/Launcher.cpp	2010-11-23 02:58:23 +0000
+++ src/Launcher.cpp	2010-11-24 15:28:12 +0000
@@ -42,6 +42,10 @@
 #define ANIM_DURATION_LONG  350
 
 #define URGENT_BLINKS       3
+
+#define MAX_STARTING_BLINKS 5
+#define STARTING_BLINK_LAMBDA 3
+
 #define BACKLIGHT_STRENGTH  0.9f
 
 int
@@ -325,37 +329,28 @@
 
 bool Launcher::IconNeedsAnimation (LauncherIcon *icon, struct timespec current)
 {
-    struct timespec enter_time = icon->ShowTime ();
-    if (TimeDelta (&current, &enter_time) < ANIM_DURATION_SHORT)
-        return true;
-    
-    struct timespec hide_time = icon->HideTime ();
-    if (TimeDelta (&current, &hide_time) < ANIM_DURATION_SHORT)
-        return true;
-    
-    struct timespec running_time = icon->RunningTime ();
+    struct timespec visible_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+    if (TimeDelta (&current, &visible_time) < ANIM_DURATION_SHORT)
+        return true;
+    
+    struct timespec running_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
     if (TimeDelta (&current, &running_time) < ANIM_DURATION_SHORT)
         return true;
     
-    if (icon->Urgent ())
+    struct timespec starting_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    if (TimeDelta (&current, &starting_time) < (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2))
+        return true;
+    
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
     {
-        struct timespec urgent_time = icon->UrgentTime ();
+        struct timespec urgent_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
         if (TimeDelta (&current, &urgent_time) < (ANIM_DURATION_LONG * URGENT_BLINKS * 2))
             return true;
     }
     
-    if (icon->Presented ())
-    {
-        struct timespec present_time = icon->PresentTime ();
-        if (TimeDelta (&current, &present_time) < ANIM_DURATION)
-            return true;
-    }
-    else
-    {
-        struct timespec unpresent_time = icon->UnpresentTime ();
-        if (TimeDelta (&current, &unpresent_time) < ANIM_DURATION)
-            return true;
-    }
+    struct timespec present_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
+    if (TimeDelta (&current, &present_time) < ANIM_DURATION)
+        return true;
     
     return false;
 }
@@ -423,15 +418,15 @@
 
 float IconVisibleProgress (LauncherIcon *icon, struct timespec current)
 {
-    if (icon->Visible ())
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
     {
-        struct timespec icon_visible_time = icon->ShowTime ();
+        struct timespec icon_visible_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
         int enter_ms = TimeDelta (&current, &icon_visible_time);
         return CLAMP ((float) enter_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
     }
     else
     {
-        struct timespec icon_hide_time = icon->HideTime ();
+        struct timespec icon_hide_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
         int hide_ms = TimeDelta (&current, &icon_hide_time);
         return 1.0f - CLAMP ((float) hide_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
     }
@@ -465,20 +460,72 @@
 
 float Launcher::IconPresentProgress (LauncherIcon *icon, struct timespec current)
 {
-    if (icon->Presented ())
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
     {
-        struct timespec icon_present_time = icon->PresentTime ();
+        struct timespec icon_present_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
         int ms = TimeDelta (&current, &icon_present_time);
         return CLAMP ((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);
     }
     else
     {
-        struct timespec icon_unpresent_time = icon->UnpresentTime ();
+        struct timespec icon_unpresent_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
         int ms = TimeDelta (&current, &icon_unpresent_time);
         return 1.0f - CLAMP ((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);
     }
 }
 
+float Launcher::IconUrgentPulseValue (LauncherIcon *icon, struct timespec current)
+{
+    if (!icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+        return 1.0f; // we are full on in a normal condition
+        
+    struct timespec urgent_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
+    int urgent_ms = TimeDelta (&current, &urgent_time);
+    double urgent_progress = (double) CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
+    
+    return 0.5f + (float) (std::cos (M_PI * (float) (URGENT_BLINKS * 2) * urgent_progress)) * 0.5f;
+}
+
+float Launcher::IconStartingPulseValue (LauncherIcon *icon, struct timespec current)
+{
+    struct timespec starting_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    int starting_ms = TimeDelta (&current, &starting_time);
+    double starting_progress = (double) CLAMP ((float) starting_ms / (float) (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2), 0.0f, 1.0f);
+    
+    return 1.0f - (0.5f + (float) (std::cos (M_PI * (float) (MAX_STARTING_BLINKS * 2) * starting_progress)) * 0.5f);
+}
+
+float Launcher::IconBackgroundIntensity (LauncherIcon *icon, struct timespec current)
+{
+    float result = 0.0f;
+    struct timespec running_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
+    int running_ms = TimeDelta (&current, &running_time);
+    float running_progress = CLAMP ((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+
+    // After we finish a fade in from running, we can reset the quirk
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING) && running_progress == 1.0f)
+        icon->ResetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+     
+    result = IconStartingPulseValue (icon, current) * BACKLIGHT_STRENGTH;
+
+    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    {
+        // running progress fades in whatever the pulsing did not fill in already
+        result += running_progress * (BACKLIGHT_STRENGTH - result);
+        
+        // urgent serves to bring the total down only
+        if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+            result *= 0.2f + 0.8f * IconUrgentPulseValue (icon, current);
+    }
+    else
+    {
+        // modestly evil
+        result += BACKLIGHT_STRENGTH - running_progress * BACKLIGHT_STRENGTH;
+    }
+    
+    return result;
+}
+
 void Launcher::RenderArgs (std::list<Launcher::RenderArg> &launcher_args, 
                            std::list<Launcher::RenderArg> &shelf_args, 
                            nux::Geometry &box_geo, nux::Geometry &shelf_geo)
@@ -489,6 +536,7 @@
     float hover_progress = GetHoverProgress ();
     float folded_z_distance = _folded_z_distance * (1.0f - hover_progress);
     float animation_neg_rads = _neg_folded_angle * (1.0f - hover_progress);
+    int vertical_offset = _parent->GetGeometry ().y;
     struct timespec current;
     clock_gettime (CLOCK_MONOTONIC, &current);
 
@@ -599,41 +647,17 @@
         arg.alpha          = 1.0f;
         arg.glow_intensity = 0.0f;
         arg.running_arrow  = false;
-        arg.active_arrow   = icon->Active ();
+        arg.active_arrow   = icon->GetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE);
         arg.folding_rads   = 0.0f;
         arg.skip           = false;
         
         arg.window_indicators = MIN (4, icon->RelatedWindows ());
         
         // we dont need to show strays
-        if (arg.window_indicators == 1 || !icon->Running ())
-          arg.window_indicators = 0;
+        if (arg.window_indicators == 1 || !icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+            arg.window_indicators = 0;
         
-        // animate this shit
-        struct timespec running_time = icon->RunningTime ();
-        int running_ms = TimeDelta (&current, &running_time);
-        float running_progress = CLAMP ((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
-
-        if (icon->Running ())
-        {
-          arg.backlight_intensity = running_progress * BACKLIGHT_STRENGTH;
-          
-          if (icon->Urgent ())
-          {
-              struct timespec urgent_time = icon->UrgentTime ();
-              int urgent_ms = TimeDelta (&current, &urgent_time);
-              double urgent_progress = (double) CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
-              
-              arg.backlight_intensity *= 0.2f + 0.8f * (0.5f + (float) (std::cos (M_PI * (float) (URGENT_BLINKS * 2) * urgent_progress)) * 0.5f);
-          }
-        }
-        else
-        {
-          if (running_ms > ANIM_DURATION_SHORT)
-            arg.backlight_intensity = 0.0f;
-          else
-            arg.backlight_intensity = BACKLIGHT_STRENGTH - running_progress * BACKLIGHT_STRENGTH;
-        }
+        arg.backlight_intensity = IconBackgroundIntensity (icon, current);
         
         // reset z
         center.z = 0;
@@ -665,7 +689,7 @@
         
         center.y += half_size * size_modifier;   // move to center
         arg.center = nux::Point3 (center);       // copy center
-        icon->SetCenter (arg.center);
+        icon->SetCenter (nux::Point3 (center.x, center.y + vertical_offset, center.z));
         center.y += half_size * size_modifier;   // move to end
         
         float spacing_overlap = CLAMP ((float) (center.y + (_space_between_icons * size_modifier) - folding_threshold) / (float) _icon_size, 0.0f, 1.0f);
@@ -687,41 +711,17 @@
         arg.alpha          = 1.0f;
         arg.glow_intensity = 0.0f;
         arg.running_arrow  = false;
-        arg.active_arrow   = icon->Active ();
+        arg.active_arrow   = icon->GetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE);
         arg.folding_rads   = 0.0f;
         arg.skip           = false;
         
         arg.window_indicators = MIN (4, icon->RelatedWindows ());
         
         // we dont need to show strays
-        if (arg.window_indicators == 1 || !icon->Running ())
+        if (arg.window_indicators == 1 || !icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
           arg.window_indicators = 0;
         
-        // animate this shit
-        struct timespec running_time = icon->RunningTime ();
-        int running_ms = TimeDelta (&current, &running_time);
-        float running_progress = CLAMP ((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
-
-        if (icon->Running ())
-        {
-          arg.backlight_intensity = running_progress * BACKLIGHT_STRENGTH;
-          
-          if (icon->Urgent ())
-          {
-              struct timespec urgent_time = icon->UrgentTime ();
-              int urgent_ms = TimeDelta (&current, &urgent_time);
-              double urgent_progress = (double) CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
-              
-              arg.backlight_intensity *= 0.2f + 0.8f * (0.5f + (float) (std::cos (M_PI * (float) (URGENT_BLINKS * 2) * urgent_progress)) * 0.5f);
-          }
-        }
-        else
-        {
-          if (running_ms > ANIM_DURATION_SHORT)
-            arg.backlight_intensity = 0.0f;
-          else
-            arg.backlight_intensity = BACKLIGHT_STRENGTH - running_progress * BACKLIGHT_STRENGTH;
-        }
+        arg.backlight_intensity = IconBackgroundIntensity (icon, current);
         
         // reset z
         center.z = 0;
@@ -743,7 +743,7 @@
       
         center.y += half_size * size_modifier;   // move to center
         arg.center = nux::Point3 (center);       // copy center
-        icon->SetCenter (arg.center);
+        icon->SetCenter (nux::Point3 (center.x, center.y + vertical_offset, center.z));
         center.y += half_size * size_modifier;   // move to end
         center.y += _space_between_icons * size_modifier;
         
@@ -1270,9 +1270,6 @@
     gPainter.Paint2DQuadColor (GfxContext, shelf_shadow, shelf_zero, shelf_color, shelf_color, shelf_zero);
     gPainter.Paint2DQuadColor (GfxContext, shelf_box, shelf_color);
 
-    CHECKGL (glLineWidth (1));
-    gPainter.Draw2DLine (GfxContext, shelf_box.x, shelf_box.y - 1, shelf_box.x + shelf_box.width, shelf_box.y - 1, nux::Color (0x66FFFFFF));
-    
     for (it = shelf_args.begin(); it != shelf_args.end(); it++)
     {
       if ((*it).skip)
@@ -1496,7 +1493,7 @@
 
   for (it = _model->shelf_begin(); it != _model->shelf_end (); it++)
   {
-    if (!(*it)->Visible ())
+    if (!(*it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
       continue;
 
     nux::Point2 screen_coord [4];
@@ -1513,7 +1510,7 @@
   // Because of the way icons fold and stack on one another, we must proceed in 2 steps.
   for (rev_it = _model->rbegin (); rev_it != _model->rend (); rev_it++)
   {
-    if ((*rev_it)->_folding_angle < 0.0f || !(*rev_it)->Visible ())
+    if ((*rev_it)->_folding_angle < 0.0f || !(*rev_it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
       continue;
 
     nux::Point2 screen_coord [4];
@@ -1529,7 +1526,7 @@
 
   for (it = _model->begin(); it != _model->end (); it++)
   {
-    if ((*it)->_folding_angle >= 0.0f || !(*it)->Visible ())
+    if ((*it)->_folding_angle >= 0.0f || !(*it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
       continue;
 
     nux::Point2 screen_coord [4];

=== modified file 'src/Launcher.h'
--- src/Launcher.h	2010-11-23 02:58:23 +0000
+++ src/Launcher.h	2010-11-24 15:28:12 +0000
@@ -119,7 +119,10 @@
   float DnDExitProgress  ();
   float GetHoverProgress ();
   float AutohideProgress ();
-  float IconPresentProgress (LauncherIcon *icon, struct timespec current);
+  float IconPresentProgress     (LauncherIcon *icon, struct timespec current);
+  float IconUrgentPulseValue    (LauncherIcon *icon, struct timespec current);
+  float IconStartingPulseValue  (LauncherIcon *icon, struct timespec current);
+  float IconBackgroundIntensity (LauncherIcon *icon, struct timespec current);
 
   void SetHover   ();
   void UnsetHover ();

=== modified file 'src/LauncherController.cpp'
--- src/LauncherController.cpp	2010-11-12 17:32:48 +0000
+++ src/LauncherController.cpp	2010-11-24 15:28:12 +0000
@@ -60,8 +60,8 @@
     
     expoIcon->SetTooltipText ("Workspace Switcher");
     expoIcon->SetIconName ("workspace-switcher");
-    expoIcon->SetVisible (true);
-    expoIcon->SetRunning (false);
+    expoIcon->SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
+    expoIcon->SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, false);
     expoIcon->SetIconType (LAUNCHER_ICON_TYPE_END);
     
     expoIcon->MouseClick.connect (sigc::mem_fun (this, &LauncherController::OnExpoClicked));

=== modified file 'src/LauncherIcon.cpp'
--- src/LauncherIcon.cpp	2010-11-23 20:00:15 +0000
+++ src/LauncherIcon.cpp	2010-11-24 15:28:12 +0000
@@ -42,26 +42,13 @@
   _launcher = launcher;
   m_TooltipText = "blank";
 
-  _show_time.tv_sec = 0;
-  _hide_time.tv_sec = 0;
-  _running_time.tv_sec = 0;
-  _urgent_time.tv_sec = 0;
-  _present_time.tv_sec = 0;
-  _unpresent_time.tv_sec = 0;
-
-  _show_time.tv_nsec = 0;
-  _hide_time.tv_nsec = 0;
-  _running_time.tv_nsec = 0;
-  _urgent_time.tv_nsec = 0;
-  _present_time.tv_nsec = 0;
-  _unpresent_time.tv_nsec = 0;
-
-  _active    = false;
-  _running   = false;
-  _visible   = false;
-  _urgent    = false;
-  _presented = false;
-  
+  for (int i = 0; i < LAUNCHER_ICON_QUIRK_LAST; i++)
+  {
+    _quirks[i] = 0;
+    _quirk_times[i].tv_sec = 0;
+    _quirk_times[i].tv_nsec = 0;
+  }
+
   _related_windows = 0;
 
   _background_color = nux::Color::White;
@@ -86,8 +73,11 @@
 {
   if (_present_time_handle)
     g_source_remove (_present_time_handle);
-  
   _present_time_handle = 0;
+  
+  if (_center_stabilize_handle)
+    g_source_remove (_center_stabilize_handle);
+  _center_stabilize_handle = 0;
 }
 
 nux::Color LauncherIcon::BackgroundColor ()
@@ -242,7 +232,7 @@
   }
   
   int tip_x = _launcher->GetBaseWidth () + 1; //icon_x + icon_w;
-  int tip_y = 24 + _center.y;
+  int tip_y = _center.y;
           
   _tooltip->ShowTooltipWithTipAt (tip_x, tip_y);
   
@@ -327,7 +317,7 @@
     
     
     int tip_x = _launcher->GetBaseWidth () + 1; //icon_x + icon_w;
-    int tip_y = 24 + _center.y;
+    int tip_y = _center.y;
 
     _quicklist->ShowQuicklistWithTipAt (tip_x, tip_y);
     _quicklist->EnableInputWindow (true);
@@ -361,34 +351,19 @@
   _tooltip->ShowWindow (false);
 }
 
-struct timespec LauncherIcon::ShowTime ()
-{
-  return _show_time;
-}
-
-struct timespec LauncherIcon::HideTime ()
-{
-  return _hide_time;
-}
-
-struct timespec LauncherIcon::RunningTime ()
-{
-  return _running_time;
-}
-
-struct timespec LauncherIcon::UrgentTime ()
-{
-  return _urgent_time;
-}
-
-struct timespec LauncherIcon::PresentTime ()
-{
-  return _present_time;
-}
-
-struct timespec LauncherIcon::UnpresentTime ()
-{
-  return _unpresent_time;
+gboolean
+LauncherIcon::OnCenterTimeout (gpointer data)
+{
+  LauncherIcon *self = (LauncherIcon*)data;
+  
+  if (self->_last_stable != self->_center)
+  {
+    self->OnCenterStabilized (self->_center);
+    self->_last_stable = self->_center;
+  }
+
+  self->_center_stabilize_handle = 0;
+  return false;
 }
 
 void 
@@ -397,80 +372,30 @@
   _center = center;
   
   int tip_x = _launcher->GetBaseWidth () + 1; //icon_x + icon_w;
-  int tip_y = 24 + _center.y;
+  int tip_y = _center.y;
     
   if (_quicklist->IsVisible ())
     _quicklist->ShowQuicklistWithTipAt (tip_x, tip_y);
   else if (_tooltip->IsVisible ())
     _tooltip->ShowTooltipWithTipAt (tip_x, tip_y);
-}
-
-void
-LauncherIcon::SetVisible (bool visible)
-{
-  if (visible == _visible)
-    return;
-      
-  _visible = visible;
-  
-  needs_redraw.emit (this);
-
-  if (visible)
-  {
-    Present (1500);
-    clock_gettime (CLOCK_MONOTONIC, &_show_time);
-    show.emit (this);
-  }
-  else
-  {
-    clock_gettime (CLOCK_MONOTONIC, &_hide_time);
-    hide.emit (this);
-  }
-}
-
-void
-LauncherIcon::SetActive (bool active)
-{
-  if (active == _active)
-    return;
-    
-  _active = active;
-  needs_redraw.emit (this);
-}
-
-void 
-LauncherIcon::SetRunning (bool running)
-{
-  if (running == _running)
-    return;
-    
-  _running = running;
-  clock_gettime (CLOCK_MONOTONIC, &_running_time);
-  needs_redraw.emit (this);
-}
-
-void 
-LauncherIcon::SetUrgent (bool urgent)
-{
-  if (urgent == _urgent)
-    return;
-  
-  _urgent = urgent;
-  
-  if (urgent)
-  {
-      Present (1500);
-      clock_gettime (CLOCK_MONOTONIC, &_urgent_time);
-  }
-  
-  needs_redraw.emit (this);
+    
+  if (_center_stabilize_handle)
+    g_source_remove (_center_stabilize_handle);
+  
+  _center_stabilize_handle = g_timeout_add (500, &LauncherIcon::OnCenterTimeout, this);
+}
+
+nux::Point3
+LauncherIcon::GetCenter ()
+{
+  return _center;
 }
 
 gboolean
 LauncherIcon::OnPresentTimeout (gpointer data)
 {
   LauncherIcon *self = (LauncherIcon*) data;
-  if (!self->_presented)
+  if (!self->GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
     return false;
   
   self->_present_time_handle = 0;
@@ -482,28 +407,25 @@
 void 
 LauncherIcon::Present (int length)
 {
-  if (_presented)
+  if (GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
     return;
   
-  _presented = true;
+  if (length >= 0)
+    _present_time_handle = g_timeout_add (length, &LauncherIcon::OnPresentTimeout, this);
   
-  _present_time_handle = g_timeout_add (length, &LauncherIcon::OnPresentTimeout, this);
-  clock_gettime (CLOCK_MONOTONIC, &_present_time);
-  needs_redraw.emit (this);
+  SetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED, true);
 }
 
 void
 LauncherIcon::Unpresent ()
 {
-  if (!_presented)
+  if (!GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
     return;
   
   if (_present_time_handle > 0)
     g_source_remove (_present_time_handle);
   
-  _presented = false;
-  clock_gettime (CLOCK_MONOTONIC, &_unpresent_time);
-  needs_redraw.emit (this);
+  SetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED, false);
 }
 
 void 
@@ -519,7 +441,7 @@
 void 
 LauncherIcon::Remove ()
 {
-  SetVisible (false);
+  SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, false);
   remove.emit (this);
 }
 
@@ -548,33 +470,44 @@
 }
 
 bool
-LauncherIcon::Visible ()
-{
-  return _visible;
-}
-
-bool
-LauncherIcon::Active ()
-{
-  return _active;
-}
-
-bool
-LauncherIcon::Running ()
-{
-  return _running;
-}
-
-bool
-LauncherIcon::Urgent ()
-{
-  return _urgent;
-}
-
-bool
-LauncherIcon::Presented ()
-{
-  return _presented;
+LauncherIcon::GetQuirk (LauncherIconQuirk quirk)
+{
+  return _quirks[quirk];
+}
+
+void
+LauncherIcon::SetQuirk (LauncherIconQuirk quirk, bool value)
+{
+  if (_quirks[quirk] == value)
+    return;
+    
+  _quirks[quirk] = value;
+  clock_gettime (CLOCK_MONOTONIC, &(_quirk_times[quirk]));
+  needs_redraw.emit (this);
+  
+  // Present on urgent as a general policy
+  if ((quirk == LAUNCHER_ICON_QUIRK_URGENT || quirk == LAUNCHER_ICON_QUIRK_VISIBLE) && value)
+    Present (1500);
+}
+
+void
+LauncherIcon::UpdateQuirkTime (LauncherIconQuirk quirk)
+{
+  clock_gettime (CLOCK_MONOTONIC, &(_quirk_times[quirk]));
+  needs_redraw.emit (this);
+}
+
+void 
+LauncherIcon::ResetQuirkTime (LauncherIconQuirk quirk)
+{
+  _quirk_times[quirk].tv_sec = 0;
+  _quirk_times[quirk].tv_nsec = 0;
+}
+
+struct timespec
+LauncherIcon::GetQuirkTime (LauncherIconQuirk quirk)
+{
+  return _quirk_times[quirk];
 }
 
 int

=== modified file 'src/LauncherIcon.h'
--- src/LauncherIcon.h	2010-11-23 02:58:23 +0000
+++ src/LauncherIcon.h	2010-11-24 15:28:12 +0000
@@ -50,22 +50,28 @@
   LAUNCHER_ICON_TYPE_END,
 } LauncherIconType;
 
+typedef enum
+{
+  LAUNCHER_ICON_QUIRK_VISIBLE,
+  LAUNCHER_ICON_QUIRK_ACTIVE,
+  LAUNCHER_ICON_QUIRK_RUNNING,
+  LAUNCHER_ICON_QUIRK_URGENT,
+  LAUNCHER_ICON_QUIRK_PRESENTED,
+  LAUNCHER_ICON_QUIRK_STARTING,
+  
+  LAUNCHER_ICON_QUIRK_LAST,
+} LauncherIconQuirk;
+
 class LauncherIcon : public nux::InitiallyUnownedObject, public sigc::trackable
 {
 public:
     LauncherIcon(Launcher* launcher);
     ~LauncherIcon();
 
-    void         SetTooltipText (const TCHAR* text);
+    void SetTooltipText (const TCHAR* text);
     
     nux::NString GetTooltipText ();
     
-    bool Visible ();
-    bool Active  ();
-    bool Running ();
-    bool Urgent  ();
-    bool Presented ();
-
     void RecvMouseEnter ();
     void RecvMouseLeave ();
     void RecvMouseDown (int button);
@@ -75,18 +81,16 @@
     void RecvHideQuicklist (nux::BaseWindow *quicklist);
     
     void HideTooltip ();
-    void SetCenter (nux::Point3 center);
+    
+    void        SetCenter (nux::Point3 center);
+    nux::Point3 GetCenter ();
     
     int SortPriority ();
     
     int RelatedWindows ();
     
-    struct timespec ShowTime ();
-    struct timespec HideTime ();
-    struct timespec RunningTime ();
-    struct timespec UrgentTime ();
-    struct timespec PresentTime ();
-    struct timespec UnpresentTime ();
+    bool GetQuirk (LauncherIconQuirk quirk);
+    struct timespec GetQuirkTime (LauncherIconQuirk quirk);
     
     LauncherIconType Type ();
     
@@ -98,8 +102,8 @@
     
     sigc::signal<void, int> MouseDown;
     sigc::signal<void, int> MouseUp;
-    sigc::signal<void> MouseEnter;
-    sigc::signal<void> MouseLeave;
+    sigc::signal<void>      MouseEnter;
+    sigc::signal<void>      MouseLeave;
     sigc::signal<void, int> MouseClick;
     
     sigc::signal<void, void *> show;
@@ -107,11 +111,11 @@
     sigc::signal<void, void *> remove;
     sigc::signal<void, void *> needs_redraw;
 protected:
-
-    void SetVisible (bool visible);
-    void SetActive  (bool active);
-    void SetRunning (bool running);
-    void SetUrgent  (bool urgent);
+    void SetQuirk (LauncherIconQuirk quirk, bool value);
+
+    void UpdateQuirkTime (LauncherIconQuirk quirk);
+    void ResetQuirkTime (LauncherIconQuirk quirk);
+
     void SetRelatedWindows (int windows);
     void Remove ();
     
@@ -123,6 +127,8 @@
 
     virtual std::list<DbusmenuClient *> GetMenus ();
     virtual nux::BaseTexture * GetTextureForSize (int size) = 0;
+    
+    virtual void OnCenterStabilized (nux::Point3 center) {};
 
     nux::BaseTexture * TextureFromGtkTheme (const char *name, int size);
 
@@ -153,30 +159,24 @@
     static void child_realized (DbusmenuMenuitem *newitem, QuicklistView *quicklist);
     static void root_changed (DbusmenuClient * client, DbusmenuMenuitem *newroot, QuicklistView *quicklist);
     static gboolean OnPresentTimeout (gpointer data);
+    static gboolean OnCenterTimeout (gpointer data);
 
     nux::Color ColorForIcon (GdkPixbuf *pixbuf);
 
     nux::Color       _background_color;
-    bool             _visible;
-    bool             _active;
-    bool             _running;
-    bool             _urgent;
-    bool             _presented;
     int              _sort_priority;
     int              _related_windows;
     guint            _present_time_handle;
+    guint            _center_stabilize_handle;
     bool             _quicklist_is_initialized;
     
     nux::Point3      _center;
-    
+    nux::Point3      _last_stable;
     LauncherIconType _icon_type;
     
-    struct timespec   _show_time;
-    struct timespec   _hide_time;
-    struct timespec   _running_time;
-    struct timespec   _urgent_time;
-    struct timespec   _present_time;
-    struct timespec   _unpresent_time;
+    bool             _quirks[LAUNCHER_ICON_QUIRK_LAST];
+    struct timespec  _quirk_times[LAUNCHER_ICON_QUIRK_LAST];
+    
 };
 
 #endif // LAUNCHERICON_H

=== added file 'src/StartupNotifyService.cpp'
--- src/StartupNotifyService.cpp	1970-01-01 00:00:00 +0000
+++ src/StartupNotifyService.cpp	2010-11-24 15:28:12 +0000
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Jason Smith <[e-mail]>
+ */
+
+#include "StartupNotifyService.h"
+#include <stdio.h>
+
+StartupNotifyService * StartupNotifyService::_default = 0;
+
+StartupNotifyService *
+StartupNotifyService::Default ()
+{
+  if (!_default)
+    _default = new StartupNotifyService ();
+    
+  return _default;
+}
+
+StartupNotifyService::StartupNotifyService()
+{
+}
+
+StartupNotifyService::~StartupNotifyService()
+{
+}
+
+void
+StartupNotifyService::OnMonitorEvent (SnMonitorEvent *sn_event, void *user_data)
+{
+  StartupNotifyService *service = (StartupNotifyService*) user_data;
+  SnStartupSequence *seq;
+  const char *id;
+  
+  seq = sn_monitor_event_get_startup_sequence (sn_event);
+  id = sn_startup_sequence_get_id (seq);
+  
+  switch (sn_monitor_event_get_type (sn_event))
+  {
+    case SN_MONITOR_EVENT_INITIATED:
+      service->StartupInitiated.emit (id);
+      break;
+    case SN_MONITOR_EVENT_COMPLETED:
+      service->StartupCompleted.emit (id);
+      break;
+    default:
+      break;
+  }
+  
+}
+
+void
+StartupNotifyService::SetSnDisplay (SnDisplay *sn_display, int screen)
+{
+  _sn_display = sn_display;
+  _sn_monitor = sn_monitor_context_new (_sn_display, screen, &StartupNotifyService::OnMonitorEvent, this, NULL);
+}

=== added file 'src/StartupNotifyService.h'
--- src/StartupNotifyService.h	1970-01-01 00:00:00 +0000
+++ src/StartupNotifyService.h	2010-11-24 15:28:12 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * 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/>.
+ *
+ * Authored by: Jason Smith <[e-mail]>
+ */
+
+#ifndef STARTUPNOTIFYSERVICE_H
+#define STARTUPNOTIFYSERVICE_H
+
+#ifndef SN_API_NOT_YET_FROZEN
+#define SN_API_NOT_YET_FROZEN
+#endif
+#include <libsn/sn.h>
+
+#include <sigc++/sigc++.h>
+
+class StartupNotifyService : public sigc::trackable
+{
+
+public:
+  static StartupNotifyService * Default();
+  
+  void SetSnDisplay (SnDisplay *sn_display, int screen);
+
+  sigc::signal<void, const char*> StartupInitiated;
+  sigc::signal<void, const char*> StartupCompleted;
+  
+protected:
+  StartupNotifyService();
+  ~StartupNotifyService();
+
+private:
+  static void OnMonitorEvent (SnMonitorEvent *sn_event, void *user_data);
+
+  static StartupNotifyService *_default;
+
+  SnDisplay                   *_sn_display;
+  SnMonitorContext            *_sn_monitor;
+};
+
+#endif // STARTUPNOTIFYSERVICE_H

=== modified file 'src/unity.cpp'
--- src/unity.cpp	2010-11-15 23:07:58 +0000
+++ src/unity.cpp	2010-11-24 15:28:12 +0000
@@ -29,6 +29,7 @@
 #include "LauncherIcon.h"
 #include "LauncherController.h"
 #include "PluginAdapter.h"
+#include "StartupNotifyService.h"
 #include "unity.h"
 
 #include <dbus/dbus.h>
@@ -438,6 +439,8 @@
     ScreenInterface::setHandler (screen); // Sets the screen function hook handler
     CompositeScreenInterface::setHandler (cScreen); // Ditto for cScreen
     GLScreenInterface::setHandler (gScreen); // Ditto for gScreen
+    
+    StartupNotifyService::Default ()->SetSnDisplay (screen->snDisplay (), screen->screenNum ());
 
     nux::NuxInitialize (0);
     wt = nux::CreateFromForeignWindow (cScreen->output (),