Merge lp:~brandontschaefer/unity/lp.1101310-fix-launcher-resize-window-buttons into lp:unity

[Brandon Schaefer]

=== Problem ===

When the launcher icons were resized the dash view would take up that extra space. The problem with this is the panel height is part of the dash view. So part of the window buttons are under the dash view which means no mouse events get to them. Meaning they no longer work :).

=== Fix ===

So to start, we can't fix this by telling the dash view to ignore the panel because the preview needs to draw over them. This means the dash view must be over the panel.

So the new fix, is to have the DashView/HudView hold the OverlayWindowButtons, which can now tell it to the area that is under the mouse. Making the buttons work again (yay!).

=== Test ===

There is an AP test

[Brandon Schaefer (brandontschaefer)]

To help with review, since most of the diff +/- is due to just moving the WindowButton* to unity-shared:

New class OverlayWindowButtons:
1156 === added file 'unity-shared/OverlayWindowButtons.cpp'
1237 === added file 'unity-shared/OverlayWindowButtons.h'

Test:
1094 === modified file 'tests/autopilot/unity/tests/test_panel.py'

DashView changes:
11 === modified file 'dash/DashView.cpp'

HudView changes:
159 === modified file 'hud/HudView.cpp'

Those are most of the real changes.

[Brandon Schaefer (brandontschaefer)]

Yay for me messing up the history of the branch....new one coming soon to fix this ridiculousness... (Rejected)

Unmerged revisions

3070. By Brandon Schaefer on 2013-01-28

* The main reason, is the DashView has to take up the PanelHeight, so when the
  launcher icons are resized, part of the window buttons get cut off from mouse events.
* Move WindowButtons over to unity-shared, it is now shared between the dash/hud/panel
* Created a class OverlayWindowButtons which will sit in the DashView/HudView
  to handle mouse events for the window buttons.
* TODO: We need to refactor the PanelMenuView to extract window button logic
  (dealing with overlays).

=== modified file 'dash/CMakeLists.txt'
--- dash/CMakeLists.txt	2012-12-19 20:53:12 +0000
+++ dash/CMakeLists.txt	2013-01-28 20:54:23 +0000
@@ -56,4 +56,4 @@
 # Standalone variant
 #
 add_executable (dash StandaloneDash.cpp)
-target_link_libraries (dash dash-lib unity-shared)
+target_link_libraries (dash dash-lib unity-shared unity-shared-standalone)

=== modified file 'dash/DashView.cpp'
--- dash/DashView.cpp	2013-01-15 21:53:55 +0000
+++ dash/DashView.cpp	2013-01-28 20:54:23 +0000
@@ -20,6 +20,7 @@
 
 #include "DashView.h"
 #include "DashViewPrivate.h"
+#include "FilterExpanderLabel.h"
 
 #include <math.h>
 
@@ -31,13 +32,12 @@
 #include <UnityCore/GLibWrapper.h>
 #include <UnityCore/RadioOptionFilter.h>
 
-#include "FilterExpanderLabel.h"
 #include "unity-shared/DashStyle.h"
 #include "unity-shared/KeyboardUtil.h"
-#include "unity-shared/UnitySettings.h"
-#include "unity-shared/UBusMessages.h"
 #include "unity-shared/PreviewStyle.h"
 #include "unity-shared/PanelStyle.h"
+#include "unity-shared/UBusMessages.h"
+#include "unity-shared/UnitySettings.h"
 
 namespace unity
 {
@@ -126,6 +126,7 @@
   , animate_split_value_(0.0)
   , animate_preview_container_value_(0.0)
   , animate_preview_value_(0.0)
+  , overlay_window_buttons_(new OverlayWindowButtons())
 {
   renderer_.SetOwner(this);
   renderer_.need_redraw.connect([this] () {
@@ -493,6 +494,8 @@
     ClosePreview();
   }
 
+  overlay_window_buttons_->AboutToShow();
+
   renderer_.AboutToShow();
 }
 
@@ -520,6 +523,8 @@
   {
     ClosePreview();
   }
+
+  overlay_window_buttons_->AboutToHide();
 }
 
 void DashView::SetupViews()
@@ -728,6 +733,8 @@
     nux::GetPainter().PopBackgroundStack();
   }
 
+  overlay_window_buttons_->QueueDraw();
+
   graphics_engine.PopClippingRectangle();
 
   renderer_.DrawInnerCleanup(graphics_engine, content_geo_, renderer_geo_abs, renderer_geo);
@@ -1089,11 +1096,6 @@
     geo.width += style.GetDashRightTileWidth();
     geo.height += style.GetDashBottomTileHeight();
   }
-
-  if (!geo.IsPointInside(x, y))
-  {
-    ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
-  }
 }
 
 void DashView::OnActivateRequest(GVariant* args)
@@ -1518,6 +1520,7 @@
   wrapper.add("right-border-width", style.GetDashRightTileWidth());
   wrapper.add("bottom-border-height", style.GetDashBottomTileHeight());
   wrapper.add("preview_displaying", preview_displaying_);
+  wrapper.add("dash_maximized", style.always_maximised());
 }
 
 nux::Area* DashView::KeyNavIteration(nux::KeyNavDirection direction)
