Merge lp:~3v1n0/unity/fading-panelmenu into lp:unity

[Marco Trevisan (Treviño)]

As requested on bug #691776 I'm finally applying a fast fade effect when the panel switches from the title to the menus state.
The fade effect is currently set to last 100ms on fade-in and 120ms on fade-out as defined with design (in the person of John Lea) and is applied to menus, title (generating a cross-fade for maximized windows) and title's gradient (to smoothly change its values).

To perform the animations I've written a new Animator class which is based on the work of Andrea Cimitan with the ayatana scrollbars, and basically is a timer that is able to call a callback function every few ms.
I would have used the nux::TimerHandler instead (using the AddPeriodicTimerHandler method), but it doesn't seem to work as it should, and it actually results slower.

In this branch I also introduced some minor tweaks to PanelIndicatorEntryView that now is typed and has different features for Menus and pure Indicators. Menus basically don't support the scroll event and the secondary-activate so they consider the middle-click as a standard click to open a menu (as it is with the Gtk). Indicators are like before but they also now support a feedback notification for secondary activation (they reduce their opacity on mouse-down).

Crossfade effect between different titles when the active window changes is planned for the future (next cycle? :))

[Andrea Cimitan (cimi)]

Marco, don't propose a review if you plan to continue hacking on it, wait until it's ready then proceed :-)
If you really want to propose it, put the status to "work in progress" until you're satisfied with the changes :-)

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

I know Andrea... But after that I proposed the request I finally found some bugs I didn't experience before, so I had to update the branch while ready for merging.

Sorry about that. Now, by the way, it should be fine for review :)

[Andrea Cimitan (cimi)]

thx Marco, even though I'll wait for the P branch.
I know my code was stable in the scrollbars, and you ported it pretty well
into unity, but considering the high chance of race conditions and pointers
that need to be correctly handled to avoid segfaults, I think merging it can
be a bit risky, even if the code could seem fine at first glance. Let's wait
my brave mates :)

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

Well, I tested this quite a lot and there are not that much more pointers than before. I never got a seg-fault with this code. Also I just added two new poiters for the animators, but they are initialized at the beginning, so they are safe.
However I submit to your decision...

[Andrea Cimitan (cimi)]

also, we might want to cache the text as a cairo pattern or surface, then paint it (instead redrawing it every cycle). also, you know, I'm not happy with your decision of deciding at which point starting the animation, I think it doesn0t suit perfectly if the same can be done in callback functions

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

Well, that could be a good thing. And I also would have loved to do that. Unfortunately the gradient can't be cached since it needs to change when the opacity changes not to get a bad effect (also if keeping a so fast transition, we also use the old code which cached it, but the effect it's not the same).

The start thing, istead, is just a facility. The callback can control that, but I'd need more local variables that would be more unsafe. I'd prefer to keep that value hidden.

[Neil J. Patel (njpatel)]

review: Approve

[Andrea Cimitan (cimi)]

Marco, why we can't cache the pattern/surface? Imagine we have the pattern/surface of the menubar with opacity 1.0, and when we want to draw the same menubar at 0.5, we set the cairo source as the cached opaque pattern and paint with alpha 0.5... What did you discover that I'm missing?

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

Ok, the opacity the title can be cached and is actually cached, but the gradient that is applied to it when a menu is shown can't (easily).
So also, if I know that there was room for optimizations, I had to focus on functionality.

=== added file 'plugins/unityshell/src/Animator.cpp'
--- plugins/unityshell/src/Animator.cpp	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/Animator.cpp	2011-09-28 09:56:29 +0000
@@ -0,0 +1,133 @@
+// -*- 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 "Animator.h"
+
+namespace unity
+{
+
+Animator::Animator(unsigned int duration, unsigned int fps_rate)
+{
+  _start_time = 0;
+  _timeout_id = 0;
+  _progress = 0.0f;
+  _start_progress = 0.0f;
+  _rate = 1;
+  _duration = 0;
+
+  SetDuration(duration);
+  SetRate(fps_rate);
+}
+
+Animator::~Animator()
+{
+  if (_timeout_id != 0)
+    g_source_remove (_timeout_id);
+}
+
+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)
+  {
+    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);
+  }
+}
+
+void
+Animator::Stop()
+{
+  if (_timeout_id != 0)
+  {
+    g_source_remove(_timeout_id);
+    animation_updated.emit(_progress);
+    animation_ended.emit();
+    animation_stopped.emit(_progress);
+    _timeout_id = 0;
+  }
+}
+
+gboolean
+Animator::TimerTimeOut(Animator *self)
+{
+  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;
+  }
+}
+
+} //namespace

