Merge lp:~3v1n0/unity/globalmenu-discovery-new-apps into lp:unity

[Marco Trevisan (Treviño)]

Implemented the design bug #874254 to make a newly opened application to quickly show its menus when firstly mapped using a slightly longer fade effect (now set to 200ms to fade in and 300ms to fade out).
To work properly, this feature, requires the merge of the BAMF branch lp:~3v1n0/bamf/always-notify-view otherwise sticky applications won't be show their menus when opened.

I've also added some fixes and features to the Animator class, and improved the drawing of the fading panel entries.

Plus, I've integrated the bug #875472, introducing 5 new configuration parameters to customize the fading timings and the menu discover-ability time.

Tests for this will be done when the autopilot system will be ready.

[Mikkel Kamstrup Erlandsen (kamstrup)]

If you have rights to merge lp:~3v1n0/bamf/always-notify-view yourself I think you can go ahead as that module is not being handled by unity-merger afaik, If you don't have the rights I think we need to make sure you have :-)

[Didier Roche-Tolomelli (didrocks)]

Bamf is handled by unity-merger, but it's not activated right now as make check doesn't pass on headless server. Please do not merge anything manually in bamf, make check should be fixed first.

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

Mikkel: I've not these rights :(

However, I knew about the BAMF status in the unity-merger...

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

Ok, I've fixed some issues on the configuration side, now it should work as expected.

[Charles Kerr (charlesk)]

I'm hesitant to suggest this because it's nitpicky, but std::set might be more appropriate than std::list for _new_apps...

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

Will that save so much computation in our case? Mh... Maybe not so much, but I can do that.

[Tim Penhey (thumper)]

What is the _new_apps for exactly? std::list is fine if you are going to be constantly adding and removing items, but if speed is needed more often than addition or removal then std::vector is better due to cache-coherency. If there are a lot of items, perhaps std::set is better.

[Tim Penhey (thumper)]

> Bamf is handled by unity-merger, but it's not activated right now as make
> check doesn't pass on headless server. Please do not merge anything manually
> in bamf, make check should be fixed first.

Didier, this isn't your decision to make. Yes I agree that make check needs to be fixed, but that will not block other changes.

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

> What is the _new_apps for exactly? std::list is fine if you are going to be
> constantly adding and removing items, but if speed is needed more often than
> addition or removal then std::vector is better due to cache-coherency. If
> there are a lot of items, perhaps std::set is better.

This is a list of new launched applications. Generally that is just containing one item, but if you quickly launch many applications together (i.e. you're doing something like "nautilus & baobab & gedit & shotwell &" in your terminal) we need to check that once one of the new applications has been focused, its menus are shown.
Using just a pointer for that is not good, otherwise we would control only the last opened application.

[Tim Penhey (thumper)]

> plugins/unityshell/src/LauncherController.cpp

Can we move the "unity-seen" inline constant to a named
file level one?

Hmm... just looked in the Animator.h file. Since you are messing
with this anyway, I'm going to dump some fun changes on you :-)
Only because I know you can handle it.

Animator.h doesn't need <Nux/Nux.h>, please remove it.

While we could change the properties to use nux properties,
lets not do that right now, but instead you can make GetRate,
GetDuration, GetProgress and IsRunning all const methods.

Can you change the member variables to use the trailing underscore.

Why is there a class FadableObject2? 2? Really? Any idea?

The logic inside TimerTimeOut should be moved into a method of the
animator class so it can be unit tested without needing the timer
itself (or timeout events).

Also, can you add a google-test style unit test for the animator
class?

It needs to test the setters, getters, constructors, timeout, start,
stop, event generation, in fact the entire public interface to the
animator :-) I can help with direction here if you need it.

Thanks.

review: Needs Fixing

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

> > plugins/unityshell/src/LauncherController.cpp
>
> Can we move the "unity-seen" inline constant to a named
> file level one?

Ehm, what do you mean?
I didn't write that code, however that data parameter is used to check if that bamf application has not already been added to the launcher, and according to Jason that should survive to crashes.

> Hmm... just looked in the Animator.h file. Since you are messing
> with this anyway, I'm going to dump some fun changes on you :-)
> Only because I know you can handle it.
>
> Animator.h doesn't need <Nux/Nux.h>, please remove it.

Ok, I added it to avoid to manually include all the needed libraries and classes, that already Nux uses; so we're sure that we support them also at the linking level.
However, done!

> While we could change the properties to use nux properties,
> lets not do that right now, but instead you can make GetRate,
> GetDuration, GetProgress and IsRunning all const methods.

Fine, done.

> Can you change the member variables to use the trailing underscore.

Ok (also if the unity code actually is missing both the styles, and IMHO the prefixed underscore is better, also for quickly finding private members).

> Why is there a class FadableObject2? 2? Really? Any idea?

Oh, sorry. That was an abstract class that I initially wrote for testing purposes, but it seems that apparently I didn't remove it before committing. Sorry, I'm moving that out.

> The logic inside TimerTimeOut should be moved into a method of the
> animator class so it can be unit tested without needing the timer
> itself (or timeout events).

Ok, I've added a DoStep() method, that we could use for testing I guess.

> Also, can you add a google-test style unit test for the animator
> class?
>
> It needs to test the setters, getters, constructors, timeout, start,
> stop, event generation, in fact the entire public interface to the
> animator :-) I can help with direction here if you need it.

Ok, I do something something for this. I'll contact you directly if I've something to ask.

Then, about the glib::Object work we talked, this http://paste.ubuntu.com/755020/ seems to work, and I'm also writing some test code for that.
The fact is that actually when creating a new glib::Object we can't optionally ref it, but this is something that can be needed. Especially when we're wrapping an object passed by a signal (as in this case).
Not reffing a new object is good only if we're firstly allocating it.

> Thanks.

Thank you for your review.

[Tim Penhey (thumper)]

Firstly, thanks for the changes in the variable names.

Can I also get you to move the method names and return types on to the same
line? That'd be great.

Can you move the member variables initialisation into an initialiser list?

Animator::Animator(unsigned int default_duration, unsigned int fps_rate)
 : start_time(0)
 , timeout_id(0)
 , // and the rest.

My idea behind having a DoStep to test it, was to allow us to specify a fake
time to illustrate that the animation does in fact stop :)

We could do this by having:

bool Animator::DoStep(gint64 current_time);

And then:

gboolean Animator::TimerTimeOut(Animator* self)
{
  return self->DoStep(g_get_monotonic_time()) ? TRUE : FALSE;
}

This way we can call DoStep in the tests.
To have complete control over the start_time_ member, we'd probably want to
have an optional guint64 parameter for both Start methods that defaults to 0.
Inside the start method we get the clock time if the time is 0. That way from
the tests we have complete control over the state of the object. This does
bring up a problem with having default parameters making two different
functions seem like a choice. Need to think about that.

We seem to have a rate, but it doesn't look like it is used anywhere.

Don't bother about the "unity-seen" string just now.

Instead of having the g_signal_connect ids, there is the signal manager that
Neil wrote. It handles the disconnections for you.

Hmm...

auto tmp_animator = Animator(200, 25);

This is wrong for two reasons:
 * The animator class isn't a value type, so shouldn't be copyable or
 assignable
 * Using auto in this way.

Animator tmp_animator(200, 25); // is the correct way.

You should hide the copy constructor and assignment operator.
You can do this in two ways:
* declare them private yourself
* inherit privately from boost::noncopyable (from boost/utility.hpp)

Inside the tests, you can then have better control over the simulation for
steps.

{
  guint64 start_time = g_get_monotonic_time();
  test_animator_.Start(0, start_time);
  test_animator_.DoStep(start_time + 100);
  // test progress
}

Do we ever start an animation with a non-zero progress?

review: Needs Fixing

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

> Firstly, thanks for the changes in the variable names.
>
> Can I also get you to move the method names and return types on to the same
> line? That'd be great.

Done.

> Can you move the member variables initialisation into an initialiser list?

Ok

> We seem to have a rate, but it doesn't look like it is used anywhere.

As I've already explained on IRC, the rate is used to compute the timeout used by the timer.

> Don't bother about the "unity-seen" string just now.

Fine

> Instead of having the g_signal_connect ids, there is the signal manager that
> Neil wrote. It handles the disconnections for you.

Moving to that...

> Hmm...
>
> Animator tmp_animator(200, 25); // is the correct way.

Moved to that.

> You should hide the copy constructor and assignment operator.
> * inherit privately from boost::noncopyable (from boost/utility.hpp)

Done.