@@ -1719,7 +1722,12 @@
 nux::Area* DashView::FindAreaUnderMouse(const nux::Point& mouse_position, nux::NuxEventType event_type)
 {
   nux::Area* view = nullptr;
-  if (preview_displaying_)
+
+  if (overlay_window_buttons_->GetGeometry().IsInside(mouse_position))
+  {
+    return overlay_window_buttons_->FindAreaUnderMouse(mouse_position, event_type);
+  }
+  else if (preview_displaying_)
   {
     nux::Point newpos = mouse_position;
     view = dynamic_cast<nux::Area*>(preview_container_.GetPointer())->FindAreaUnderMouse(newpos, event_type);

=== modified file 'dash/DashView.h'
--- dash/DashView.h	2012-12-17 09:28:31 +0000
+++ dash/DashView.h	2013-01-28 20:54:23 +0000
@@ -28,17 +28,20 @@
 #include <UnityCore/HomeLens.h>
 #include <UnityCore/GLibSource.h>
 
-#include "unity-shared/BackgroundEffectHelper.h"
-#include "unity-shared/SearchBar.h"
-#include "unity-shared/Introspectable.h"
-#include "unity-shared/BGHash.h"
 #include "LensBar.h"
 #include "LensView.h"
-#include "unity-shared/UBusWrapper.h"
-#include "unity-shared/OverlayRenderer.h"
-#include "UnityCore/Preview.h"
 #include "previews/PreviewContainer.h"
 #include "PreviewStateMachine.h"
+#include "UnityCore/Preview.h"
+
+#include "unity-shared/BackgroundEffectHelper.h"
+#include "unity-shared/BGHash.h"
+#include "unity-shared/Introspectable.h"
+#include "unity-shared/OverlayRenderer.h"
+#include "unity-shared/SearchBar.h"
+#include "unity-shared/UBusWrapper.h"
+#include "unity-shared/OverlayWindowButtons.h"
+
 
 namespace na = nux::animation;
 
@@ -185,6 +188,8 @@
 
   std::unique_ptr<na::AnimateValue<float>> preview_animation_;
   float animate_preview_value_;
+
+  nux::ObjectPtr<OverlayWindowButtons> overlay_window_buttons_;
 };
 
 

=== modified file 'hud/CMakeLists.txt'
--- hud/CMakeLists.txt	2012-12-19 20:53:12 +0000
+++ hud/CMakeLists.txt	2013-01-28 20:54:23 +0000
@@ -34,4 +34,4 @@
 # Standalone variant
 #
 add_executable (hud StandaloneHud.cpp)
-target_link_libraries (hud hud-lib unity-shared)
+target_link_libraries (hud hud-lib unity-shared unity-shared-standalone)

=== modified file 'hud/HudView.cpp'
--- hud/HudView.cpp	2013-01-09 13:17:04 +0000
+++ hud/HudView.cpp	2013-01-28 20:54:23 +0000
@@ -67,6 +67,7 @@
   , selected_button_(0)
   , show_embedded_icon_(true)
   , keyboard_stole_focus_(false)
+  , overlay_window_buttons_(new OverlayWindowButtons())
 {
   renderer_.SetOwner(this);
   renderer_.need_redraw.connect([this] () {
@@ -345,12 +346,14 @@
 void View::AboutToShow()
 {
   visible_ = true;
+  overlay_window_buttons_->AboutToShow();
   renderer_.AboutToShow();
 }
 
 void View::AboutToHide()
 {
   visible_ = false;
+  overlay_window_buttons_->AboutToHide();
   renderer_.AboutToHide();
 }
 
@@ -484,6 +487,9 @@
   {
     GetLayout()->ProcessDraw(gfx_context, force_draw);
   }
+
+  overlay_window_buttons_->QueueDraw();
+
   gfx_context.PopClippingRectangle();
 
   renderer_.DrawInnerCleanup(gfx_context, draw_content_geo, GetAbsoluteGeometry(), GetGeometry());

=== modified file 'hud/HudView.h'
--- hud/HudView.h	2012-11-28 14:23:01 +0000
+++ hud/HudView.h	2013-01-28 20:54:23 +0000
@@ -29,6 +29,7 @@
 #include "HudButton.h"
 #include "HudAbstractView.h"
 #include "unity-shared/OverlayRenderer.h"
+#include "unity-shared/OverlayWindowButtons.h"
 #include "unity-shared/SearchBar.h"
 #include "unity-shared/UBusWrapper.h"
 
@@ -121,6 +122,8 @@
   bool show_embedded_icon_;
   bool activated_signal_sent_;
   bool keyboard_stole_focus_;
+
+  nux::ObjectPtr<OverlayWindowButtons> overlay_window_buttons_;
 };
 
 

=== modified file 'panel/CMakeLists.txt'
--- panel/CMakeLists.txt	2012-12-19 20:53:12 +0000
+++ panel/CMakeLists.txt	2013-01-28 20:54:23 +0000
@@ -24,7 +24,6 @@
      PanelTitlebarGrabAreaView.cpp
      PanelTray.cpp
      PanelView.cpp
-     WindowButtons.cpp
      )
 
 add_library (panel-lib STATIC ${PANEL_SOURCES})

=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2013-01-09 14:16:07 +0000
+++ panel/PanelMenuView.cpp	2013-01-28 20:54:23 +0000
@@ -356,8 +356,9 @@
   WindowManager& wm = WindowManager::Default();
   bool screen_grabbed = (wm.IsExpoActive() || wm.IsScaleActive());
 
+  // TODO: We need to refactor this code to extract the window button logic
   if (overlay_showing_)
-    return true;
+    return false;
 
   if (we_control_active_ && is_maximized_ && !screen_grabbed &&
       !launcher_keynav_ && !switcher_showing_)

=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2012-12-12 18:07:08 +0000
+++ panel/PanelMenuView.h	2013-01-28 20:54:23 +0000
@@ -28,7 +28,7 @@
 
 #include "PanelIndicatorsView.h"
 #include "unity-shared/StaticCairoText.h"
-#include "WindowButtons.h"
+#include "unity-shared/WindowButtons.h"
 #include "PanelTitlebarGrabAreaView.h"
 #include "unity-shared/UBusWrapper.h"
 

=== removed file 'panel/WindowButtonPriv.h'
--- panel/WindowButtonPriv.h	2012-12-14 14:41:16 +0000
+++ panel/WindowButtonPriv.h	1970-01-01 00:00:00 +0000
@@ -1,84 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
- *              Marco Trevisan (Treviño) <[e-mail]>
- */
-
-#ifndef WINDOW_BUTTON_PRIVATE_H
-#define WINDOW_BUTTON_PRIVATE_H
-
-#include <Nux/Button.h>
-
-#include "unity-shared/PanelStyle.h"
-#include "unity-shared/UBusWrapper.h"
-#include "unity-shared/Introspectable.h"
-
-namespace unity
-{
-class WindowButtons;
-
-namespace internal
-{
-
-class WindowButton : public nux::Button, public debug::Introspectable
-{
-  // A single window button
-public:
-  WindowButton(panel::WindowButtonType type);
-
-  panel::WindowButtonType GetType() const;
-  void SetVisualState(nux::ButtonVisualState new_state);
-
-  nux::RWProperty<bool> enabled;
-  nux::Property<bool> overlay_mode;
-
-protected:
-  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
-  std::string GetName() const;
-  void AddProperties(GVariantBuilder* builder);
-
-private:
-  void UpdateSize();
-  void LoadImages();
-  bool EnabledSetter(bool enabled);
-  static nux::ObjectPtr<nux::BaseTexture> GetDashWindowButton(panel::WindowButtonType type, panel::WindowState state);
-
-  inline WindowButtons* Parent() const
-  {
-    return static_cast<WindowButtons*>(GetParentObject());
-  }
-
-private:
-  panel::WindowButtonType type_;
-
-  nux::ObjectPtr<nux::BaseTexture> normal_tex_;
-  nux::ObjectPtr<nux::BaseTexture> prelight_tex_;
-  nux::ObjectPtr<nux::BaseTexture> pressed_tex_;
-  nux::ObjectPtr<nux::BaseTexture> unfocused_tex_;
-  nux::ObjectPtr<nux::BaseTexture> unfocused_prelight_tex_;
-  nux::ObjectPtr<nux::BaseTexture> unfocused_pressed_tex_;
-  nux::ObjectPtr<nux::BaseTexture> disabled_tex_;
-  nux::ObjectPtr<nux::BaseTexture> normal_dash_tex_;
-  nux::ObjectPtr<nux::BaseTexture> prelight_dash_tex_;
-  nux::ObjectPtr<nux::BaseTexture> pressed_dash_tex_;
-  nux::ObjectPtr<nux::BaseTexture> disabled_dash_tex_;
-};
-
-} // internal namespace
-} // unity namespace
-
-#endif // WINDOW_BUTTON_PRIVATE_H

=== removed file 'panel/WindowButtons.cpp'
--- panel/WindowButtons.cpp	2012-12-17 19:35:34 +0000
+++ panel/WindowButtons.cpp	1970-01-01 00:00:00 +0000
@@ -1,662 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
- *              Marco Trevisan (Treviño) <[e-mail]>
- */
-
-#include "config.h"
-
-#include <Nux/Nux.h>
-#include <array>
-
-#include <UnityCore/GLibWrapper.h>
-#include <UnityCore/Variant.h>
-
-#include "WindowButtons.h"
-#include "WindowButtonPriv.h"
-
-#include "unity-shared/UBusMessages.h"
-#include "unity-shared/WindowManager.h"
-
-namespace unity
-{
-
-namespace internal
-{
-WindowButton::WindowButton(panel::WindowButtonType type)
-  : nux::Button("", NUX_TRACKER_LOCATION)
-  , enabled(sigc::mem_fun(this, &WindowButton::IsViewEnabled),
-            sigc::mem_fun(this, &WindowButton::EnabledSetter))
-  , overlay_mode(false)
-  , type_(type)
-{
-  overlay_mode.changed.connect([this] (bool) { UpdateSize(); QueueDraw(); });
-  SetAcceptKeyNavFocusOnMouseDown(false);
-  panel::Style::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::LoadImages));
-  LoadImages();
-}
-
-void WindowButton::SetVisualState(nux::ButtonVisualState new_state)
-{
-  if (new_state != visual_state_)
-  {
-    visual_state_ = new_state;
-    QueueDraw();
-  }
-}
-
-void WindowButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
-{
-  nux::Geometry const& geo = GetGeometry();
-  nux::BaseTexture* tex = nullptr;
-
-  GfxContext.PushClippingRectangle(geo);
-
-  if (overlay_mode())
-  {
-    if (!enabled())
-    {
-      tex = disabled_dash_tex_.GetPointer();
-    }
-    else
-    {
-      switch (visual_state_)
-      {
-        case nux::VISUAL_STATE_PRESSED:
-          tex = pressed_dash_tex_.GetPointer();
-          break;
-        case nux::VISUAL_STATE_PRELIGHT:
-          tex = prelight_dash_tex_.GetPointer();
-          break;
-        default:
-          tex = normal_dash_tex_.GetPointer();
-      }
-    }
-  }
-  else if (!enabled())
-  {
-    tex = disabled_tex_.GetPointer();
-  }
-  else if (!Parent()->focused())
-  {
-    switch (visual_state_)
-    {
-      case nux::VISUAL_STATE_PRESSED:
-        tex = unfocused_pressed_tex_.GetPointer();
-        break;
-      case nux::VISUAL_STATE_PRELIGHT:
-        tex = unfocused_prelight_tex_.GetPointer();
-        break;
-      default:
-        tex = unfocused_tex_.GetPointer();
-    }
-  }
-  else
-  {
-    switch (visual_state_)
-    {
-      case nux::VISUAL_STATE_PRESSED:
-        tex = pressed_tex_.GetPointer();
-        break;
-      case nux::VISUAL_STATE_PRELIGHT:
-        tex = prelight_tex_.GetPointer();
-        break;
-      default:
-        tex = normal_tex_.GetPointer();
-    }
-  }
-
-  if (tex)
-  {
-    nux::TexCoordXForm texxform;
-    GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
-                        tex->GetDeviceTexture(), texxform,
-                        nux::color::White * Parent()->opacity());
-  }
-
-  GfxContext.PopClippingRectangle();
-}
-
-void WindowButton::UpdateSize()
-{
-  int panel_height = panel::Style::Instance().panel_height;
-  nux::BaseTexture* tex;
-  tex = (overlay_mode()) ? normal_dash_tex_.GetPointer() : normal_tex_.GetPointer();
-  int width = 0;
-  int height = 0;
-
-  if (tex)
-  {
-    width = std::min(panel_height, tex->GetWidth());
-    height = std::min(panel_height, tex->GetHeight());
-  }
-
-  SetMinMaxSize(width, height);
-}
-
-void WindowButton::LoadImages()
-{
-  panel::Style& style = panel::Style::Instance();
-
-  normal_tex_ = style.GetWindowButton(type_, panel::WindowState::NORMAL);
-  prelight_tex_ = style.GetWindowButton(type_, panel::WindowState::PRELIGHT);
-  pressed_tex_ = style.GetWindowButton(type_, panel::WindowState::PRESSED);
-  unfocused_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED);
-  disabled_tex_ = style.GetWindowButton(type_, panel::WindowState::DISABLED);
-  unfocused_prelight_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED_PRELIGHT);
-  unfocused_pressed_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED_PRESSED);
-  normal_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::NORMAL);
-  prelight_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::PRELIGHT);
-  pressed_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::PRESSED);
-  disabled_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::DISABLED);
-
-  UpdateSize();
-  QueueDraw();
-}
-
-nux::ObjectPtr<nux::BaseTexture> WindowButton::GetDashWindowButton(panel::WindowButtonType type, panel::WindowState state)
-{
-  nux::ObjectPtr<nux::BaseTexture> texture;
-  static const std::array<std::string, 4> names = {{ "close_dash", "minimize_dash", "unmaximize_dash", "maximize_dash" }};
-  static const std::array<std::string, 4> states = {{ "", "_prelight", "_pressed", "_disabled" }};
-
-  std::string subpath = names[static_cast<int>(type)] + states[static_cast<int>(state)] + ".png";
-
-  glib::String filename(g_build_filename(PKGDATADIR, subpath.c_str(), NULL));
-  texture.Adopt(nux::CreateTexture2DFromFile(filename, -1, true));
-
-  if (!texture)
-    texture = panel::Style::Instance().GetFallbackWindowButton(type, state);
-
-  return texture;
-}
-
-panel::WindowButtonType WindowButton::GetType() const
-{
-  return type_;
-}
-
-bool WindowButton::EnabledSetter(bool new_value)
-{
-  if (enabled() == new_value)
-    return false;
-
-  SetEnableView(new_value);
-  QueueDraw();
-  return true;
-}
-
-std::string WindowButton::GetName() const
-{
-  return "WindowButton";
-}
-
-void WindowButton::AddProperties(GVariantBuilder* builder)
-{
-  std::string type_name;
-  std::string state_name;
-
-  switch (type_)
-  {
-    case panel::WindowButtonType::CLOSE:
-      type_name = "Close";
-      break;
-    case panel::WindowButtonType::MINIMIZE:
-      type_name = "Minimize";
-      break;
-    case panel::WindowButtonType::MAXIMIZE:
-      type_name = "Maximize";
-      break;
-    case panel::WindowButtonType::UNMAXIMIZE:
-      type_name = "Unmaximize";
-      break;
-  }
-
-  switch (visual_state_)
-  {
-    case nux::VISUAL_STATE_PRESSED:
-      state_name = "pressed";
-      break;
-    case nux::VISUAL_STATE_PRELIGHT:
-      state_name = "prelight";
-      break;
-    default:
-      state_name = "normal";
-  }
-
-  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry())
-                                  .add("type", type_name)
-                                  .add("visible", IsVisible() && Parent()->opacity() != 0.0f)
-                                  .add("sensitive", Parent()->GetInputEventSensitivity())
-                                  .add("enabled", enabled())
-                                  .add("visual_state", state_name)
-                                  .add("opacity", Parent()->opacity())
-                                  .add("focused", Parent()->focused())
-                                  .add("overlay_mode", overlay_mode());
-}
-} // Internal Namespace
-
-
-WindowButtons::WindowButtons()
-  : HLayout("", NUX_TRACKER_LOCATION)
-  , monitor(0)
-  , controlled_window(0)
-  , opacity(1.0f, sigc::mem_fun(this, &WindowButtons::OpacitySetter))
-  , focused(true)
-{
-  controlled_window.changed.connect(sigc::mem_fun(this, &WindowButtons::OnControlledWindowChanged));
-  focused.changed.connect(sigc::hide(sigc::mem_fun(this, &WindowButtons::QueueDraw)));
-
-  auto lambda_enter = [&](int x, int y, unsigned long button_flags, unsigned long key_flags)
-  {
-    mouse_enter.emit(x, y, button_flags, key_flags);
-  };
-
-  auto lambda_leave = [&](int x, int y, unsigned long button_flags, unsigned long key_flags)
-  {
-    mouse_leave.emit(x, y, button_flags, key_flags);
-  };
-
-  auto lambda_moved = [&](int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
-  {
-    mouse_move.emit(x, y, dx, dy, button_flags, key_flags);
-  };
-
-  internal::WindowButton* but;
-  but = new internal::WindowButton(panel::WindowButtonType::CLOSE);
-  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
-  AddChild(but);
-  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnCloseClicked));
-  but->mouse_enter.connect(lambda_enter);
-  but->mouse_leave.connect(lambda_leave);
-  but->mouse_move.connect(lambda_moved);
-
-  but = new internal::WindowButton(panel::WindowButtonType::MINIMIZE);
-  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
-  AddChild(but);
-  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMinimizeClicked));
-  but->mouse_enter.connect(lambda_enter);
-  but->mouse_leave.connect(lambda_leave);
-  but->mouse_move.connect(lambda_moved);
-
-  but = new internal::WindowButton(panel::WindowButtonType::UNMAXIMIZE);
-  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
-  AddChild(but);
-  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnRestoreClicked));
-  but->mouse_enter.connect(lambda_enter);
-  but->mouse_leave.connect(lambda_leave);
-  but->mouse_move.connect(lambda_moved);
-
-  but = new internal::WindowButton(panel::WindowButtonType::MAXIMIZE);
-  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
-  AddChild(but);
-  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMaximizeClicked));
-  but->mouse_enter.connect(lambda_enter);
-  but->mouse_leave.connect(lambda_leave);
-  but->mouse_move.connect(lambda_moved);
-  but->SetVisible(false);
-
-  SetContentDistribution(nux::MAJOR_POSITION_START);
-
-  ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &WindowButtons::OnOverlayShown));
-  ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &WindowButtons::OnOverlayHidden));
-  Settings::Instance().form_factor.changed.connect(sigc::mem_fun(this, &WindowButtons::OnDashSettingsUpdated));
-}
-
-nux::Area* WindowButtons::FindAreaUnderMouse(const nux::Point& mouse, nux::NuxEventType event_type)
-{
-  if (!GetInputEventSensitivity())
-    return nullptr;
-
-  /* The first button should be clickable on the left space too, to
-   * make Fitts happy. All also on their top side. See bug #839690 */
-  bool first_found = false;
-
-  for (auto area : GetChildren())
-  {
-    if (area->IsVisible())
-    {
-      nux::Geometry const& geo = area->GetAbsoluteGeometry();
-
-      if (!first_found)
-      {
-        first_found = true;
-
-        if (mouse.x < geo.x && mouse.y < (geo.y + geo.height))
-          return area;
-      }
-
-      if (geo.IsPointInside(mouse.x, mouse.y))
-        return area;
-
-      if (mouse.x >= geo.x && mouse.x <= (geo.x + geo.width) && mouse.y <= geo.y)
-        return area;
-    }
-  }
-
-  return nullptr;
-}
-
-void WindowButtons::OnCloseClicked(nux::Button *button)
-{
-  auto win_button = dynamic_cast<internal::WindowButton*>(button);
-
-  if (!win_button || !win_button->enabled())
-    return;
-
-  if (win_button->overlay_mode())
-  {
-    ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
-  }
-  else
-  {
-    WindowManager::Default().Close(controlled_window());
-  }
-
-  close_clicked.emit();
-}
-
-void WindowButtons::OnMinimizeClicked(nux::Button *button)
-{
-  auto win_button = dynamic_cast<internal::WindowButton*>(button);
-
-  if (!win_button || !win_button->enabled())
-    return;
-
-  if (!win_button->overlay_mode())
-    WindowManager::Default().Minimize(controlled_window());
-
-  minimize_clicked.emit();
-}
-
-void WindowButtons::OnRestoreClicked(nux::Button *button)
-{
-  auto win_button = dynamic_cast<internal::WindowButton*>(button);
-
-  if (!win_button || !win_button->enabled())
-    return;
-
-  if (win_button->overlay_mode())
-  {
-    Settings::Instance().form_factor = FormFactor::DESKTOP;
-  }
-  else
-  {
-    WindowManager& wm = WindowManager::Default();
-    Window to_restore = controlled_window();
-
-    wm.Raise(to_restore);
-    wm.Activate(to_restore);
-    wm.Restore(to_restore);
-  }
-
-  restore_clicked.emit();
-}
-
-void WindowButtons::OnMaximizeClicked(nux::Button *button)
-{
-  auto win_button = dynamic_cast<internal::WindowButton*>(button);
-
-  if (!win_button || !win_button->enabled())
-    return;
-
-  if (win_button->overlay_mode())
-  {
-    Settings::Instance().form_factor = FormFactor::NETBOOK;
-  }
-
-  maximize_clicked.emit();
-}
-
-void WindowButtons::OnOverlayShown(GVariant* data)
-{
-  internal::WindowButton* maximize_button = nullptr;
-  internal::WindowButton* restore_button = nullptr;
-  glib::String overlay_identity;
-  gboolean can_maximise = FALSE;
-  gint32 overlay_monitor = 0;
-  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
-                &overlay_identity, &can_maximise, &overlay_monitor);
-
-  if (overlay_monitor != monitor())
-  {
-    for (auto area : GetChildren())
-    {
-      auto button = dynamic_cast<internal::WindowButton*>(area);
-
-      if (button)
-        button->enabled = false;
-    }
-
-    return;
-  }
-
-  active_overlay_ = overlay_identity.Str();
-
-  for (auto area : GetChildren())
-  {
-    auto button = dynamic_cast<internal::WindowButton*>(area);
-
-    if (button)
-    {
-      if (button->GetType() == panel::WindowButtonType::CLOSE)
-        button->enabled = true;
-
-      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
-        restore_button = button;
-
-      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
-        maximize_button = button;
-
-      if (button->GetType() == panel::WindowButtonType::MINIMIZE)
-        button->enabled = false;
-
-      button->overlay_mode = true;
-    }
-  }
-
-  if (restore_button && maximize_button)
-  {
-    Settings &dash_settings = Settings::Instance();
-    bool maximizable = (dash_settings.form_factor() == FormFactor::DESKTOP);
-
-    restore_button->enabled = can_maximise;
-    maximize_button->enabled = can_maximise;
-
-    if (maximizable != maximize_button->IsVisible())
-    {
-      if (maximize_button->IsVisible())
-        restore_button->SetVisualState(maximize_button->GetVisualState());
-      else if (restore_button->IsVisible())
-        maximize_button->SetVisualState(restore_button->GetVisualState());
-
-      restore_button->SetVisible(!maximizable);
-      maximize_button->SetVisible(maximizable);
-
-      QueueDraw();
-    }
-  }
-}
-
-void WindowButtons::OnOverlayHidden(GVariant* data)
-{
-  internal::WindowButton* maximize_button = nullptr;
-  internal::WindowButton* restore_button = nullptr;
-
-  glib::String overlay_identity;
-  gboolean can_maximise = FALSE;
-  gint32 overlay_monitor = 0;
-  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
-                &overlay_identity, &can_maximise, &overlay_monitor);
-
-  if (overlay_monitor != monitor())
-  {
-    for (auto area : GetChildren())
-    {
-      auto button = dynamic_cast<internal::WindowButton*>(area);
-
-      if (button)
-        button->enabled = true;
-    }
-  }
-
-  if (active_overlay_ != overlay_identity.Str())
-    return;
-
-  active_overlay_ = "";
-
-  WindowManager& wm = WindowManager::Default();
-  for (auto area : GetChildren())
-  {
-    auto button = dynamic_cast<internal::WindowButton*>(area);
-
-    if (button)
-    {
-      if (controlled_window())
-      {
-        if (button->GetType() == panel::WindowButtonType::CLOSE)
-          button->enabled = wm.IsWindowClosable(controlled_window());
-
-        if (button->GetType() == panel::WindowButtonType::MINIMIZE)
-          button->enabled = wm.IsWindowMinimizable(controlled_window());
-      }
-
-      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
-        restore_button = button;
-
-      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
-        maximize_button = button;
-
-      button->overlay_mode = false;
-    }
-  }
-
-  if (restore_button && maximize_button)
-  {
-    restore_button->enabled = true;
-    maximize_button->enabled = true;
-
-    if (!restore_button->IsVisible())
-    {
-      restore_button->SetVisualState(maximize_button->GetVisualState());
-
-      restore_button->SetVisible(true);
-      maximize_button->SetVisible(false);
-
-      QueueDraw();
-    }
-  }
-}
-
-void WindowButtons::OnDashSettingsUpdated(FormFactor form_factor)
-{
-  internal::WindowButton* maximize_button = nullptr;
-  internal::WindowButton* restore_button = nullptr;
-
-  for (auto area : GetChildren())
-  {
-    auto button = dynamic_cast<internal::WindowButton*>(area);
-
-    if (button)
-    {
-      if (!button->overlay_mode())
-        break;
-
-      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
-        restore_button = button;
-
-      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
-        maximize_button = button;
-
-      if (restore_button && maximize_button)
-        break;
-    }
-  }
-
-  if (restore_button && restore_button->overlay_mode() && maximize_button)
-  {
-    bool maximizable = (form_factor == FormFactor::DESKTOP);
-
-    if (maximizable != maximize_button->IsVisible())
-    {
-      if (maximize_button->IsVisible())
-        restore_button->SetVisualState(maximize_button->GetVisualState());
-      else if (restore_button->IsVisible())
-        maximize_button->SetVisualState(restore_button->GetVisualState());
-
-      restore_button->SetVisible(!maximizable);
-      maximize_button->SetVisible(maximizable);
-
-      QueueRelayout();
-    }
-  }
-}
-
-bool WindowButtons::OpacitySetter(double& target, double new_value)
-{
-  double opacity = CLAMP(new_value, 0.0f, 1.0f);
-
-  if (opacity != target)
-  {
-    target = opacity;
-    SetInputEventSensitivity(opacity != 0.0f);
-    QueueDraw();
-
-    return true;
-  }
-
-  return false;
-}
-
-void WindowButtons::OnControlledWindowChanged(Window xid)
-{
-  if (xid && active_overlay_.empty())
-  {
-    WindowManager& wm = WindowManager::Default();
-    for (auto area : GetChildren())
-    {
-      auto button = dynamic_cast<internal::WindowButton*>(area);
-
-      if (!button)
-        continue;
-
-      if (button->GetType() == panel::WindowButtonType::CLOSE)
-        button->enabled = wm.IsWindowClosable(xid);
-
-      if (button->GetType() == panel::WindowButtonType::MINIMIZE)
-        button->enabled = wm.IsWindowMinimizable(xid);
-    }
-  }
-}
-
-std::string WindowButtons::GetName() const
-{
-  return "WindowButtons";
-}
-
-void WindowButtons::AddProperties(GVariantBuilder* builder)
-{
-  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry())
-                                  .add("monitor", monitor())
-                                  .add("opacity", opacity())
-                                  .add("visible", opacity() != 0.0f)
-                                  .add("sensitive", GetInputEventSensitivity())
-                                  .add("focused", focused())
-                                  .add("controlled_window", controlled_window());
-}
-
-} // unity namespace