=== added file 'plugins/unityshell/src/Animator.h'
--- plugins/unityshell/src/Animator.h	1970-01-01 00:00:00 +0000
+++ plugins/unityshell/src/Animator.h	2011-09-28 09:56:29 +0000
@@ -0,0 +1,70 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_ANIMATOR_H_
+#define UNITY_ANIMATOR_H_
+
+#include <Nux/Nux.h>
+
+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);
+  ~Animator();
+
+  void SetRate(unsigned int fps_rate);
+  void SetDuration(unsigned int duration);
+
+  unsigned int GetRate();
+  unsigned int GetDuration();
+  double GetProgress();
+  bool IsRunning();
+
+  void Start(double start_progress = 0.0f);
+  void Stop();
+
+  sigc::signal<void> animation_started;
+  sigc::signal<void> animation_ended;
+
+  sigc::signal<void, double> animation_updated;
+  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;
+
+  static gboolean TimerTimeOut(Animator *self);
+};
+
+}
+#endif

=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.cpp'
--- plugins/unityshell/src/PanelIndicatorEntryView.cpp	2011-09-24 10:20:59 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.cpp	2011-09-28 09:56:29 +0000
@@ -54,11 +54,15 @@
 
 PanelIndicatorEntryView::PanelIndicatorEntryView(
   indicator::Entry::Ptr const& proxy,
-  int padding)
+  int padding,
+  IndicatorEntryType type)
   : TextureArea(NUX_TRACKER_LOCATION)
   , proxy_(proxy)
+  , type_(type)
   , util_cg_(CAIRO_FORMAT_ARGB32, 1, 1)
-  , padding_(padding)
+  , texture_layer_(NULL)
+  , padding_(padding < 0 ? 0 : padding)
+  , opacity_(1.0f)
   , draw_active_(false)
   , dash_showing_(false)
 {
@@ -71,7 +75,8 @@
   InputArea::mouse_up.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseUp));
 
   InputArea::SetAcceptMouseWheelEvent(true);
-  InputArea::mouse_wheel.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseWheel));
+  if (type_ != MENU)
+    InputArea::mouse_wheel.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::OnMouseWheel));
 
   on_panelstyle_changed_connection_ = PanelStyle::GetDefault()->changed.connect(sigc::mem_fun(this, &PanelIndicatorEntryView::Refresh));
   Refresh();
@@ -83,6 +88,8 @@
   on_indicator_updated_connection_.disconnect();
   on_panelstyle_changed_connection_.disconnect();
   g_signal_handler_disconnect(gtk_settings_get_default(), on_font_changed_connection_);
+  if (texture_layer_)
+    delete texture_layer_;
 }
 
 void PanelIndicatorEntryView::OnActiveChanged(bool is_active)
@@ -109,30 +116,39 @@
   if (proxy_->active())
     return;
 
+  if (((proxy_->label_visible() && proxy_->label_sensitive()) ||
+       (proxy_->image_visible() && proxy_->image_sensitive())))
+  {
+    int button = nux::GetEventButton(button_flags);
+
+    if (button == 2 && type_ == INDICATOR)
+      SetOpacity(0.75f);
+    else
+      ShowMenu(button);
+  }
+
+  Refresh();
+}
+
+void PanelIndicatorEntryView::OnMouseUp(int x, int y, long button_flags, long key_flags)
+{
+  if (proxy_->active())
+    return;
+
   int button = nux::GetEventButton(button_flags);
 
-  if (((proxy_->label_visible() && proxy_->label_sensitive()) ||
-       (proxy_->image_visible() && proxy_->image_sensitive())) && button != 2)
-  {
-    ShowMenu(button);
-  }
-  Refresh();
-}
-
-void PanelIndicatorEntryView::OnMouseUp(int x, int y, long button_flags, long key_flags)
-{
-  if (proxy_->active())
-    return;
-
   nux::Geometry geo = GetAbsoluteGeometry();
   int px = geo.x + x;
   int py = geo.y + y;
 
   if (((proxy_->label_visible() && proxy_->label_sensitive()) ||
        (proxy_->image_visible() && proxy_->image_sensitive())) &&
-      geo.IsPointInside(px, py) && nux::GetEventButton(button_flags) == 2)
+       button == 2 && type_ == INDICATOR)
   {
-    proxy_->SecondaryActivate(time(NULL));
+    if (geo.IsPointInside(px, py))
+      proxy_->SecondaryActivate(time(NULL));
+
+    SetOpacity(1.0f);
   }
 
   Refresh();
@@ -312,7 +328,7 @@
       cairo_paint_with_alpha(cr, proxy_->image_sensitive() ? 1.0 : 0.5);
 
       cairo_pattern_t* pat = cairo_pop_group(cr);
-      
+
       cairo_set_source_rgba(cr, 1.0f, 1.0f, 1.0f, 1.0f);
       cairo_rectangle(cr, x, y, width, height);
       cairo_mask(cr, pat);
@@ -387,21 +403,43 @@
   rop.Blend = true;
   rop.SrcBlend = GL_ONE;
   rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
