Merge lp:~3v1n0/unity/shutdown-view into lp:unity

[Marco Trevisan (Treviño)]

Session: added a SessionController and View. Use the GnomeSessionManager to perform session actions

Such as suspend, hibernate, logout, lockscreen, reboot and shutdown.

Video: http://youtu.be/h_qqjOMGlrI

Implemented a View to use the GnomeSessionManager, added unit tests.

[Brandon Schaefer (brandontschaefer)]

Awesome work! Looks amazing:

Logout:
http://i.imgur.com/T5ytfcN.png

Shutdown:
http://i.imgur.com/f4he5KH.png

Code looks good, just a few more test. Approved. Will approve to merge once some more tests land :).

review: Approve

[Brandon Schaefer (brandontschaefer)]

Still looks good to me. Awesome amount of tests, lets merge!

review: Approve

[Michael Terry (mterry)]

Mmm, mightn't this break Feature Freeze?

[Adolfo Jayme Barrientos (fitojb)]

@mterry: I consider this as a bug fix ;-)

@treviño: this is really cool!

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

Freeze exception was accepted, re-approving! ;-)

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2013-03-04 15:44:32 +0000
+++ CMakeLists.txt	2013-03-07 22:50:34 +0000
@@ -235,6 +235,7 @@
   add_subdirectory(plugins/unitydialog)
   add_subdirectory(plugins/unity-mt-grab-handles)
   add_subdirectory(shortcuts)
+  add_subdirectory(shutdown)
   add_subdirectory(unity-standalone)
 endif ()
 

=== modified file 'plugins/unityshell/CMakeLists.txt'
--- plugins/unityshell/CMakeLists.txt	2013-01-08 09:07:52 +0000
+++ plugins/unityshell/CMakeLists.txt	2013-03-07 22:50:34 +0000
@@ -13,7 +13,7 @@
 compiz_plugin (unityshell
                PKGDEPS ${UNITY_PLUGIN_DEPS}
                PLUGINDEPS composite opengl compiztoolbox scale
-               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${PKGDATADIR}\"' -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR} ${BOOT_LOGGER_FLAG} -DGETTEXT_PACKAGE='\"unity\"' ${MAINTAINER_CXXFLAGS} -I${CMAKE_SOURCE_DIR}/dash/ -I${CMAKE_SOURCE_DIR}/launcher/ -I${CMAKE_SOURCE_DIR}/hud/ -I${CMAKE_SOURCE_DIR}/panel/ -I${CMAKE_SOURCE_DIR}/shortcuts/ -I${CMAKE_SOURCE_DIR}/unity-shared/"
+               CFLAGSADD "-DINSTALLPREFIX='\"${CMAKE_INSTALL_PREFIX}\"' -DPKGDATADIR='\"${PKGDATADIR}\"' -I${CMAKE_BINARY_DIR} -I${CMAKE_SOURCE_DIR} ${BOOT_LOGGER_FLAG} -DGETTEXT_PACKAGE='\"unity\"' ${MAINTAINER_CXXFLAGS} -I${CMAKE_SOURCE_DIR}/dash/ -I${CMAKE_SOURCE_DIR}/launcher/ -I${CMAKE_SOURCE_DIR}/hud/ -I${CMAKE_SOURCE_DIR}/panel/ -I${CMAKE_SOURCE_DIR}/shortcuts/ -I${CMAKE_SOURCE_DIR}/shutdown/ -I${CMAKE_SOURCE_DIR}/unity-shared/"
                LIBDIRS "${CMAKE_BINARY_DIR}/UnityCore"
                )
 
@@ -21,9 +21,9 @@
   set (CMAKE_BUILD_TYPE "" CACHE STRING "Build type (Debug/Release/RelWithDebInfo/MinSizeRe)" FORCE)
 endif()
 
-add_dependencies(unityshell unity-core-${UNITY_API_VERSION} dash-lib launcher-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-compiz)
-target_link_libraries(unityshell unity-core-${UNITY_API_VERSION} launcher-lib dash-lib switcher-lib hud-lib panel-lib shortcuts-lib unity-shared unity-shared-bamf unity-shared-compiz)
-set_target_properties(unityshell 
+add_dependencies(unityshell unity-core-${UNITY_API_VERSION} dash-lib launcher-lib switcher-lib hud-lib panel-lib shortcuts-lib shutdown-lib unity-shared unity-shared-compiz)
+target_link_libraries(unityshell unity-core-${UNITY_API_VERSION} launcher-lib dash-lib switcher-lib hud-lib panel-lib shortcuts-lib shutdown-lib unity-shared unity-shared-bamf unity-shared-compiz)
+set_target_properties(unityshell
                       PROPERTIES INSTALL_RPATH "${CACHED_UNITY_PRIVATE_DEPS_LIBRARY_DIRS}"
                       INSTALL_RPATH_USE_LINK_PATH TRUE)
 

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-03-04 21:24:47 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-03-07 22:50:34 +0000
@@ -25,8 +25,9 @@
 #include <Nux/BaseWindow.h>
 #include <Nux/WindowCompositor.h>
 
+#include <UnityCore/Lens.h>
+#include <UnityCore/GnomeSessionManager.h>
 #include <UnityCore/Variant.h>
-#include <UnityCore/Lens.h>
 
 #include "BaseWindowRaiserImp.h"
 #include "IconRenderer.h"
@@ -2577,6 +2578,12 @@
     paintInnerGlow(scaled_geo, matrix, attrib, mask);
   }
 
+  if (uScreen->session_controller_ && uScreen->session_controller_->Visible())
+  {
+    // Let's darken the other windows if the session dialog is visible
+    wAttrib.brightness *= 0.75f;
+  }
+
   return gWindow->glPaint(wAttrib, matrix, region, mask);
 }
 
@@ -3255,6 +3262,11 @@
   shortcut_controller_ = std::make_shared<shortcut::Controller>(base_window_raiser, shortcuts_modeller);
   AddChild(shortcut_controller_.get());
 