=== removed file 'panel/WindowButtons.h'
--- panel/WindowButtons.h	2012-12-14 17:19:44 +0000
+++ panel/WindowButtons.h	1970-01-01 00:00:00 +0000
@@ -1,76 +0,0 @@
-// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
-/*
- * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
- *              Marco Trevisan (Treviño) <[e-mail]>
- */
-
-#ifndef WINDOW_BUTTONS_H
-#define WINDOW_BUTTONS_H
-
-#include <Nux/HLayout.h>
-#include <Nux/Button.h>
-
-#include "unity-shared/Introspectable.h"
-#include "unity-shared/UBusWrapper.h"
-#include "unity-shared/UnitySettings.h"
-
-namespace unity
-{
-class WindowButtons : public nux::HLayout, public debug::Introspectable
-{
-  // These are the [close][minimize][restore] buttons on the panel when there
-  // is a maximized window
-
-public:
-  WindowButtons();
-
-  nux::Property<int> monitor;
-  nux::Property<Window> controlled_window;
-  nux::Property<double> opacity;
-  nux::Property<bool> focused;
-
-  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_pos, nux::NuxEventType event_type);
-
-  sigc::signal<void> close_clicked;
-  sigc::signal<void> minimize_clicked;
-  sigc::signal<void> restore_clicked;
-  sigc::signal<void> maximize_clicked;
-  sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_move;
-  sigc::signal<void, int, int, unsigned long, unsigned long> mouse_enter;
-  sigc::signal<void, int, int, unsigned long, unsigned long> mouse_leave;
-
-protected:
-  std::string GetName() const;
-  void AddProperties(GVariantBuilder* builder);
-
-private:
-  void OnCloseClicked(nux::Button *button);
-  void OnMinimizeClicked(nux::Button *button);
-  void OnRestoreClicked(nux::Button *button);
-  void OnMaximizeClicked(nux::Button *button);
-  void OnOverlayShown(GVariant* data);
-  void OnOverlayHidden(GVariant* data);
-  void OnDashSettingsUpdated(FormFactor form_factor);
-  void OnControlledWindowChanged(Window xid);
-  bool OpacitySetter(double& target, double new_value);
-
-  std::string active_overlay_;
-  UBusManager ubus_manager_;
-};
-}
-
-#endif