-  nux::TextureLayer* texture_layer = new nux::TextureLayer(texture2D->GetDeviceTexture(),
-                                                           texxform,
-                                                           nux::color::White,
-                                                           true,
-                                                           rop);
-  SetPaintLayer(texture_layer);
+
+  if (texture_layer_)
+    delete texture_layer_;
+
+  texture_layer_ = new nux::TextureLayer(texture2D->GetDeviceTexture(), texxform,
+                                         nux::color::White, true, rop);
+  SetPaintLayer(texture_layer_);
 
   texture2D->UnReference();
-  delete texture_layer;
 
   NeedRedraw();
 
   refreshed.emit(this);
 }
 
+void PanelIndicatorEntryView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  if (opacity_ == 1.0f)
+  {
+    TextureArea::Draw(GfxContext, force_draw);
+    return;
+  }
+
+  auto geo = GetGeometry();
+  GfxContext.PushClippingRectangle(geo);
+
+  if (texture_layer_)
+  {
+    nux::TexCoordXForm texxform;
+    GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
+                        texture_layer_->GetDeviceTexture(), texxform,
+                        nux::color::White * opacity_);
+  }
+
+  GfxContext.PopClippingRectangle();
+}
+
 void PanelIndicatorEntryView::DashShown()
 {
   dash_showing_ = true;
@@ -414,6 +452,22 @@
   Refresh();
 }
 
+void PanelIndicatorEntryView::SetOpacity(double opacity)
+{
+  opacity = CLAMP(opacity, 0.0f, 1.0f);
+
+  if (opacity_ != opacity)
+  {
+    opacity_ = opacity;
+    NeedRedraw();
+  }
+}
+
+double PanelIndicatorEntryView::GetOpacity()
+{
+  return opacity_;
+}
+
 const gchar* PanelIndicatorEntryView::GetName()
 {
   if (proxy_->IsUnused())

=== modified file 'plugins/unityshell/src/PanelIndicatorEntryView.h'
--- plugins/unityshell/src/PanelIndicatorEntryView.h	2011-09-20 16:23:55 +0000
+++ plugins/unityshell/src/PanelIndicatorEntryView.h	2011-09-28 09:56:29 +0000
@@ -38,8 +38,14 @@
 class PanelIndicatorEntryView : public nux::TextureArea, public unity::Introspectable
 {
 public:
-  PanelIndicatorEntryView(indicator::Entry::Ptr const& proxy,
-                                int padding = 5);
+  typedef enum {
+    INDICATOR,
+    MENU,
+    OTHER
+  } IndicatorEntryType;
+
+  PanelIndicatorEntryView(indicator::Entry::Ptr const& proxy, int padding = 5,
+                          IndicatorEntryType type = INDICATOR);
   ~PanelIndicatorEntryView();
 
   void Refresh();
@@ -47,6 +53,8 @@
   void Activate(int button = 1);
   void Unactivate();
   bool GetShowNow();
+  void SetOpacity(double alpha);
+  double GetOpacity();
 
   void GetGeometryForSync(indicator::EntryLocationMap& locations);
   bool IsEntryValid() const;
@@ -60,13 +68,18 @@
   const gchar* GetName();
   void         AddProperties(GVariantBuilder* builder);
 
+  virtual void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+
   sigc::signal<void, PanelIndicatorEntryView*, bool> active_changed;
   sigc::signal<void, PanelIndicatorEntryView*> refreshed;
 
 private:
   unity::indicator::Entry::Ptr proxy_;
+  IndicatorEntryType type_;
   nux::CairoGraphics util_cg_;
+  nux::TextureLayer* texture_layer_;
   int padding_;
+  double opacity_;
   bool draw_active_;
   bool dash_showing_;
   gulong on_font_changed_connection_;

=== modified file 'plugins/unityshell/src/PanelIndicatorsView.cpp'
--- plugins/unityshell/src/PanelIndicatorsView.cpp	2011-09-26 08:38:05 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.cpp	2011-09-28 09:56:29 +0000
@@ -41,6 +41,7 @@
 PanelIndicatorsView::PanelIndicatorsView()
 : View(NUX_TRACKER_LOCATION)
 , layout_(NULL)
+, opacity_(1.0f)
 {
   LOG_DEBUG(logger) << "Indicators View Added: ";
   layout_ = new nux::HLayout("", NUX_TRACKER_LOCATION);
@@ -223,16 +224,13 @@
 }
 
 PanelIndicatorEntryView *
-PanelIndicatorsView::AddEntry(indicator::Entry::Ptr const& entry, int padding, IndicatorEntryPosition pos)
+PanelIndicatorsView::AddEntry(indicator::Entry::Ptr const& entry, int padding,
+                              IndicatorEntryPosition pos, IndicatorEntryType type)
 {
-  PanelIndicatorEntryView *view;
+  auto view = new PanelIndicatorEntryView(entry, padding, type);
   int entry_pos = pos;
 
-  if (padding > -1)
-    view = new PanelIndicatorEntryView(entry, padding);
-  else
-    view = new PanelIndicatorEntryView(entry);
-
+  view->SetOpacity(opacity_);
   view->refreshed.connect(sigc::mem_fun(this, &PanelIndicatorsView::OnEntryRefreshed));
 
   if (entry_pos == IndicatorEntryPosition::AUTO)
@@ -320,6 +318,27 @@
     entry.second->DashHidden();
 }
 
+double
+PanelIndicatorsView::GetOpacity()
+{
+  return opacity_;
+}
+
+void
+PanelIndicatorsView::SetOpacity(double opacity)
+{
+  opacity = CLAMP(opacity, 0.0f, 1.0f);
+
+  for (auto entry: entries_)
+    entry.second->SetOpacity(opacity);
+
+  if (opacity_ != opacity)
+  {
+    opacity_ = opacity;
+    NeedRedraw();
+  }
+}
+
 const gchar* PanelIndicatorsView::GetName()
 {
   return "IndicatorsView";

=== modified file 'plugins/unityshell/src/PanelIndicatorsView.h'
--- plugins/unityshell/src/PanelIndicatorsView.h	2011-09-20 00:39:21 +0000
+++ plugins/unityshell/src/PanelIndicatorsView.h	2011-09-28 09:56:29 +0000
@@ -48,9 +48,12 @@
     END = nux::NUX_LAYOUT_END,
   } IndicatorEntryPosition;
 
+  typedef PanelIndicatorEntryView::IndicatorEntryType IndicatorEntryType;
+
   PanelIndicatorEntryView* AddEntry(indicator::Entry::Ptr const& entry,
-                                    int padding = -1,
-                                    IndicatorEntryPosition pos = AUTO);
+                                    int padding = 5,
+                                    IndicatorEntryPosition pos = AUTO,
+                                    IndicatorEntryType type = IndicatorEntryType::INDICATOR);
   void RemoveEntry(std::string const& entry_id);
 
   bool OnPointerMoved(int x, int y);
@@ -70,6 +73,9 @@
   void DashShown();
   void DashHidden();
 
+  void SetOpacity(double opacity);
+  double GetOpacity();
+
   sigc::signal<void, PanelIndicatorEntryView*> on_indicator_updated;
 
 protected:
@@ -84,6 +90,7 @@
 private:
   typedef std::vector<indicator::Indicator::Ptr> Indicators;
   Indicators indicators_;
+  double opacity_;
 
   std::map<indicator::Indicator::Ptr, std::vector<sigc::connection>> indicators_connections_;
 };