+  // Setup Session Controller
+  auto manager = std::make_shared<session::GnomeManager>();
+  session_controller_ = std::make_shared<session::Controller>(manager);
+  AddChild(session_controller_.get());
+
   launcher_controller_->launcher().size_changed.connect([this] (nux::Area*, int w, int h) {
     /* The launcher geometry includes 1px used to draw the right margin
      * that must not be considered when drawing an overlay */

=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2013-02-19 18:21:22 +0000
+++ plugins/unityshell/src/unityshell.h	2013-03-07 22:50:34 +0000
@@ -50,6 +50,7 @@
 #include "DebugDBusInterface.h"
 #include "ScreenIntrospection.h"
 #include "SwitcherController.h"
+#include "SessionController.h"
 #include "UBusWrapper.h"
 #include "UnityshellPrivate.h"
 #include "UnityShowdesktopHandler.h"
@@ -272,6 +273,7 @@
   switcher::Controller::Ptr switcher_controller_;
   hud::Controller::Ptr      hud_controller_;
   shortcut::Controller::Ptr shortcut_controller_;
+  session::Controller::Ptr  session_controller_;
   debug::DebugDBusInterface debugger_;
 
   /* Subscription for gestures that manipulate Unity launcher */

=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2013-02-05 22:01:10 +0000
+++ po/POTFILES.in	2013-03-07 22:50:34 +0000
@@ -32,6 +32,7 @@
 shortcuts/ShortcutHintPrivate.cpp
 shortcuts/ShortcutView.cpp
 shortcuts/CompizShortcutModeller.cpp
+shutdown/SessionView.cpp
 services/panel-service.c
 unity-shared/DashStyle.cpp
 unity-shared/SearchBar.cpp

=== added file 'resources/hibernate.png'
Binary files resources/hibernate.png	1970-01-01 00:00:00 +0000 and resources/hibernate.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/hibernate_highlight.png'
Binary files resources/hibernate_highlight.png	1970-01-01 00:00:00 +0000 and resources/hibernate_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/lockscreen.png'
Binary files resources/lockscreen.png	1970-01-01 00:00:00 +0000 and resources/lockscreen.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/lockscreen_highlight.png'
Binary files resources/lockscreen_highlight.png	1970-01-01 00:00:00 +0000 and resources/lockscreen_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/logout.png'
Binary files resources/logout.png	1970-01-01 00:00:00 +0000 and resources/logout.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/logout_highlight.png'
Binary files resources/logout_highlight.png	1970-01-01 00:00:00 +0000 and resources/logout_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/restart.png'
Binary files resources/restart.png	1970-01-01 00:00:00 +0000 and resources/restart.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/restart_highlight.png'
Binary files resources/restart_highlight.png	1970-01-01 00:00:00 +0000 and resources/restart_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/shutdown.png'
Binary files resources/shutdown.png	1970-01-01 00:00:00 +0000 and resources/shutdown.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/shutdown_highlight.png'
Binary files resources/shutdown_highlight.png	1970-01-01 00:00:00 +0000 and resources/shutdown_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/suspend.png'
Binary files resources/suspend.png	1970-01-01 00:00:00 +0000 and resources/suspend.png	2013-03-07 22:50:34 +0000 differ
=== added file 'resources/suspend_highlight.png'
Binary files resources/suspend_highlight.png	1970-01-01 00:00:00 +0000 and resources/suspend_highlight.png	2013-03-07 22:50:34 +0000 differ
=== added directory 'shutdown'
=== added file 'shutdown/CMakeLists.txt'
--- shutdown/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ shutdown/CMakeLists.txt	2013-03-07 22:50:34 +0000
@@ -0,0 +1,33 @@
+set(UNITY_SRC ../plugins/unityshell/src)
+
+set (CFLAGS
+     ${CACHED_UNITY_DEPS_CFLAGS}
+     ${CACHED_UNITY_DEPS_CFLAGS_OTHER}
+     ${PIC_FLAGS}
+     )
+
+string (REPLACE ";" " " CFLAGS "${CFLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CFLAGS}")
+
+set (LIBS ${CACHED_UNITY_DEPS_LDFLAGS} ${UNITY_STANDALONE_LADD})
+
+include_directories (.. ../services ../UnityCore ${UNITY_SRC} ${CMAKE_BINARY_DIR})
+
+#
+# Headers & Sources
+#
+set (SHUTDOWN_SOURCES
+     SessionButton.cpp
+     SessionController.cpp
+     SessionView.cpp
+     )
+
+add_library (shutdown-lib STATIC ${SHUTDOWN_SOURCES})
+add_dependencies (shutdown-lib unity-core-${UNITY_API_VERSION} unity-shared)
+add_pch(pch/shutdown_pch.hh shutdown-lib)
+
+#
+# Standalone variant
+#
+add_executable (shutdown StandaloneSession.cpp)
+target_link_libraries (shutdown shutdown-lib unity-shared unity-shared-standalone)

=== added file 'shutdown/SessionButton.cpp'
--- shutdown/SessionButton.cpp	1970-01-01 00:00:00 +0000
+++ shutdown/SessionButton.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,105 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 "config.h"
+#include "SessionButton.h"
+
+#include <Nux/VLayout.h>
+#include <UnityCore/Variant.h>
+
+
+namespace unity
+{
+namespace session
+{
+
+namespace style
+{
+  const std::string FONT = "Ubuntu Light 12";
+
+  const unsigned BUTTON_SPACE = 9;
+}
+
+NUX_IMPLEMENT_OBJECT_TYPE(Button);
+
+Button::Button(std::string const& label, std::string const& texture_name, NUX_FILE_LINE_DECL)
+  : nux::View(NUX_FILE_LINE_PARAM)
+  , highlighted(false)
+  , label([this] { return label_view_->GetText(); })
+{
+  SetAcceptKeyNavFocusOnMouseDown(false);
+  SetAcceptKeyNavFocusOnMouseEnter(true);
+
+  std::string texture_prefix = PKGDATADIR"/" + texture_name;
+  normal_tex_.Adopt(nux::CreateTexture2DFromFile((texture_prefix + ".png").c_str(), -1, true));
+  highlight_tex_.Adopt(nux::CreateTexture2DFromFile((texture_prefix + "_highlight.png").c_str(), -1, true));
+
+  auto main_layout = new nux::VLayout();
+  main_layout->SetContentDistribution(nux::MAJOR_POSITION_CENTER);
+  main_layout->SetSpaceBetweenChildren(style::BUTTON_SPACE);
+  SetLayout(main_layout);
+
+  image_view_ = new IconTexture(normal_tex_);
+  image_view_->SetInputEventSensitivity(false);
+  main_layout->AddView(image_view_, 1, nux::MINOR_POSITION_CENTER);
+
+  label_view_ = new StaticCairoText(label);
+  label_view_->SetFont(style::FONT);
+  label_view_->SetTextAlignment(StaticCairoText::AlignState::NUX_ALIGN_CENTRE);
+  label_view_->SetTextColor(nux::color::Transparent);
+  label_view_->SetInputEventSensitivity(false);
+  main_layout->AddView(label_view_, 1, nux::MINOR_POSITION_CENTER);
+
+  mouse_enter.connect([this] (int, int, unsigned long, unsigned long) { highlighted = true; });
+  mouse_leave.connect([this] (int, int, unsigned long, unsigned long) { highlighted = false; });
+  mouse_click.connect([this] (int, int, unsigned long, unsigned long) { activated.emit(); });
+
+  begin_key_focus.connect([this] { highlighted = true; });
+  end_key_focus.connect([this] { highlighted = false; });
+  key_nav_focus_activate.connect([this] (Area*) { activated.emit(); });
+
+  highlighted.changed.connect([this] (bool value) {
+    image_view_->SetTexture(value ? highlight_tex_ : normal_tex_);
+    label_view_->SetTextColor(value ? nux::color::White : nux::color::Transparent);
+  });
+}
+
+void Button::Draw(nux::GraphicsEngine& ctx, bool force)
+{
+  GetLayout()->ProcessDraw(ctx, force);
+}
+
+//
+// Introspectable methods
+//
+std::string Button::GetName() const
+{
+  return "SessionButton";
+}
+
+void Button::AddProperties(GVariantBuilder* builder)
+{
+  unity::variant::BuilderWrapper(builder)
+    .add("highlighted", highlighted())
+    .add("label", label())
+    .add("label_visible", label_view_->GetTextColor() != nux::color::Transparent);
+}
+
+} // namespace session
+} // namespace unity

=== added file 'shutdown/SessionButton.h'
--- shutdown/SessionButton.h	1970-01-01 00:00:00 +0000
+++ shutdown/SessionButton.h	2013-03-07 22:50:34 +0000
@@ -0,0 +1,68 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 UNITYSHELL_SESSION_BUTTON_H
+#define UNITYSHELL_SESSION_BUTTON_H
+
+#include <Nux/Nux.h>
+#include <Nux/View.h>
+#include <NuxCore/Property.h>
+
+#include "unity-shared/IconTexture.h"
+#include "unity-shared/Introspectable.h"
+#include "unity-shared/StaticCairoText.h"
+
+namespace unity
+{
+namespace session
+{
+
+class Button : public nux::View, public debug::Introspectable
+{
+  NUX_DECLARE_OBJECT_TYPE(Button, nux::View);
+public:
+  Button(std::string const& label, std::string const& texture_name, NUX_FILE_LINE_PROTO);
+
+  nux::Property<bool> highlighted;
+  nux::ROProperty<std::string> label;
+
+  sigc::signal<void> activated;
+
+protected:
+  void Draw(nux::GraphicsEngine&, bool force);
+
+  // Introspectable methods
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  friend class TestSessionButton;
+
+  IconTexture* image_view_;
+  StaticCairoText* label_view_;
+  nux::ObjectPtr<nux::BaseTexture> normal_tex_;
+  nux::ObjectPtr<nux::BaseTexture> highlight_tex_;
+};
+
+} // namespace session
+
+} // namespace unity
+
+#endif // UNITYSHELL_SESSION_BUTTON_H
+

=== added file 'shutdown/SessionController.cpp'
--- shutdown/SessionController.cpp	1970-01-01 00:00:00 +0000
+++ shutdown/SessionController.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,235 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 "SessionController.h"
+
+#include "unity-shared/UBusMessages.h"
+#include "unity-shared/UScreen.h"
+#include "unity-shared/WindowManager.h"
+
+namespace na = nux::animation;
+
+namespace unity
+{
+namespace session
+{
+namespace
+{
+const unsigned int FADE_DURATION = 100;
+}
+
+Controller::Controller(session::Manager::Ptr const& manager)
+  : manager_(manager)
+  , bg_color_(0.0, 0.0, 0.0, 0.5)
+  , fade_animator_(FADE_DURATION)
+{
+  manager_->reboot_requested.connect([this] (bool inhibitors) {
+    Show(View::Mode::SHUTDOWN, inhibitors);
+  });
+
+  manager_->shutdown_requested.connect([this] (bool inhibitors) {
+    Show(View::Mode::FULL, inhibitors);
+  });
+
+  manager_->logout_requested.connect([this] (bool inhibitors) {
+    Show(View::Mode::LOGOUT, inhibitors);
+  });
+
+  manager_->cancel_requested.connect(sigc::mem_fun(this, &Controller::Hide));
+
+  ubus_manager_.RegisterInterest(UBUS_BACKGROUND_COLOR_CHANGED,
+                                 sigc::mem_fun(this, &Controller::OnBackgroundUpdate));
+
+  ubus_manager_.SendMessage(UBUS_BACKGROUND_REQUEST_COLOUR_EMIT);
+
+  fade_animator_.updated.connect([this] (double opacity) {
+    if (!view_window_)
+      return;
+
+    view_window_->SetOpacity(opacity);
+
+    if (opacity == 0.0f && fade_animator_.GetFinishValue() == 0.0f)
+      CloseWindow();
+  });
+}
+
+void Controller::OnBackgroundUpdate(GVariant* data)
+{
+  gdouble red, green, blue, alpha;
+  g_variant_get(data, "(dddd)", &red, &green, &blue, &alpha);
+  bg_color_ = nux::Color(red, green, blue, alpha);
+
+  if (view_)
+    view_->background_color = bg_color_;
+}
+
+void Controller::Show(View::Mode mode)
+{
+  Show(mode, false);
+}
+
+void Controller::Show(View::Mode mode, bool inhibitors)
+{
+  EnsureView();
+
+  if (Visible() && mode == view_->mode())
+    return;
+
+  WindowManager::Default().SaveInputFocus();
+
+  if (nux::GetWindowThread()->IsEmbeddedWindow())
+  {
+    view_window_->EnableInputWindow(true, view_window_->GetWindowName().c_str(), true, false);
+    view_window_->GrabPointer();
+    view_window_->GrabKeyboard();
+  }
+
+  view_->mode = mode;
+  view_->have_inhibitors = inhibitors;
+  view_->live_background = true;
+
+  view_window_->ShowWindow(true);
+  view_window_->PushToFront();
+  view_window_->SetInputFocus();
+  nux::GetWindowCompositor().SetKeyFocusArea(view_.GetPointer());
+
+  if (fade_animator_.CurrentState() == na::Animation::State::Running)
+  {
+    if (fade_animator_.GetFinishValue() == 0.0f)
+      fade_animator_.Reverse();
+  }
+  else
+  {
+    fade_animator_.SetStartValue(0.0f).SetFinishValue(1.0f).Start();
+  }
+}
+
+nux::Point Controller::GetOffsetPerMonitor(int monitor)
+{
+  EnsureView();
+
+  auto const& view_geo = view_->GetGeometry();
+  auto const& monitor_geo = UScreen::GetDefault()->GetMonitorGeometry(monitor);
+
+  nux::Point offset(adjustment_.x + monitor_geo.x, adjustment_.y + monitor_geo.y);
+  offset.x += (monitor_geo.width - view_geo.width - adjustment_.x) / 2;
+  offset.y += (monitor_geo.height - view_geo.height - adjustment_.y) / 2;
+
+  return offset;
+}
+
+void Controller::ConstructView()
+{
+  view_ = View::Ptr(new View(manager_));
+  view_->background_color = bg_color_;
+  debug::Introspectable::AddChild(view_.GetPointer());
+
+  auto layout = new nux::HLayout(NUX_TRACKER_LOCATION);
+  layout->SetVerticalExternalMargin(0);
+  layout->SetHorizontalExternalMargin(0);
+  layout->AddView(view_.GetPointer());
+
+  view_window_ = new nux::BaseWindow("SessionManager");
+  view_window_->SetLayout(layout);
+  view_window_->SetBackgroundColor(nux::color::Transparent);
+  view_window_->SetWindowSizeMatchLayout(true);
+  view_window_->ShowWindow(false);
+  view_window_->SetOpacity(0.0f);
+  view_window_->SetEnterFocusInputArea(view_.GetPointer());
+
+  view_window_->mouse_down_outside_pointer_grab_area.connect([this] (int, int, unsigned long, unsigned long) {
+    CancelAndHide();
+  });
+
+  view_->request_hide.connect(sigc::mem_fun(this, &Controller::Hide));
+  view_->request_close.connect(sigc::mem_fun(this, &Controller::CancelAndHide));
+
+  if (nux::GetWindowThread()->IsEmbeddedWindow())
+  {
+    view_->size_changed.connect([this] (nux::Area*, int, int) {
+      int monitor = UScreen::GetDefault()->GetMonitorWithMouse();
+      auto const& offset = GetOffsetPerMonitor(monitor);
+      view_window_->SetXY(offset.x, offset.y);
+    });
+  }
+  else
+  {
+    view_window_->SetXY(0, 0);
+  }
+}
+
+void Controller::EnsureView()
+{
+  if (!view_window_)
+    ConstructView();
+}
+
+void Controller::CancelAndHide()
+{
+  manager_->CancelAction();
+  Hide();
+}
+
+void Controller::Hide()
+{
+  if (fade_animator_.CurrentState() == na::Animation::State::Running)
+  {
+    if (fade_animator_.GetFinishValue() == 1.0f)
+      fade_animator_.Reverse();
+  }
+  else
+  {
+    fade_animator_.SetStartValue(1.0f).SetFinishValue(0.0f).Start();
+  }
+}
+
+void Controller::CloseWindow()
+{
+  view_window_->PushToBack();
+  view_window_->ShowWindow(false);
+  view_window_->UnGrabPointer();
+  view_window_->UnGrabKeyboard();
+  view_window_->EnableInputWindow(false);
+  view_->live_background = false;
+
+  nux::GetWindowCompositor().SetKeyFocusArea(nullptr);
+  WindowManager::Default().RestoreInputFocus();
+}
+
+bool Controller::Visible() const
+{
+  return (view_window_ && view_window_->IsVisible());
+}
+
+//
+// Introspection
+//
+std::string Controller::GetName() const
+{
+  return "SessionController";
+}
+
+void Controller::AddProperties(GVariantBuilder* builder)
+{
+  variant::BuilderWrapper(builder)
+    .add("visible", Visible());
+}
+
+} // namespace session
+} // namespace unity

=== added file 'shutdown/SessionController.h'
--- shutdown/SessionController.h	1970-01-01 00:00:00 +0000
+++ shutdown/SessionController.h	2013-03-07 22:50:34 +0000
@@ -0,0 +1,83 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 UNITYSHELL_SESSION_CONTROLLER_H
+#define UNITYSHELL_SESSION_CONTROLLER_H
+
+#include <memory>
+
+#include <Nux/Nux.h>
+#include <Nux/BaseWindow.h>
+#include <Nux/HLayout.h>
+#include <NuxCore/Color.h>
+#include <NuxCore/Animation.h>
+#include <UnityCore/SessionManager.h>
+
+#include "SessionView.h"
+#include "unity-shared/UBusWrapper.h"
+
+namespace unity
+{
+namespace session
+{
+
+class Controller : public debug::Introspectable
+{
+public:
+  typedef std::shared_ptr<Controller> Ptr;
+
+  Controller(session::Manager::Ptr const& manager);
+  virtual ~Controller() = default;
+
+  void Show(View::Mode mode);
+  void Hide();
+
+  bool Visible() const;
+
+protected:
+  // Introspectable
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  friend class TestSessionController;
+
+  void Show(View::Mode mode, bool inhibitors);
+  void CancelAndHide();
+  void ConstructView();
+  void EnsureView();
+  void CloseWindow();
+  void OnBackgroundUpdate(GVariant* data);
+  nux::Point GetOffsetPerMonitor(int monitor);
+
+  View::Ptr view_;
+  nux::ObjectPtr<nux::BaseWindow> view_window_;
+  nux::Point adjustment_;
+  session::Manager::Ptr manager_;
+
+  nux::Color bg_color_;
+
+  nux::animation::AnimateValue<double> fade_animator_;
+  UBusManager ubus_manager_;
+};
+
+}
+}
+
+#endif

=== added file 'shutdown/SessionView.cpp'
--- shutdown/SessionView.cpp	1970-01-01 00:00:00 +0000
+++ shutdown/SessionView.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,326 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 "SessionView.h"
+#include "SessionButton.h"
+
+#include <Nux/VLayout.h>
+#include <UnityCore/GLibWrapper.h>
+#include <UnityCore/Variant.h>
+#include <glib/gi18n-lib.h>
+
+namespace unity
+{
+namespace session
+{
+
+namespace style
+{
+  const std::string FONT = "Ubuntu Light";
+  const std::string TITLE_FONT = FONT+" 15";
+  const std::string SUBTITLE_FONT = FONT+" 12";
+
+  const unsigned LEFT_RIGHT_PADDING = 30;
+  const unsigned TOP_PADDING = 19;
+  const unsigned BOTTOM_PADDING = 12;
+  const unsigned MAIN_SPACE = 10;
+  const unsigned BUTTONS_SPACE = 20;
+}
+
+NUX_IMPLEMENT_OBJECT_TYPE(View);
+
+View::View(Manager::Ptr const& manager)
+  : mode(Mode::FULL)
+  , manager_(manager)
+{
+  closable = true;
+  auto main_layout = new nux::VLayout();
+  main_layout->SetTopAndBottomPadding(style::TOP_PADDING, style::BOTTOM_PADDING);
+  main_layout->SetLeftAndRightPadding(style::LEFT_RIGHT_PADDING);
+  main_layout->SetSpaceBetweenChildren(style::MAIN_SPACE);
+  SetLayout(main_layout);
+
+  title_ = new StaticCairoText("");
+  title_->SetFont(style::TITLE_FONT);
+  title_->SetTextAlignment(StaticCairoText::AlignState::NUX_ALIGN_LEFT);
+  title_->SetInputEventSensitivity(false);
+  title_->SetVisible(false);
+  main_layout->AddView(title_);
+
+  subtitle_ = new StaticCairoText("");
+  subtitle_->SetFont(style::SUBTITLE_FONT);
+  subtitle_->SetTextAlignment(StaticCairoText::AlignState::NUX_ALIGN_LEFT);
+  subtitle_->SetInputEventSensitivity(false);
+  subtitle_->SetLines(std::numeric_limits<int>::min());
+  subtitle_->SetLineSpacing(2);
+  main_layout->AddView(subtitle_);
+
+  buttons_layout_ = new nux::HLayout();
+  buttons_layout_->SetSpaceBetweenChildren(style::BUTTONS_SPACE);
+  main_layout->AddLayout(buttons_layout_, 1, nux::MINOR_POSITION_CENTER, nux::MINOR_SIZE_PERCENTAGE, 0.0f);
+
+  GetBoundingArea()->mouse_click.connect([this] (int, int, unsigned long, unsigned long) { request_close.emit(); });
+
+  have_inhibitors.changed.connect(sigc::hide(sigc::mem_fun(this, &View::UpdateText)));
+
+  mode.SetSetterFunction([this] (Mode& target, Mode new_mode) {
+    if (new_mode == Mode::SHUTDOWN && !manager_->CanShutdown())
+      new_mode = Mode::LOGOUT;
+
+    if (target != new_mode)
+    {
+      target = new_mode;
+      return true;
+    }
+
+    return false;
+  });
+
+  mode.changed.connect([this] (Mode m) {
+    UpdateText();
+    Populate();
+  });
+
+  UpdateText();
+  Populate();
+}
+
+void View::UpdateText()
+{
+  const char* message = nullptr;
+  auto const& real_name = manager_->RealName();
+  auto const& name = (real_name.empty() ? manager_->UserName() : real_name);
+
+  if (mode() == Mode::SHUTDOWN)
+  {
+    title_->SetText(_("Shut Down"));
+    title_->SetVisible(true);
+
+    if (have_inhibitors())
+    {
+      message = _("Hi %s, you have open files that you might want to save " \
+                  "before shutting down. Are you sure you want to continue?");
+    }
+    else
+    {
+      message = _("Goodbye %s! Are you sure you want to close all programs " \
+                  "and shut down the computer?");
+    }
+  }
+  else if (mode() == Mode::LOGOUT)
+  {
+    title_->SetText(_("Log Out"));
+    title_->SetVisible(true);
+
+    if (have_inhibitors())
+    {
+      message = _("Hi %s, you have open files that you might want to save " \
+                  "before logging out. Are you sure you want to continue?");
+    }
+    else
+    {
+      message = _("Goodbye %s! Are you sure you want to close all programs " \
+                  "and log out from your account?");
+    }
+  }
+  else
+  {
+    title_->SetVisible(false);
+
+    if (have_inhibitors())
+    {
+      message = _("Hi %s, you have open files that you might want to save " \
+                  "before shutting down.\nWould you like to…");
+    }
+    else
+    {
+      message = _("Goodbye %s! Would you like to…");
+    }
+  }
+
+  subtitle_->SetText(glib::String(g_strdup_printf(message, name.c_str())).Str());
+}
+
+void View::Populate()
+{
+  debug::Introspectable::RemoveAllChildren();
+  buttons_layout_->Clear();
+
+  if (mode() == Mode::LOGOUT)
+  {
+    auto* button = new Button(_("Lock"), "lockscreen", NUX_TRACKER_LOCATION);
+    button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
+    AddButton(button);
+
+    button = new Button(_("Logout"), "logout", NUX_TRACKER_LOCATION);
+    button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Logout));
+    AddButton(button);
+  }
+  else
+  {
+    if (mode() == Mode::FULL)
+    {
+      auto* button = new Button(_("Lock"), "lockscreen", NUX_TRACKER_LOCATION);
+      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::LockScreen));
+      AddButton(button);
+
+      if (manager_->CanSuspend())
+      {
+        button = new Button(_("Suspend"), "suspend", NUX_TRACKER_LOCATION);
+        button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Suspend));
+        AddButton(button);
+      }
+
+      if (manager_->CanHibernate())
+      {
+        button = new Button(_("Hibernate"), "hibernate", NUX_TRACKER_LOCATION);
+        button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Hibernate));
+        AddButton(button);
+      }
+    }
+
+    if (manager_->CanShutdown())
+    {
+      auto* button = new Button(_("Shutdown"), "shutdown", NUX_TRACKER_LOCATION);
+      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Shutdown));
+      AddButton(button);
+
+      button = new Button(_("Restart"), "restart", NUX_TRACKER_LOCATION);
+      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Reboot));
+      AddButton(button);
+    }
+    else if (mode() == Mode::FULL)
+    {
+      auto* button = new Button(_("Logout"), "logout", NUX_TRACKER_LOCATION);
+      button->activated.connect(sigc::mem_fun(manager_.get(), &Manager::Logout));
+      AddButton(button);
+    }
+  }
+}
+
+void View::AddButton(Button* button)
+{
+  button->activated.connect([this] {request_hide.emit();});
+  buttons_layout_->AddView(button);
+  debug::Introspectable::AddChild(button);
+
+  // This resets back the keyboard focus to the view when a button is unselected
+  button->highlighted.changed.connect([this] (bool value) {
+    if (!value)
+      nux::GetWindowCompositor().SetKeyFocusArea(this);
+  });
+
+  // This function ensures that when an item is activated, the button state
+  // is reset as soon as the parent window has been closed.
+  button->activated.connect([this, button] {
+    auto* top_win = static_cast<nux::BaseWindow*>(GetTopLevelViewWindow());
+    if (top_win && top_win->IsVisible())
+    {
+      auto conn = std::make_shared<sigc::connection>();
+      *conn = top_win->sigHidden.connect([this, button, conn] (nux::BaseWindow*) {
+        button->highlighted = false;
+        conn->disconnect();
+      });
+    }
+    else
+    {
+      button->highlighted = false;
+    }
+  });
+}
+
+void View::PreLayoutManagement()
+{
+  subtitle_->SetMaximumWidth(buttons_layout_->GetContentWidth());
+
+  nux::View::PreLayoutManagement();
+}
+
+nux::Geometry View::GetBackgroundGeometry()
+{
+  return GetGeometry();
+}
+
+void View::DrawOverlay(nux::GraphicsEngine& GfxContext, bool force_draw, nux::Geometry const& clip)
+{
+  view_layout_->ProcessDraw(GfxContext, force_draw);
+}
+
+nux::Area* View::FindKeyFocusArea(unsigned etype, unsigned long key_code, unsigned long modifiers)
+{
+  if (etype != nux::NUX_KEYDOWN)
+    return UnityWindowView::FindKeyFocusArea(etype, key_code, modifiers);
+
+  if (key_code == NUX_VK_LEFT || key_code == NUX_VK_RIGHT)
+  {
+    nux::InputArea* focused = nux::GetWindowCompositor().GetKeyFocusArea();
+
+    if (!focused || focused == this || !focused->IsChildOf(this))
+    {
+      if (key_code == NUX_VK_LEFT)
+      {
+        return buttons_layout_->GetChildren().front();
+      }
+      else if (key_code == NUX_VK_RIGHT)
+      {
+        return buttons_layout_->GetChildren().back();
+      }
+    }
+  }
+  else if (key_code == NUX_VK_ESCAPE)
+  {
+    nux::InputArea* focused = nux::GetWindowCompositor().GetKeyFocusArea();
+
+    if (!focused || !focused->IsMouseInside())
+      return this;
+  }
+
+  return UnityWindowView::FindKeyFocusArea(etype, key_code, modifiers);
+}
+
+nux::Area* View::KeyNavIteration(nux::KeyNavDirection direction)
+{
+  if (direction == nux::KEY_NAV_LEFT)
+    return buttons_layout_->GetChildren().back();
+  else if (direction == nux::KEY_NAV_RIGHT)
+    return buttons_layout_->GetChildren().front();
+
+  return nux::View::KeyNavIteration(direction);
+}
+
+//
+// Introspectable methods
+//
+std::string View::GetName() const
+{
+  return "SessionView";
+}
+
+void View::AddProperties(GVariantBuilder* builder)
+{
+  UnityWindowView::AddProperties(builder);
+  variant::BuilderWrapper(builder)
+    .add("mode", static_cast<int>(mode()))
+    .add("inhibitors", have_inhibitors())
+    .add("title",title_->GetText())
+    .add("subtitle",subtitle_->GetText());
+}
+
+} // namespace session
+} // namespace unity

