Merge lp:~canonical-dx-team/unity/unity.spec-conformance into lp:unity

[Jason Smith]

Adds options to implement all different features I could find proposed.

[Alex Launi (alexlauni)]

Can you add what launch animation is currently selected to introspection data, and then it looks ok to me.

review: Approve

[lp:~canonical-dx-team/unity/unity.spec-conformance]

732. By Jason Smith on 2010-12-22

Change defaults

733. By Jason Smith on 2010-12-22

implement urgent wiggle animation

734. By Jason Smith on 2010-12-22

Use C++ style scoping for enums rather than C style enums

735. By Jason Smith on 2010-12-22

black trash

736. By Jason Smith on 2010-12-22

ensure super short lived windows do not result in a jumpy animation

=== modified file 'po/unity.pot'
--- po/unity.pot	2010-12-15 16:16:09 +0000
+++ po/unity.pot	2010-12-22 01:51:30 +0000
@@ -8,7 +8,7 @@
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: [e-mail]\n"
-"POT-Creation-Date: 2010-12-15 16:03+0000\n"
+"POT-Creation-Date: 2010-12-17 19:24-0500\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"

=== modified file 'src/BamfLauncherIcon.cpp'
--- src/BamfLauncherIcon.cpp	2010-12-17 10:03:18 +0000
+++ src/BamfLauncherIcon.cpp	2010-12-22 01:51:30 +0000
@@ -59,15 +59,15 @@
 
   SetTooltipText (bamf_view_get_name (BAMF_VIEW (app)));
   SetIconName (icon_name);
-  SetIconType (LAUNCHER_ICON_TYPE_APPLICATION);
+  SetIconType (TYPE_APPLICATION);
 
   if (bamf_view_is_sticky (BAMF_VIEW (m_App)))
-    SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
+    SetQuirk (QUIRK_VISIBLE, true);
   else
-    SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, bamf_view_user_visible (BAMF_VIEW (m_App)));
+    SetQuirk (QUIRK_VISIBLE, bamf_view_user_visible (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)));
+  SetQuirk (QUIRK_ACTIVE, bamf_view_is_active (BAMF_VIEW (m_App)));
+  SetQuirk (QUIRK_RUNNING, bamf_view_is_running (BAMF_VIEW (m_App)));
 
   g_free (icon_name);
 
@@ -110,7 +110,7 @@
     return;
 
   Present (0.5f, 600);
-  UpdateQuirkTimeDelayed (300, LAUNCHER_ICON_QUIRK_SHIMMER);
+  UpdateQuirkTimeDelayed (300, QUIRK_SHIMMER);
 }
 
 bool
@@ -197,7 +197,7 @@
     g_error_free (error);
   }
 
-  UpdateQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+  UpdateQuirkTime (QUIRK_STARTING);
 }
 
 void
@@ -353,9 +353,9 @@
 
   if (!running)
   {
-    if (GetQuirk (LAUNCHER_ICON_QUIRK_STARTING))
+    if (GetQuirk (QUIRK_STARTING))
       return;
-    SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, true);
+    SetQuirk (QUIRK_STARTING, true);
     OpenInstance ();
     return;
   }
@@ -380,14 +380,14 @@
   BamfLauncherIcon *self = (BamfLauncherIcon *) data;
 
   if (!bamf_view_is_sticky (BAMF_VIEW (self->m_App)))
-    self->SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, visible);
+    self->SetQuirk (QUIRK_VISIBLE, visible);
 }
 
 void
 BamfLauncherIcon::OnRunningChanged (BamfView *view, gboolean running, gpointer data)
 {
   BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-  self->SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, running);
+  self->SetQuirk (QUIRK_RUNNING, running);
 
   if (running)
   {
@@ -400,14 +400,14 @@
 BamfLauncherIcon::OnActiveChanged (BamfView *view, gboolean active, gpointer data)
 {
   BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-  self->SetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE, active);
+  self->SetQuirk (QUIRK_ACTIVE, active);
 }
 
 void
 BamfLauncherIcon::OnUrgentChanged (BamfView *view, gboolean urgent, gpointer data)
 {
   BamfLauncherIcon *self = (BamfLauncherIcon *) data;
-  self->SetQuirk (LAUNCHER_ICON_QUIRK_URGENT, urgent);
+  self->SetQuirk (QUIRK_URGENT, urgent);
 }
 
 void

=== modified file 'src/Launcher.cpp'
--- src/Launcher.cpp	2010-12-17 11:49:38 +0000
+++ src/Launcher.cpp	2010-12-22 01:51:30 +0000
@@ -38,11 +38,8 @@
 #include "QuicklistManager.h"
 #include "QuicklistView.h"
 
-#define ANIM_DURATION_SHORT 125
-#define ANIM_DURATION       200
-#define ANIM_DURATION_LONG  350
-
 #define URGENT_BLINKS       3
+#define WIGGLE_CYCLES       6
 
 #define MAX_STARTING_BLINKS 5
 #define STARTING_BLINK_LAMBDA 3
@@ -240,8 +237,9 @@
     _launcher_top_y         = 0;
     _launcher_bottom_y      = 0;
     _folded_z_distance      = 10.0f;
-    _launcher_state         = LAUNCHER_FOLDED;
     _launcher_action_state  = ACTION_NONE;
+    _launch_animation       = LAUNCH_ANIMATION_NONE;
+    _urgent_animation       = URGENT_ANIMATION_NONE;
     _icon_under_mouse       = NULL;
     _icon_mouse_down        = NULL;
     _drag_icon              = NULL;
@@ -271,6 +269,8 @@
     _mouse_inside_trigger   = false;
     _window_over_launcher   = false;
     _render_drag_window     = false;
+    _backlight_always_on    = false;
+    
 
     // 0 out timers to avoid wonky startups
     _enter_time.tv_sec = 0;