=== modified file 'plugins/unityshell/src/PanelMenuView.cpp'
--- plugins/unityshell/src/PanelMenuView.cpp	2011-09-25 11:17:13 +0000
+++ plugins/unityshell/src/PanelMenuView.cpp	2011-09-28 09:56:29 +0000
@@ -46,6 +46,9 @@
 
 #define WINDOW_TITLE_FONT_KEY "/apps/metacity/general/titlebar_font"
 
+#define PANEL_ENTRIES_FADEIN 100
+#define PANEL_ENTRIES_FADEOUT 120
+
 namespace unity
 {
 
@@ -78,7 +81,9 @@
     _active_moved_id(0),
     _update_show_now_id(0),
     _place_shown_interest(0),
-    _place_hidden_interest(0)
+    _place_hidden_interest(0),
+    _fade_in_animator(NULL),
+    _fade_out_animator(NULL)
 {
   WindowManager* win_manager;
 
@@ -150,7 +155,19 @@
                                                          (UBusCallback)PanelMenuView::OnPlaceViewHidden,
                                                          this);
 
+  _fade_in_animator = new Animator(PANEL_ENTRIES_FADEIN);
+  _fade_out_animator = new Animator(PANEL_ENTRIES_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));
+  _fade_out_animator->animation_updated.connect(sigc::mem_fun(this, &PanelMenuView::OnFadeOutChanged));
+  _fade_out_animator->animation_ended.connect(sigc::mem_fun(this, &PanelMenuView::FullRedraw));
+
+  SetOpacity(0.0f);
+  _window_buttons->SetOpacity(0.0f);
+
   Refresh();
+  FullRedraw();
 }
 
 PanelMenuView::~PanelMenuView()
@@ -167,6 +184,12 @@
   if (_title_layer)
     delete _title_layer;
 
+  if (_fade_in_animator)
+    delete _fade_in_animator;
+
+  if (_fade_out_animator)
+    delete _fade_out_animator;
+
   _menu_layout->UnReference();
   _window_buttons->UnReference();
   _panel_titlebar_grab_area->UnReference();