=== added file 'shutdown/SessionView.h'
--- shutdown/SessionView.h	1970-01-01 00:00:00 +0000
+++ shutdown/SessionView.h	2013-03-07 22:50:34 +0000
@@ -0,0 +1,86 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+* Copyright (C) 2013 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 UNITYSHELL_SESSION_VIEW_H
+#define UNITYSHELL_SESSION_VIEW_H
+
+#include <Nux/Nux.h>
+#include <Nux/View.h>
+#include <Nux/HLayout.h>
+
+#include "unity-shared/UnityWindowView.h"
+
+namespace unity
+{
+class StaticCairoText;
+namespace session
+{
+class Button;
+
+class View : public ui::UnityWindowView
+{
+  NUX_DECLARE_OBJECT_TYPE(View, ui::UnityWindowView);
+public:
+  typedef nux::ObjectPtr<View> Ptr;
+
+  enum class Mode
+  {
+    FULL,
+    SHUTDOWN,
+    LOGOUT
+  };
+
+  View(Manager::Ptr const& manager);
+
+  nux::Property<Mode> mode;
+  nux::Property<bool> have_inhibitors;
+
+  sigc::signal<void> request_hide;
+
+protected:
+  void PreLayoutManagement();
+  void DrawOverlay(nux::GraphicsEngine&, bool force, nux::Geometry const&);
+  nux::Geometry GetBackgroundGeometry();
+
+  nux::Area* FindKeyFocusArea(unsigned etype, unsigned long key, unsigned long mod);
+  nux::Area* KeyNavIteration(nux::KeyNavDirection);
+
+  // Introspectable methods
+  std::string GetName() const;
+  void AddProperties(GVariantBuilder* builder);
+
+private:
+  friend class TestSessionView;
+
+  void UpdateText();
+  void Populate();
+  void AddButton(Button*);
+
+  Manager::Ptr manager_;
+  StaticCairoText* title_;
+  StaticCairoText* subtitle_;
+  nux::HLayout* buttons_layout_;
+};
+
+} // namespace session
+
+} // namespace unity
+
+#endif // UNITYSHELL_SESSION_VIEW_H
+