@@ -390,35 +390,35 @@
 
 bool Launcher::IconNeedsAnimation (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
-    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
-        return true;
-
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
-    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
-        return true;
-
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    struct timespec time = icon->GetQuirkTime (LauncherIcon::QUIRK_VISIBLE);
+    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
+        return true;
+
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_RUNNING);
+    if (TimeDelta (&current, &time) < ANIM_DURATION_SHORT)
+        return true;
+
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_STARTING);
     if (TimeDelta (&current, &time) < (ANIM_DURATION_LONG * MAX_STARTING_BLINKS * STARTING_BLINK_LAMBDA * 2))
         return true;
 
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_URGENT);
     if (TimeDelta (&current, &time) < (ANIM_DURATION_LONG * URGENT_BLINKS * 2))
         return true;
 
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_PRESENTED);
     if (TimeDelta (&current, &time) < ANIM_DURATION)
         return true;
 
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_SHIMMER);
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_SHIMMER);
     if (TimeDelta (&current, &time) < ANIM_DURATION_LONG)
         return true;
 
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_CENTER_SAVED);
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_CENTER_SAVED);
     if (TimeDelta (&current, &time) < ANIM_DURATION)
         return true;
 
-    time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PROGRESS);
+    time = icon->GetQuirkTime (LauncherIcon::QUIRK_PROGRESS);
     if (TimeDelta (&current, &time) < ANIM_DURATION)
         return true;
 
@@ -495,15 +495,15 @@
 
 float IconVisibleProgress (LauncherIcon *icon, struct timespec const &current)
 {
-    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+    if (icon->GetQuirk (LauncherIcon::QUIRK_VISIBLE))
     {
-        struct timespec icon_visible_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+        struct timespec icon_visible_time = icon->GetQuirkTime (LauncherIcon::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->GetQuirkTime (LAUNCHER_ICON_QUIRK_VISIBLE);
+        struct timespec icon_hide_time = icon->GetQuirkTime (LauncherIcon::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);
     }
@@ -537,11 +537,11 @@
 
 float Launcher::IconPresentProgress (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec icon_present_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PRESENTED);
+    struct timespec icon_present_time = icon->GetQuirkTime (LauncherIcon::QUIRK_PRESENTED);
     int ms = TimeDelta (&current, &icon_present_time);
     float result = CLAMP ((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);
 
-    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
+    if (icon->GetQuirk (LauncherIcon::QUIRK_PRESENTED))
         return result;
     else
         return 1.0f - result;
@@ -549,11 +549,16 @@
 
 float Launcher::IconUrgentProgress (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec urgent_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_URGENT);
+    struct timespec urgent_time = icon->GetQuirkTime (LauncherIcon::QUIRK_URGENT);
     int urgent_ms = TimeDelta (&current, &urgent_time);
-    float result = CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
+    float result;
+    
+    if (_urgent_animation == URGENT_ANIMATION_WIGGLE)
+      result = CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_SHORT * WIGGLE_CYCLES), 0.0f, 1.0f);
+    else
+      result = CLAMP ((float) urgent_ms / (float) (ANIM_DURATION_LONG * URGENT_BLINKS * 2), 0.0f, 1.0f);
 
-    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+    if (icon->GetQuirk (LauncherIcon::QUIRK_URGENT))
       return result;
     else
       return 1.0f - result;
@@ -561,83 +566,117 @@
 
 float Launcher::IconShimmerProgress (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec shimmer_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_SHIMMER);
+    struct timespec shimmer_time = icon->GetQuirkTime (LauncherIcon::QUIRK_SHIMMER);
     int shimmer_ms = TimeDelta (&current, &shimmer_time);
     return CLAMP ((float) shimmer_ms / (float) ANIM_DURATION_LONG, 0.0f, 1.0f);
 }
 
 float Launcher::IconCenterTransitionProgress (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec save_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_CENTER_SAVED);