@@ -311,6 +334,63 @@
 }
 
 void
+PanelMenuView::OnFadeInChanged(double opacity)
+{
+  if (DrawMenus() && GetOpacity() != 1.0f)
+    SetOpacity(opacity);
+
+  if (DrawWindowButtons() && _window_buttons->GetOpacity() != 1.0f)
+    _window_buttons->SetOpacity(opacity);
+
+  NeedRedraw();
+}
+
+void
+PanelMenuView::OnFadeOutChanged(double progress)
+{
+  double opacity = CLAMP(1.0f - progress, 0.0f, 1.0f);
+
+  if (!DrawMenus() && GetOpacity() != 0.0f)
+    SetOpacity(opacity);
+
+  if (!DrawWindowButtons() && _window_buttons->GetOpacity() != 0.0f)
+    _window_buttons->SetOpacity(opacity);
+
+  NeedRedraw();
+}
+
+bool
+PanelMenuView::DrawMenus()
+{
+  if (!_is_own_window && !_places_showing && _we_control_active)
+  {
+    if (_is_inside || _last_active_view || _show_now_activated)
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool
+PanelMenuView::DrawWindowButtons()
+{
+  if (_places_showing)
+    return true;
+
+  if (!_is_own_window && _we_control_active && _is_maximized)
+  {
+    if (_is_inside || _show_now_activated)
+    {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+void
 PanelMenuView::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   nux::Geometry geo = GetGeometry();
@@ -334,103 +414,155 @@
   rop.DstBlend = GL_ONE_MINUS_SRC_ALPHA;
 
   nux::ColorLayer layer(nux::Color(0x00000000), true, rop);
-  gPainter.PushDrawLayer(GfxContext, GetGeometry(), &layer);
-
-  if (_is_own_window || !_we_control_active || (_is_maximized && (_is_inside || _show_now_activated)))
-  {
-
-  }
-  else
-  {
-    bool have_valid_entries = false;
-    for (auto entry : entries_)
+  nux::GetPainter().PushDrawLayer(GfxContext, GetGeometry(), &layer);
+
+  if (_title_layer && !_is_own_window)
+  {
+    guint blend_alpha = 0, blend_src = 0, blend_dest = 0;
+    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)))
     {
-      if (entry.second->IsEntryValid())
+      for (auto entry : entries_)
       {
-        have_valid_entries = true;
-        break;
+        if (entry.second->IsEntryValid())
+        {
+          draw_faded_title = true;
+          break;
+        }
       }
     }
 
-    if ((_is_inside || _last_active_view || _show_now_activated) && have_valid_entries)
+    if (draw_faded_title)
     {
+      bool build_gradient = false;
+      nux::SURFACE_LOCKED_RECT lockrect;
+      bool locked = false;
+
       if (_gradient_texture.IsNull())
       {
+        build_gradient = true;
+      }
+      else
+      {
+        if (_gradient_texture->LockRect(0, &lockrect, NULL) != OGL_OK)
+          build_gradient = true;
+        else
+          locked = true;
+
+        if (!lockrect.pBits)
+        {
+          build_gradient = true;
+
+          if (locked)
+            _gradient_texture->UnlockRect(0);
+        }
+      }
+
+      if (build_gradient)
+      {
         nux::NTextureData texture_data(nux::BITFMT_R8G8B8A8, geo.width, 1, 1);
-        nux::ImageSurface surface = texture_data.GetSurface(0);
-        nux::SURFACE_LOCKED_RECT lockrect;
-        BYTE* dest;
-        int num_row;
-
-        _gradient_texture = nux::GetGraphicsDisplay()->GetGpuDevice()->CreateSystemCapableDeviceTexture(texture_data.GetWidth(), texture_data.GetHeight(), 1, texture_data.GetFormat());
-
-        _gradient_texture->LockRect(0, &lockrect, 0);
-
-        dest = (BYTE*) lockrect.pBits;
-        num_row = surface.GetBlockHeight();
-
-        for (int y = 0; y < num_row; y++)
-        {
-          for (int x = 0; x < geo.width; x++)
-          {
-            BYTE a;
-            if (x < button_width * (factor - 1))
-            {
-              a = 0xff;
-            }
-            else if (x < button_width * factor)
-            {
-              a = 255 - 255 * (((float)x - (button_width * (factor - 1))) / (float)(button_width));
-            }
-            else
-            {
-              a = 0x00;
-            }
-
-            *(dest + y * lockrect.Pitch + 4 * x + 0) = (223 * a) / 255; //red
-            *(dest + y * lockrect.Pitch + 4 * x + 1) = (219 * a) / 255; //green
-            *(dest + y * lockrect.Pitch + 4 * x + 2) = (210 * a) / 255; //blue
-            *(dest + y * lockrect.Pitch + 4 * x + 3) = a;
-          }
-        }
+
+        _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);
+      }
+
+      int gradient_opacity = 255.0f * GetOpacity();
+      BYTE* dest_buffer = (BYTE*) lockrect.pBits;
+
+      for (int x = 0; x < geo.width && dest_buffer && locked; x++)
+      {
+        BYTE a;
+        if (x < button_width * (factor - 1))
+        {
+          a = 0xff;
+        }
+        else if (x < button_width * factor)
+        {
+          a = 0xff - gradient_opacity * (((float)x - (button_width * (factor - 1))) / (float)(button_width));
+        }
+        else
+        {
+          if (!DrawMenus())
+          {
+            a = 0xff - gradient_opacity;
+          }
+          else if (0xff - gradient_opacity > 0x55)
+          {
+            // 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;
+          }
+        }
+
+        *(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 + 3) = a;
+      }
+
+      // FIXME Nux shouldn't make unity to crash if we try to unlock a wrong rect
+      if (locked)
         _gradient_texture->UnlockRect(0);
-      }
-      guint alpha = 0, src = 0, dest = 0;
 
-      GfxContext.GetRenderStates().GetBlend(alpha, src, dest);
       GfxContext.GetRenderStates().SetBlend(true, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
       nux::TexCoordXForm texxform0;
       nux::TexCoordXForm texxform1;
 
       // Modulate the checkboard and the gradient texture
-      if (_title_layer)
-        GfxContext.QRP_2TexMod(geo.x, geo.y,
-                               geo.width, geo.height,
-                               _gradient_texture, texxform0,
-                               nux::color::White,
-                               _title_layer->GetDeviceTexture(),
-                               texxform1,
-                               nux::color::White);
+      GfxContext.QRP_2TexMod(geo.x, geo.y,
+                             geo.width, geo.height,
+                             _gradient_texture, texxform0,
+                             nux::color::White,
+                             _title_layer->GetDeviceTexture(),
+                             texxform1,
+                             nux::color::White);
 
-      GfxContext.GetRenderStates().SetBlend(alpha, src, dest);
       // 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);
-      if (_title_layer)
-        gPainter.PushDrawLayer(GfxContext, geo, _title_layer);
+      nux::GetPainter().PushDrawLayer(GfxContext, geo, _title_layer);
       geo = GetGeometry();
     }
-    else
-    {
-      if (_title_layer)
-        gPainter.PushDrawLayer(GfxContext,
-                               geo,
-                               _title_layer);
-    }
+    else if (!_places_showing && _window_buttons->GetOpacity() < 1.0f && _window_buttons->GetOpacity() > 0.0f)
+    {
+      double title_opacity = 1.0f - _window_buttons->GetOpacity();
+      
+      if (!DrawWindowButtons())
+      {
+        // 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);
+      }
+      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);
+      }
+
+      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);
   }
 