=== added file 'shutdown/StandaloneSession.cpp'
--- shutdown/StandaloneSession.cpp	1970-01-01 00:00:00 +0000
+++ shutdown/StandaloneSession.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,99 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 <[e-mail]>
+ */
+
+#include "config.h"
+#include <glib/gi18n-lib.h>
+#include <gtk/gtk.h>
+#include <Nux/Nux.h>
+#include <Nux/NuxTimerTickSource.h>
+#include <Nux/WindowThread.h>
+#include <NuxCore/AnimationController.h>
+
+#include "unity-shared/BackgroundEffectHelper.h"
+#include "SessionController.h"
+#include "unity-shared/UnitySettings.h"
+
+using namespace unity;
+
+class MockSessionManager : public session::Manager
+{
+public:
+  MockSessionManager() = default;
+
+  std::string RealName() const { return "Marco Trevisan"; }
+  std::string UserName() const { return "marco"; }
+
+  void LockScreen() { std::cout << "LockScreen" << std::endl; }
+  void Logout() { std::cout << "Logout" << std::endl; }
+  void Reboot() { std::cout << "Reboot" << std::endl; }
+  void Shutdown() { std::cout << "Shutdown" << std::endl; }
+  void Suspend() { std::cout << "Suspend" << std::endl; }
+  void Hibernate() { std::cout << "Hibernate" << std::endl; }
+
+  void CancelAction() { std::cout << "CancelAction" << std::endl; }
+
+  bool CanShutdown() const {return true;}
+  bool CanSuspend() const {return true;}
+  bool CanHibernate() const {return true;}
+};
+
+struct SessionWindow
+{
+  SessionWindow()
+    : wt(nux::CreateGUIThread("Unity Session Controller", 1024, 300, 0, &SessionWindow::ThreadWidgetInit, this))
+    , animation_controller(tick_source)
+  {}
+
+  void Show()
+  {
+    wt->Run(nullptr);
+  }
+
+private:
+  void Init();
+
+  static void ThreadWidgetInit(nux::NThread* thread, void* self)
+  {
+    static_cast<SessionWindow*>(self)->Init();
+  }
+
+  unity::Settings settings;
+  std::shared_ptr<nux::WindowThread> wt;
+  nux::NuxTimerTickSource tick_source;
+  nux::animation::AnimationController animation_controller;
+  session::Controller::Ptr controller;
+};
+
+void SessionWindow::Init()
+{
+  BackgroundEffectHelper::blur_type = BLUR_NONE;
+  auto manager = std::make_shared<MockSessionManager>();
+  controller = std::make_shared<session::Controller>(manager);
+  manager->shutdown_requested.emit(false);
+}
+
+int main(int argc, char** argv)
+{
+  gtk_init(&argc, &argv);
+
+  nux::NuxInitialize(0);
+  SessionWindow().Show();
+
+  return 0;
+}