=== modified file 'tests/autopilot/unity/tests/test_panel.py'
--- tests/autopilot/unity/tests/test_panel.py	2013-01-25 09:49:47 +0000
+++ tests/autopilot/unity/tests/test_panel.py	2013-01-28 20:54:23 +0000
@@ -298,6 +298,22 @@
         self.assertThat(self.panel.window_buttons_shown, Eventually(Equals(True)))
         self.assertWinButtonsInOverlayMode(True)
 
+    def test_window_buttons_work_in_dash_after_launcher_resize(self):
+        """When the launcher icons are resized, the window
+        buttons must still work in the dash."""
+
+        self.set_unity_option("icon_size", 25)
+        self.dash.ensure_visible()
+        self.addCleanup(self.dash.ensure_hidden)
+
+        dash_max = self.dash.view.dash_maximized
+        if dash_max:
+            self.panel.window_buttons.maximize.mouse_click()
+        else:
+            self.panel.window_buttons.unmaximize.mouse_click()
+
+        self.assertThat(dash_max, Eventually(Equals(self.dash.view.dash_maximized)))
+
     def test_window_buttons_show_with_hud(self):
         """Window buttons must be shown when the HUD is open."""
         self.hud.ensure_visible()

=== modified file 'tests/test_window_buttons.cpp'
--- tests/test_window_buttons.cpp	2012-12-14 17:19:44 +0000
+++ tests/test_window_buttons.cpp	2013-01-28 20:54:23 +0000
@@ -24,8 +24,8 @@
 #include "PanelStyle.h"
 #include "StandaloneWindowManager.h"
 #include "UnitySettings.h"