+    struct timespec save_time = icon->GetQuirkTime (LauncherIcon::QUIRK_CENTER_SAVED);
     int save_ms = TimeDelta (&current, &save_time);
     return CLAMP ((float) save_ms / (float) ANIM_DURATION, 0.0f, 1.0f);
 }
 
 float Launcher::IconUrgentPulseValue (LauncherIcon *icon, struct timespec const &current)
 {
-    if (!icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+    if (!icon->GetQuirk (LauncherIcon::QUIRK_URGENT))
         return 1.0f; // we are full on in a normal condition
 
     double urgent_progress = (double) IconUrgentProgress (icon, current);
     return 0.5f + (float) (std::cos (M_PI * (float) (URGENT_BLINKS * 2) * urgent_progress)) * 0.5f;
 }
 
+float Launcher::IconUrgentWiggleValue (LauncherIcon *icon, struct timespec const &current)
+{
+    if (!icon->GetQuirk (LauncherIcon::QUIRK_URGENT))
+        return 0.0f; // we are full on in a normal condition
+
+    double urgent_progress = (double) IconUrgentProgress (icon, current);
+    return 0.3f * (float) (std::sin (M_PI * (float) (WIGGLE_CYCLES * 2) * urgent_progress)) * 0.5f;
+}
+
+float Launcher::IconStartingBlinkValue (LauncherIcon *icon, struct timespec const &current)
+{
+    struct timespec starting_time = icon->GetQuirkTime (LauncherIcon::QUIRK_STARTING);
+    int starting_ms = TimeDelta (&current, &starting_time);
+    double starting_progress = (double) CLAMP ((float) starting_ms / (float) (ANIM_DURATION_LONG * STARTING_BLINK_LAMBDA), 0.0f, 1.0f);
+    return 0.5f + (float) (std::cos (M_PI * (_backlight_always_on ? 4.0f : 3.0f) * starting_progress)) * 0.5f;
+}
+
 float Launcher::IconStartingPulseValue (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec starting_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+    struct timespec starting_time = icon->GetQuirkTime (LauncherIcon::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);
 
-    if (starting_progress == 1.0f && !icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    if (starting_progress == 1.0f && !icon->GetQuirk (LauncherIcon::QUIRK_RUNNING))
     {
-        icon->SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, false);
-        icon->ResetQuirkTime (LAUNCHER_ICON_QUIRK_STARTING);
+        icon->SetQuirk (LauncherIcon::QUIRK_STARTING, false);
+        icon->ResetQuirkTime (LauncherIcon::QUIRK_STARTING);
     }
 
-    return 1.0f - (0.5f + (float) (std::cos (M_PI * (float) (MAX_STARTING_BLINKS * 2) * starting_progress)) * 0.5f);
+    return 0.5f + (float) (std::cos (M_PI * (float) (MAX_STARTING_BLINKS * 2) * starting_progress)) * 0.5f;
 }
 
 float Launcher::IconBackgroundIntensity (LauncherIcon *icon, struct timespec const &current)
 {
     float result = 0.0f;
-    struct timespec running_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_RUNNING);
+
+    struct timespec running_time = icon->GetQuirkTime (LauncherIcon::QUIRK_RUNNING);
     int running_ms = TimeDelta (&current, &running_time);
     float running_progress = CLAMP ((float) running_ms / (float) ANIM_DURATION_SHORT, 0.0f, 1.0f);
+    
+    if (!icon->GetQuirk (LauncherIcon::QUIRK_RUNNING))
+      running_progress = 1.0f - running_progress;
 
     // After we finish a fade in from running, we can reset the quirk
-    if (running_progress == 1.0f && icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
-    {
-         icon->SetQuirk (LAUNCHER_ICON_QUIRK_STARTING, false);
-         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);
-    }
+    if (running_progress == 1.0f && icon->GetQuirk (LauncherIcon::QUIRK_RUNNING))
+       icon->SetQuirk (LauncherIcon::QUIRK_STARTING, false);
+    
+    float backlight_strength;
+    if (_backlight_always_on)
+      backlight_strength = BACKLIGHT_STRENGTH;
     else
+      backlight_strength = BACKLIGHT_STRENGTH * running_progress;
+      
+    switch (_launch_animation)
     {
-        // modestly evil
-        result += BACKLIGHT_STRENGTH - running_progress * BACKLIGHT_STRENGTH;
+      case LAUNCH_ANIMATION_NONE:
+        result = backlight_strength;
+        break;
+      case LAUNCH_ANIMATION_BLINK:
+        if (_backlight_always_on)
+          result = IconStartingBlinkValue (icon, current);
+        else
+          result = backlight_strength; // The blink concept is a failure in this case (it just doesn't work right)
+        break;
+      case LAUNCH_ANIMATION_PULSE:
+        if (running_progress == 1.0f && icon->GetQuirk (LauncherIcon::QUIRK_RUNNING))
+          icon->ResetQuirkTime (LauncherIcon::QUIRK_STARTING);
+        
+        result = backlight_strength;
+        if (_backlight_always_on)
+          result *= CLAMP (running_progress + IconStartingPulseValue (icon, current), 0.0f, 1.0f);
+        else
+          result += (BACKLIGHT_STRENGTH - result) * (1.0f - IconStartingPulseValue (icon, current));
+        break;
     }
-
+    
+      // urgent serves to bring the total down only
+    if (icon->GetQuirk (LauncherIcon::QUIRK_URGENT) && _urgent_animation == URGENT_ANIMATION_PULSE)
+      result *= 0.2f + 0.8f * IconUrgentPulseValue (icon, current);
+    
     return result;
 }
 
 float Launcher::IconProgressBias (LauncherIcon *icon, struct timespec const &current)
 {
-    struct timespec icon_progress_time = icon->GetQuirkTime (LAUNCHER_ICON_QUIRK_PROGRESS);
+    struct timespec icon_progress_time = icon->GetQuirkTime (LauncherIcon::QUIRK_PROGRESS);
     int ms = TimeDelta (&current, &icon_progress_time);
     float result = CLAMP ((float) ms / (float) ANIM_DURATION, 0.0f, 1.0f);
 
-    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_PROGRESS))
+    if (icon->GetQuirk (LauncherIcon::QUIRK_PROGRESS))
         return -1.0f + result;
     else
         return result;
@@ -647,9 +686,9 @@
 {
     arg.icon            = icon;
     arg.alpha           = 1.0f;
-    arg.running_arrow   = icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING);
-    arg.active_arrow    = icon->GetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE);
-    arg.running_colored = icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT);
+    arg.running_arrow   = icon->GetQuirk (LauncherIcon::QUIRK_RUNNING);
+    arg.active_arrow    = icon->GetQuirk (LauncherIcon::QUIRK_ACTIVE);
+    arg.running_colored = icon->GetQuirk (LauncherIcon::QUIRK_URGENT);
     arg.active_colored  = false;
     arg.x_rotation      = 0.0f;
     arg.y_rotation      = 0.0f;
@@ -660,7 +699,7 @@
     arg.progress        = CLAMP (icon->GetProgress (), 0.0f, 1.0f);
 
     // we dont need to show strays
-    if (!icon->GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING))
+    if (!icon->GetQuirk (LauncherIcon::QUIRK_RUNNING))
         arg.window_indicators = 0;
     else
         arg.window_indicators = MIN (4, icon->RelatedWindows ());
@@ -670,11 +709,16 @@
 
     float urgent_progress = IconUrgentProgress (icon, current);
     
-    if (icon->GetQuirk (LAUNCHER_ICON_QUIRK_URGENT))
+    if (icon->GetQuirk (LauncherIcon::QUIRK_URGENT))
       urgent_progress = CLAMP (urgent_progress * 3.0f, 0.0f, 1.0f); // we want to go 3x faster than the urgent normal cycle
     else
       urgent_progress = CLAMP (urgent_progress * 3.0f - 2.0f, 0.0f, 1.0f); // we want to go 3x faster than the urgent normal cycle
     arg.glow_intensity = urgent_progress;
+    
+    if (icon->GetQuirk (LauncherIcon::QUIRK_URGENT) && _urgent_animation == URGENT_ANIMATION_WIGGLE)
+    {
+      arg.z_rotation = IconUrgentWiggleValue (icon, current);
+    }
 }
 
 void Launcher::FillRenderArg (LauncherIcon *icon,
@@ -1037,6 +1081,50 @@
     EnsureAnimation ();
 }
 