-  gPainter.PopBackground();
+  nux::GetPainter().PopBackground();
 
   GfxContext.PopClippingRectangle();
 }
@@ -439,21 +571,54 @@
 PanelMenuView::DrawContent(nux::GraphicsEngine& GfxContext, bool force_draw)
 {
   nux::Geometry geo = GetGeometry();
+  bool draw_menus = DrawMenus();
+  bool draw_buttons = DrawWindowButtons();
 
   GfxContext.PushClippingRectangle(geo);
 
-  if (!_is_own_window && !_places_showing && _we_control_active)
-  {
-    if (_is_inside || _last_active_view || _show_now_activated)
-    {
-      _menu_layout->ProcessDraw(GfxContext, force_draw);
-    }
-  }
-
-  if ((!_is_own_window && _we_control_active && _is_maximized &&
-      (_is_inside || _show_now_activated)) || _places_showing)
-  {
-    _window_buttons->ProcessDraw(GfxContext, true);
+  if (draw_menus)
+  {
+    _menu_layout->ProcessDraw(GfxContext, true);
+
+    _fade_out_animator->Stop();
+    _fade_in_animator->Start(GetOpacity());
+  }
+
+  if (GetOpacity() != 0.0f && !draw_menus)
+  {
+    _menu_layout->ProcessDraw(GfxContext, true);
+
+    _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 (draw_buttons)
+  {
+    _window_buttons->ProcessDraw(GfxContext, true);
+
+    _fade_out_animator->Stop();
+    _fade_in_animator->Start(_window_buttons->GetOpacity());
+  }
+
+  if (_window_buttons->GetOpacity() != 0.0f && !draw_buttons)
+  {
+    _window_buttons->ProcessDraw(GfxContext, true);
+    _fade_in_animator->Stop();
+
+    /* 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());
+    }
   }
 
   GfxContext.PopClippingRectangle();
@@ -471,16 +636,21 @@
   if (BAMF_IS_WINDOW(window))
   {
     std::vector<Window> const& our_xids = nux::XInputWindow::NativeHandleList();
+    guint32 window_xid = bamf_window_get_xid(BAMF_WINDOW(window));
 
-    if (std::find(our_xids.begin(), our_xids.end(), bamf_window_get_xid(BAMF_WINDOW(window))) != our_xids.end())
+    if (std::find(our_xids.begin(), our_xids.end(), window_xid) != our_xids.end())
+    {
       _is_own_window = true;
-  }
-
-  if (_is_maximized)
-  {
-    BamfWindow* window = bamf_matcher_get_active_window(_matcher);
-
-    if (BAMF_IS_WINDOW(window))
+      return g_strdup("");
+    }
+
+    if (!WindowManager::Default()->IsWindowOnCurrentDesktop(window_xid) ||
+        WindowManager::Default()->IsWindowObscured(window_xid))
+    {
+      return g_strdup("");
+    }
+
+    if (_is_maximized)
       label = bamf_view_get_name(BAMF_VIEW(window));
   }
 
@@ -705,7 +875,7 @@
 void
 PanelMenuView::OnEntryAdded(unity::indicator::Entry::Ptr const& entry)
 {
-  auto view = AddEntry(entry, 6, IndicatorEntryPosition::END);
+  auto view = AddEntry(entry, 6, IndicatorEntryPosition::END, IndicatorEntryType::MENU);
 
   entry->show_now_changed.connect(sigc::mem_fun(this, &PanelMenuView::UpdateShowNow));
 
@@ -927,7 +1097,10 @@
 
     window = bamf_matcher_get_active_window(_matcher);
     if (BAMF_IS_WINDOW(window))
+    {
       WindowManager::Default()->Close(bamf_window_get_xid(window));
+      NeedRedraw();
+    }
   }
 }
 
@@ -945,7 +1118,10 @@
 
     window = bamf_matcher_get_active_window(_matcher);
     if (BAMF_IS_WINDOW(window))
+    {
       WindowManager::Default()->Minimize(bamf_window_get_xid(window));
+      NeedRedraw();
+    }
   }
 }
 
@@ -965,7 +1141,10 @@
 
     window = bamf_matcher_get_active_window(_matcher);
     if (BAMF_IS_WINDOW(window))
+    {
       WindowManager::Default()->Restore(bamf_window_get_xid(window));
+      NeedRedraw();
+    }
   }
 }
 
@@ -1113,6 +1292,7 @@
  * C code for callbacks
  */
 static void
+
 on_active_window_changed(BamfMatcher*   matcher,
                          BamfView*      old_view,
                          BamfView*      new_view,

=== modified file 'plugins/unityshell/src/PanelMenuView.h'
--- plugins/unityshell/src/PanelMenuView.h	2011-09-24 07:23:53 +0000
+++ plugins/unityshell/src/PanelMenuView.h	2011-09-28 09:56:29 +0000
@@ -30,6 +30,7 @@
 #include "WindowButtons.h"
 #include "PanelTitlebarGrabAreaView.h"
 #include "PluginAdapter.h"
+#include "Animator.h"
 
 #include <libbamf/libbamf.h>
 
@@ -112,6 +113,12 @@
   static gboolean UpdateActiveWindowPosition(PanelMenuView* self);
   static gboolean UpdateShowNowWithDelay(PanelMenuView* self);
 
+  bool DrawMenus();
+  bool DrawWindowButtons();
+
+  void OnFadeInChanged(double);
+  void OnFadeOutChanged(double);
+
 private:
   BamfMatcher* _matcher;
 
@@ -152,6 +159,9 @@
 
   guint32 _place_shown_interest;
   guint32 _place_hidden_interest;
+
+  Animator* _fade_in_animator;
+  Animator* _fade_out_animator;
 };
 
 }

=== modified file 'plugins/unityshell/src/PanelView.h'
--- plugins/unityshell/src/PanelView.h	2011-09-20 00:39:21 +0000
+++ plugins/unityshell/src/PanelView.h	2011-09-28 09:56:29 +0000
@@ -72,7 +72,7 @@
   void EndFirstMenuShow();
 
   void SetOpacity(float opacity);
-  
+
   void TrackMenuPointer();
 
   unsigned int GetTrayXid ();

=== modified file 'plugins/unityshell/src/WindowButtons.cpp'
--- plugins/unityshell/src/WindowButtons.cpp	2011-09-26 08:38:05 +0000
+++ plugins/unityshell/src/WindowButtons.cpp	2011-09-28 09:56:29 +0000
@@ -57,7 +57,8 @@
       _dash_is_open(false),
       _mouse_is_down(false),
       _place_shown_interest(0),
-      _place_hidden_interest(0)
+      _place_hidden_interest(0),
+      _opacity(1.0f)
   {
     LoadImages();
     UpdateDashUnmaximize();
@@ -104,7 +105,6 @@
     nux::TexCoordXForm texxform;
 
     GfxContext.PushClippingRectangle(geo);
-    nux::GetPainter().PaintBackground(GfxContext, geo);
 
     if (_dash_is_open)
     {
@@ -127,9 +127,6 @@
         tex = _normal_tex;
     }
 
-    GfxContext.GetRenderStates().SetBlend(true);
-    GfxContext.GetRenderStates().SetPremultipliedBlend(nux::SRC_OVER);
-    GfxContext.GetRenderStates().SetColorMask(true, true, true, true);
     if (tex)
       GfxContext.QRP_1Tex(geo.x,
                           geo.y,
@@ -137,8 +134,8 @@
                           (float)geo.height,
                           tex->GetDeviceTexture(),
                           texxform,
-                          nux::color::White);
-    GfxContext.GetRenderStates().SetBlend(false);
+                          nux::color::White * _opacity);
+
     GfxContext.PopClippingRectangle();
   }
 
@@ -220,6 +217,20 @@
     QueueDraw();
   }
 
+  void SetOpacity(double opacity)
+  {
+    if (_opacity != opacity)
+    {
+      _opacity = opacity;
+      NeedRedraw();
+    }
+  }
+
+  double GetOpacity()
+  {
+    return _opacity;
+  }
+
 private:
   PanelStyle::WindowButtonType _type;
   nux::BaseTexture* _normal_tex;
@@ -232,6 +243,7 @@
   bool _mouse_is_down;
   guint32 _place_shown_interest;
   guint32 _place_hidden_interest;
+  double _opacity;
 
   static void OnPlaceViewShown(GVariant* data, void* val)
   {
@@ -292,6 +304,7 @@
 
 WindowButtons::WindowButtons()
   : HLayout("", NUX_TRACKER_LOCATION)
+  , _opacity(1.0f)
 {
   WindowButton* but;
 
@@ -363,6 +376,32 @@
   return nux::HLayout::FindAreaUnderMouse(mouse_position, event_type);
 }
 
+void
+WindowButtons::SetOpacity(double opacity)
+{
+  opacity = CLAMP(opacity, 0.0f, 1.0f);
+
+  for (auto area : GetChildren())
+  {
+    auto but = dynamic_cast<WindowButton*>(area);
+
+    if (but)
+      but->SetOpacity(opacity);
+  }
+
+  if (_opacity != opacity)
+  {
+    _opacity = opacity;
+    NeedRedraw();
+  }
+}
+
+double
+WindowButtons::GetOpacity()
+{
+  return _opacity;
+}
+
 const gchar*
 WindowButtons::GetName()
 {

=== modified file 'plugins/unityshell/src/WindowButtons.h'
--- plugins/unityshell/src/WindowButtons.h	2011-09-02 14:46:22 +0000
+++ plugins/unityshell/src/WindowButtons.h	2011-09-28 09:56:29 +0000
@@ -25,7 +25,9 @@
 
 #include "Introspectable.h"
 
-class WindowButtons : public nux::HLayout, public unity::Introspectable
+namespace unity
+{
+class WindowButtons : public nux::HLayout, public Introspectable
 {
   // These are the [close][minimize][restore] buttons on the panel when there
   // is a maximized window
@@ -34,6 +36,9 @@
   WindowButtons();
   ~WindowButtons();
 
+  void SetOpacity(double opacity);
+  double GetOpacity();
+
   sigc::signal<void> close_clicked;
   sigc::signal<void> minimize_clicked;
   sigc::signal<void> restore_clicked;
@@ -52,6 +57,8 @@
   void OnCloseClicked(nux::View *view);
   void OnMinimizeClicked(nux::View *view);
   void OnRestoreClicked(nux::View *view);
+
+  double _opacity;
 };
-
+}
 #endif

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2011-09-23 23:02:51 +0000
+++ tests/CMakeLists.txt	2011-09-28 09:56:29 +0000
@@ -148,6 +148,8 @@
 #
 add_executable (test-panel
                 TestPanel.cpp
+                ${UNITY_SRC}/Animator.cpp
+                ${UNITY_SRC}/Animator.h
                 ${UNITY_SRC}/BackgroundEffectHelper.cpp
                 ${UNITY_SRC}/BackgroundEffectHelper.h
                 ${UNITY_SRC}/DashSettings.cpp
@@ -166,6 +168,8 @@
                 ${UNITY_SRC}/PanelTray.h
                 ${UNITY_SRC}/Introspectable.cpp
                 ${UNITY_SRC}/Introspectable.h
+                ${UNITY_SRC}/LauncherController.cpp
+                ${UNITY_SRC}/LauncherController.h
                 ${UNITY_SRC}/PanelMenuView.cpp
                 ${UNITY_SRC}/PanelMenuView.h
                 ${UNITY_SRC}/Timer.cpp