> My idea behind having a DoStep to test it, was to allow us to specify a fake
> time to illustrate that the animation does in fact stop :)
>
> We could do this by having:
>
> bool Animator::DoStep(gint64 current_time);
>
> And then:
>
> gboolean Animator::TimerTimeOut(Animator* self)
> {
> return self->DoStep(g_get_monotonic_time()) ? TRUE : FALSE;
> }
>
> This way we can call DoStep in the tests.
> To have complete control over the start_time_ member, we'd probably want to
> have an optional guint64 parameter for both Start methods that defaults to 0.
> Inside the start method we get the clock time if the time is 0. That way from
> the tests we have complete control over the state of the object. This does
> bring up a problem with having default parameters making two different
> functions seem like a choice. Need to think about that.
> Inside the tests, you can then have better control over the simulation for
> steps.
>
> {
> guint64 start_time = g_get_monotonic_time();
> test_animator_.Start(0, start_time);
> test_animator_.DoStep(start_time + 100);
> // test progress
> }

I'm not sure I'd like this for two reasons:
 1) Putting an unneeded value like the start time on a public interface,
    only for testing is something good on test side, but bad on the API side.
    Also because no one would need it. At least that we use that start time
    to support a "delayed start time" (basically, if it's greater than "now",
    we add a timeout to delay the start of the animation).
    So in this case would be useful in some rare cases.
 2) Also if we would allow what I've stated above, the Start function would
    also fire a timeout that could interfere with our DoStep() test, and disabing
    the timeout in some cases is something I wouldn't do.

A workaround that allows to test is to use somewhat:
  /* Using a low frame rate and a long duration we're sure that the first
   * step is not called after we call Start and before the Stop get called
   * since that should happen after one second.
   * Also when we call the DoStep() the private start time is near to the actual
   * time, so this would make DoStep() more testable as it is now. */
  test_animator_.SetDuration(2000);
  test_animator_.SetRate(1);
  test_animator_.Start();
  test_animator_.Stop();
  test_animator_.DoStep...

[Tim Penhey (thumper)]

review: Approve

[Unity Merger (unity-merger)]

Attempt to merge into lp:unity failed due to conflicts:

text conflict in plugins/unityshell/src/PanelMenuView.cpp
text conflict in tests/CMakeLists.txt

=== modified file 'manual-tests/Panel.txt'
--- manual-tests/Panel.txt	2011-12-08 04:14:22 +0000
+++ manual-tests/Panel.txt	2011-12-14 17:24:33 +0000
@@ -16,3 +16,18 @@
   should become opaque, also if the opacity setting is set to 0.0. 
   Once all the maximized windows are closed, restored or not visible,
   the panel should go back to its defined opacity.
+
+
+Panel Menus Revelation
+----------------------
+This test shows how the menus should be revealed when a new application has been
+launched.
+
+#. Start with a clear screen
+#. Open a new application that has menus (i.e. gnome-terminal)
+
+Outcome
+  The panel should show the menus in global menu bar for two seconds.
+  If a new gnome-terminal window is opened, the menus are not shown again.
+  If more than one application is open at once, the menus of each application
+  are shown once is focused.

=== modified file 'plugins/unityshell/src/Animator.cpp'
--- plugins/unityshell/src/Animator.cpp	2011-09-27 06:52:31 +0000
+++ plugins/unityshell/src/Animator.cpp	2011-12-14 17:24:33 +0000
@@ -22,112 +22,121 @@
 namespace unity
 {
 
-Animator::Animator(unsigned int duration, unsigned int fps_rate)
+Animator::Animator(unsigned int default_duration, unsigned int fps_rate)
+  : start_time_(0)
+  , rate_(1)
+  , duration_(0)
+  , one_time_duration_(0)
+  , timeout_id_(0)
+  , start_progress_(0.0f)
+  , progress_(0.0f)
 {
-  _start_time = 0;
-  _timeout_id = 0;
-  _progress = 0.0f;
-  _start_progress = 0.0f;
-  _rate = 1;
-  _duration = 0;
-
-  SetDuration(duration);
+  SetDuration(default_duration);
   SetRate(fps_rate);
 }
 
 Animator::~Animator()
 {
-  if (_timeout_id != 0)
-    g_source_remove (_timeout_id);
+  Stop();
 }
 
-void
-Animator::SetRate(unsigned int fps_rate)
+void Animator::SetRate(unsigned int fps_rate)
 {
   if (fps_rate != 0)
-    _rate = 1000 / fps_rate;
-}
-
-void
-Animator::SetDuration(unsigned int duration)
-{
-  if (duration != 0)
-    _duration = duration * 1000;
-}
-
-unsigned int
-Animator::GetRate()
-{
-  return _rate;
-}
-
-unsigned int
-Animator::GetDuration()
-{
-  return _duration;
-}
-
-bool
-Animator::IsRunning()
-{
-  return (_timeout_id != 0);
-}
-
-double
-Animator::GetProgress()
-{
-  return _progress;
-}
-
-void
-Animator::Start(double start_progress)
-{
-  if (_timeout_id == 0 && start_progress < 1.0f)
+    rate_ = 1000 / fps_rate;
+}
+
+void Animator::SetDuration(unsigned int duration)
+{
+  duration_ = duration * 1000;
+}
+
+unsigned int Animator::GetRate() const
+{
+  if (rate_ != 0)
+    return 1000 / rate_;
+
+  return rate_;
+}
+
+unsigned int Animator::GetDuration() const
+{
+  return (one_time_duration_ > 0 ? one_time_duration_ : duration_) / 1000;
+}
+
+bool Animator::IsRunning() const
+{
+  return (timeout_id_ != 0);
+}
+
+double Animator::GetProgress() const
+{
+  return progress_;
+}
+
+void Animator::Start(unsigned int one_time_duration, double start_progress)
+{
+  if (timeout_id_ == 0 && start_progress < 1.0f)
   {
     if (start_progress < 0.0f)
       start_progress = 0.0f;
 
-    _start_progress = start_progress;
-    _progress = _start_progress;
-    _start_time = g_get_monotonic_time();
-    _timeout_id = g_timeout_add(_rate, (GSourceFunc) &Animator::TimerTimeOut, this);
+    one_time_duration_ = one_time_duration * 1000;
+    start_progress_ = start_progress;
+    progress_ = start_progress_;
+    start_time_ = g_get_monotonic_time();
+    timeout_id_ = g_timeout_add(rate_, (GSourceFunc) &Animator::TimerTimeOut, this);
+    animation_started.emit();
   }
 }
 
-void
-Animator::Stop()
-{
-  if (_timeout_id != 0)
+void Animator::Start(double start_progress)
+{
+  Start(0, start_progress);
+}
+
+void Animator::Stop()
+{
+  if (timeout_id_ != 0)
   {
-    g_source_remove(_timeout_id);
-    animation_updated.emit(_progress);
+    g_source_remove(timeout_id_);
+    animation_updated.emit(progress_);
     animation_ended.emit();
-    animation_stopped.emit(_progress);
-    _timeout_id = 0;
+    animation_stopped.emit(progress_);
+    one_time_duration_ = 0;
+    timeout_id_ = 0;
   }
 }
 
-gboolean
-Animator::TimerTimeOut(Animator *self)
+bool Animator::DoStep()
 {
   const gint64 current_time = g_get_monotonic_time();
-  const gint64 end_time = self->_start_time + self->_duration;
-
-  if (current_time < end_time && self->_progress < 1.0f)
-  {
-    const double diff_time = current_time - self->_start_time;
-    self->_progress = CLAMP(self->_start_progress + (diff_time / self->_duration), 0.0f, 1.0f);
-    self->animation_updated.emit(self->_progress);
-
-    return TRUE;
-  } else {
-    self->_progress = 1.0f;
-    self->animation_updated.emit(1.0f);
-    self->animation_ended.emit();
-    self->_timeout_id = 0;
-
-    return FALSE;
-  }
+  const gint64 duration = one_time_duration_ > 0 ? one_time_duration_ : duration_;
+  const gint64 end_time = start_time_ + duration;
+
+  if (current_time < end_time && progress_ < 1.0f && duration > 0)
+  {
+    const double diff_time = current_time - start_time_;
+    progress_ = CLAMP(start_progress_ + (diff_time / duration), 0.0f, 1.0f);
+    animation_updated.emit(progress_);
+
+    return true;
+  }
+  else
+  {
+    progress_ = 1.0f;
+    animation_updated.emit(1.0f);
+    animation_ended.emit();
+    one_time_duration_ = 0;
+    timeout_id_ = 0;
+
+    return false;
+  }
+}
+
+gboolean Animator::TimerTimeOut(Animator *self)
+{
+  return self->DoStep() ? TRUE : FALSE;
 }
 
 } //namespace

=== modified file 'plugins/unityshell/src/Animator.h'
--- plugins/unityshell/src/Animator.h	2011-09-23 00:31:08 +0000
+++ plugins/unityshell/src/Animator.h	2011-12-14 17:24:33 +0000
@@ -20,33 +20,30 @@
 #ifndef UNITY_ANIMATOR_H_
 #define UNITY_ANIMATOR_H_
 
-#include <Nux/Nux.h>
+#include <glib.h>
+#include <cstdint>
+#include <sigc++/sigc++.h>
+#include <boost/utility.hpp>
 
 namespace unity
 {
-  
-class FadableObject2
-{
-public:
-  virtual void SetOpacity(double value) = 0;
-  virtual double GetOpacity() = 0;
-};
-
-class Animator
-{
-public:
-  Animator(unsigned int duration, unsigned int fps_rate = 30);
+class Animator : boost::noncopyable
+{
+public:
+  Animator(unsigned int default_duration, unsigned int fps_rate = 30);
   ~Animator();
 
   void SetRate(unsigned int fps_rate);
   void SetDuration(unsigned int duration);
 
-  unsigned int GetRate();
-  unsigned int GetDuration();
-  double GetProgress();
-  bool IsRunning();
+  unsigned int GetRate() const;
+  unsigned int GetDuration() const;
+  double GetProgress() const;
+  bool IsRunning() const;
 
   void Start(double start_progress = 0.0f);
+  void Start(unsigned int one_time_duration, double start_progress = 0.0f);
+  bool DoStep();
   void Stop();
 
   sigc::signal<void> animation_started;
@@ -56,12 +53,13 @@
   sigc::signal<void, double> animation_stopped;
 
 private:
-  int64_t _start_time;
-  unsigned int _rate;
-  unsigned int _duration;
-  unsigned int _timeout_id;
-  double _start_progress;
-  double _progress;
+  int64_t start_time_;
+  unsigned int rate_;
+  unsigned int duration_;
+  unsigned int one_time_duration_;
+  unsigned int timeout_id_;
+  double start_progress_;
+  double progress_;
 
   static gboolean TimerTimeOut(Animator *self);
 };

=== modified file 'plugins/unityshell/src/LauncherController.cpp'
--- plugins/unityshell/src/LauncherController.cpp	2011-11-30 03:06:44 +0000
+++ plugins/unityshell/src/LauncherController.cpp	2011-12-14 17:24:33 +0000
@@ -403,8 +403,11 @@
 
   app = BAMF_APPLICATION(view);
 
-  if (g_object_get_qdata(G_OBJECT(app), g_quark_from_static_string("unity-seen")))
+  if (bamf_view_is_sticky(view) ||
+      g_object_get_qdata(G_OBJECT(app), g_quark_from_static_string("unity-seen")))
+  {
     return;
+  }
 
   BamfLauncherIcon* icon = new BamfLauncherIcon(self->launcher_.GetPointer(), app);
   icon->SetIconType(LauncherIcon::TYPE_APPLICATION);

=== modified file 'plugins/unityshell/src/PanelController.cpp'
--- plugins/unityshell/src/PanelController.cpp	2011-11-16 00:09:59 +0000
+++ plugins/unityshell/src/PanelController.cpp	2011-12-14 17:24:33 +0000
@@ -55,6 +55,9 @@
 
   float opacity() const;
 
+  void SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                          int discovery_fadein, int discovery_fadeout);
+
 private:
   unity::PanelView* ViewForWindow(nux::BaseWindow* window);
   void OnScreenChanged(int primary_monitor, std::vector<nux::Geometry>& monitors);
@@ -68,6 +71,11 @@
   float opacity_;
   bool opacity_maximized_toggle_;
   bool open_menu_start_received_;
+  int menus_fadein_;
+  int menus_fadeout_;
+  int menus_discovery_;
+  int menus_discovery_fadein_;
+  int menus_discovery_fadeout_;
 };
 
 
@@ -147,12 +155,28 @@
 {
   opacity_maximized_toggle_ = enabled;
 
-  for (auto window : windows_)
+  for (auto window: windows_)
   {
     ViewForWindow(window)->SetOpacityMaximizedToggle(opacity_maximized_toggle_);
   }
 }
 
+void Controller::Impl::SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                                          int discovery_fadein, int discovery_fadeout)
+{
+  menus_fadein_ = fadein;
+  menus_fadeout_ = fadeout;
+  menus_discovery_ = discovery;
+  menus_discovery_fadein_ = discovery_fadein;
+  menus_discovery_fadeout_ = discovery_fadeout;
+
+  for (auto window: windows_)
+  {
+    ViewForWindow(window)->SetMenuShowTimings(fadein, fadeout, discovery,
+                                              discovery_fadein, discovery_fadeout);
+  }
+}
+
 void Controller::Impl::QueueRedraw()
 {
   for (auto window: windows_)
@@ -216,6 +240,8 @@
       view->SetMaximumHeight(24);
       view->SetOpacity(opacity_);
       view->SetOpacityMaximizedToggle(opacity_maximized_toggle_);
+      view->SetMenuShowTimings(menus_fadein_, menus_fadeout_, menus_discovery_,
+                               menus_discovery_fadein_, menus_discovery_fadeout_);
       view->SetPrimary(i == primary_monitor);
       view->SetMonitor(i);
 
@@ -301,6 +327,12 @@
   pimpl->SetOpacityMaximizedToggle(enabled);
 }
 