+void Launcher::SetBacklightAlwaysOn (bool always_on)
+{
+  if (_backlight_always_on == always_on)
+    return;
+  
+  _backlight_always_on = always_on;
+  EnsureAnimation ();
+}
+
+bool Launcher::GetBacklightAlwaysOn ()
+{
+  return _backlight_always_on;
+}
+
+void 
+Launcher::SetLaunchAnimation (LaunchAnimation animation)
+{
+  if (_launch_animation == animation)
+    return;
+    
+  _launch_animation = animation;  
+}
+
+Launcher::LaunchAnimation 
+Launcher::GetLaunchAnimation ()
+{
+  return _launch_animation;
+}
+
+void 
+Launcher::SetUrgentAnimation (UrgentAnimation animation)
+{
+  if (_urgent_animation == animation)
+    return;
+    
+  _urgent_animation = animation;  
+}
+
+Launcher::UrgentAnimation 
+Launcher::GetUrgentAnimation ()
+{
+  return _urgent_animation;
+}
+
 void
 Launcher::EnsureHoverState ()
 {
@@ -1228,7 +1316,7 @@
   nux::Matrix4 ProjectionMatrix;
   nux::Matrix4 ViewProjectionMatrix;
 
-  if(nux::Abs (arg.x_rotation) < 0.01f)
+  if(nux::Abs (arg.x_rotation) < 0.01f && nux::Abs (arg.y_rotation) < 0.01f && nux::Abs (arg.z_rotation) < 0.01f)
     icon->SetFiltering(GL_NEAREST, GL_NEAREST);
   else
     icon->SetFiltering(GL_LINEAR, GL_LINEAR);
@@ -1890,7 +1978,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)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+    if ((*rev_it)->_folding_angle < 0.0f || !(*rev_it)->GetQuirk (LauncherIcon::QUIRK_VISIBLE))
       continue;
 
     nux::Point2 screen_coord [4];
@@ -1906,7 +1994,7 @@
 
   for (it = _model->begin(); it != _model->end (); it++)
   {
-    if ((*it)->_folding_angle >= 0.0f || !(*it)->GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE))
+    if ((*it)->_folding_angle >= 0.0f || !(*it)->GetQuirk (LauncherIcon::QUIRK_VISIBLE))
       continue;
 
     nux::Point2 screen_coord [4];

=== modified file 'src/Launcher.h'
--- src/Launcher.h	2010-12-16 07:02:03 +0000
+++ src/Launcher.h	2010-12-22 01:51:30 +0000
@@ -25,6 +25,7 @@
 
 #include <Nux/View.h>
 #include <Nux/BaseWindow.h>
+
 #include "Introspectable.h"
 #include "LauncherIcon.h"
 #include "LauncherDragWindow.h"
@@ -32,12 +33,32 @@
 #include "Nux/TimerProc.h"
 #include "PluginAdapter.h"
 
+#define ANIM_DURATION_SHORT 125
+#define ANIM_DURATION       200
+#define ANIM_DURATION_LONG  350
+
 class LauncherModel;
 class QuicklistView;
+class LauncherIcon;
+class LauncherDragWindow;
 
 class Launcher : public Introspectable, public nux::View
 {
 public:
+  typedef enum
+  {
+    LAUNCH_ANIMATION_NONE,
+    LAUNCH_ANIMATION_PULSE,
+    LAUNCH_ANIMATION_BLINK,
+  } LaunchAnimation;
+
+  typedef enum
+  {
+    URGENT_ANIMATION_NONE,
+    URGENT_ANIMATION_PULSE,
+    URGENT_ANIMATION_WIGGLE,
+  } UrgentAnimation;
+
   Launcher(nux::BaseWindow *parent, CompScreen *screen, NUX_FILE_LINE_PROTO);
   ~Launcher();
 
@@ -57,9 +78,20 @@
 
   void SetAutohide (bool autohide, nux::View *show_trigger);
   bool AutohideEnabled ();
+
+  void SetBacklightAlwaysOn (bool always_on);
+  bool GetBacklightAlwaysOn ();
+  
+  void SetLaunchAnimation (LaunchAnimation animation);
+  LaunchAnimation GetLaunchAnimation ();
+  
+  void SetUrgentAnimation (UrgentAnimation animation);
+  UrgentAnimation GetUrgentAnimation ();
   
   nux::BaseWindow* GetParent () { return _parent; };
 
+  static void SetTimeStruct (struct timespec *timer, struct timespec *sister = 0, int sister_relation = 0);
+
   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);
   virtual void RecvMouseDrag(int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags);
@@ -81,12 +113,6 @@
 private:
   typedef enum
   {
-    LAUNCHER_FOLDED,
-    LAUNCHER_UNFOLDED
-  } LauncherState;
-
-  typedef enum
-  {
     ACTION_NONE,
     ACTION_DRAG_LAUNCHER,
     ACTION_DRAG_ICON,
@@ -131,7 +157,6 @@
 
   bool IconNeedsAnimation  (LauncherIcon *icon, struct timespec const &current);
   bool AnimationInProgress ();
-  void SetTimeStruct       (struct timespec *timer, struct timespec *sister = 0, int sister_relation = 0);
 
   void EnsureHoverState ();
   void EnsureHiddenState ();
@@ -149,6 +174,8 @@
   float IconUrgentProgress      (LauncherIcon *icon, struct timespec const &current);
   float IconShimmerProgress     (LauncherIcon *icon, struct timespec const &current);
   float IconUrgentPulseValue    (LauncherIcon *icon, struct timespec const &current);
+  float IconUrgentWiggleValue   (LauncherIcon *icon, struct timespec const &current);
+  float IconStartingBlinkValue  (LauncherIcon *icon, struct timespec const &current);
   float IconStartingPulseValue  (LauncherIcon *icon, struct timespec const &current);
   float IconBackgroundIntensity (LauncherIcon *icon, struct timespec const &current);
   float IconProgressBias        (LauncherIcon *icon, struct timespec const &current);
@@ -237,6 +264,7 @@
   bool  _mouse_inside_trigger;
   bool  _window_over_launcher;
   bool  _render_drag_window;
+  bool  _backlight_always_on;
 
   float _folded_angle;
   float _neg_folded_angle;
@@ -244,8 +272,9 @@
   float _launcher_top_y;
   float _launcher_bottom_y;
 
-  LauncherState _launcher_state;
   LauncherActionState _launcher_action_state;
+  LaunchAnimation _launch_animation;
+  UrgentAnimation _urgent_animation;
   
   LauncherIcon* _icon_under_mouse;
   LauncherIcon* _icon_mouse_down;

=== modified file 'src/LauncherController.cpp'
--- src/LauncherController.cpp	2010-12-15 23:50:38 +0000
+++ src/LauncherController.cpp	2010-12-22 01:51:30 +0000
@@ -193,9 +193,9 @@
   
   expoIcon->SetTooltipText ("Workspace Switcher");
   expoIcon->SetIconName ("workspace-switcher");
-  expoIcon->SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
-  expoIcon->SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, false);
-  expoIcon->SetIconType (LAUNCHER_ICON_TYPE_END);
+  expoIcon->SetQuirk (LauncherIcon::QUIRK_VISIBLE, true);
+  expoIcon->SetQuirk (LauncherIcon::QUIRK_RUNNING, false);
+  expoIcon->SetIconType (LauncherIcon::TYPE_END);
   
   expoIcon->MouseClick.connect (sigc::mem_fun (this, &LauncherController::OnExpoClicked));
   