-#include "WindowButtons.h"
-#include "WindowButtonPriv.h"
+#include "unity-shared/WindowButtons.h"
+#include "unity-shared/WindowButtonPriv.h"
 
 namespace unity
 {

=== modified file 'unity-shared/CMakeLists.txt'
--- unity-shared/CMakeLists.txt	2012-12-19 20:53:12 +0000
+++ unity-shared/CMakeLists.txt	2013-01-28 20:54:23 +0000
@@ -39,6 +39,7 @@
      LayoutSystem.cpp
      LineSeparator.cpp
      OverlayRenderer.cpp
+     OverlayWindowButtons.cpp
      PanelStyle.cpp
      PlacesVScrollBar.cpp
      PlacesOverlayVScrollBar.cpp
@@ -61,6 +62,7 @@
      UnityWindowView.cpp
      UserThumbnailProvider.cpp
      VScrollBarOverlayWindow.cpp
+     WindowButtons.cpp
      WindowManager.cpp
      XPathQueryPart.cpp
 )

=== added file 'unity-shared/OverlayWindowButtons.cpp'
--- unity-shared/OverlayWindowButtons.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/OverlayWindowButtons.cpp	2013-01-28 20:54:23 +0000
@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Brandon Schaefer <[e-mail]>
+ *
+ */
+
+#include "OverlayWindowButtons.h"
+#include "PanelStyle.h"
+#include "UScreen.h"
+
+const int MAIN_LEFT_PADDING = 4;
+const int MENUBAR_PADDING = 4;
+
+namespace unity
+{
+
+OverlayWindowButtons::OverlayWindowButtons()
+  : nux::BaseWindow("OverlayWindowButtons")
+  , window_buttons_(new WindowButtons())
+{
+  UpdateGeometry();
+  SetBackgroundColor(nux::color::Transparent);
+}
+
+void OverlayWindowButtons::UpdateGeometry()
+{
+  int monitor = unity::UScreen::GetDefault()->GetMonitorWithMouse();
+  nux::Geometry const& geo = unity::UScreen::GetDefault()->GetMonitorGeometry(monitor);
+
+  SetX(geo.x + MAIN_LEFT_PADDING);
+  SetY(geo.y + MENUBAR_PADDING);
+  SetHeight(panel::Style::Instance().panel_height);
+
+  window_buttons_->monitor = monitor;
+}
+
+void OverlayWindowButtons::AboutToShow()
+{
+  UpdateGeometry();
+  ShowWindow(true);
+  PushToFront();
+  QueueDraw();
+}
+
+void OverlayWindowButtons::AboutToHide()
+{
+  ShowWindow(false);
+  PushToBack();
+  QueueDraw();
+}
+
+nux::Area* OverlayWindowButtons::FindAreaUnderMouse(nux::Point const& mouse_position,
+                                                 nux::NuxEventType event_type)
+{
+  return window_buttons_->FindAreaUnderMouse(mouse_position, event_type);
+}
+
+void OverlayWindowButtons::Draw(nux::GraphicsEngine& gfx_context, bool force_draw)
+{
+  window_buttons_->ProcessDraw(gfx_context, true);
+}
+
+} // namespace unity

=== added file 'unity-shared/OverlayWindowButtons.h'
--- unity-shared/OverlayWindowButtons.h	1970-01-01 00:00:00 +0000
+++ unity-shared/OverlayWindowButtons.h	2013-01-28 20:54:23 +0000
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2010 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Brandon Schaefer <[e-mail]>
+ *
+ */
+
+#ifndef OVERLAY_WINDOW_BUTTONS
+#define OVERLAY_WINDOW_BUTTONS
+
+#include "Nux/Nux.h"
+#include "Nux/BaseWindow.h"
+
+#include "WindowButtons.h"
+
+namespace unity
+{
+
+class OverlayWindowButtons : public nux::BaseWindow
+{
+public:
+  OverlayWindowButtons();
+
+  void AboutToShow();
+  void AboutToHide();
+
+  nux::Area* FindAreaUnderMouse(nux::Point const& mouse_position, 
+                                nux::NuxEventType event_type);
+
+protected:
+  void Draw(nux::GraphicsEngine& gfx_context, bool force_draw);
+
+private:
+  void UpdateGeometry();
+
+  nux::ObjectPtr<WindowButtons> window_buttons_;
+};
+
+} // namespace unity
+
+#endif // OVERLAY_WINDOW_BUTTONS