+void Controller::SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                                    int discovery_fadein, int discovery_fadeout)
+{
+  pimpl->SetMenuShowTimings(fadein, fadeout, discovery, discovery_fadein, discovery_fadeout);
+}
+
 void Controller::QueueRedraw()
 {
   pimpl->QueueRedraw();

=== modified file 'plugins/unityshell/src/PanelController.h'
--- plugins/unityshell/src/PanelController.h	2011-11-16 00:09:59 +0000
+++ plugins/unityshell/src/PanelController.h	2011-12-14 17:24:33 +0000
@@ -48,6 +48,8 @@
   // NOTE: nux::Property maybe?
   void SetOpacity(float opacity);
   void SetOpacityMaximizedToggle(bool enabled);
+  void SetMenuShowTimings(int fadein, int fadeout, int discovery, int discovery_fadein, int discovery_fadeout);
+
   float opacity() const;
 
 private:

=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2011-12-14 17:24:33 +0000
@@ -49,44 +49,40 @@
 
 #define WINDOW_TITLE_FONT_KEY "/apps/metacity/general/titlebar_font"
 
-#define PANEL_ENTRIES_FADEIN 100
-#define PANEL_ENTRIES_FADEOUT 120
-
 namespace unity
 {
 
-static void on_active_window_changed(BamfMatcher*   matcher,
-                                     BamfView*      old_view,
-                                     BamfView*      new_view,
-                                     PanelMenuView* self);
-
-static void on_name_changed(BamfView*      bamf_view,
-                            gchar*         old_name,
-                            gchar*         new_name,
-                            PanelMenuView* self);
-
 PanelMenuView::PanelMenuView(int padding)
-  : _matcher(NULL),
-    _title_layer(NULL),
+  : _matcher(bamf_matcher_get_default()),
+    _title_layer(nullptr),
     _util_cg(CAIRO_FORMAT_ARGB32, 1, 1),
-    _gradient_texture(NULL),
+    _gradient_texture(nullptr),
     _is_inside(false),
     _is_maximized(false),
     _is_own_window(false),
-    _last_active_view(NULL),
+    _last_active_view(nullptr),
+    _new_application(nullptr),
     _last_width(0),
     _last_height(0),
     _places_showing(false),
     _show_now_activated(false),
     _we_control_active(false),
+    _new_app_menu_shown(false),
     _monitor(0),
     _active_xid(0),
     _active_moved_id(0),
     _update_show_now_id(0),
+    _new_app_show_id(0),
+    _new_app_hide_id(0),
     _place_shown_interest(0),
     _place_hidden_interest(0),
-    _fade_in_animator(NULL),
-    _fade_out_animator(NULL)
+    _menus_fadein(100),
+    _menus_fadeout(120),
+    _menus_discovery(2),
+    _menus_discovery_fadein(200),
+    _menus_discovery_fadeout(300),
+    _fade_in_animator(nullptr),
+    _fade_out_animator(nullptr)
 {
   WindowManager* win_manager;
 
@@ -100,13 +96,16 @@
    */
   layout_ = _menu_layout;
 
-  _matcher = bamf_matcher_get_default();
-  _activate_window_changed_id = g_signal_connect(_matcher, "active-window-changed",
-                                                 G_CALLBACK(on_active_window_changed), this);
+  _view_opened_signal.Connect(_matcher, "view-opened",
+                              sigc::mem_fun(this, &PanelMenuView::OnViewOpened));
+  _view_closed_signal.Connect(_matcher, "view-closed",
+                              sigc::mem_fun(this, &PanelMenuView::OnViewClosed));
+  _active_win_changed_signal.Connect(_matcher, "active-window-changed",
+                                     sigc::mem_fun(this, &PanelMenuView::OnActiveWindowChanged));
+  _active_app_changed_signal.Connect(_matcher, "active-application-changed",
+                                     sigc::mem_fun(this, &PanelMenuView::OnActiveAppChanged));
 
   _padding = padding;
-  _name_changed_callback_instance = NULL;
-  _name_changed_callback_id = 0;
 
   _window_buttons = new WindowButtons();
   _window_buttons->SetParentObject(this);
@@ -163,8 +162,8 @@
                                                          (UBusCallback)PanelMenuView::OnPlaceViewHidden,
                                                          this);
 
-  _fade_in_animator = new Animator(PANEL_ENTRIES_FADEIN);
-  _fade_out_animator = new Animator(PANEL_ENTRIES_FADEOUT);
+  _fade_in_animator = new Animator(_menus_fadein);
+  _fade_out_animator = new Animator(_menus_fadeout);
 
   _fade_in_animator->animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeInChanged));
   _fade_in_animator->animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