@@ -253,7 +253,7 @@
   app = BAMF_APPLICATION (view);
   
   BamfLauncherIcon *icon = new BamfLauncherIcon (self->_launcher, app, self->_screen);
-  icon->SetIconType (LAUNCHER_ICON_TYPE_APPLICATION);
+  icon->SetIconType (LauncherIcon::TYPE_APPLICATION);
   icon->SetSortPriority (self->_sort_priority++);
 
   self->RegisterIcon (icon);
@@ -279,7 +279,7 @@
   
   bamf_view_set_sticky (BAMF_VIEW (app), true);
   icon = new BamfLauncherIcon (_launcher, app, _screen);
-  icon->SetIconType (LAUNCHER_ICON_TYPE_APPLICATION);
+  icon->SetIconType (LauncherIcon::TYPE_APPLICATION);
   icon->SetSortPriority (_sort_priority++);
   
   return icon;

=== modified file 'src/LauncherIcon.cpp'
--- src/LauncherIcon.cpp	2010-12-15 19:21:14 +0000
+++ src/LauncherIcon.cpp	2010-12-22 01:51:30 +0000
@@ -49,7 +49,7 @@
   _launcher = launcher;
   m_TooltipText = "blank";
 
-  for (int i = 0; i < LAUNCHER_ICON_QUIRK_LAST; i++)
+  for (int i = 0; i < QUIRK_LAST; i++)
   {
     _quirks[i] = 0;
     _quirk_times[i].tv_sec = 0;
@@ -63,7 +63,7 @@
   
   _mouse_inside = false;
   _tooltip = new nux::Tooltip ();
-  _icon_type = LAUNCHER_ICON_TYPE_NONE;
+  _icon_type = TYPE_NONE;
   _sort_priority = 0;
 
   _quicklist = new QuicklistView ();
@@ -114,11 +114,11 @@
   g_variant_builder_add (builder, "{sv}", "tooltip-text", g_variant_new_string (m_TooltipText.GetTCharPtr ()));
   
   g_variant_builder_add (builder, "{sv}", "sort-priority", g_variant_new_int32 (_sort_priority));
-  g_variant_builder_add (builder, "{sv}", "quirk-active", g_variant_new_boolean (GetQuirk (LAUNCHER_ICON_QUIRK_ACTIVE)));
-  g_variant_builder_add (builder, "{sv}", "quirk-visible", g_variant_new_boolean (GetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE)));
-  g_variant_builder_add (builder, "{sv}", "quirk-urgent", g_variant_new_boolean (GetQuirk (LAUNCHER_ICON_QUIRK_URGENT)));
-  g_variant_builder_add (builder, "{sv}", "quirk-running", g_variant_new_boolean (GetQuirk (LAUNCHER_ICON_QUIRK_RUNNING)));
-  g_variant_builder_add (builder, "{sv}", "quirk-presented", g_variant_new_boolean (GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED)));
+  g_variant_builder_add (builder, "{sv}", "quirk-active", g_variant_new_boolean (GetQuirk (QUIRK_ACTIVE)));
+  g_variant_builder_add (builder, "{sv}", "quirk-visible", g_variant_new_boolean (GetQuirk (QUIRK_VISIBLE)));
+  g_variant_builder_add (builder, "{sv}", "quirk-urgent", g_variant_new_boolean (GetQuirk (QUIRK_URGENT)));
+  g_variant_builder_add (builder, "{sv}", "quirk-running", g_variant_new_boolean (GetQuirk (QUIRK_RUNNING)));
+  g_variant_builder_add (builder, "{sv}", "quirk-presented", g_variant_new_boolean (GetQuirk (QUIRK_PRESENTED)));
 }
 
 nux::Color LauncherIcon::BackgroundColor ()
@@ -422,14 +422,14 @@
 LauncherIcon::SaveCenter ()
 {
   _saved_center = _center;
-  UpdateQuirkTime (LAUNCHER_ICON_QUIRK_CENTER_SAVED);
+  UpdateQuirkTime (QUIRK_CENTER_SAVED);
 }
 
 gboolean
 LauncherIcon::OnPresentTimeout (gpointer data)
 {
   LauncherIcon *self = (LauncherIcon*) data;
-  if (!self->GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
+  if (!self->GetQuirk (QUIRK_PRESENTED))
     return false;
   
   self->_present_time_handle = 0;
@@ -446,26 +446,26 @@
 void 
 LauncherIcon::Present (float present_urgency, int length)
 {
-  if (GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
+  if (GetQuirk (QUIRK_PRESENTED))
     return;
   
   if (length >= 0)
     _present_time_handle = g_timeout_add (length, &LauncherIcon::OnPresentTimeout, this);
   
   _present_urgency = CLAMP (present_urgency, 0.0f, 1.0f);
-  SetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED, true);
+  SetQuirk (QUIRK_PRESENTED, true);
 }
 
 void
 LauncherIcon::Unpresent ()
 {
-  if (!GetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED))
+  if (!GetQuirk (QUIRK_PRESENTED))
     return;
   
   if (_present_time_handle > 0)
     g_source_remove (_present_time_handle);
   
-  SetQuirk (LAUNCHER_ICON_QUIRK_PRESENTED, false);
+  SetQuirk (QUIRK_PRESENTED, false);
 }
 
 void 
@@ -481,12 +481,12 @@
 void 
 LauncherIcon::Remove ()
 {
-  SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, false);
+  SetQuirk (QUIRK_VISIBLE, false);
   remove.emit (this);
 }
 
 void 