=== added directory 'shutdown/pch'
=== added file 'shutdown/pch/shutdown_pch.hh'
--- shutdown/pch/shutdown_pch.hh	1970-01-01 00:00:00 +0000
+++ shutdown/pch/shutdown_pch.hh	2013-03-07 22:50:34 +0000
@@ -0,0 +1,29 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 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: Jussi Pakkanen <[e-mail]>
+ */
+
+/*
+ * These are the precompiled header includes for this module.
+ * Only system header files can be listed here.
+ */
+
+#include <memory>
+
+#include <Nux/Nux.h>
+#include <NuxCore/Property.h>
+#include <UnityCore/GnomeSessionManager.h>

=== modified file 'tests/CMakeLists.txt'
--- tests/CMakeLists.txt	2013-03-07 22:50:33 +0000
+++ tests/CMakeLists.txt	2013-03-07 22:50:34 +0000
@@ -49,6 +49,7 @@
 include_directories (${CMAKE_SOURCE_DIR}/panel)
 include_directories (${CMAKE_SOURCE_DIR}/hud)
 include_directories (${CMAKE_SOURCE_DIR}/shortcuts)
+include_directories (${CMAKE_SOURCE_DIR}/shutdown)
 include_directories (${CMAKE_SOURCE_DIR}/unity-shared)
 # We can't have convenience libs so we need to rebuild with what we need
 # Please keep actual test files alphabetically at top and then files