@@ -180,15 +179,15 @@
 
 PanelMenuView::~PanelMenuView()
 {
-  if (_name_changed_callback_id)
-    g_signal_handler_disconnect(_name_changed_callback_instance,
-                                _name_changed_callback_id);
-  if (_activate_window_changed_id)
-    g_signal_handler_disconnect(_matcher,
-                                _activate_window_changed_id);
   if (_active_moved_id)
     g_source_remove(_active_moved_id);
 
+  if (_new_app_show_id)
+    g_source_remove(_new_app_show_id);
+
+  if (_new_app_hide_id)
+    g_source_remove(_new_app_hide_id);
+
   if (_title_layer)
     delete _title_layer;
 
@@ -208,6 +207,35 @@
 
   if (_place_hidden_interest != 0)
     ubus_server_unregister_interest(ubus, _place_hidden_interest);
+
+  for (auto app : _new_apps)
+    g_object_unref(app);
+}
+
+void
+PanelMenuView::SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                                  int discovery_fadein, int discovery_fadeout)
+{
+  if (fadein > -1)
+  {
+    _menus_fadein = fadein;
+    _fade_in_animator->SetDuration(_menus_fadein);
+  }
+
+  if (fadeout > -1)
+  {
+    _menus_fadeout = fadeout;
+    _fade_out_animator->SetDuration(_menus_fadeout);
+  }
+
+  if (discovery > -1)
+    _menus_discovery = discovery;
+
+  if (discovery_fadein > -1)
+    _menus_discovery_fadein = discovery_fadein;
+
+  if (discovery_fadeout > -1)
+    _menus_discovery_fadeout = discovery_fadeout;
 }
 
 void
@@ -224,9 +252,9 @@
   bool mouse_inside = TestMousePointerInclusionFilterMouseWheel(mouse_position, event_type);
 
   if (mouse_inside == false)
-    return NULL;
+    return nullptr;
 
-  Area* found_area = NULL;
+  Area* found_area = nullptr;
   if (!_we_control_active)
   {
     found_area = _panel_titlebar_grab_area->FindAreaUnderMouse(mouse_position, event_type);
@@ -327,7 +355,7 @@
 {
   if (!_is_own_window && !_places_showing && _we_control_active)
   {
-    if (_is_inside || _last_active_view || _show_now_activated)
+    if (_is_inside || _last_active_view || _show_now_activated || _new_application)
     {
       return true;
     }
@@ -344,7 +372,7 @@
 
   if (!_is_own_window && _we_control_active && _is_maximized)
   {
-    if (_is_inside || _show_now_activated)
+    if (_is_inside || _show_now_activated || _new_application)
     {
       return true;
     }
@@ -382,23 +410,28 @@
   if (_title_layer && !_is_own_window)
   {
     guint blend_alpha = 0, blend_src = 0, blend_dest = 0;
+    bool draw_menus = DrawMenus();
+    bool draw_window_buttons = DrawWindowButtons();
+    bool has_menu = false;
     bool draw_faded_title = false;
 
     GfxContext.GetRenderStates().GetBlend(blend_alpha, blend_src, blend_dest);
 
-    if (!DrawWindowButtons() && _we_control_active &&
-        (DrawMenus() || (GetOpacity() > 0.0f && _window_buttons->GetOpacity() == 0.0f)))
+    for (auto entry : entries_)
     {
-      for (auto entry : entries_)
+      if (entry.second->IsEntryValid())
       {
-        if (entry.second->IsEntryValid())
-        {
-          draw_faded_title = true;
-          break;
-        }
+        has_menu = true;
+        break;
       }
     }
 
+    if (!draw_window_buttons && _we_control_active && has_menu &&
+        (draw_menus || (GetOpacity() > 0.0f && _window_buttons->GetOpacity() == 0.0f)))
+    {
+      draw_faded_title = true;
+    }
+
     if (draw_faded_title)
     {
       bool build_gradient = false;
@@ -412,7 +445,7 @@
       }
       else
       {
-        if (_gradient_texture->LockRect(0, &lockrect, NULL) != OGL_OK)
+        if (_gradient_texture->LockRect(0, &lockrect, nullptr) != OGL_OK)
           build_gradient = true;
         else
           locked = true;
@@ -433,44 +466,55 @@
         _gradient_texture = nux::GetGraphicsDisplay()->GetGpuDevice()->
                             CreateSystemCapableDeviceTexture(texture_data.GetWidth(),
                             texture_data.GetHeight(), 1, texture_data.GetFormat());
-        locked = (_gradient_texture->LockRect(0, &lockrect, NULL) == OGL_OK);
+        locked = (_gradient_texture->LockRect(0, &lockrect, nullptr) == OGL_OK);
       }
 
+      BYTE* dest_buffer = (BYTE*) lockrect.pBits;
       int gradient_opacity = 255.0f * GetOpacity();
-      BYTE* dest_buffer = (BYTE*) lockrect.pBits;
+      int buttons_opacity = 255.0f * _window_buttons->GetOpacity();
+
+      int first_step = button_width * (factor - 1);
+      int second_step = button_width * factor;
 
       for (int x = 0; x < geo.width && dest_buffer && locked; x++)
       {
-        BYTE a;
-        if (x < button_width * (factor - 1))
+        BYTE r, g, b, a;
+
+        r = 223;
+        g = 219;
+        b = 210;
+
+        if (x < first_step)
         {
-          a = 0xff;
+          int color_increment = (first_step - x) * 4;
+
+          r = CLAMP(r + color_increment, r, 0xff);
+          g = CLAMP(g + color_increment, g, 0xff);
+          b = CLAMP(b + color_increment, b, 0xff);
+          a = 0xff - buttons_opacity;
         }
-        else if (x < button_width * factor)
+        else if (x < second_step)
         {
-          a = 0xff - gradient_opacity * (((float)x - (button_width * (factor - 1))) / (float)(button_width));
+          a = 0xff - gradient_opacity * (((float)x - (first_step)) /
+                                         (float)(button_width));
         }
         else
         {
-          if (!DrawMenus())
+          if (!draw_menus)
           {
             a = 0xff - gradient_opacity;
           }
-          else if (0xff - gradient_opacity > 0x55)
+          else
           {
             // If we're fading-out the title, it's better to quickly hide
             // the transparent right-most area
-            a = 0xff - gradient_opacity - 0x55;
-          }
-          else
-          {
-            a = 0x00;
+            a = CLAMP(0xff - gradient_opacity - 0x55, 0x00, 0xff);
           }
         }
 
-        *(dest_buffer + 4 * x + 0) = (223 * a) / 255; //red
-        *(dest_buffer + 4 * x + 1) = (219 * a) / 255; //green
-        *(dest_buffer + 4 * x + 2) = (210 * a) / 255; //blue
+        *(dest_buffer + 4 * x + 0) = (r * a) / 0xff; //red
+        *(dest_buffer + 4 * x + 1) = (g * a) / 0xff; //green
+        *(dest_buffer + 4 * x + 2) = (b * a) / 0xff; //blue
         *(dest_buffer + 4 * x + 3) = a;
       }
 
@@ -491,37 +535,39 @@
                              _title_layer->GetDeviceTexture(),
                              texxform1,
                              nux::color::White);
-
-      // The previous blend is too aggressive on the texture and therefore there
-      // is a slight loss of clarity. This fixes that
-      geo.width = button_width * (factor - 1);
-      nux::GetPainter().PushDrawLayer(GfxContext, geo, _title_layer);
-      geo = GetGeometry();
     }
-    else if (_window_buttons->GetOpacity() < 1.0f &&
-             _window_buttons->GetOpacity() > 0.0f && !_places_showing)
+    else if (!_places_showing)
     {
-      double title_opacity = 1.0f - _window_buttons->GetOpacity();
-      
-      if (!DrawWindowButtons())
+      if (_we_control_active && _window_buttons->GetOpacity() == 0.0 &&
+          (!has_menu || (has_menu && GetOpacity() == 0.0)))
       {
-        // If we're fading-out the buttons/menus, let's fade-in quickly the title
-        title_opacity = CLAMP(title_opacity + 0.25f, 0.0f, 1.0f);
+        nux::GetPainter().PushDrawLayer(GfxContext, geo, _title_layer);
       }
       else
       {
-        // If we're fading-in the buttons/menus, let's fade-out quickly the title
-        title_opacity = CLAMP(title_opacity - 0.25f, 0.0f, 1.0f);
+        double title_opacity = 1.0f;
+
+        if (has_menu)
+          title_opacity -= MAX(GetOpacity(), _window_buttons->GetOpacity());
+        else
+          title_opacity -= _window_buttons->GetOpacity();
+
+        if (!draw_window_buttons && !draw_menus)
+        {
+          // If we're fading-out the buttons/menus, let's fade-in quickly the title
+          title_opacity = CLAMP(title_opacity + 0.1f, 0.0f, 1.0f);
+        }
+        else
+        {
+          // If we're fading-in the buttons/menus, let's fade-out quickly the title
+          title_opacity = CLAMP(title_opacity - 0.2f, 0.0f, 1.0f);
+        }
+
+        nux::TexCoordXForm texxform;
+        GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
+                            _title_layer->GetDeviceTexture(), texxform,
+                            nux::color::White * title_opacity);
       }
-
-      nux::TexCoordXForm texxform;
-      GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                          _title_layer->GetDeviceTexture(), texxform,
-                          nux::color::White * title_opacity);
-    }
-    else if (_window_buttons->GetOpacity() == 0.0f && _we_control_active)
-    {
-      nux::GetPainter().PushDrawLayer(GfxContext, geo, _title_layer);
     }
 
     GfxContext.GetRenderStates().SetBlend(blend_alpha, blend_src, blend_dest);
@@ -549,7 +595,16 @@
     _menu_layout->ProcessDraw(GfxContext, true);
 
     _fade_out_animator->Stop();
-    _fade_in_animator->Start(GetOpacity());
+
+    if (_new_application && !_is_inside)
+    {
+      _fade_in_animator->Start(_menus_discovery_fadein, GetOpacity());
+    }
+    else
+    {
+      _fade_in_animator->Start(GetOpacity());
+      _new_app_menu_shown = false;
+    }
   }
   else
   {
@@ -563,14 +618,14 @@
 
     _fade_in_animator->Stop();
 
-    if (_fade_out_animator->GetDuration() != PANEL_ENTRIES_FADEOUT)
-    {
-      if (_fade_out_animator->IsRunning())
-        _fade_out_animator->Stop();
-
-      _fade_out_animator->SetDuration(PANEL_ENTRIES_FADEOUT);
-    }
-    _fade_out_animator->Start(1.0f - GetOpacity());
+    if (!_new_app_menu_shown)
+    {
+      _fade_out_animator->Start(1.0f - GetOpacity());
+    }
+    else
+    {
+      _fade_out_animator->Start(_menus_discovery_fadeout, 1.0f - GetOpacity());
+    }
   }
 
   if (draw_buttons)