-LauncherIcon::SetIconType (LauncherIconType type)
+LauncherIcon::SetIconType (IconType type)
 {
   _icon_type = type;
 }
@@ -503,32 +503,35 @@
   return _sort_priority;
 }
     
-LauncherIconType 
+LauncherIcon::IconType 
 LauncherIcon::Type ()
 {
   return _icon_type;
 }
 
 bool
-LauncherIcon::GetQuirk (LauncherIconQuirk quirk)
+LauncherIcon::GetQuirk (LauncherIcon::Quirk quirk)
 {
   return _quirks[quirk];
 }
 
 void
-LauncherIcon::SetQuirk (LauncherIconQuirk quirk, bool value)
+LauncherIcon::SetQuirk (LauncherIcon::Quirk quirk, bool value)
 {
   if (_quirks[quirk] == value)
     return;
     
   _quirks[quirk] = value;
-  clock_gettime (CLOCK_MONOTONIC, &(_quirk_times[quirk]));
+  if (quirk == QUIRK_VISIBLE)
+    Launcher::SetTimeStruct (&(_quirk_times[quirk]), &(_quirk_times[quirk]), ANIM_DURATION_SHORT);
+  else
+    clock_gettime (CLOCK_MONOTONIC, &(_quirk_times[quirk]));
   needs_redraw.emit (this);
   
   // Present on urgent as a general policy
-  if (quirk == LAUNCHER_ICON_QUIRK_VISIBLE && value)
+  if (quirk == QUIRK_VISIBLE && value)
     Present (0.5f, 1500);
-  if (quirk == LAUNCHER_ICON_QUIRK_URGENT && value)
+  if (quirk == QUIRK_URGENT && value)
     Present (0.5f, 1500);
 }
 
@@ -545,7 +548,7 @@
 }
 
 void
-LauncherIcon::UpdateQuirkTimeDelayed (guint ms, LauncherIconQuirk quirk)
+LauncherIcon::UpdateQuirkTimeDelayed (guint ms, LauncherIcon::Quirk quirk)
 {
   DelayedUpdateArg *arg = new DelayedUpdateArg ();
   arg->self = this;
@@ -555,21 +558,21 @@
 }
 
 void
-LauncherIcon::UpdateQuirkTime (LauncherIconQuirk quirk)
+LauncherIcon::UpdateQuirkTime (LauncherIcon::Quirk quirk)
 {
   clock_gettime (CLOCK_MONOTONIC, &(_quirk_times[quirk]));
   needs_redraw.emit (this);
 }
 
 void 
-LauncherIcon::ResetQuirkTime (LauncherIconQuirk quirk)
+LauncherIcon::ResetQuirkTime (LauncherIcon::Quirk quirk)
 {
   _quirk_times[quirk].tv_sec = 0;
   _quirk_times[quirk].tv_nsec = 0;
 }
 
 struct timespec
-LauncherIcon::GetQuirkTime (LauncherIconQuirk quirk)
+LauncherIcon::GetQuirkTime (LauncherIcon::Quirk quirk)
 {
   return _quirk_times[quirk];
 }

=== modified file 'src/LauncherIcon.h'
--- src/LauncherIcon.h	2010-12-15 19:21:14 +0000
+++ src/LauncherIcon.h	2010-12-22 01:51:30 +0000
@@ -36,40 +36,42 @@
 #include "Tooltip.h"
 #include "QuicklistView.h"
 #include "Introspectable.h"
+#include "Launcher.h"
 
 class Launcher;
 class QuicklistView;
 
-typedef enum
-{
-  LAUNCHER_ICON_TYPE_NONE,
-  LAUNCHER_ICON_TYPE_BEGIN,
-  LAUNCHER_ICON_TYPE_FAVORITE,
-  LAUNCHER_ICON_TYPE_APPLICATION,
-  LAUNCHER_ICON_TYPE_PLACE,
-  LAUNCHER_ICON_TYPE_DEVICE,
-  LAUNCHER_ICON_TYPE_TRASH,
-  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_SHIMMER,
-  LAUNCHER_ICON_QUIRK_CENTER_SAVED,
-  LAUNCHER_ICON_QUIRK_PROGRESS,
-  
-  LAUNCHER_ICON_QUIRK_LAST,
-} LauncherIconQuirk;
 
 class LauncherIcon : public Introspectable, public nux::InitiallyUnownedObject, public sigc::trackable
 {
 public:
+    typedef enum
+    {
+      TYPE_NONE,
+      TYPE_BEGIN,
+      TYPE_FAVORITE,
+      TYPE_APPLICATION,
+      TYPE_PLACE,
+      TYPE_DEVICE,
+      TYPE_TRASH,
+      TYPE_END,
+    } IconType;
+
+    typedef enum
+    {
+      QUIRK_VISIBLE,
+      QUIRK_ACTIVE,
+      QUIRK_RUNNING,
+      QUIRK_URGENT,
+      QUIRK_PRESENTED,
+      QUIRK_STARTING,
+      QUIRK_SHIMMER,
+      QUIRK_CENTER_SAVED,
+      QUIRK_PROGRESS,
+      
+      QUIRK_LAST,
+    } Quirk;
+
     LauncherIcon(Launcher* launcher);
     virtual ~LauncherIcon();
 
@@ -97,13 +99,13 @@
     
     float GetProgress ();
     
-    bool GetQuirk (LauncherIconQuirk quirk);
-    struct timespec GetQuirkTime (LauncherIconQuirk quirk);
-    
-    LauncherIconType Type ();
-    
-    nux::Color BackgroundColor ();
-    nux::Color GlowColor ();
+    bool GetQuirk (Quirk quirk);
+    struct timespec GetQuirkTime (Quirk quirk);
+    
+    IconType Type ();
+    
+    virtual nux::Color BackgroundColor ();
+    virtual nux::Color GlowColor ();
     
     nux::BaseTexture * TextureForSize (int size);
     
@@ -123,11 +125,11 @@
     const gchar * GetName ();
     void AddProperties (GVariantBuilder *builder);
 
-    void SetQuirk (LauncherIconQuirk quirk, bool value);
+    void SetQuirk (Quirk quirk, bool value);
 
-    void UpdateQuirkTimeDelayed (guint ms, LauncherIconQuirk quirk);
-    void UpdateQuirkTime (LauncherIconQuirk quirk);
-    void ResetQuirkTime (LauncherIconQuirk quirk);
+    void UpdateQuirkTimeDelayed (guint ms, Quirk quirk);
+    void UpdateQuirkTime (Quirk quirk);
+    void ResetQuirkTime (Quirk quirk);
 
     void SetRelatedWindows (int windows);
     void Remove ();
@@ -137,7 +139,7 @@
     void Present (float urgency, int length);
     void Unpresent ();
     
-    void SetIconType (LauncherIconType type);
+    void SetIconType (IconType type);
     void SetSortPriority (int priority);
 
     virtual std::list<DbusmenuMenuitem *> GetMenus ();
@@ -171,7 +173,7 @@
     typedef struct
     {
       LauncherIcon *self;
-      LauncherIconQuirk quirk;
+      Quirk quirk;
     } DelayedUpdateArg;
 
     static void ChildRealized (DbusmenuMenuitem *newitem, QuicklistView *quicklist);
@@ -195,10 +197,10 @@
     nux::Point3      _center;
     nux::Point3      _last_stable;
     nux::Point3      _saved_center;
-    LauncherIconType _icon_type;
+    IconType _icon_type;
     
-    bool             _quirks[LAUNCHER_ICON_QUIRK_LAST];
-    struct timespec  _quirk_times[LAUNCHER_ICON_QUIRK_LAST];
+    bool             _quirks[QUIRK_LAST];
+    struct timespec  _quirk_times[QUIRK_LAST];
     
 };
 