=== added file 'unity-shared/WindowButtonPriv.h'
--- unity-shared/WindowButtonPriv.h	1970-01-01 00:00:00 +0000
+++ unity-shared/WindowButtonPriv.h	2013-01-28 20:54:23 +0000
@@ -0,0 +1,84 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef WINDOW_BUTTON_PRIVATE_H
+#define WINDOW_BUTTON_PRIVATE_H
+
+#include <Nux/Button.h>
+
+#include "PanelStyle.h"
+#include "UBusWrapper.h"
+#include "Introspectable.h"
+
+namespace unity
+{
+class WindowButtons;
+
+namespace internal
+{
+
+class WindowButton : public nux::Button, public debug::Introspectable
+{
+  // A single window button
+public:
+  WindowButton(panel::WindowButtonType type);
+
+  panel::WindowButtonType GetType() const;
+  void SetVisualState(nux::ButtonVisualState new_state);
+
+  nux::RWProperty<bool> enabled;
+  nux::Property<bool> overlay_mode;
+
+protected:
+  void Draw(nux::GraphicsEngine& GfxContext, bool force_draw);
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  void UpdateSize();
+  void LoadImages();
+  bool EnabledSetter(bool enabled);
+  static nux::ObjectPtr<nux::BaseTexture> GetDashWindowButton(panel::WindowButtonType type, panel::WindowState state);
+
+  inline WindowButtons* Parent() const
+  {
+    return static_cast<WindowButtons*>(GetParentObject());
+  }
+
+private:
+  panel::WindowButtonType type_;
+
+  nux::ObjectPtr<nux::BaseTexture> normal_tex_;
+  nux::ObjectPtr<nux::BaseTexture> prelight_tex_;
+  nux::ObjectPtr<nux::BaseTexture> pressed_tex_;
+  nux::ObjectPtr<nux::BaseTexture> unfocused_tex_;
+  nux::ObjectPtr<nux::BaseTexture> unfocused_prelight_tex_;
+  nux::ObjectPtr<nux::BaseTexture> unfocused_pressed_tex_;
+  nux::ObjectPtr<nux::BaseTexture> disabled_tex_;
+  nux::ObjectPtr<nux::BaseTexture> normal_dash_tex_;
+  nux::ObjectPtr<nux::BaseTexture> prelight_dash_tex_;
+  nux::ObjectPtr<nux::BaseTexture> pressed_dash_tex_;
+  nux::ObjectPtr<nux::BaseTexture> disabled_dash_tex_;
+};
+
+} // internal namespace
+} // unity namespace
+
+#endif // WINDOW_BUTTON_PRIVATE_H