@@ -589,8 +644,7 @@
     /* If we try to hide only the buttons, then use a faster fadeout */
     if (!_fade_out_animator->IsRunning())
     {
-      _fade_out_animator->SetDuration(PANEL_ENTRIES_FADEOUT/5);
-      _fade_out_animator->Start(1.0f - _window_buttons->GetOpacity());
+      _fade_out_animator->Start(_menus_fadeout/3, 1.0f - _window_buttons->GetOpacity());
     }
   }
 
@@ -600,7 +654,7 @@
 gchar*
 PanelMenuView::GetActiveViewName()
 {
-  gchar*         label = NULL;
+  gchar*         label = nullptr;
   BamfWindow*    window;
 
   _is_own_window = false;
@@ -659,7 +713,7 @@
         }
       }
 
-      if (label == NULL)
+      if (label == nullptr)
       {
         BamfView* active_view;
 
@@ -691,8 +745,8 @@
                              int increase_size
                              )
 {
-  PangoLayout*          layout = NULL;
-  PangoFontDescription* desc = NULL;
+  PangoLayout*          layout = nullptr;
+  PangoFontDescription* desc = nullptr;
   GtkSettings*          settings = gtk_settings_get_default();
   cairo_t*              cr;
   cairo_pattern_t*      linpat;
@@ -712,9 +766,9 @@
 
     cr = _util_cg.GetContext();
 
-    g_object_get(settings, "gtk-xft-dpi", &dpi, NULL);
+    g_object_get(settings, "gtk-xft-dpi", &dpi, nullptr);
 
-    font_description = gconf_client_get_string(client, WINDOW_TITLE_FONT_KEY, NULL);
+    font_description = gconf_client_get_string(client, WINDOW_TITLE_FONT_KEY, nullptr);
     desc = pango_font_description_from_string(font_description);
 
     if (font_desc)
@@ -742,7 +796,7 @@
     pango_cairo_context_set_resolution(cxt, (float)dpi / (float)PANGO_SCALE);
     pango_layout_context_changed(layout);
 
-    pango_layout_get_extents(layout, NULL, &log_rect);
+    pango_layout_get_extents(layout, nullptr, &log_rect);
     text_width = log_rect.width / PANGO_SCALE;
     text_height = log_rect.height / PANGO_SCALE;
 
@@ -833,7 +887,7 @@
   y = 0;
 
   if (label)
-    DrawText(cr, x, y, width, height, NULL, label);
+    DrawText(cr, x, y, width, height, nullptr, label);
 
   cairo_destroy(cr);
 
@@ -869,7 +923,7 @@
   {
     if (_last_active_view == view)
     {
-      _last_active_view = NULL;
+      _last_active_view = nullptr;
     }
   }
 
@@ -894,28 +948,139 @@
 {
   auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
   _is_inside = GetAbsoluteGeometry().IsPointInside(mouse.x, mouse.y);
-  _last_active_view = NULL;
+  _last_active_view = nullptr;
 
   FullRedraw();
 }
 
 void
-PanelMenuView::OnNameChanged(gchar* new_name, gchar* old_name)
+PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
 {
   Refresh();
   FullRedraw();
 }
 
-void
-PanelMenuView::OnActiveWindowChanged(BamfView* old_view,
+gboolean
+PanelMenuView::OnNewAppShow(PanelMenuView* self)
+{
+  self->_new_application = bamf_matcher_get_active_application(self->_matcher);
+  self->QueueDraw();
+
+  if (self->_new_app_hide_id)
+  {
+    g_source_remove(self->_new_app_hide_id);
+    self->_new_app_hide_id = 0;
+    self->_new_app_menu_shown = false;
+  }
+
+  self->_new_app_hide_id = g_timeout_add_seconds(self->_menus_discovery,
+                                                 (GSourceFunc)PanelMenuView::OnNewAppHide,
+                                                 self);
+  self->_new_app_show_id = 0;
+
+  return FALSE;
+}
+
+gboolean
+PanelMenuView::OnNewAppHide(PanelMenuView* self)
+{
+  self->OnViewClosed(self->_matcher, BAMF_VIEW(self->_new_application.RawPtr()));
+  self->_new_app_hide_id = 0;
+  self->_new_app_menu_shown = true;
+  self->QueueDraw();
+
+  return FALSE;
+}
+
+void
+PanelMenuView::OnViewOpened(BamfMatcher *matcher, BamfView *view)
+{
+  /* FIXME: here we should also check for if the view is also user_visible
+   * but it seems that BAMF doesn't handle this correctly after some
+   * stress tests (repeated launches). */
+  if (!BAMF_IS_APPLICATION(view))
+    return;
+
+  _new_apps.push_front(BAMF_APPLICATION(g_object_ref(view)));
+}
+
+void
+PanelMenuView::OnViewClosed(BamfMatcher *matcher, BamfView *view)
+{
+  if (!BAMF_IS_APPLICATION(view))
+    return;
+
+  BamfApplication* app = BAMF_APPLICATION(view);
+
+  if (std::find(_new_apps.begin(), _new_apps.end(), app) != _new_apps.end())
+  {
+    _new_apps.remove(app);
+    g_object_unref(app);
+
+    if (_new_application == app)
+      _new_application = nullptr;
+  }
+}
+
+void
+PanelMenuView::OnActiveAppChanged(BamfMatcher *matcher,
+                                  BamfApplication* old_app,
+                                  BamfApplication* new_app)
+{
+  if (BAMF_IS_APPLICATION(new_app))
+  {
+    if (std::find(_new_apps.begin(), _new_apps.end(), new_app) != _new_apps.end())
+    {
+      if (_new_application != new_app)
+      {
+        /* Add a small delay before showing the menus, this is done both
+         * to fix the issues with applications that takes some time to loads
+         * menus and to show the menus only when an application has been
+         * kept active for some time */
+
+        if (_new_app_show_id)
+          g_source_remove(_new_app_show_id);
+
+        _new_app_show_id = g_timeout_add(300,
+                                         (GSourceFunc)PanelMenuView::OnNewAppShow,
+                                         this);
+      }
+    }
+    else
+    {
+      if (_new_app_show_id)
+      {
+        g_source_remove(_new_app_show_id);
+        _new_app_show_id = 0;
+      }
+
+      if (_new_app_hide_id)
+      {
+        g_source_remove(_new_app_hide_id);
+        _new_app_hide_id = 0;
+        _new_app_menu_shown = false;
+      }
+
+      if (_new_application)
+        OnViewClosed(matcher, BAMF_VIEW(_new_application.RawPtr()));
+    }
+  }
+}
+
+void
+PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher,
+                                     BamfView* old_view,
                                      BamfView* new_view)
 {
   _show_now_activated = false;
   _is_maximized = false;
   _active_xid = 0;
+
   if (_active_moved_id)
+  {
     g_source_remove(_active_moved_id);
-  _active_moved_id = 0;
+    _active_moved_id = 0;
+  }
 
   if (BAMF_IS_WINDOW(new_view))
   {
@@ -944,16 +1109,11 @@
     }
 
     // first see if we need to remove and old callback
-    if (_name_changed_callback_id != 0)
-      g_signal_handler_disconnect(_name_changed_callback_instance,
-                                  _name_changed_callback_id);
+    _view_name_changed_signal.Disconnect();
 
-    // register callback for new view and store handler-id
-    _name_changed_callback_instance = G_OBJECT(new_view);
-    _name_changed_callback_id = g_signal_connect(_name_changed_callback_instance,
-                                                 "name-changed",
-                                                 (GCallback) on_name_changed,
-                                                 this);
+    // register callback for new view
+    _view_name_changed_signal.Connect(new_view, "name-changed",
+                                      sigc::mem_fun(this, &PanelMenuView::OnNameChanged));
   }
 
   Refresh();
@@ -1129,7 +1289,7 @@
 {
   if (_places_showing)
   {
-    ubus_server_send_message(ubus_server_get_default(), UBUS_PLACE_VIEW_CLOSE_REQUEST, NULL);
+    ubus_server_send_message(ubus_server_get_default(), UBUS_PLACE_VIEW_CLOSE_REQUEST, nullptr);
   }
   else
   {
@@ -1342,35 +1502,13 @@
 const gchar*
 PanelMenuView::GetChildsName()
 {
-  return NULL;
+  return nullptr;
 }
 
 void PanelMenuView::AddProperties(GVariantBuilder* builder)
 {
 }
 
-/*
- * C code for callbacks
- */
-static void
-
-on_active_window_changed(BamfMatcher*   matcher,
-                         BamfView*      old_view,
-                         BamfView*      new_view,
-                         PanelMenuView* self)
-{
-  self->OnActiveWindowChanged(old_view, new_view);
-}
-
-static void
-on_name_changed(BamfView*      bamf_view,
-                gchar*         old_name,
-                gchar*         new_name,
-                PanelMenuView* self)
-{
-  self->OnNameChanged(new_name, old_name);
-}
-
 void
 PanelMenuView::OnPlaceViewShown(GVariant* data, PanelMenuView* self)
 {

=== modified file 'plugins/unityshell/src/PanelMenuView.h'
--- plugins/unityshell/src/PanelMenuView.h	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/PanelMenuView.h	2011-12-14 17:24:33 +0000
@@ -31,6 +31,8 @@
 #include "PluginAdapter.h"
 #include "Animator.h"
 
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/GLibSignal.h>
 #include <libbamf/libbamf.h>
 
 namespace unity
@@ -54,6 +56,9 @@
   PanelMenuView(int padding = 6);
   ~PanelMenuView();
 
+  void SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                          int discovery_fadein, int discovery_fadeout);
+
   void FullRedraw();
 
   virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
@@ -63,8 +68,11 @@
   void SetMousePosition(int x, int y);
 
   void OnActiveChanged(PanelIndicatorEntryView* view, bool is_active);
-  void OnActiveWindowChanged(BamfView* old_view, BamfView* new_view);
-  void OnNameChanged(gchar* new_name, gchar* old_name);
+  void OnViewOpened(BamfMatcher* matcher, BamfView* view);
+  void OnViewClosed(BamfMatcher* matcher, BamfView* view);
+  void OnActiveWindowChanged(BamfMatcher* matcher, BamfView* old_view, BamfView* new_view);
+  void OnActiveAppChanged(BamfMatcher* matcher, BamfApplication* old_app, BamfApplication* new_app);
+  void OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name);
 
   void OnSpreadInitiate();
   void OnSpreadTerminate();
@@ -116,6 +124,8 @@
   void UpdateShowNow(bool ignore);
   static gboolean UpdateActiveWindowPosition(PanelMenuView* self);
   static gboolean UpdateShowNowWithDelay(PanelMenuView* self);
+  static gboolean OnNewAppShow(PanelMenuView* self);
+  static gboolean OnNewAppHide(PanelMenuView* self);
   void DrawText(cairo_t *cr_real,
                 int &x, int y, int width, int height,
                 const char* font_desc,
@@ -130,7 +140,7 @@
   void OnFadeOutChanged(double);
 
 private:
-  BamfMatcher* _matcher;
+  glib::Object<BamfMatcher> _matcher;
 
   nux::TextureLayer*       _title_layer;
   nux::HLayout*            _menu_layout;
@@ -142,34 +152,47 @@
   bool _is_maximized;
   bool _is_own_window;
   PanelIndicatorEntryView* _last_active_view;
+  glib::Object<BamfApplication> _new_application;
 
   WindowButtons* _window_buttons;
   PanelTitlebarGrabArea* _panel_titlebar_grab_area;
 
   std::map<guint32, bool> _decor_map;
   std::set<guint32> _maximized_set;
+  std::list<BamfApplication*> _new_apps;
+
   int _padding;
-  gpointer _name_changed_callback_instance;
-  gulong _name_changed_callback_id;
-
   int _last_width;
   int _last_height;
 
   bool _places_showing;
   bool _show_now_activated;
-
   bool _we_control_active;
+  bool _new_app_menu_shown;
+
   int  _monitor;
   guint32 _active_xid;
   guint32 _active_moved_id;
   guint32 _update_show_now_id;
+  guint32 _new_app_show_id;
+  guint32 _new_app_hide_id;
   nux::Geometry _monitor_geo;
 
-  gulong _activate_window_changed_id;
+  glib::Signal<void, BamfMatcher*, BamfView*> _view_opened_signal;
+  glib::Signal<void, BamfMatcher*, BamfView*> _view_closed_signal;
+  glib::Signal<void, BamfMatcher*, BamfView*, BamfView*> _active_win_changed_signal;
+  glib::Signal<void, BamfMatcher*, BamfApplication*, BamfApplication*> _active_app_changed_signal;
+  glib::Signal<void, BamfView*, gchar*, gchar*> _view_name_changed_signal;
 
   guint32 _place_shown_interest;
   guint32 _place_hidden_interest;
 
+  int _menus_fadein;
+  int _menus_fadeout;
+  int _menus_discovery;
+  int _menus_discovery_fadein;
+  int _menus_discovery_fadeout;
+
   Animator* _fade_in_animator;
   Animator* _fade_out_animator;
 };

=== modified file 'plugins/unityshell/src/PanelView.cpp'
--- plugins/unityshell/src/PanelView.cpp	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/PanelView.cpp	2011-12-14 17:24:33 +0000
@@ -621,6 +621,13 @@
 }
 
 void
+PanelView::SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                              int discovery_fadein, int discovery_fadeout)
+{
+  _menu_view->SetMenuShowTimings(fadein, fadeout, discovery, discovery_fadein, discovery_fadeout);
+}
+
+void
 PanelView::SetOpacityMaximizedToggle(bool enabled)
 {
   if (_opacity_maximized_toggle != enabled)

=== modified file 'plugins/unityshell/src/PanelView.h'
--- plugins/unityshell/src/PanelView.h	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/PanelView.h	2011-12-14 17:24:33 +0000
@@ -71,6 +71,8 @@
 
   void SetOpacity(float opacity);
   void SetOpacityMaximizedToggle(bool enabled);
+  void SetMenuShowTimings(int fadein, int fadeout, int discovery,
+                          int discovery_fadein, int discovery_fadeout);
 
   void TrackMenuPointer();
 

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2011-12-14 16:18:41 +0000
+++ plugins/unityshell/src/unityshell.cpp	2011-12-14 17:24:33 +0000
@@ -240,6 +240,11 @@
      optionSetUrgentAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetPanelOpacityNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetPanelOpacityMaximizedToggleNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetMenusFadeinNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetMenusFadeoutNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetMenusDiscoveryDurationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetMenusDiscoveryFadeinNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetMenusDiscoveryFadeoutNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetLauncherOpacityNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetIconSizeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetAutohideAnimationNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -2025,6 +2030,17 @@
     case UnityshellOptions::PanelOpacityMaximizedToggle:
       panel_controller_->SetOpacityMaximizedToggle(optionGetPanelOpacityMaximizedToggle());
       break;
+    case UnityshellOptions::MenusFadein:
+    case UnityshellOptions::MenusFadeout:
+    case UnityshellOptions::MenusDiscoveryFadein:
+    case UnityshellOptions::MenusDiscoveryFadeout:
+    case UnityshellOptions::MenusDiscoveryDuration:
+      panel_controller_->SetMenuShowTimings(optionGetMenusFadein(),
+                                            optionGetMenusFadeout(),
+                                            optionGetMenusDiscoveryDuration(),
+                                            optionGetMenusDiscoveryFadein(),
+                                            optionGetMenusDiscoveryFadeout());
+      break;
     case UnityshellOptions::LauncherOpacity:
       launcher.SetBackgroundAlpha(optionGetLauncherOpacity());
       break;
@@ -2412,6 +2428,11 @@
   /* Setup panel */
   timer.Reset();
   panel_controller_.reset(new panel::Controller());
+  panel_controller_->SetMenuShowTimings(optionGetMenusFadein(),
+                                        optionGetMenusFadeout(),
+                                        optionGetMenusDiscoveryDuration(),
+                                        optionGetMenusDiscoveryFadein(),
+                                        optionGetMenusDiscoveryFadeout());
   LOG_INFO(logger) << "initLauncher-Panel " << timer.ElapsedSeconds() << "s";
 
   /* Setup Places */

=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2011-12-08 04:13:56 +0000
+++ plugins/unityshell/unityshell.xml.in	2011-12-14 17:24:33 +0000
@@ -342,12 +342,52 @@
                     </desc>
                 </option>
 
-		<option name="show_desktop_icon" type="bool">
+                <option name="show_desktop_icon" type="bool">
                     <_short>Show "Desktop Icon" in the launcher</_short>
                     <_long>Enable/Disable "Show Dekstop icon" in the launcher.</_long>
                     <default>false</default>
                 </option>
 
+                <option name="menus_fadein" type="int">
+                    <_short>Menus Fade-in duration</_short>
+                    <_long>Duration (in milliseconds) of the menus fade-in animation, used when the mouse goes over the top-panel.</_long>
+                    <min>0</min>
+                    <max>1000</max>
+                    <default>100</default>
+                </option>
+
+                <option name="menus_fadeout" type="int">
+                    <_short>Menus fade-out duration</_short>
+                    <_long>Duration (in milliseconds) of the menus fade-out animation, used when the mouse goes over the top-panel.</_long>
+                    <min>0</min>
+                    <max>1000</max>
+                    <default>120</default>
+                </option>
+
+                <option name="menus_discovery_duration" type="int">
+                    <_short>Menus discovery duration</_short>
+                    <_long>How many seconds the menus should be shown when a new application has been launched.</_long>
+                    <min>0</min>
+                    <max>10</max>
+                    <default>2</default>
+                </option>
+
+                <option name="menus_discovery_fadein" type="int">
+                    <_short>Menus discovery fade-in duration</_short>
+                    <_long>Duration (in milliseconds) of the menus fade-in animation, used when the menus of a new launched application have been shown.</_long>
+                    <min>0</min>
+                    <max>1000</max>
+                    <default>200</default>
+                </option>
+
+                <option name="menus_discovery_fadeout" type="int">
+                    <_short>Menus discovery fade-out duration</_short>
+                    <_long>Duration (in milliseconds) of the menus fade-out animation, used when the menus of a new launched application have been shown.</_long>
+                    <min>0</min>
+                    <max>1000</max>
+                    <default>300</default>
+                </option>
+
             </group>
         </options>
     </plugin>

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2011-12-14 16:18:41 +0000
+++ tests/CMakeLists.txt	2011-12-14 17:24:33 +0000
@@ -99,6 +99,7 @@
 
 # The actual test executable (xless) - do not put anything that requires X in here
   add_executable(test-gtest-xless
+                 test_animator.cpp
                  test_glib_signals.cpp
                  test_glib_signals_utils.cpp
                  test_glib_signals_utils.h
@@ -107,6 +108,8 @@
                  test_introspection.cpp
                  test_main_xless.cpp
                  ${UNITY_SRC}/AbstractLauncherIcon.h
+                 ${UNITY_SRC}/Animator.cpp
+                 ${UNITY_SRC}/Animator.h
                  ${UNITY_SRC}/DebugDBusInterface.h
                  ${UNITY_SRC}/DebugDBusInterface.cpp
                  ${UNITY_SRC}/XPathQueryPart.h

=== added file 'tests/test_animator.cpp'
--- tests/test_animator.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_animator.cpp	2011-12-14 17:24:33 +0000
@@ -0,0 +1,295 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2011 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: Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include <gtest/gtest.h>
+
+#include "Animator.h"
+#include "test_utils.h"
+
+using namespace std;
+using namespace unity;
+
+namespace
+{
+
+class TestAnimator : public ::testing::Test
+{
+public:
+  TestAnimator() :
+   test_animator_(100),
+   n_steps_(0),
+   current_progress_(0.0f),
+   got_update_(false),
+   half_reached_(false),
+   started_(false),
+   stopped_(false),
+   ended_(false)
+  {
+    test_animator_.animation_started.connect([&started_]() {
+      started_ = true;
+    });
+
+    test_animator_.animation_ended.connect([&ended_]() {
+      ended_ = true;
+    });
+
+    test_animator_.animation_stopped.connect([&stopped_](double progress) {
+      stopped_ = true;
+    });
+
+    test_animator_.animation_updated.connect([&](double progress) {
+      n_steps_++;
+      current_progress_ = progress;
+      got_update_ = true;
+
+      if (progress >= 0.5f)
+        half_reached_ = true;
+    });
+  }
+
+protected:
+  void ResetValues()
+  {
+    n_steps_ = 0;
+    current_progress_ = 0.0f;
+    started_ = false;
+    stopped_ = false;
+    ended_ = false;
+    got_update_ = false;
+    half_reached_ = false;
+  }
+
+  Animator test_animator_;
+  unsigned int n_steps_;
+  double current_progress_;
+  bool got_update_;
+  bool half_reached_;
+  bool started_;
+  bool stopped_;
+  bool ended_;
+};
+
+TEST_F(TestAnimator, ConstructDestroy)
+{
+  bool stopped = false;
+  double progress = 0.0f;
+  
+  {
+    Animator tmp_animator(200, 25);
+
+    EXPECT_EQ(tmp_animator.GetDuration(), 200);
+    EXPECT_EQ(tmp_animator.GetRate(), 25);
+
+    bool got_update = false;
+    tmp_animator.animation_updated.connect([&progress, &got_update](double p) {
+      progress = p;
+      got_update = true;
+    });
+
+    tmp_animator.animation_stopped.connect([&stopped](double p) {
+      stopped = true;
+    });
+
+    tmp_animator.Start();
+
+    Utils::WaitUntil(got_update);
+
+    EXPECT_EQ(tmp_animator.IsRunning(), true);
+    EXPECT_GT(progress, 0.0f);
+    EXPECT_EQ(stopped, false);
+  }
+
+  EXPECT_EQ(stopped, true);
+}
+
+TEST_F(TestAnimator, SetGetValues)
+{
+  test_animator_.SetRate(30);
+  EXPECT_EQ(test_animator_.GetRate(), 30);
+
+  test_animator_.SetDuration(100);
+  EXPECT_EQ(test_animator_.GetDuration(), 100);
+
+  EXPECT_EQ(test_animator_.GetProgress(), 0.0f);
+  EXPECT_EQ(test_animator_.IsRunning(), false);
+}
+
+TEST_F(TestAnimator, SimulateStep)
+{
+  test_animator_.DoStep();
+  EXPECT_EQ(test_animator_.IsRunning(), false);
+  EXPECT_EQ(n_steps_, 1);
+  EXPECT_GT(test_animator_.GetProgress(), 0.0f);
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateAnimation)
+{
+  test_animator_.SetRate(20);
+  test_animator_.SetDuration(200);
+  long long start_time = g_get_monotonic_time() / 1000;
+  test_animator_.Start();
+
+  EXPECT_EQ(started_, true);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+  
+  Utils::WaitUntil(got_update_);
+  EXPECT_GT(test_animator_.GetProgress(), 0.0f);
+  EXPECT_EQ(test_animator_.GetProgress(), current_progress_);
+  EXPECT_EQ(n_steps_, 1);
+
+  Utils::WaitUntil(ended_);
+  EXPECT_EQ(stopped_, false);
+  EXPECT_EQ(ended_, true);
+
+  unsigned int expected_steps = (test_animator_.GetDuration() / 1000.0f) * test_animator_.GetRate();
+  EXPECT_EQ(n_steps_, ceil(expected_steps));
+
+  long long actual_time = g_get_monotonic_time() / 1000;
+  long long expected_end = start_time+test_animator_.GetDuration();
+  EXPECT_GE(actual_time, expected_end);
+  EXPECT_LE(actual_time-expected_end, test_animator_.GetRate()*2);
+
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateStoppedAnimation)
+{
+  test_animator_.SetRate(30);
+  test_animator_.SetDuration(100);
+  test_animator_.Start();
+  EXPECT_EQ(started_, true);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+
+  Utils::WaitUntil(half_reached_);
+  EXPECT_GT(test_animator_.GetProgress(), 0.5f);
+  EXPECT_EQ(test_animator_.GetProgress(), current_progress_);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+
+  test_animator_.Stop();
+  EXPECT_EQ(test_animator_.IsRunning(), false);
+  EXPECT_LT(test_animator_.GetProgress(), 1.0f);
+  EXPECT_EQ(stopped_, true);
+  EXPECT_EQ(ended_, true);
+
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateStoppedAndContinueAnimation)
+{
+  test_animator_.SetRate(30);
+  test_animator_.SetDuration(100);
+  test_animator_.Start();
+  EXPECT_EQ(started_, true);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+
+  Utils::WaitUntil(half_reached_);
+  test_animator_.Stop();
+
+  EXPECT_LT(test_animator_.GetProgress(), 1.0f);
+  EXPECT_EQ(stopped_, true);
+  EXPECT_EQ(ended_, true);
+  stopped_ = false;
+  ended_ = false;
+
+  long long start_time = g_get_monotonic_time() / 1000;
+  long long expected_end = start_time + (test_animator_.GetDuration() / current_progress_);
+  test_animator_.Start(test_animator_.GetProgress());
+  Utils::WaitUntil(ended_);
+  EXPECT_EQ(stopped_, false);
+  EXPECT_EQ(ended_, true);
+
+  long long actual_time = g_get_monotonic_time() / 1000;
+  EXPECT_LT(expected_end-actual_time, test_animator_.GetDuration());
+
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateOneTimeDurationStart)
+{
+  unsigned int default_duration = 100;
+
+  test_animator_.SetRate(30);
+  test_animator_.SetDuration(default_duration);
+
+  unsigned int one_time_duration = 75;
+  test_animator_.Start(one_time_duration);
+  EXPECT_EQ(started_, true);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+
+  Utils::WaitUntil(half_reached_);
+  EXPECT_LT(test_animator_.GetProgress(), 1.0f);
+  EXPECT_EQ(test_animator_.GetDuration(), one_time_duration);
+  EXPECT_EQ(ended_, false);
+
+  Utils::WaitUntil(ended_);
+  EXPECT_EQ(stopped_, false);
+  EXPECT_EQ(ended_, true);
+
+  EXPECT_EQ(test_animator_.GetDuration(), default_duration);
+
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateOneTimeDurationStartStop)
+{
+  unsigned int default_duration = 100;
+
+  test_animator_.SetRate(30);
+  test_animator_.SetDuration(default_duration);
+
+  unsigned int one_time_duration = 75;
+  test_animator_.Start(one_time_duration);
+  EXPECT_EQ(started_, true);
+  EXPECT_EQ(test_animator_.IsRunning(), true);
+
+  Utils::WaitUntil(half_reached_);
+  EXPECT_EQ(test_animator_.GetDuration(), one_time_duration);
+  EXPECT_EQ(ended_, false);
+
+  test_animator_.Stop();
+  EXPECT_EQ(stopped_, true);
+  EXPECT_EQ(ended_, true);
+  EXPECT_EQ(test_animator_.GetDuration(), default_duration);
+
+  ResetValues();
+}
+
+TEST_F(TestAnimator, SimulateZeroDuration)
+{
+  test_animator_.SetRate(30);
+  test_animator_.SetDuration(0);
+
+  EXPECT_EQ(started_, false);
+  EXPECT_EQ(ended_, false);
+  EXPECT_EQ(test_animator_.IsRunning(), false);
+
+  long long start_time = g_get_monotonic_time() / 1000;
+  test_animator_.Start();
+  EXPECT_EQ(started_, true);
+
+  Utils::WaitUntil(ended_);
+  EXPECT_EQ(ended_, true);
+
+  long long end_time = g_get_monotonic_time() / 1000;
+  EXPECT_LT(end_time - start_time, test_animator_.GetRate()*2);
+}
+
+
+} // Namespace

=== modified file 'tests/test_lens.cpp'
--- tests/test_lens.cpp	2011-10-12 12:02:17 +0000
+++ tests/test_lens.cpp	2011-12-14 17:24:33 +0000
@@ -48,36 +48,11 @@
   {
     n_filters_++;
   }
-
-  static gboolean TimeoutCallback(gpointer data)
-  {
-    *(bool*)data = true;
-    return FALSE;
-  };
-
-  guint32 ScheduleTimeout(bool* timeout_reached)
-  {
-    return g_timeout_add_seconds(10, TimeoutCallback, timeout_reached);
-  }
-
-  void WaitUntil(bool& success)
-  {
-    bool timeout_reached = false;
-    guint32 timeout_id = ScheduleTimeout(&timeout_reached);
-
-    while (!success && !timeout_reached)
-      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
-
-    if (success)
-      g_source_remove(timeout_id);
-
-    EXPECT_TRUE(success);
-  }
  
   void WaitForConnected()
   {
     bool timeout_reached = false;
-    guint32 timeout_id = ScheduleTimeout(&timeout_reached);
+    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached);
 
     while (!lens_->connected && !timeout_reached)
     {
@@ -93,7 +68,7 @@
   void WaitForModel(Model<Adaptor>* model, unsigned int n_rows)
   {
     bool timeout_reached = false;
-    guint32 timeout_id = ScheduleTimeout(&timeout_reached);
+    guint32 timeout_id = Utils::ScheduleTimeout(&timeout_reached);
     
     while (model->count != n_rows && !timeout_reached)
     {
@@ -229,7 +204,7 @@
   lens_->activated.connect(sigc::slot<void, std::string const&, HandledType,Lens::Hints const&>(activated_cb));  
   
   lens_->Activate(uri);
-  WaitUntil(activated);
+  Utils::WaitUntil(activated);
 }
 
 TEST_F(TestLens, TestPreview)
@@ -262,7 +237,7 @@
   lens_->preview_ready.connect(sigc::slot<void, std::string const&, Preview::Ptr>(preview_cb));
 
   lens_->Preview(uri);
-  WaitUntil(previewed);
+  Utils::WaitUntil(previewed);
 }
 
 TEST_F(TestLens, TestFilterSync)

=== modified file 'tests/test_utils.h'
--- tests/test_utils.h	2011-07-25 10:54:25 +0000
+++ tests/test_utils.h	2011-12-14 17:24:33 +0000
@@ -31,6 +31,32 @@
     if (model.count == n_rows)
       g_source_remove(timeout_id);
   }
+
+  static void WaitUntil(bool& success, unsigned int max_wait = 10)
+  {
+    bool timeout_reached = false;
+    guint32 timeout_id = ScheduleTimeout(&timeout_reached, max_wait);
+
+    while (!success && !timeout_reached)
+      g_main_context_iteration(g_main_context_get_thread_default(), TRUE);
+
+    if (success)
+      g_source_remove(timeout_id);
+
+    EXPECT_TRUE(success);
+  }
+
+  static guint32 ScheduleTimeout(bool* timeout_reached, unsigned int timeout_duration = 10)
+  {
+    return g_timeout_add_seconds(timeout_duration, TimeoutCallback, timeout_reached);
+  }
+
+private:
+  static gboolean TimeoutCallback(gpointer data)
+  {
+    *(bool*)data = true;
+    return FALSE;
+  };
 };
 
 }