=== modified file 'src/LauncherModel.cpp'
--- src/LauncherModel.cpp	2010-12-11 05:56:12 +0000
+++ src/LauncherModel.cpp	2010-12-22 01:51:30 +0000
@@ -36,7 +36,7 @@
 
 bool LauncherModel::IconShouldShelf (LauncherIcon *icon)
 {
-  return icon->Type () == LAUNCHER_ICON_TYPE_TRASH; 
+  return icon->Type () == LauncherIcon::TYPE_TRASH; 
 }
 
 void

=== modified file 'src/QuicklistMenuItemRadio.cpp'
--- src/QuicklistMenuItemRadio.cpp	2010-12-07 16:20:08 +0000
+++ src/QuicklistMenuItemRadio.cpp	2010-12-22 01:51:30 +0000
@@ -349,4 +349,4 @@
     return _normalTexture[0]->GetWidth ();
 
   return 0;
-}
\ No newline at end of file
+}

=== modified file 'src/TrashLauncherIcon.cpp'
--- src/TrashLauncherIcon.cpp	2010-12-13 23:30:10 +0000
+++ src/TrashLauncherIcon.cpp	2010-12-22 01:51:30 +0000
@@ -25,9 +25,9 @@
 {
   SetTooltipText ("Trash");
   SetIconName ("user-trash");
-  SetQuirk (LAUNCHER_ICON_QUIRK_VISIBLE, true);
-  SetQuirk (LAUNCHER_ICON_QUIRK_RUNNING, false);
-  SetIconType (LAUNCHER_ICON_TYPE_TRASH); 
+  SetQuirk (QUIRK_VISIBLE, true);
+  SetQuirk (QUIRK_RUNNING, false);
+  SetIconType (TYPE_TRASH); 
 
   m_TrashMonitor = g_file_monitor_directory (g_file_new_for_uri("trash:///"),
 					     G_FILE_MONITOR_NONE,
@@ -47,6 +47,18 @@
   g_object_unref (m_TrashMonitor);
 }
 
+nux::Color 
+TrashLauncherIcon::BackgroundColor ()
+{
+  return nux::Color (0xFF333333);
+}
+
+nux::Color 
+TrashLauncherIcon::GlowColor ()
+{
+  return nux::Color (0xFF333333);
+}
+
 void
 TrashLauncherIcon::OnMouseClick (int button)
 {

=== modified file 'src/TrashLauncherIcon.h'
--- src/TrashLauncherIcon.h	2010-12-07 18:14:21 +0000
+++ src/TrashLauncherIcon.h	2010-12-22 01:51:30 +0000
@@ -27,6 +27,9 @@
 public:
   TrashLauncherIcon  (Launcher *launcher);
   ~TrashLauncherIcon ();
+  
+  virtual nux::Color BackgroundColor ();
+  virtual nux::Color GlowColor ();
 
 protected:
   void OnMouseClick (int button);

=== modified file 'src/unityshell.cpp'
--- src/unityshell.cpp	2010-12-17 14:11:55 +0000
+++ src/unityshell.cpp	2010-12-22 01:51:30 +0000
@@ -357,8 +357,14 @@
       launcher->SetAutohide (optionGetLauncherAutohide (),
                              (nux::View *) panelView->HomeButton ());
       break;
-    case UnityshellOptions::LauncherFloat:
-      launcher->SetFloating (optionGetLauncherFloat ());
+    case UnityshellOptions::BacklightAlwaysOn:
+      launcher->SetBacklightAlwaysOn (optionGetBacklightAlwaysOn ());
+      break;
+    case UnityshellOptions::LaunchAnimation:
+      launcher->SetLaunchAnimation ((Launcher::LaunchAnimation) optionGetLaunchAnimation ());
+      break;
+    case UnityshellOptions::UrgentAnimation:
+      launcher->SetUrgentAnimation ((Launcher::UrgentAnimation) optionGetUrgentAnimation ());
       break;
     default:
       break;
@@ -412,8 +418,10 @@
 
   debugger = new IntrospectionDBusInterface (this);
 
-  optionSetLauncherAutohideNotify (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
-  optionSetLauncherFloatNotify (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+  optionSetLauncherAutohideNotify  (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+  optionSetBacklightAlwaysOnNotify (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+  optionSetLaunchAnimationNotify   (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
+  optionSetUrgentAnimationNotify   (boost::bind (&UnityScreen::optionChanged, this, _1, _2));
 
   g_timeout_add (0, &UnityScreen::initPluginActions, this);
   g_timeout_add (5000, (GSourceFunc) write_logger_data_to_disk, NULL);
@@ -471,6 +479,7 @@
   self->launcherWindow->InputWindowEnableStruts(true);
 
   self->launcher->SetIconSize (54, 48);
+  self->launcher->SetBacklightAlwaysOn (true);
   LOGGER_END_PROCESS ("initLauncher-Launcher");
 
   /* Setup panel */
@@ -500,6 +509,9 @@
   /* Setup Places */
   self->placesController = new PlacesController ();
 
+  self->launcher->SetAutohide (true, (nux::View *) self->panelView->HomeButton ());
+  self->launcher->SetLaunchAnimation (Launcher::LAUNCH_ANIMATION_PULSE);
+  self->launcher->SetUrgentAnimation (Launcher::URGENT_ANIMATION_WIGGLE);
   g_timeout_add (2000, &UnityScreen::strutHackTimeout, self);
 
   END_FUNCTION ();

=== modified file 'unityshell.xml.in'
--- unityshell.xml.in	2010-12-13 20:43:37 +0000
+++ unityshell.xml.in	2010-12-22 01:51:30 +0000
@@ -1,52 +1,96 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <compiz>
     <plugin name="unityshell" useBcop="true">
-	<_short>Ubuntu Unity Plugin</_short>
-	<_long>Plugin to draw the Unity Shell</_long>
-	<category>Desktop</category>
-	<deps>
-	    <relation type="after">
-		<plugin>bailer</plugin>
-		<plugin>detection</plugin>
-		<plugin>composite</plugin>
-		<plugin>opengl</plugin>
-		<plugin>mousepoll</plugin>
-		<plugin>move</plugin>
-		<plugin>resize</plugin>
-		<plugin>decor</plugin>
-		<plugin>compiztoolbox</plugin>
-		<plugin>place</plugin>
-		<plugin>session</plugin>
-		<plugin>animation</plugin>
-		<plugin>regex</plugin>
-		<plugin>cube</plugin>
-		<plugin>rotate</plugin>
-		<plugin>cubeaddon</plugin>
-		<plugin>gnomecompat</plugin>
-		<plugin>vpswitch</plugin>
-		<plugin>fade</plugin>
-		<plugin>staticswitcher</plugin>
-		<plugin>scale</plugin>
-		<plugin>expo</plugin>
-		<plugin>ezoom</plugin>
-		<plugin>wall</plugin>
-	    </relation>
-	    <requirement>
-		<plugin>opengl</plugin>
-		<plugin>wall</plugin>
-	    </requirement>
-	</deps>
-	<options>
-	    <option name="launcher_autohide" type="bool">
-	    <_short>Autohide Launcher</_short>
-	    <_long>Make the launcher hide automatically after some time inactive</_long>
-	    <default>false</default>
-	    </option>
-	    <option name="launcher_float" type="bool">
-	    <_short>Float Launcher</_short>
-	    <_long>Make the launcher appear above other windows</_long>
-	    <default>false</default>
-	    </option>
-	</options>
+        <_short>Ubuntu Unity Plugin</_short>
+        <_long>Plugin to draw the Unity Shell</_long>
+        <category>Desktop</category>
+        <deps>
+            <relation type="after">
+                <plugin>bailer</plugin>
+                <plugin>detection</plugin>
+                <plugin>composite</plugin>
+                <plugin>opengl</plugin>
+                <plugin>mousepoll</plugin>
+                <plugin>move</plugin>
+                <plugin>resize</plugin>
+                <plugin>decor</plugin>
+                <plugin>compiztoolbox</plugin>
+                <plugin>place</plugin>
+                <plugin>session</plugin>
+                <plugin>animation</plugin>
+                <plugin>regex</plugin>
+                <plugin>cube</plugin>
+                <plugin>rotate</plugin>
+                <plugin>cubeaddon</plugin>
+                <plugin>gnomecompat</plugin>
+                <plugin>vpswitch</plugin>
+                <plugin>fade</plugin>
+                <plugin>staticswitcher</plugin>
+                <plugin>scale</plugin>
+                <plugin>expo</plugin>
+                <plugin>ezoom</plugin>
+                <plugin>wall</plugin>
+            </relation>
+            <requirement>
+                <plugin>opengl</plugin>
+                <plugin>wall</plugin>
+            </requirement>
+        </deps>
+        <options>
+	          <group>
+                <_short>Behaviour</_short>
+	              <option name="launcher_autohide" type="bool">
+                    <_short>Autohide Launcher</_short>
+                    <_long>Make the launcher hide automatically after some time inactive</_long>
+                    <default>true</default>
+	              </option>
+	          </group>
+	          <group>
+                <_short>Experimental</_short>
+                <option name="backlight_always_on" type="bool">
+                    <_short>Backlight Always On</_short>
+                    <_long>Make the launcher icons always have a backlight</_long>
+                    <default>true</default>
+                </option>
+                <option name="launch_animation" type="int">
+                    <_short>Launch Animation</_short>
+                    <_long>Animation played when a launcher icon is in the process of spawning a process</_long>
+                    <min>0</min>
+                    <max>2</max>
+                    <default>1</default>
+                    <desc>
+                        <value>0</value>
+                        <_name>None</_name>
+                    </desc>
+                    <desc>
+                        <value>1</value>
+                        <_name>Pulse Until Running</_name>
+                    </desc>
+                    <desc>
+                        <value>2</value>
+                        <_name>Blink</_name>
+                    </desc>
+                </option>
+                <option name="urgent_animation" type="int">
+                    <_short>Uregnt Animation</_short>
+                    <_long>Animation played when a launcher icon is in the urgent state</_long>
+                    <min>0</min>
+                    <max>2</max>
+                    <default>2</default>
+                    <desc>
+                        <value>0</value>
+                        <_name>None</_name>
+                    </desc>
+                    <desc>
+                        <value>1</value>
+                        <_name>Pulse</_name>
+                    </desc>
+                    <desc>
+                        <value>2</value>
+                        <_name>Wiggle</_name>
+                    </desc>
+                </option>
+            </group>
+        </options>
     </plugin>
 </compiz>