=== added file 'unity-shared/WindowButtons.cpp'
--- unity-shared/WindowButtons.cpp	1970-01-01 00:00:00 +0000
+++ unity-shared/WindowButtons.cpp	2013-01-28 20:54:23 +0000
@@ -0,0 +1,662 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#include "config.h"
+
+#include <Nux/Nux.h>
+#include <array>
+
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Variant.h>
+
+#include "WindowButtons.h"
+#include "WindowButtonPriv.h"
+
+#include "unity-shared/UBusMessages.h"
+#include "unity-shared/WindowManager.h"
+
+namespace unity
+{
+
+namespace internal
+{
+WindowButton::WindowButton(panel::WindowButtonType type)
+  : nux::Button("", NUX_TRACKER_LOCATION)
+  , enabled(sigc::mem_fun(this, &WindowButton::IsViewEnabled),
+            sigc::mem_fun(this, &WindowButton::EnabledSetter))
+  , overlay_mode(false)
+  , type_(type)
+{
+  overlay_mode.changed.connect([this] (bool) { UpdateSize(); QueueDraw(); });
+  SetAcceptKeyNavFocusOnMouseDown(false);
+  panel::Style::Instance().changed.connect(sigc::mem_fun(this, &WindowButton::LoadImages));
+  LoadImages();
+}
+
+void WindowButton::SetVisualState(nux::ButtonVisualState new_state)
+{
+  if (new_state != visual_state_)
+  {
+    visual_state_ = new_state;
+    QueueDraw();
+  }
+}
+
+void WindowButton::Draw(nux::GraphicsEngine& GfxContext, bool force_draw)
+{
+  nux::Geometry const& geo = GetGeometry();
+  nux::BaseTexture* tex = nullptr;
+
+  GfxContext.PushClippingRectangle(geo);
+
+  if (overlay_mode())
+  {
+    if (!enabled())
+    {
+      tex = disabled_dash_tex_.GetPointer();
+    }
+    else
+    {
+      switch (visual_state_)
+      {
+        case nux::VISUAL_STATE_PRESSED:
+          tex = pressed_dash_tex_.GetPointer();
+          break;
+        case nux::VISUAL_STATE_PRELIGHT:
+          tex = prelight_dash_tex_.GetPointer();
+          break;
+        default:
+          tex = normal_dash_tex_.GetPointer();
+      }
+    }
+  }
+  else if (!enabled())
+  {
+    tex = disabled_tex_.GetPointer();
+  }
+  else if (!Parent()->focused())
+  {
+    switch (visual_state_)
+    {
+      case nux::VISUAL_STATE_PRESSED:
+        tex = unfocused_pressed_tex_.GetPointer();
+        break;
+      case nux::VISUAL_STATE_PRELIGHT:
+        tex = unfocused_prelight_tex_.GetPointer();
+        break;
+      default:
+        tex = unfocused_tex_.GetPointer();
+    }
+  }
+  else
+  {
+    switch (visual_state_)
+    {
+      case nux::VISUAL_STATE_PRESSED:
+        tex = pressed_tex_.GetPointer();
+        break;
+      case nux::VISUAL_STATE_PRELIGHT:
+        tex = prelight_tex_.GetPointer();
+        break;
+      default:
+        tex = normal_tex_.GetPointer();
+    }
+  }
+
+  if (tex)
+  {
+    nux::TexCoordXForm texxform;
+    GfxContext.QRP_1Tex(geo.x, geo.y, geo.width, geo.height,
+                        tex->GetDeviceTexture(), texxform,
+                        nux::color::White * Parent()->opacity());
+  }
+
+  GfxContext.PopClippingRectangle();
+}
+
+void WindowButton::UpdateSize()
+{
+  int panel_height = panel::Style::Instance().panel_height;
+  nux::BaseTexture* tex;
+  tex = (overlay_mode()) ? normal_dash_tex_.GetPointer() : normal_tex_.GetPointer();
+  int width = 0;
+  int height = 0;
+
+  if (tex)
+  {
+    width = std::min(panel_height, tex->GetWidth());
+    height = std::min(panel_height, tex->GetHeight());
+  }
+
+  SetMinMaxSize(width, height);
+}
+
+void WindowButton::LoadImages()
+{
+  panel::Style& style = panel::Style::Instance();
+
+  normal_tex_ = style.GetWindowButton(type_, panel::WindowState::NORMAL);
+  prelight_tex_ = style.GetWindowButton(type_, panel::WindowState::PRELIGHT);
+  pressed_tex_ = style.GetWindowButton(type_, panel::WindowState::PRESSED);
+  unfocused_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED);
+  disabled_tex_ = style.GetWindowButton(type_, panel::WindowState::DISABLED);
+  unfocused_prelight_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED_PRELIGHT);
+  unfocused_pressed_tex_ = style.GetWindowButton(type_, panel::WindowState::UNFOCUSED_PRESSED);
+  normal_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::NORMAL);
+  prelight_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::PRELIGHT);
+  pressed_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::PRESSED);
+  disabled_dash_tex_ = GetDashWindowButton(type_, panel::WindowState::DISABLED);
+
+  UpdateSize();
+  QueueDraw();
+}
+
+nux::ObjectPtr<nux::BaseTexture> WindowButton::GetDashWindowButton(panel::WindowButtonType type, panel::WindowState state)
+{
+  nux::ObjectPtr<nux::BaseTexture> texture;
+  static const std::array<std::string, 4> names = {{ "close_dash", "minimize_dash", "unmaximize_dash", "maximize_dash" }};
+  static const std::array<std::string, 4> states = {{ "", "_prelight", "_pressed", "_disabled" }};
+
+  std::string subpath = names[static_cast<int>(type)] + states[static_cast<int>(state)] + ".png";
+
+  glib::String filename(g_build_filename(PKGDATADIR, subpath.c_str(), NULL));
+  texture.Adopt(nux::CreateTexture2DFromFile(filename, -1, true));
+
+  if (!texture)
+    texture = panel::Style::Instance().GetFallbackWindowButton(type, state);
+
+  return texture;
+}
+
+panel::WindowButtonType WindowButton::GetType() const
+{
+  return type_;
+}
+
+bool WindowButton::EnabledSetter(bool new_value)
+{
+  if (enabled() == new_value)
+    return false;
+
+  SetEnableView(new_value);
+  QueueDraw();
+  return true;
+}
+
+std::string WindowButton::GetName() const
+{
+  return "WindowButton";
+}
+
+void WindowButton::AddProperties(GVariantBuilder* builder)
+{
+  std::string type_name;
+  std::string state_name;
+
+  switch (type_)
+  {
+    case panel::WindowButtonType::CLOSE:
+      type_name = "Close";
+      break;
+    case panel::WindowButtonType::MINIMIZE:
+      type_name = "Minimize";
+      break;
+    case panel::WindowButtonType::MAXIMIZE:
+      type_name = "Maximize";
+      break;
+    case panel::WindowButtonType::UNMAXIMIZE:
+      type_name = "Unmaximize";
+      break;
+  }
+
+  switch (visual_state_)
+  {
+    case nux::VISUAL_STATE_PRESSED:
+      state_name = "pressed";
+      break;
+    case nux::VISUAL_STATE_PRELIGHT:
+      state_name = "prelight";
+      break;
+    default:
+      state_name = "normal";
+  }
+
+  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry())
+                                  .add("type", type_name)
+                                  .add("visible", IsVisible() && Parent()->opacity() != 0.0f)
+                                  .add("sensitive", Parent()->GetInputEventSensitivity())
+                                  .add("enabled", enabled())
+                                  .add("visual_state", state_name)
+                                  .add("opacity", Parent()->opacity())
+                                  .add("focused", Parent()->focused())
+                                  .add("overlay_mode", overlay_mode());
+}
+} // Internal Namespace
+
+
+WindowButtons::WindowButtons()
+  : HLayout("", NUX_TRACKER_LOCATION)
+  , monitor(0)
+  , controlled_window(0)
+  , opacity(1.0f, sigc::mem_fun(this, &WindowButtons::OpacitySetter))
+  , focused(true)
+{
+  controlled_window.changed.connect(sigc::mem_fun(this, &WindowButtons::OnControlledWindowChanged));
+  focused.changed.connect(sigc::hide(sigc::mem_fun(this, &WindowButtons::QueueDraw)));
+
+  auto lambda_enter = [&](int x, int y, unsigned long button_flags, unsigned long key_flags)
+  {
+    mouse_enter.emit(x, y, button_flags, key_flags);
+  };
+
+  auto lambda_leave = [&](int x, int y, unsigned long button_flags, unsigned long key_flags)
+  {
+    mouse_leave.emit(x, y, button_flags, key_flags);
+  };
+
+  auto lambda_moved = [&](int x, int y, int dx, int dy, unsigned long button_flags, unsigned long key_flags)
+  {
+    mouse_move.emit(x, y, dx, dy, button_flags, key_flags);
+  };
+
+  internal::WindowButton* but;
+  but = new internal::WindowButton(panel::WindowButtonType::CLOSE);
+  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+  AddChild(but);
+  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnCloseClicked));
+  but->mouse_enter.connect(lambda_enter);
+  but->mouse_leave.connect(lambda_leave);
+  but->mouse_move.connect(lambda_moved);
+
+  but = new internal::WindowButton(panel::WindowButtonType::MINIMIZE);
+  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+  AddChild(but);
+  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMinimizeClicked));
+  but->mouse_enter.connect(lambda_enter);
+  but->mouse_leave.connect(lambda_leave);
+  but->mouse_move.connect(lambda_moved);
+
+  but = new internal::WindowButton(panel::WindowButtonType::UNMAXIMIZE);
+  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+  AddChild(but);
+  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnRestoreClicked));
+  but->mouse_enter.connect(lambda_enter);
+  but->mouse_leave.connect(lambda_leave);
+  but->mouse_move.connect(lambda_moved);
+
+  but = new internal::WindowButton(panel::WindowButtonType::MAXIMIZE);
+  AddView(but, 0, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_FIX);
+  AddChild(but);
+  but->click.connect(sigc::mem_fun(this, &WindowButtons::OnMaximizeClicked));
+  but->mouse_enter.connect(lambda_enter);
+  but->mouse_leave.connect(lambda_leave);
+  but->mouse_move.connect(lambda_moved);
+  but->SetVisible(false);
+
+  SetContentDistribution(nux::MAJOR_POSITION_START);
+
+  ubus_manager_.RegisterInterest(UBUS_OVERLAY_SHOWN, sigc::mem_fun(this, &WindowButtons::OnOverlayShown));
+  ubus_manager_.RegisterInterest(UBUS_OVERLAY_HIDDEN, sigc::mem_fun(this, &WindowButtons::OnOverlayHidden));
+  Settings::Instance().form_factor.changed.connect(sigc::mem_fun(this, &WindowButtons::OnDashSettingsUpdated));
+}
+
+nux::Area* WindowButtons::FindAreaUnderMouse(const nux::Point& mouse, nux::NuxEventType event_type)
+{
+  if (!GetInputEventSensitivity())
+    return nullptr;
+
+  /* The first button should be clickable on the left space too, to
+   * make Fitts happy. All also on their top side. See bug #839690 */
+  bool first_found = false;
+
+  for (auto area : GetChildren())
+  {
+    if (area->IsVisible())
+    {
+      nux::Geometry const& geo = area->GetAbsoluteGeometry();
+
+      if (!first_found)
+      {
+        first_found = true;
+
+        if (mouse.x < geo.x && mouse.y < (geo.y + geo.height))
+          return area;
+      }
+
+      if (geo.IsPointInside(mouse.x, mouse.y))
+        return area;
+
+      if (mouse.x >= geo.x && mouse.x <= (geo.x + geo.width) && mouse.y <= geo.y)
+        return area;
+    }
+  }
+
+  return nullptr;
+}
+
+void WindowButtons::OnCloseClicked(nux::Button *button)
+{
+  auto win_button = dynamic_cast<internal::WindowButton*>(button);
+
+  if (!win_button || !win_button->enabled())
+    return;
+
+  if (win_button->overlay_mode())
+  {
+    ubus_manager_.SendMessage(UBUS_PLACE_VIEW_CLOSE_REQUEST);
+  }
+  else
+  {
+    WindowManager::Default().Close(controlled_window());
+  }
+
+  close_clicked.emit();
+}
+
+void WindowButtons::OnMinimizeClicked(nux::Button *button)
+{
+  auto win_button = dynamic_cast<internal::WindowButton*>(button);
+
+  if (!win_button || !win_button->enabled())
+    return;
+
+  if (!win_button->overlay_mode())
+    WindowManager::Default().Minimize(controlled_window());
+
+  minimize_clicked.emit();
+}
+
+void WindowButtons::OnRestoreClicked(nux::Button *button)
+{
+  auto win_button = dynamic_cast<internal::WindowButton*>(button);
+
+  if (!win_button || !win_button->enabled())
+    return;
+
+  if (win_button->overlay_mode())
+  {
+    Settings::Instance().form_factor = FormFactor::DESKTOP;
+  }
+  else
+  {
+    WindowManager& wm = WindowManager::Default();
+    Window to_restore = controlled_window();
+
+    wm.Raise(to_restore);
+    wm.Activate(to_restore);
+    wm.Restore(to_restore);
+  }
+
+  restore_clicked.emit();
+}
+
+void WindowButtons::OnMaximizeClicked(nux::Button *button)
+{
+  auto win_button = dynamic_cast<internal::WindowButton*>(button);
+
+  if (!win_button || !win_button->enabled())
+    return;
+
+  if (win_button->overlay_mode())
+  {
+    Settings::Instance().form_factor = FormFactor::NETBOOK;
+  }
+
+  maximize_clicked.emit();
+}
+
+void WindowButtons::OnOverlayShown(GVariant* data)
+{
+  internal::WindowButton* maximize_button = nullptr;
+  internal::WindowButton* restore_button = nullptr;
+  glib::String overlay_identity;
+  gboolean can_maximise = FALSE;
+  gint32 overlay_monitor = 0;
+  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
+                &overlay_identity, &can_maximise, &overlay_monitor);
+
+  if (overlay_monitor != monitor())
+  {
+    for (auto area : GetChildren())
+    {
+      auto button = dynamic_cast<internal::WindowButton*>(area);
+
+      if (button)
+        button->enabled = false;
+    }
+
+    return;
+  }
+
+  active_overlay_ = overlay_identity.Str();
+
+  for (auto area : GetChildren())
+  {
+    auto button = dynamic_cast<internal::WindowButton*>(area);
+
+    if (button)
+    {
+      if (button->GetType() == panel::WindowButtonType::CLOSE)
+        button->enabled = true;
+
+      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
+        restore_button = button;
+
+      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
+        maximize_button = button;
+
+      if (button->GetType() == panel::WindowButtonType::MINIMIZE)
+        button->enabled = false;
+
+      button->overlay_mode = true;
+    }
+  }
+
+  if (restore_button && maximize_button)
+  {
+    Settings &dash_settings = Settings::Instance();
+    bool maximizable = (dash_settings.form_factor() == FormFactor::DESKTOP);
+
+    restore_button->enabled = can_maximise;
+    maximize_button->enabled = can_maximise;
+
+    if (maximizable != maximize_button->IsVisible())
+    {
+      if (maximize_button->IsVisible())
+        restore_button->SetVisualState(maximize_button->GetVisualState());
+      else if (restore_button->IsVisible())
+        maximize_button->SetVisualState(restore_button->GetVisualState());
+
+      restore_button->SetVisible(!maximizable);
+      maximize_button->SetVisible(maximizable);
+
+      QueueDraw();
+    }
+  }
+}
+
+void WindowButtons::OnOverlayHidden(GVariant* data)
+{
+  internal::WindowButton* maximize_button = nullptr;
+  internal::WindowButton* restore_button = nullptr;
+
+  glib::String overlay_identity;
+  gboolean can_maximise = FALSE;
+  gint32 overlay_monitor = 0;
+  g_variant_get(data, UBUS_OVERLAY_FORMAT_STRING,
+                &overlay_identity, &can_maximise, &overlay_monitor);
+
+  if (overlay_monitor != monitor())
+  {
+    for (auto area : GetChildren())
+    {
+      auto button = dynamic_cast<internal::WindowButton*>(area);
+
+      if (button)
+        button->enabled = true;
+    }
+  }
+
+  if (active_overlay_ != overlay_identity.Str())
+    return;
+
+  active_overlay_ = "";
+
+  WindowManager& wm = WindowManager::Default();
+  for (auto area : GetChildren())
+  {
+    auto button = dynamic_cast<internal::WindowButton*>(area);
+
+    if (button)
+    {
+      if (controlled_window())
+      {
+        if (button->GetType() == panel::WindowButtonType::CLOSE)
+          button->enabled = wm.IsWindowClosable(controlled_window());
+
+        if (button->GetType() == panel::WindowButtonType::MINIMIZE)
+          button->enabled = wm.IsWindowMinimizable(controlled_window());
+      }
+
+      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
+        restore_button = button;
+
+      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
+        maximize_button = button;
+
+      button->overlay_mode = false;
+    }
+  }
+
+  if (restore_button && maximize_button)
+  {
+    restore_button->enabled = true;
+    maximize_button->enabled = true;
+
+    if (!restore_button->IsVisible())
+    {
+      restore_button->SetVisualState(maximize_button->GetVisualState());
+
+      restore_button->SetVisible(true);
+      maximize_button->SetVisible(false);
+
+      QueueDraw();
+    }
+  }
+}
+
+void WindowButtons::OnDashSettingsUpdated(FormFactor form_factor)
+{
+  internal::WindowButton* maximize_button = nullptr;
+  internal::WindowButton* restore_button = nullptr;
+
+  for (auto area : GetChildren())
+  {
+    auto button = dynamic_cast<internal::WindowButton*>(area);
+
+    if (button)
+    {
+      if (!button->overlay_mode())
+        break;
+
+      if (button->GetType() == panel::WindowButtonType::UNMAXIMIZE)
+        restore_button = button;
+
+      if (button->GetType() == panel::WindowButtonType::MAXIMIZE)
+        maximize_button = button;
+
+      if (restore_button && maximize_button)
+        break;
+    }
+  }
+
+  if (restore_button && restore_button->overlay_mode() && maximize_button)
+  {
+    bool maximizable = (form_factor == FormFactor::DESKTOP);
+
+    if (maximizable != maximize_button->IsVisible())
+    {
+      if (maximize_button->IsVisible())
+        restore_button->SetVisualState(maximize_button->GetVisualState());
+      else if (restore_button->IsVisible())
+        maximize_button->SetVisualState(restore_button->GetVisualState());
+
+      restore_button->SetVisible(!maximizable);
+      maximize_button->SetVisible(maximizable);
+
+      QueueRelayout();
+    }
+  }
+}
+
+bool WindowButtons::OpacitySetter(double& target, double new_value)
+{
+  double opacity = CLAMP(new_value, 0.0f, 1.0f);
+
+  if (opacity != target)
+  {
+    target = opacity;
+    SetInputEventSensitivity(opacity != 0.0f);
+    QueueDraw();
+
+    return true;
+  }
+
+  return false;
+}
+
+void WindowButtons::OnControlledWindowChanged(Window xid)
+{
+  if (xid && active_overlay_.empty())
+  {
+    WindowManager& wm = WindowManager::Default();
+    for (auto area : GetChildren())
+    {
+      auto button = dynamic_cast<internal::WindowButton*>(area);
+
+      if (!button)
+        continue;
+
+      if (button->GetType() == panel::WindowButtonType::CLOSE)
+        button->enabled = wm.IsWindowClosable(xid);
+
+      if (button->GetType() == panel::WindowButtonType::MINIMIZE)
+        button->enabled = wm.IsWindowMinimizable(xid);
+    }
+  }
+}
+
+std::string WindowButtons::GetName() const
+{
+  return "WindowButtons";
+}
+
+void WindowButtons::AddProperties(GVariantBuilder* builder)
+{
+  variant::BuilderWrapper(builder).add(GetAbsoluteGeometry())
+                                  .add("monitor", monitor())
+                                  .add("opacity", opacity())
+                                  .add("visible", opacity() != 0.0f)
+                                  .add("sensitive", GetInputEventSensitivity())
+                                  .add("focused", focused())
+                                  .add("controlled_window", controlled_window());
+}
+
+} // unity namespace