@@ -244,6 +245,9 @@
                  test_result_renderer.cpp
                  test_resultviewgrid.cpp
                  test_searchbar.cpp
+                 test_session_button.cpp
+                 test_session_controller.cpp
+                 test_session_view.cpp
                  test_shortcut_controller.cpp
                  test_shortcut_modeller_compiz.cpp
                  test_shortcut_view.cpp
@@ -280,7 +284,22 @@
               gmockmount.c
               gmockvolume.c
               )
-  target_link_libraries(test-gtest test-gtest-plainc gtest gmock unity-shared ${LIBS} launcher-lib unity-shared-bamf unity-shared-standalone shortcuts-lib previews-lib hud-lib switcher-lib dash-lib panel-lib)
+  target_link_libraries(test-gtest
+                        test-gtest-plainc
+                        gtest
+                        gmock
+                        unity-shared
+                        ${LIBS}
+                        launcher-lib
+                        unity-shared-bamf
+                        unity-shared-standalone
+                        shortcuts-lib
+                        previews-lib
+                        hud-lib
+                        switcher-lib
+                        shutdown-lib
+                        dash-lib
+                        panel-lib)
   add_test(UnityGTest test-gtest)
 endif (ENABLE_X_SUPPORT)
 endif (GTEST_SRC_DIR AND

=== added file 'tests/test_mock_session_manager.h'
--- tests/test_mock_session_manager.h	1970-01-01 00:00:00 +0000
+++ tests/test_mock_session_manager.h	2013-03-07 22:50:34 +0000
@@ -0,0 +1,49 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 <gmock/gmock.h>
+#include <UnityCore/SessionManager.h>
+
+namespace unity
+{
+namespace session
+{
+
+struct MockManager : Manager
+{
+  typedef std::shared_ptr<MockManager> Ptr;
+
+  MOCK_CONST_METHOD0(RealName, std::string());
+  MOCK_CONST_METHOD0(UserName, std::string());
+
+  MOCK_METHOD0(LockScreen, void());
+  MOCK_METHOD0(Logout, void());
+  MOCK_METHOD0(Reboot, void());
+  MOCK_METHOD0(Shutdown, void());
+  MOCK_METHOD0(Suspend, void());
+  MOCK_METHOD0(Hibernate, void());
+  MOCK_METHOD0(CancelAction, void());
+
+  MOCK_CONST_METHOD0(CanShutdown, bool());
+  MOCK_CONST_METHOD0(CanSuspend, bool());
+  MOCK_CONST_METHOD0(CanHibernate, bool());
+};
+
+} // session
+} // unity
\ No newline at end of file

=== added file 'tests/test_session_button.cpp'
--- tests/test_session_button.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_session_button.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,124 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 <gmock/gmock.h>
+#include "SessionButton.h"
+
+using namespace unity::session;
+
+namespace unity
+{
+namespace session
+{
+
+struct TestSessionButton : testing::Test
+{
+  struct ButtonWrap : Button
+  {
+    ButtonWrap() : Button("ButtonLabel", "hibernate") {}
+
+    using Button::AcceptKeyNavFocusOnMouseEnter;
+    using Button::AcceptKeyNavFocusOnMouseDown;
+    using Button::image_view_;
+    using Button::highlight_tex_;
+    using Button::normal_tex_;
+    using Button::label_view_;
+  };
+
+  ButtonWrap button;
+};
+
+TEST_F(TestSessionButton, Construct)
+{
+  EXPECT_FALSE(button.highlighted());
+  EXPECT_EQ(button.label(), "ButtonLabel");
+  EXPECT_TRUE(button.AcceptKeyNavFocusOnMouseEnter());
+  EXPECT_FALSE(button.AcceptKeyNavFocusOnMouseDown());
+}
+
+TEST_F(TestSessionButton, HighlightUpdatesTextures)
+{
+  button.highlighted = true;
+  EXPECT_EQ(button.image_view_->texture(), button.highlight_tex_);
+}
+
+TEST_F(TestSessionButton, HighlightShowsText)
+{
+  button.highlighted = true;
+  EXPECT_NE(button.label_view_->GetTextColor(), nux::color::Transparent);
+}
+
+TEST_F(TestSessionButton, UnHighlightUpdatesTextures)
+{
+  button.highlighted = true;
+  button.highlighted = false;
+  EXPECT_EQ(button.image_view_->texture(), button.normal_tex_);
+}
+
+TEST_F(TestSessionButton, UnHighlightHidesText)
+{
+  button.highlighted = true;
+  button.highlighted = false;
+  EXPECT_EQ(button.label_view_->GetTextColor(), nux::color::Transparent);
+}
+
+TEST_F(TestSessionButton, MouseEnterHighlights)
+{
+  button.mouse_enter.emit(0, 0, 0, 0);
+  EXPECT_TRUE(button.highlighted());
+}
+
+TEST_F(TestSessionButton, MouseLeaveUnhighlights)
+{
+  button.highlighted = true;
+  button.mouse_leave.emit(0, 0, 0, 0);
+  EXPECT_FALSE(button.highlighted());
+}
+
+TEST_F(TestSessionButton, MouseClickActivatesIt)
+{
+  bool activated = false;
+  button.activated.connect([&activated] { activated = true; });
+  button.mouse_click.emit(0, 0, 0, 0);
+  EXPECT_TRUE(activated);
+}
+
+TEST_F(TestSessionButton, KeyFocusBeginHighlights)
+{
+  button.begin_key_focus.emit();
+  EXPECT_TRUE(button.highlighted());
+}
+
+TEST_F(TestSessionButton, KeyFocusEndUnhighlights)
+{
+  button.highlighted = true;
+  button.end_key_focus.emit();
+  EXPECT_FALSE(button.highlighted());
+}
+
+TEST_F(TestSessionButton, KeyFocusActivatesIt)
+{
+  bool activated = false;
+  button.activated.connect([&activated] { activated = true; });
+  button.key_nav_focus_activate.emit(&button);
+  EXPECT_TRUE(activated);
+}
+
+} // session
+} // unity
\ No newline at end of file

=== added file 'tests/test_session_controller.cpp'
--- tests/test_session_controller.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_session_controller.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,162 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 <gmock/gmock.h>
+#include <Nux/NuxTimerTickSource.h>
+#include <NuxCore/AnimationController.h>
+#include "test_mock_session_manager.h"
+#include "SessionController.h"
+#include "UnitySettings.h"
+
+namespace unity
+{
+namespace session
+{
+
+const unsigned ANIMATION_DURATION = 90 * 1000; // in microseconds
+
+struct TestSessionController : testing::Test
+{
+  TestSessionController()
+    : animation_controller(tick_source)
+    , manager(std::make_shared<testing::NiceMock<MockManager>>())
+    , controller(manager)
+  {
+    ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  }
+
+  struct ControllerWrap : Controller
+  {
+    ControllerWrap(Manager::Ptr const& manager) : Controller(manager) {}
+
+    using Controller::view_;
+    using Controller::view_window_;
+  };
+
+  nux::NuxTimerTickSource tick_source;
+  nux::animation::AnimationController animation_controller;
+  unity::Settings settings;
+  MockManager::Ptr manager;
+  ControllerWrap controller;
+};
+
+TEST_F(TestSessionController, Construct)
+{
+  EXPECT_FALSE(controller.Visible());
+}
+
+struct ShowMode : TestSessionController, testing::WithParamInterface<View::Mode> {};
+INSTANTIATE_TEST_CASE_P(TestSessionController, ShowMode,
+  testing::Values(View::Mode::SHUTDOWN, View::Mode::LOGOUT, View::Mode::FULL));
+
+TEST_P(/*TestSessionController*/ShowMode, Show)
+{
+  controller.Show(GetParam());
+  EXPECT_TRUE(controller.Visible());
+  EXPECT_EQ(controller.view_->mode(), GetParam());
+  EXPECT_EQ(nux::GetWindowCompositor().GetKeyFocusArea(), controller.view_.GetPointer());
+  EXPECT_TRUE(controller.view_->live_background());
+}
+
+TEST_F(TestSessionController, Hide)
+{
+  controller.Show(View::Mode::FULL);
+  ASSERT_TRUE(controller.Visible());
+  EXPECT_CALL(*manager, CancelAction()).Times(0);
+
+  controller.Hide();
+  tick_source.tick(ANIMATION_DURATION);
+
+  EXPECT_FALSE(controller.Visible());
+  EXPECT_FALSE(controller.view_->live_background());
+}
+
+struct Inhibited : TestSessionController, testing::WithParamInterface<bool> {};
+INSTANTIATE_TEST_CASE_P(TestSessionController, Inhibited, testing::Values(true, false));
+
+TEST_P(/*TestSessionController*/Inhibited, RebootRequested)
+{
+  manager->reboot_requested.emit(GetParam());
+  EXPECT_TRUE(controller.Visible());
+  EXPECT_EQ(controller.view_->mode(), View::Mode::SHUTDOWN);
+  EXPECT_EQ(controller.view_->have_inhibitors(), GetParam());
+}
+
+TEST_P(/*TestSessionController*/Inhibited, ShutdownRequested)
+{
+  manager->shutdown_requested.emit(GetParam());
+  EXPECT_TRUE(controller.Visible());
+  EXPECT_EQ(controller.view_->mode(), View::Mode::FULL);
+  EXPECT_EQ(controller.view_->have_inhibitors(), GetParam());
+}
+
+TEST_P(/*TestSessionController*/Inhibited, LogoutRequested)
+{
+  manager->logout_requested.emit(GetParam());
+  EXPECT_TRUE(controller.Visible());
+  EXPECT_EQ(controller.view_->mode(), View::Mode::LOGOUT);
+  EXPECT_EQ(controller.view_->have_inhibitors(), GetParam());
+}
+
+TEST_F(TestSessionController, CancelRequested)
+{
+  controller.Show(View::Mode::FULL);
+  ASSERT_TRUE(controller.Visible());
+
+  EXPECT_CALL(*manager, CancelAction()).Times(0);
+  manager->cancel_requested.emit();
+  tick_source.tick(ANIMATION_DURATION);
+  EXPECT_FALSE(controller.Visible());
+}
+
+TEST_F(TestSessionController, RequestHide)
+{
+  controller.Show(View::Mode::FULL);
+  ASSERT_TRUE(controller.Visible());
+
+  EXPECT_CALL(*manager, CancelAction()).Times(0);
+  controller.view_->request_hide.emit();
+  tick_source.tick(ANIMATION_DURATION);
+  EXPECT_FALSE(controller.Visible());
+}
+
+TEST_F(TestSessionController, RequestClose)
+{
+  controller.Show(View::Mode::FULL);
+  ASSERT_TRUE(controller.Visible());
+
+  EXPECT_CALL(*manager, CancelAction());
+  controller.view_->request_close.emit();
+  tick_source.tick(ANIMATION_DURATION);
+  EXPECT_FALSE(controller.Visible());
+}
+
+TEST_F(TestSessionController, HidesAndCancelOnClickOutside)
+{
+  controller.Show(View::Mode::FULL);
+  ASSERT_TRUE(controller.Visible());
+
+  EXPECT_CALL(*manager, CancelAction());
+  controller.view_window_->mouse_down_outside_pointer_grab_area.emit(0, 0, 0, 0);
+  tick_source.tick(ANIMATION_DURATION);
+  EXPECT_FALSE(controller.Visible());
+}
+
+} // session
+} // unity
\ No newline at end of file

=== added file 'tests/test_session_view.cpp'
--- tests/test_session_view.cpp	1970-01-01 00:00:00 +0000
+++ tests/test_session_view.cpp	2013-03-07 22:50:34 +0000
@@ -0,0 +1,280 @@
+// -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
+/*
+ * Copyright (C) 2013 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 <gmock/gmock.h>
+#include "test_mock_session_manager.h"
+#include "SessionButton.h"
+#include "SessionView.h"
+#include "UnitySettings.h"
+
+namespace unity
+{
+namespace session
+{
+
+struct TestSessionView : testing::Test
+{
+  TestSessionView()
+    : manager(std::make_shared<testing::NiceMock<MockManager>>())
+    , view(manager)
+  {}
+
+  struct ViewWrap : View
+  {
+    ViewWrap(Manager::Ptr const& manager) : View(manager) {}
+
+    std::string GetTitle() const { return title_->IsVisible() ? title_->GetText() : ""; }
+    std::string GetSubTitle() const { return subtitle_->GetText(); }
+
+    std::list<Button*> GetButtons() const
+    {
+      std::list<Button*> buttons;
+
+      for (auto const& button : buttons_layout_->GetChildren())
+      {
+        auto session_button = dynamic_cast<Button*>(button);
+        EXPECT_NE(session_button, nullptr);
+
+        if (!session_button)
+          return std::list<Button*>();
+
+        buttons.push_back(session_button);
+      }
+
+      return buttons;
+    }
+
+    Button* GetButtonByLabel(std::string const& label) const
+    {
+      for (auto const& button : GetButtons())
+      {
+        if (button->label() == label)
+          return button;
+      }
+
+      return nullptr;
+    }
+  };
+
+  void TearDown()
+  {
+    nux::GetWindowCompositor().SetKeyFocusArea(nullptr);
+  }
+
+  unity::Settings settings;
+  MockManager::Ptr manager;
+  ViewWrap view;
+};
+
+TEST_F(TestSessionView, Construct)
+{
+  EXPECT_TRUE(view.closable());
+  EXPECT_FALSE(view.have_inhibitors());
+  EXPECT_EQ(view.mode(), View::Mode::FULL);
+}
+
+TEST_F(TestSessionView, RequestCloseOnBoundingAreaClick)
+{
+  bool request_close = false;
+  view.request_close.connect([&request_close] { request_close = true; });
+  view.GetBoundingArea()->mouse_click.emit(0, 0, 0, 0);
+  EXPECT_TRUE(request_close);
+}
+
+TEST_F(TestSessionView, ModeChange)
+{
+  view.mode = View::Mode::LOGOUT;
+  EXPECT_EQ(view.mode, View::Mode::LOGOUT);
+
+  view.mode = View::Mode::FULL;
+  EXPECT_EQ(view.mode, View::Mode::FULL);
+}
+
+TEST_F(TestSessionView, ModeChangeOnShutdownSupported)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+
+  view.mode = View::Mode::SHUTDOWN;
+  EXPECT_EQ(view.mode, View::Mode::SHUTDOWN);
+}
+
+TEST_F(TestSessionView, ModeChangeOnShutdownUnsupported)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(false));
+
+  view.mode = View::Mode::SHUTDOWN;
+  EXPECT_EQ(view.mode, View::Mode::LOGOUT);
+}
+
+TEST_F(TestSessionView, FullModeButtons)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  ON_CALL(*manager, CanSuspend()).WillByDefault(testing::Return(true));
+  ON_CALL(*manager, CanHibernate()).WillByDefault(testing::Return(true));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_EQ(view.GetButtonByLabel("Logout"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Lock"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Suspend"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Hibernate"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Shutdown"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Restart"), nullptr);
+
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(false));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_NE(view.GetButtonByLabel("Logout"), nullptr);
+  EXPECT_EQ(view.GetButtonByLabel("Shutdown"), nullptr);
+  EXPECT_EQ(view.GetButtonByLabel("Restart"), nullptr);
+
+  ON_CALL(*manager, CanSuspend()).WillByDefault(testing::Return(false));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_EQ(view.GetButtonByLabel("Suspend"), nullptr);
+
+  ON_CALL(*manager, CanHibernate()).WillByDefault(testing::Return(false));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_EQ(view.GetButtonByLabel("Hibernate"), nullptr);
+}
+
+TEST_F(TestSessionView, ShutdownModeButtons)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  view.mode = View::Mode::SHUTDOWN;
+
+  EXPECT_EQ(view.GetButtons().size(), 2);
+  EXPECT_NE(view.GetButtonByLabel("Shutdown"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Restart"), nullptr);
+}
+
+TEST_F(TestSessionView, LogoutModeButtons)
+{
+  view.mode = View::Mode::LOGOUT;
+
+  EXPECT_EQ(view.GetButtons().size(), 2);
+  EXPECT_NE(view.GetButtonByLabel("Logout"), nullptr);
+  EXPECT_NE(view.GetButtonByLabel("Lock"), nullptr);
+}
+
+TEST_F(TestSessionView, FullModeTitle)
+{
+  EXPECT_TRUE(view.GetTitle().empty());
+}
+
+TEST_F(TestSessionView, ShutdownModeTitle)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  view.mode = View::Mode::SHUTDOWN;
+
+  EXPECT_EQ(view.GetTitle(), "Shut Down");
+}
+
+TEST_F(TestSessionView, LogoutModeTitle)
+{
+  view.mode = View::Mode::LOGOUT;
+
+  EXPECT_EQ(view.GetTitle(), "Log Out");
+}
+
+TEST_F(TestSessionView, ButtonsActivateRequestsHide)
+{
+  bool request_hide = false;
+  view.request_hide.connect([&request_hide] { request_hide = true; });
+
+  auto button = view.GetButtonByLabel("Lock");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+
+  EXPECT_TRUE(request_hide);
+}
+
+TEST_F(TestSessionView, ButtonsActivateDeselectButton)
+{
+  auto button = view.GetButtonByLabel("Lock");
+  ASSERT_NE(button, nullptr);
+  button->highlighted = true;
+  button->activated.emit();
+
+  EXPECT_FALSE(button->highlighted());
+}
+
+TEST_F(TestSessionView, LockButtonActivateLocks)
+{
+  EXPECT_CALL(*manager, LockScreen());
+  auto button = view.GetButtonByLabel("Lock");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+TEST_F(TestSessionView, LogoutButtonActivateLogouts)
+{
+  view.mode = View::Mode::LOGOUT;
+  EXPECT_CALL(*manager, Logout());
+  auto button = view.GetButtonByLabel("Logout");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+TEST_F(TestSessionView, SuspendButtonActivateSuspends)
+{
+  ON_CALL(*manager, CanSuspend()).WillByDefault(testing::Return(true));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_CALL(*manager, Suspend());
+  auto button = view.GetButtonByLabel("Suspend");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+TEST_F(TestSessionView, HibernateButtonActivateHibernates)
+{
+  ON_CALL(*manager, CanHibernate()).WillByDefault(testing::Return(true));
+  view.mode.changed.emit(View::Mode::FULL);
+
+  EXPECT_CALL(*manager, Hibernate());
+  auto button = view.GetButtonByLabel("Hibernate");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+TEST_F(TestSessionView, ShutdownButtonActivateShutsdown)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  view.mode = View::Mode::SHUTDOWN;
+
+  EXPECT_CALL(*manager, Shutdown());
+  auto button = view.GetButtonByLabel("Shutdown");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+TEST_F(TestSessionView, RebootButtonActivateReboots)
+{
+  ON_CALL(*manager, CanShutdown()).WillByDefault(testing::Return(true));
+  view.mode = View::Mode::SHUTDOWN;
+
+  EXPECT_CALL(*manager, Reboot());
+  auto button = view.GetButtonByLabel("Restart");
+  ASSERT_NE(button, nullptr);
+  button->activated.emit();
+}
+
+} // session
+} // unity
\ No newline at end of file

=== modified file 'tests/test_unity_window_view.cpp'
--- tests/test_unity_window_view.cpp	2013-03-07 22:50:33 +0000
+++ tests/test_unity_window_view.cpp	2013-03-07 22:50:34 +0000
@@ -21,7 +21,6 @@
 #include "UnityWindowView.h"
 #include "UnitySettings.h"
 #include "WindowManager.h"
-#include "test_utils.h"
 #include <Nux/VLayout.h>
 
 using namespace unity;

=== modified file 'unity-shared/UnityWindowStyle.cpp'
--- unity-shared/UnityWindowStyle.cpp	2013-03-07 22:50:33 +0000
+++ unity-shared/UnityWindowStyle.cpp	2013-03-07 22:50:34 +0000
@@ -50,7 +50,7 @@
 
 int UnityWindowStyle::GetCloseButtonPadding() const
 {
-  return 2;
+  return 3;
 }
 
 UnityWindowStyle::BaseTexturePtr UnityWindowStyle::GetCloseIcon()