=== added file 'unity-shared/WindowButtons.h'
--- unity-shared/WindowButtons.h	1970-01-01 00:00:00 +0000
+++ unity-shared/WindowButtons.h	2013-01-28 20:54:23 +0000
@@ -0,0 +1,77 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2010-2012 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: Neil Jagdish Patel <[e-mail]>
+ *              Marco Trevisan (Treviño) <[e-mail]>
+ */
+
+#ifndef WINDOW_BUTTONS_H
+#define WINDOW_BUTTONS_H
+
+#include <Nux/HLayout.h>
+#include <Nux/Button.h>
+
+#include "Introspectable.h"
+#include "UBusWrapper.h"
+#include "UnitySettings.h"
+#include "PluginAdapter.h"
+
+namespace unity
+{
+class WindowButtons : public nux::HLayout, public debug::Introspectable
+{
+  // These are the [close][minimize][restore] buttons on the panel when there
+  // is a maximized window
+
+public:
+  WindowButtons();
+
+  nux::Property<int> monitor;
+  nux::Property<Window> controlled_window;
+  nux::Property<double> opacity;
+  nux::Property<bool> focused;
+
+  virtual nux::Area* FindAreaUnderMouse(const nux::Point& mouse_pos, nux::NuxEventType event_type);
+
+  sigc::signal<void> close_clicked;
+  sigc::signal<void> minimize_clicked;
+  sigc::signal<void> restore_clicked;
+  sigc::signal<void> maximize_clicked;
+  sigc::signal<void, int, int, int, int, unsigned long, unsigned long> mouse_move;
+  sigc::signal<void, int, int, unsigned long, unsigned long> mouse_enter;
+  sigc::signal<void, int, int, unsigned long, unsigned long> mouse_leave;
+
+protected:
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  void OnCloseClicked(nux::Button *button);
+  void OnMinimizeClicked(nux::Button *button);
+  void OnRestoreClicked(nux::Button *button);
+  void OnMaximizeClicked(nux::Button *button);
+  void OnOverlayShown(GVariant* data);
+  void OnOverlayHidden(GVariant* data);
+  void OnDashSettingsUpdated(FormFactor form_factor);
+  void OnControlledWindowChanged(Window xid);
+  bool OpacitySetter(double& target, double new_value);
+
+  std::string active_overlay_;
+  UBusManager ubus_manager_;
+};
+}
+
+#endif