Merge lp:~3v1n0/unity/unity-decorations into lp:unity

[Marco Trevisan (Treviño)]

decorations: added new unity-decorations fully gtk-css-themed inside unity

Added new decorations to unity, inside unity itself instead of depending on the
compiz "decor" plugin and on a decorator (gtk-window-decorator).
My mission: «Everything changes, but nothing changes»; so completely new backend,
same results.

- Support for full Gtk3 Theming (https://wiki.ubuntu.com/Unity/Theming)
- Improved resizing speed when using "Normal Resize" in compiz
- Removed duplicated textures, IPC between compiz and the decorator
- Anti aliased corners!!

Screenshot:
 - Ambiance: http://ubuntuone.com/0QIWISIXmf1zRJfDiIqLHz
 - Radiance: http://ubuntuone.com/1CfUWwRj0xICU3otSfjTyY

Things to do:
- Add right-click window menu support
- Add "force quit" dialog

Not supported:
- Window buttons positions (we want a consistent user experience in unity, that
  covers both the windows and the top panel and here the window buttons are, by
  design on the top left corner of a window. Always).
- Custom actions on bar clicks (maybe to be supported later)
- Different decorators, just use themes.

This branch needs has a "soft dependency" on lp:~3v1n0/ubuntu-themes/unity-decorations
(for proper theming) and on lp:~3v1n0/compiz/disable-decor-with-unity to disable
decor plugin on settings.

=================

Technical details (use a better diff visualizer for review, like bzr qdiff):

- Added DecorationsManager: that handles all the windows, creates them and
  redirect to the proper target the relative events.
- DecoratedWindow: wraps a CompWindow, set the extents, generates the background
  textures, the top layout and draws them on screen.

Both DecorationsManager is allocated and controlled by UnityScreen (that redirects
the events to it), while each UnityWindow controls a DecoratedWindow, and redirects
to it the relevant compiz calls.

As for the decoration widgets, since I needed a simple way to handle textures and
to create a simple layout for displaying them, depending on the window size and
positioning, I've decided to write a small "widgets library" used to paint elements
and handle input events. What I called decoration::Item is basically a simple
widget with a geometry and that can be added into a container and managed by it.
Also, I've built an "InputMixer" (event compositor) that has the role to redirect
events to the proper widget that it manages.

So, with these tools, I've built all the widgets that are in a decoration:
 - A DecorationsEdgeBorders, that is a container of DecorationsGrabEdge, that are
   input-only widgets that care about mouse events, draw the right mouse pointers
   and allow to resize and move a window (now the GrabEdge has the same logic of
   the PanelGrabArea).
 - A Layout containing the window buttons and the window title.

To properly theme the decorations I've built a decoration::Style class that
defines custom gtk-css parameters for an "UnityDecoration" widget that is used
for theming the whole decorations; read the values, caches the relevant settings
and emits signals when theme or font parameters changes. panel::Style has been
rewritten to use decoration::Style as its main source.

Other aspects:
- Removed all the unneeded code for decorating, undecorating and monitoring
  decorations from PluginAdapter.
- Moved some XLib-only calls from PluginAdapter to XWindowManager and optimized
  GetWindowName using the new GetStringProperty.
- Removing the unneeded code from PanelMenuView that was handling the decorations
  and use decoration::Style on it; also remove a lot of unneeded redraws.
- Use decoration::Style for painting fake-decorations in UnityWindow.
- Added CompizUtils to unity-shared-compiz, that contains some structs, classes
  and functions that are useful for other components that are handling things
  with compiz (allows removing duplicated code from UnityWindow as well).
- Added decoration::DataPool utility class to load and cache shared resources
- Shadows are based on simple pixmaps that are generated through cairo just
  once per session (or when the shadow settings change) and shared by all
  the windows.
- Fixed linking of standalone components (and tests) against libunity-protocol-private
  (now the library dir is added to dpath, no need to use LD_LIBRARY_PATH any more).
- Added compiz settings to override theme shadow parameters.
- Improved fallback window buttons (now they're filled with foreground color).
- All the decoration objects support debug introspection for autopilot tests.
- Added unit tests for decoration::Item and InputMixer, more tests to come later.

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3890
http://jenkins.qa.ubuntu.com/job/unity-ci/563/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/99
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/95
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/97

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/563/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3891
http://jenkins.qa.ubuntu.com/job/unity-ci/565/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/101
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/97
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/99

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/565/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

On a side note this only causes 4 conflicts in my panel high dpi code!

Text conflict in unity-shared/PanelStyle.cpp
Text conflict in unity-shared/PanelStyle.h
Text conflict in unity-shared/WindowButtonPriv.h
Text conflict in unity-shared/WindowButtons.cpp
4 conflicts encountered.

So it shouldn't be to bad to merge those over this. Ill get on that tomorrow after I finish going through this!

[Brandon Schaefer (brandontschaefer)]

Ignore what I already sent you! Im at about 7-8k (The test looked good!) What I have so far:

You shouldn't need the ';' but i could be wrong

+ set(UNITY_STANDALONE_LADD ${UNITY_STANDALONE_LADD};${UNITY_PROTOCOL_PRIVATE_LIB})

----

To make things a but more readable, we should split this function into 2 smaller functions that accept the frame_geo as an arguments:

+void Window::Impl::UpdateFrame()

1, + if (!frame_), should then just call CreateNewFrame(frame_geo);

2, + if (frame_geo_ != frame_geo), UpdateFrameGeo(frame_geo) ... or something like that, so the function will just look like:

+void Window::Impl::UpdateFrame()
+{
+ auto const& input = win_->input();
+ auto const& server = win_->serverGeometry();
+ nux::Geometry frame_geo(0, 0, server.widthIncBorders() + input.left + input.right,
+ server.heightIncBorders() + input.top + input.bottom);
+
+ if (win_->shaded())
+ frame_geo.height = input.top + input.bottom;
+
+ if (!frame_)
+ CreateNewFrame(frame_geo);
+
+ if (frame_geo_ != frame_geo)
+ UpdateFrameGeo(frame_geo);
+}

Just makes things a bit more readable, imo.

----

An if statement is a bit more readable here.

+ return active() || parent_->scaled() ? mi->active_shadow_pixmap_->texture() : mi->inactive_shadow_pixmap_->texture();

+ return active() || parent_->scaled() ? manager_->active_shadow_radius() : manager_->inactive_shadow_radius();

----

Should be a const pointer, or rather could be a const pointer to const data:

auto const* const texture.

+ auto* texture = ShadowTexture();

+ auto* win = impl_->win_;

----

Are these just for testing? As I see a lot of friend classes...which kind of defeats the purpose of encapsulation. It'll make it hard to track down bugs when all these other classes have access to the private members.... I would much rather provide an access function to these for Read only if thats whats needed. (Vs having read/write of private members.)

+ friend class Manager;

+ friend class Window;

+ friend class Window;
+ friend struct Manager::Impl;

+ friend class Manager;
+ friend struct Window::Impl;

+ friend class InputMixer;

+ friend class Item;

+ friend class decoration::Manager;

+ friend class decoration::Window;
+ friend class decoration::Manager;

----

Why make a global read/write variable for this? This should be part of the class.

+Display* dpy = nullptr;

----

You can simply this:

+EdgeBorders::EdgeBorders(CompWindow* win)
+{
+ items_.resize(size_t(Edge::Type::Size));
+
+ auto item = std::make_shared<Edge>(win, Edge::Type::TOP);
+ items_[unsigned(Edge::Type::TOP)] = item;
+
+ item = std::make_shared<Edge>(win, Edge::Type::TOP_LEFT);
+ items_[unsigned(Edge::Type::TOP_LEFT)] = item;
+
+ item = std::make_shared<Edge>(win, Edge::Type::TOP_RIGHT);
+ items_[unsigned(Edge::Type::TOP_RIGHT)] = item;
+
+ item = std::make_shared<Edge>(win, Edge::Type::LEFT);
+ items_[unsigned(Edge::Type::LEFT)] = item;
+
+ item = std::make_shared<Edge>(win, Edge::Type::RIGHT);
+ items_[unsigned(Edge::Type::RIGHT)] = item;
+
+ item = std::make_shared<Edge>(win, Edge::Type::BOTTOM);
+ items_[unsigned(Edge::Type::BOTTOM)] = item;
+
+ item = std::...

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

> You shouldn't need the ';' but i could be wrong
>
> + set(UNITY_STANDALONE_LADD ${UNITY_STANDALONE_LADD};${UNITY_PROTOCOL_PRIVATE_LIB})

Oh, I thought I had a linking error without it, but it seems to go...
So, I've removed it. This is with gold btw.

> To make things a but more readable, we should split this function into 2 smaller
> functions that accept the frame_geo as an arguements:
>
> +void Window::Impl::UpdateFrame()
>
> 1, + if (!frame_), should then just call CreateNewFrame(frame_geo);

> 2, + if (frame_geo_ != frame_geo), UpdateFrameGeo(frame_geo) ... or something like that, so the function will just look like:
>
> +void Window::Impl::UpdateFrame()
> +{
> + auto const& input = win_->input();
> + auto const& server = win_->serverGeometry();
> + nux::Geometry frame_geo(0, 0, server.widthIncBorders() + input.left + input.right,
> + server.heightIncBorders() + input.top + input.bottom);
> +
> + if (win_->shaded())
> + frame_geo.height = input.top + input.bottom;
> +
> + if (!frame_)
> + CreateNewFrame(frame_geo);
> +
> + if (frame_geo_ != frame_geo)
> + UpdateFrameGeo(frame_geo);
> +}
>

Ok, sounds good!
I didn't that to keep the frame_geo in the same function without passing it, and
not to reclare input, in UpdateFrameGeo, but it's not really a problem.
I think you're right.

> An if statement is a bit more readable here.

> + return active() || parent_->scaled() ? mi->active_shadow_pixmap_->texture() : mi->inactive_shadow_pixmap_->texture();

> + return active() || parent_->scaled() ? manager_->active_shadow_radius() : manager_->inactive_shadow_radius();

Agreedo, it was smaller at the beginning, then it got bigger :P.

> Should be a const pointer, or rather could be a const pointer to const data:
>
> auto const* const texture.
>
> + auto* texture = ShadowTexture();
>
> + auto* win = impl_->win_;
>
> ----

It doesn't change much, but ok.

> Are these just for testing? As I see a lot of friend classes...which kind of
> defeats the purpose of encaspulation. It'll make it hard to track down bugs when
> all these other classes have access to the private members.... I would much rather
> provide an access funtion to these for Read only if thats whats needed. (Vs having
> read/write of private members.)
>
> + friend class Manager;

Unfortunately I need these to make possible to a Window to access to Impl
functions that are private, but not for manager... I mean, decoration::Manager
is strictly connected to the windows and it has to access to some methods that I
don't want to make visible to everyone... So, unfortunately here we can't use
protected in the way is in java or other languages (access to the members of the
"package"), so I need to use this way... That I don't like, but it's the only
method we have to access to private methods in very limited cases.
For sure the friendship with UnityScreen/UnityWindow can be removed (it was there
for testing), and I could also remove the friendship with the Impl structs, by
just adding some more "public" methods to them, so that there's no private write
access to the members... That's what already happens in fact, but if we want to
protect more I...

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3898
http://jenkins.qa.ubuntu.com/job/unity-ci/566/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/102
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/98
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/100/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/566/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3901
http://jenkins.qa.ubuntu.com/job/unity-ci/567/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/103
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/99
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/101

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/567/rebuild

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3902
http://jenkins.qa.ubuntu.com/job/unity-ci/568/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/104
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/100
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/102

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/unity-ci/568/rebuild

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

I've been using this branch for about a week now, and its working well!

Would like at lease one more person to go through the code, as this is a larger branch!

review: Approve

[Christopher Townsend (townsend)]

This works well for me too and I have nothing to add on the code itself. Well done!

review: Approve

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-01-03 16:26:42 +0000
+++ CMakeLists.txt	2014-01-23 15:21:26 +0000
@@ -157,6 +157,7 @@
 set (TESTDATADIR "${CMAKE_CURRENT_SOURCE_DIR}/tests/data")
 
 find_package (PkgConfig)
+execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} gtk+-3.0 --variable prefix OUTPUT_VARIABLE GTK_PREFIX OUTPUT_STRIP_TRAILING_WHITESPACE)
 execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} unity --variable lensesdir OUTPUT_VARIABLE LENSES_DIR OUTPUT_STRIP_TRAILING_WHITESPACE)
 execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} indicator3-0.4 --variable indicatordir OUTPUT_VARIABLE INDICATORDIR OUTPUT_STRIP_TRAILING_WHITESPACE)
 execute_process (COMMAND ${PKG_CONFIG_EXECUTABLE} indicator3-0.4 --variable iconsdir OUTPUT_VARIABLE INDICATORICONDIR OUTPUT_STRIP_TRAILING_WHITESPACE)
@@ -253,12 +254,16 @@
 
 pkg_check_modules (CACHED_UNITY_DEPS REQUIRED ${UNITY_PLUGIN_DEPS})
 pkg_check_modules (CACHED_UNITY_PRIVATE_DEPS REQUIRED ${UNITY_PROTOCOL_PRIVATE_DEPS})
+find_library (UNITY_PROTOCOL_PRIVATE_LIB unity-protocol-private ${CACHED_UNITY_PRIVATE_DEPS_LIBDIR} ${CACHED_UNITY_PRIVATE_DEPS_LIBRARY_DIRS})
+set(UNITY_STANDALONE_LADD ${UNITY_STANDALONE_LADD} ${UNITY_PROTOCOL_PRIVATE_LIB})
+
 add_subdirectory(unity-shared)
 add_subdirectory(dash)
 add_subdirectory(launcher)
 if (ENABLE_X_SUPPORT)
   add_subdirectory(hud)
   add_subdirectory(panel)
+  add_subdirectory(decorations)
   add_subdirectory(plugins/unityshell)
   add_subdirectory(plugins/networkarearegion)
   add_subdirectory(plugins/unitydialog)

=== modified file 'config.h.cmake'
--- config.h.cmake	2013-07-22 17:11:47 +0000
+++ config.h.cmake	2014-01-23 15:21:26 +0000
@@ -11,6 +11,7 @@
 #cmakedefine TESTDATADIR "@TESTDIRDIR@"
 #cmakedefine GETTEXT_PACKAGE "@GETTEXT_PACKAGE@"
 #cmakedefine LENSES_DIR "@LENSES_DIR@"
+#cmakedefine GTK_PREFIX "@GTK_PREFIX@"
 #ifndef INDICATORDIR
 #cmakedefine INDICATORDIR "@INDICATORDIR@"
 #endif

=== added directory 'decorations'
=== added file 'decorations/CMakeLists.txt'
--- decorations/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ decorations/CMakeLists.txt	2014-01-23 15:21:26 +0000
@@ -0,0 +1,38 @@
+find_package (PkgConfig)
+pkg_check_modules (COMPIZ_COMPOSITE REQUIRED "compiz-composite")
+
+set (CFLAGS
+     ${COMPIZ_COMPOSITE_CFLAGS}
+     ${CACHED_UNITY_DEPS_CFLAGS}
+     ${CACHED_UNITY_DEPS_CFLAGS_OTHER}
+     ${PIC_FLAGS}
+     )
+
+string (REPLACE ";" " " CFLAGS "${CFLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${CFLAGS}")
+include_directories (.. ../UnityCore ../unity-shared ${CMAKE_BINARY_DIR})
+
+# This makes linker to include library dir in RUNPATH
+find_library (COMPIZ_COMPOSITE_LIB composite ${COMPIZ_COMPOSITE_LIBDIR})
+set (LIBS ${CACHED_UNITY_DEPS_LDFLAGS} ${COMPIZ_COMPOSITE_LIB} ${COMPIZ_COMPOSITE_LDFLAGS} unity-shared-compiz)
+
+#
+# Headers & Sources
+#
+set (DECORATION_SOURCES
+     DecorationsManager.cpp
+     DecoratedWindow.cpp
+     DecorationsWidgets.cpp
+     DecorationsWindowButton.cpp
+     DecorationsEdge.cpp
+     DecorationsGrabEdge.cpp
+     DecorationsEdgeBorders.cpp
+     DecorationsTitle.cpp
+     DecorationsInputMixer.cpp
+     DecorationsDataPool.cpp
+     )
+
+add_library (decorations-lib STATIC ${DECORATION_SOURCES})
+target_link_libraries (decorations-lib ${LIBS})
+add_dependencies (decorations-lib unity-core-${UNITY_API_VERSION} unity-shared-compiz)
+add_pch(pch/decorations_pch.hh decorations-lib)

=== added file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecoratedWindow.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,654 @@
+// -*- 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 <NuxCore/Logger.h>
+#include "DecorationsPriv.h"
+#include "DecorationsWindowButton.h"
+#include "DecorationsEdgeBorders.h"
+#include "DecorationsGrabEdge.h"
+#include "WindowManager.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.decoration.window");
+}
+
+Window::Impl::Impl(Window* parent, CompWindow* win)
+  : active(false)
+  , parent_(parent)
+  , win_(win)
+  , cwin_(CompositeWindow::get(win_))
+  , glwin_(GLWindow::get(win_))
+  , frame_(0)
+  , dirty_geo_(true)
+{
+  active.changed.connect([this] (bool active) {
+    bg_textures_.clear();
+    if (top_layout_) top_layout_->focused = active;
+    RedrawDecorations();
+  });
+
+  parent->title.SetGetterFunction([this] {
+    if (title_)
+      return title_->text();
+
+    if (last_title_.empty())
+      last_title_ = WindowManager::Default().GetWindowName(win_->id());
+
+    return last_title_;
+  });
+
+  parent->title.SetSetterFunction([this] (std::string const& new_title) {
+    if (!title_)
+    {
+      if (last_title_ != new_title)
+      {
+        last_title_ = new_title;
+        return true;
+      }
+
+      return false;
+    }
+
+    if (new_title == title_->text())
+      return false;
+
+    title_->text = new_title;
+    return true;
+  });
+
+  parent->scaled.changed.connect(sigc::hide(sigc::mem_fun(this, &Impl::Update)));
+
+  if (win_->isViewable() || win_->shaded())
+    Update();
+}
+
+Window::Impl::~Impl()
+{
+  Undecorate();
+}
+
+void Window::Impl::Update()
+{
+  ShouldBeDecorated() ? Decorate() : Undecorate();
+}
+
+void Window::Impl::Decorate()
+{
+  SetupExtents();
+  UpdateFrame();
+  SetupWindowControls();
+}
+
+void Window::Impl::Undecorate()
+{
+  UnsetExtents();
+  UnsetFrame();
+  CleanupWindowControls();
+  bg_textures_.clear();
+}
+
+void Window::Impl::UnsetExtents()
+{
+  if (win_->hasUnmapReference())
+    return;
+
+  CompWindowExtents empty(0, 0, 0, 0);
+
+  if (win_->border() != empty || win_->input() != empty)
+    win_->setWindowFrameExtents(&empty, &empty);
+}
+
+void Window::Impl::SetupExtents()
+{
+  if (win_->hasUnmapReference())
+    return;
+
+  auto const& sb = Style::Get()->Border();
+  CompWindowExtents border(sb.left, sb.right, sb.top, sb.bottom);
+
+  auto const& ib = Style::Get()->InputBorder();
+  CompWindowExtents input(sb.left + ib.left, sb.right + ib.right,
+                          sb.top + ib.top, sb.bottom + ib.bottom);
+
+  if (win_->border() != border || win_->input() != input)
+    win_->setWindowFrameExtents(&border, &input);
+}
+
+void Window::Impl::UnsetFrame()
+{
+  if (!frame_)
+    return;
+
+  XDestroyWindow(screen->dpy(), frame_);
+  framed.emit(false, frame_);
+  frame_ = 0;
+  frame_geo_.Set(0, 0, 0, 0);
+}
+
+void Window::Impl::UpdateFrame()
+{
+  auto const& input = win_->input();
+  auto const& server = win_->serverGeometry();
+  nux::Geometry frame_geo(0, 0, server.widthIncBorders() + input.left + input.right,
+                          server.heightIncBorders() + input.top  + input.bottom);
+
+  if (win_->shaded())
+    frame_geo.height = input.top + input.bottom;
+
+  if (!frame_)
+    CreateFrame(frame_geo);
+
+  if (frame_geo_ != frame_geo)
+    UpdateFrameGeo(frame_geo);
+}
+
+void Window::Impl::CreateFrame(nux::Geometry const& frame_geo)
+{
+  /* Since we're reparenting windows here, we need to grab the server
+   * which sucks, but its necessary */
+  Display* dpy = screen->dpy();
+  XGrabServer(dpy);
+
+  XSetWindowAttributes attr;
+  attr.event_mask = StructureNotifyMask | ButtonPressMask | ButtonReleaseMask |
+                    EnterWindowMask | LeaveWindowMask | PointerMotionMask;
+  attr.override_redirect = True;
+
+  auto parent = win_->frame();
+  frame_ = XCreateWindow(dpy, parent, frame_geo.x, frame_geo.y,
+                         frame_geo.width, frame_geo.height, 0, CopyFromParent,
+                         InputOnly, CopyFromParent, CWOverrideRedirect | CWEventMask, &attr);
+
+  if (screen->XShape())
+    XShapeSelectInput(dpy, frame_, ShapeNotifyMask);
+
+  XMapWindow(dpy, frame_);
+  framed.emit(true, frame_);
+
+  XUngrabServer(dpy);
+}
+
+void Window::Impl::UpdateFrameGeo(nux::Geometry const& frame_geo)
+{
+  auto const& input = win_->input();
+  Display* dpy = screen->dpy();
+  XMoveResizeWindow(dpy, frame_, frame_geo.x, frame_geo.y, frame_geo.width, frame_geo.height);
+  XLowerWindow(dpy, frame_);
+
+  int i = 0;
+  XRectangle rects[4];
+
+  rects[i].x = 0;
+  rects[i].y = 0;
+  rects[i].width = frame_geo.width;
+  rects[i].height = input.top;
+
+  if (rects[i].width && rects[i].height)
+    i++;
+
+  rects[i].x = 0;
+  rects[i].y = input.top;
+  rects[i].width = input.left;
+  rects[i].height = frame_geo.height - input.top - input.bottom;
+
+  if (rects[i].width && rects[i].height)
+    i++;
+
+  rects[i].x = frame_geo.width - input.right;
+  rects[i].y = input.top;
+  rects[i].width = input.right;
+  rects[i].height = frame_geo.height - input.top - input.bottom;
+
+  if (rects[i].width && rects[i].height)
+    i++;
+
+  rects[i].x = 0;
+  rects[i].y = frame_geo.height - input.bottom;
+  rects[i].width = frame_geo.width;
+  rects[i].height = input.bottom;
+
+  if (rects[i].width && rects[i].height)
+    i++;
+
+  XShapeCombineRectangles(dpy, frame_, ShapeBounding, 0, 0, rects, i, ShapeSet, YXBanded);
+
+  frame_geo_ = frame_geo;
+  SyncXShapeWithFrameRegion();
+}
+
+void Window::Impl::SyncXShapeWithFrameRegion()
+{
+  frame_region_ = CompRegion();
+
+  int n = 0;
+  int order = 0;
+  XRectangle *rects = nullptr;
+
+  rects = XShapeGetRectangles(screen->dpy(), frame_, ShapeInput, &n, &order);
+  if (!rects)
+    return;
+
+  for (int i = 0; i < n; ++i)
+  {
+    auto& rect = rects[i];
+    frame_region_ += CompRegion(rect.x, rect.y, rect.width, rect.height);
+  }
+
+  XFree(rects);
+
+  win_->updateFrameRegion();
+}
+
+void Window::Impl::SetupWindowControls()
+{
+  if (top_layout_)
+    return;
+
+  auto const& style = Style::Get();
+  theme_changed_ = style->theme.changed.connect([this] (std::string const&) {
+    Undecorate();
+    Decorate();
+  });
+
+  input_mixer_ = std::make_shared<InputMixer>();
+
+  if (win_->actions() & CompWindowActionResizeMask)
+    edge_borders_ = std::make_shared<EdgeBorders>(win_);
+  else if (win_->actions() & CompWindowActionMoveMask)
+    edge_borders_ = std::make_shared<GrabEdge>(win_);
+  else
+    edge_borders_.reset();
+
+  input_mixer_->PushToFront(edge_borders_);
+
+  auto padding = style->Padding(Side::TOP);
+  top_layout_ = std::make_shared<Layout>();
+  top_layout_->left_padding = padding.left;
+  top_layout_->right_padding = padding.right;
+  top_layout_->top_padding = padding.top;
+  top_layout_->focused = active();
+
+  if (win_->actions() & CompWindowActionCloseMask)
+    top_layout_->Append(std::make_shared<WindowButton>(win_, WindowButtonType::CLOSE));
+
+  if (win_->actions() & CompWindowActionMinimizeMask)
+    top_layout_->Append(std::make_shared<WindowButton>(win_, WindowButtonType::MINIMIZE));
+
+  if (win_->actions() & (CompWindowActionMaximizeHorzMask|CompWindowActionMaximizeVertMask))
+    top_layout_->Append(std::make_shared<WindowButton>(win_, WindowButtonType::MAXIMIZE));
+
+  title_ = std::make_shared<Title>();
+  title_->text = last_title_.empty() ? WindowManager::Default().GetWindowName(win_->id()) : last_title_;
+  title_->sensitive = false;
+  last_title_.clear();
+
+  auto title_layout = std::make_shared<Layout>();
+  title_layout->left_padding = style->TitleIndent();
+  title_layout->Append(title_);
+  top_layout_->Append(title_layout);
+
+  input_mixer_->PushToFront(top_layout_);
+
+  RedrawDecorations();
+}
+
+void Window::Impl::CleanupWindowControls()
+{
+  if (title_)
+    last_title_ = title_->text();
+
+  theme_changed_->disconnect();
+  title_.reset();
+  top_layout_.reset();
+  input_mixer_.reset();
+  edge_borders_.reset();
+}
+
+bool Window::Impl::IsMaximized() const
+{
+  return (win_->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE;
+}
+
+bool Window::Impl::ShadowDecorated() const
+{
+  if (!parent_->scaled() && IsMaximized())
+    return false;
+
+  if (!cu::IsWindowShadowDecorable(win_))
+    return false;
+
+  return true;
+}
+
+bool Window::Impl::FullyDecorated() const
+{
+  if (!parent_->scaled() && IsMaximized())
+    return false;
+
+  if (!cu::IsWindowFullyDecorable(win_))
+    return false;
+
+  return true;
+}
+
+bool Window::Impl::ShouldBeDecorated() const
+{
+  return (win_->frame() || win_->hasUnmapReference()) && FullyDecorated();
+}
+
+GLTexture* Window::Impl::ShadowTexture() const
+{
+  auto const& mi = manager_->impl_;
+  if (active() || parent_->scaled())
+    return mi->active_shadow_pixmap_->texture();
+
+  return mi->inactive_shadow_pixmap_->texture();
+}
+
+unsigned Window::Impl::ShadowRadius() const
+{
+  if (active() || parent_->scaled())
+    return manager_->active_shadow_radius();
+
+  return manager_->inactive_shadow_radius();
+}
+
+void Window::Impl::RenderDecorationTexture(Side s, nux::Geometry const& geo)
+{
+  auto& deco_tex = bg_textures_[unsigned(s)];
+
+  if (deco_tex.quad.box.width() != geo.width || deco_tex.quad.box.height() != geo.height)
+  {
+    cu::CairoContext ctx(geo.width, geo.height);
+    auto ws = active() ? WidgetState::NORMAL : WidgetState::BACKDROP;
+    Style::Get()->DrawSide(s, ws, ctx, geo.width, geo.height);
+    deco_tex.SetTexture(ctx);
+  }
+
+  deco_tex.SetCoords(geo.x, geo.y);
+}
+
+void Window::Impl::UpdateDecorationTextures()
+{
+  if (!FullyDecorated())
+  {
+    bg_textures_.clear();
+    return;
+  }
+
+  auto const& geo = win_->borderRect();
+  auto const& input = win_->inputRect();
+  auto const& border = win_->border();
+
+  bg_textures_.resize(4);
+  RenderDecorationTexture(Side::TOP, {geo.x(), geo.y(), geo.width(), border.top});
+  RenderDecorationTexture(Side::LEFT, {geo.x(), geo.y() + border.top, border.left, geo.height() - border.top - border.bottom});
+  RenderDecorationTexture(Side::RIGHT, {geo.x2() - border.right, geo.y() + border.top, border.right, geo.height() - border.top - border.bottom});
+  RenderDecorationTexture(Side::BOTTOM, {geo.x(), geo.y2() - border.bottom, geo.width(), border.bottom});
+
+  top_layout_->SetCoords(geo.x(), geo.y());
+  top_layout_->SetSize(geo.width(), border.top);
+
+  if (edge_borders_)
+  {
+    edge_borders_->SetCoords(input.x(), input.y());
+    edge_borders_->SetSize(input.width(), input.height());
+  }
+}
+
+void Window::Impl::ComputeShadowQuads()
+{
+  if (!ShadowDecorated())
+    return;
+
+  const auto* texture = ShadowTexture();
+
+  if (!texture || !texture->width() || !texture->height())
+    return;
+
+  Quads& quads = shadow_quads_;
+  auto const& tex_matrix = texture->matrix();
+  auto const& border = win_->borderRect();
+  auto const& offset = manager_->shadow_offset();
+  int texture_offset = ShadowRadius() * 2;
+
+  /* Top left quad */
+  auto* quad = &quads[Quads::Pos::TOP_LEFT];
+  quad->box.setGeometry(border.x() + offset.x - texture_offset,
+                        border.y() + offset.y - texture_offset,
+                        border.width() + offset.x + texture_offset * 2 - texture->width(),
+                        border.height() + offset.y + texture_offset * 2 - texture->height());
+
+  quad->matrix = tex_matrix;
+  quad->matrix.x0 = 0.0f - COMP_TEX_COORD_X(quad->matrix, quad->box.x1());
+  quad->matrix.y0 = 0.0f - COMP_TEX_COORD_Y(quad->matrix, quad->box.y1());
+
+  /* Top right quad */
+  quad = &quads[Quads::Pos::TOP_RIGHT];
+  quad->box.setGeometry(quads[Quads::Pos::TOP_LEFT].box.x2(),
+                        quads[Quads::Pos::TOP_LEFT].box.y1(),
+                        texture->width(),
+                        quads[Quads::Pos::TOP_LEFT].box.height());
+
+  quad->matrix = tex_matrix;
+  quad->matrix.xx = -1.0f / texture->width();
+  quad->matrix.x0 = 1.0f - COMP_TEX_COORD_X(quad->matrix, quad->box.x1());
+  quad->matrix.y0 = 0.0f - COMP_TEX_COORD_Y(quad->matrix, quad->box.y1());
+
+  /* Bottom left */
+  quad = &quads[Quads::Pos::BOTTOM_LEFT];
+  quad->box.setGeometry(quads[Quads::Pos::TOP_LEFT].box.x1(),
+                        quads[Quads::Pos::TOP_LEFT].box.y2(),
+                        quads[Quads::Pos::TOP_LEFT].box.width(),
+                        texture->height());
+
+  quad->matrix = tex_matrix;
+  quad->matrix.yy = -1.0f / texture->height();
+  quad->matrix.x0 = 0.0f - COMP_TEX_COORD_X(quad->matrix, quad->box.x1());
+  quad->matrix.y0 = 1.0f - COMP_TEX_COORD_Y(quad->matrix, quad->box.y1());
+
+  /* Bottom right */
+  quad = &quads[Quads::Pos::BOTTOM_RIGHT];
+  quad->box.setGeometry(quads[Quads::Pos::BOTTOM_LEFT].box.x2(),
+                        quads[Quads::Pos::TOP_RIGHT].box.y2(),
+                        texture->width(),
+                        texture->height());
+
+  quad->matrix = tex_matrix;
+  quad->matrix.xx = -1.0f / texture->width();
+  quad->matrix.yy = -1.0f / texture->height();
+  quad->matrix.x0 = 1.0f - COMP_TEX_COORD_X(quad->matrix, quad->box.x1());
+  quad->matrix.y0 = 1.0f - COMP_TEX_COORD_Y(quad->matrix, quad->box.y1());
+
+  /* Fix the quads if the texture is actually bigger than the area */
+  if (texture->width() > border.width())
+  {
+    int half = win_->x() + win_->width() / 2.0f;
+    quads[Quads::Pos::TOP_LEFT].box.setRight(half);
+    quads[Quads::Pos::TOP_RIGHT].box.setLeft(half);
+    quads[Quads::Pos::BOTTOM_LEFT].box.setRight(half);
+    quads[Quads::Pos::BOTTOM_RIGHT].box.setLeft(half);
+  }
+
+  if (texture->height() > border.height())
+  {
+    int half = win_->y() + win_->height() / 2.0f;
+    quads[Quads::Pos::TOP_LEFT].box.setBottom(half);
+    quads[Quads::Pos::TOP_RIGHT].box.setBottom(half);
+    quads[Quads::Pos::BOTTOM_LEFT].box.setTop(half);
+    quads[Quads::Pos::BOTTOM_RIGHT].box.setTop(half);
+  }
+
+  CompRect shadows_rect;
+  shadows_rect.setLeft(quads[Quads::Pos::TOP_LEFT].box.x1());
+  shadows_rect.setTop(quads[Quads::Pos::TOP_LEFT].box.y1());
+  shadows_rect.setRight(quads[Quads::Pos::TOP_RIGHT].box.x2());
+  shadows_rect.setBottom(quads[Quads::Pos::BOTTOM_LEFT].box.y2());
+
+  if (shadows_rect != last_shadow_rect_)
+  {
+    last_shadow_rect_ = shadows_rect;
+    win_->updateWindowOutputExtents();
+  }
+}
+
+void Window::Impl::Draw(GLMatrix const& transformation,
+                        GLWindowPaintAttrib const& attrib,
+                        CompRegion const& region, unsigned mask)
+{
+  if (!ShadowDecorated())
+    return;
+
+  auto const& clip_region = (mask & PAINT_WINDOW_TRANSFORMED_MASK) ? infiniteRegion : region;
+  mask |= PAINT_WINDOW_BLEND_MASK;
+
+  if (dirty_geo_)
+    parent_->UpdateDecorationPosition();
+
+  glwin_->vertexBuffer()->begin();
+
+  for (unsigned i = 0; i < shadow_quads_.size(); ++i)
+  {
+    auto& quad = shadow_quads_[Quads::Pos(i)];
+    glwin_->glAddGeometry({quad.matrix}, CompRegion(quad.box) - win_->region(), clip_region);
+  }
+
+  if (glwin_->vertexBuffer()->end())
+    glwin_->glDrawTexture(ShadowTexture(), transformation, attrib, mask);
+
+  for (auto const& dtex : bg_textures_)
+  {
+    glwin_->vertexBuffer()->begin();
+    glwin_->glAddGeometry({dtex.quad.matrix}, dtex.quad.box, clip_region);
+
+    if (glwin_->vertexBuffer()->end())
+      glwin_->glDrawTexture(dtex, transformation, attrib, mask);
+  }
+
+  if (top_layout_)
+    top_layout_->Draw(glwin_, transformation, attrib, region, mask);
+}
+
+void Window::Impl::RedrawDecorations()
+{
+  dirty_geo_ = true;
+  cwin_->damageOutputExtents();
+}
+
+// Public APIs
+
+Window::Window(CompWindow* cwin)
+  : scaled(false)
+  , impl_(new Impl(this, cwin))
+{}
+
+void Window::Update()
+{
+  impl_->Update();
+}
+
+void Window::UpdateFrameRegion(CompRegion& r)
+{
+  if (impl_->frame_region_.isEmpty())
+    return;
+
+  auto const& geo = impl_->win_->geometry();
+  auto const& input = impl_->win_->input();
+
+  r += impl_->frame_region_.translated(geo.x() - input.left, geo.y() - input.top);
+  UpdateDecorationPositionDelayed();
+}
+
+void Window::UpdateOutputExtents(compiz::window::extents::Extents& output)
+{
+  const auto* win = impl_->win_;
+  auto const& shadow = impl_->last_shadow_rect_;
+  output.top = std::max(output.top, win->y() - shadow.y1());
+  output.left = std::max(output.left, win->x() - shadow.x1());
+  output.right = std::max(output.right, shadow.x2() - win->width() - win->x());
+  output.bottom = std::max(output.bottom, shadow.y2() - win->height() - win->y());
+}
+
+void Window::Draw(GLMatrix const& matrix, GLWindowPaintAttrib const& attrib,
+                  CompRegion const& region, unsigned mask)
+{
+  impl_->Draw(matrix, attrib, region, mask);
+}
+
+void Window::Undecorate()
+{
+  impl_->Undecorate();
+}
+
+void Window::UpdateDecorationPosition()
+{
+  impl_->ComputeShadowQuads();
+  impl_->UpdateDecorationTextures();
+  impl_->dirty_geo_ = false;
+}
+
+void Window::UpdateDecorationPositionDelayed()
+{
+  impl_->dirty_geo_ = true;
+}
+
+std::string Window::GetName() const
+{
+  return "DecoratedWindow";
+}
+
+void Window::AddProperties(debug::IntrospectionData& data)
+{
+  data.add(impl_->win_->borderRect())
+  .add("input_geo", impl_->win_->inputRect())
+  .add("content_geo", impl_->win_->region().boundingRect())
+  .add("title", title())
+  .add("active", impl_->active())
+  .add("scaled", scaled())
+  .add("xid", impl_->win_->id())
+  .add("fully_decorable", cu::IsWindowFullyDecorable(impl_->win_))
+  .add("shadow_decorable", cu::IsWindowShadowDecorable(impl_->win_))
+  .add("shadow_decorated", impl_->ShadowDecorated())
+  .add("fully_decorated", impl_->FullyDecorated())
+  .add("should_be_decorated", impl_->ShouldBeDecorated())
+  .add("framed", (impl_->frame_ != 0))
+  .add("frame_geo", impl_->frame_geo_)
+  .add("shadow_rect", impl_->last_shadow_rect_)
+  .add("maximized", impl_->IsMaximized())
+  .add("v_maximized", (impl_->win_->state() & CompWindowStateMaximizedVertMask))
+  .add("h_maximized", (impl_->win_->state() & CompWindowStateMaximizedHorzMask))
+  .add("resizable", (impl_->win_->actions() & CompWindowActionResizeMask))
+  .add("movable", (impl_->win_->actions() & CompWindowActionMoveMask))
+  .add("closable", (impl_->win_->actions() & CompWindowActionCloseMask))
+  .add("minimizable", (impl_->win_->actions() & CompWindowActionMinimizeMask))
+  .add("maximizable", (impl_->win_->actions() & (CompWindowActionMaximizeHorzMask|CompWindowActionMaximizeVertMask)));
+}
+
+debug::Introspectable::IntrospectableList Window::GetIntrospectableChildren()
+{
+  return IntrospectableList({impl_->top_layout_.get(), impl_->edge_borders_.get()});
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecoratedWindow.h'
--- decorations/DecoratedWindow.h	1970-01-01 00:00:00 +0000
+++ decorations/DecoratedWindow.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,73 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATED_WINDOW
+#define UNITY_DECORATED_WINDOW
+
+#include "Introspectable.h"
+#include <memory>
+
+class CompRegion;
+class CompWindow;
+class GLWindowPaintAttrib;
+class GLMatrix;
+namespace compiz { namespace window { namespace extents { class Extents; } } }
+
+namespace unity
+{
+namespace decoration
+{
+class Window : public debug::Introspectable
+{
+public:
+  typedef std::shared_ptr<Window> Ptr;
+
+  Window(CompWindow*);
+  virtual ~Window() = default;
+
+  nux::RWProperty<std::string> title;
+  nux::Property<bool> scaled;
+
+  void Update();
+  void Undecorate();
+  void UpdateDecorationPosition();
+  void UpdateDecorationPositionDelayed();
+  void UpdateFrameRegion(CompRegion&);
+  void UpdateOutputExtents(compiz::window::extents::Extents&);
+  void Draw(GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
+
+protected:
+  std::string GetName() const;
+  void AddProperties(debug::IntrospectionData&);
+  IntrospectableList GetIntrospectableChildren();
+
+private:
+  Window(Window const&) = delete;
+  Window& operator=(Window const&) = delete;
+
+  friend class Manager;
+
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif

=== added file 'decorations/DecorationsDataPool.cpp'
--- decorations/DecorationsDataPool.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsDataPool.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,153 @@
+// -*- 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 <NuxCore/Logger.h>
+#include <X11/cursorfont.h>
+#include <sigc++/adaptors/hide.h>
+#include "glow_texture.h"
+#include "DecorationsDataPool.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.decoration.datapool");
+const std::string PLUGIN_NAME = "unityshell";
+const int BUTTONS_SIZE = 16;
+const int BUTTONS_PADDING = 1;
+const cu::SimpleTexture::Ptr EMPTY_BUTTON;
+Display* dpy = nullptr;
+
+unsigned EdgeTypeToCursorShape(Edge::Type type)
+{
+  switch (type)
+  {
+    case Edge::Type::TOP:
+      return XC_top_side;
+    case Edge::Type::TOP_LEFT:
+      return XC_top_left_corner;
+    case Edge::Type::TOP_RIGHT:
+      return XC_top_right_corner;
+    case Edge::Type::LEFT:
+      return XC_left_side;
+    case Edge::Type::RIGHT:
+      return XC_right_side;
+    case Edge::Type::BOTTOM:
+      return XC_bottom_side;
+    case Edge::Type::BOTTOM_LEFT:
+      return XC_bottom_left_corner;
+    case Edge::Type::BOTTOM_RIGHT:
+      return XC_bottom_right_corner;
+    default:
+      return XC_left_ptr;
+  }
+}
+
+}
+
+DataPool::DataPool()
+{
+  dpy = screen->dpy();
+  SetupCursors();
+  SetupTextures();
+
+  auto cb = sigc::hide(sigc::mem_fun(this, &DataPool::SetupTextures));
+  Style::Get()->theme.changed.connect(cb);
+}
+
+DataPool::~DataPool()
+{
+  for (auto cursor : edge_cursors_)
+    XFreeCursor(dpy, cursor);
+}
+
+DataPool::Ptr const& DataPool::Get()
+{
+  static DataPool::Ptr data_pool(new DataPool());
+  return data_pool;
+}
+
+void DataPool::SetupCursors()
+{
+  for (unsigned c = 0; c < edge_cursors_.size(); ++c)
+    edge_cursors_[c] = XCreateFontCursor(dpy, EdgeTypeToCursorShape(Edge::Type(c)));
+}
+
+Cursor DataPool::EdgeCursor(Edge::Type type) const
+{
+  return edge_cursors_[unsigned(type)];
+}
+
+void DataPool::SetupTextures()
+{
+  CompSize size;
+  CompString plugin_name(PLUGIN_NAME);
+  auto const& style = Style::Get();
+
+  for (unsigned button = 0; button < window_buttons_.size(); ++button)
+  {
+    for (unsigned state = 0; state < window_buttons_[button].size(); ++state)
+    {
+      auto file = style->WindowButtonFile(WindowButtonType(button), WidgetState(state));
+      auto const& tex_list = GLTexture::readImageToTexture(file, plugin_name, size);
+
+      if (!tex_list.empty())
+      {
+        LOG_DEBUG(logger) << "Loading texture " << file;
+        window_buttons_[button][state] = std::make_shared<cu::SimpleTexture>(tex_list);
+      }
+      else
+      {
+        LOG_WARN(logger) << "Impossible to load local button texture file; "
+                         << "falling back to cairo generated one";
+
+        cu::CairoContext ctx(BUTTONS_SIZE + BUTTONS_PADDING*2, BUTTONS_SIZE + BUTTONS_PADDING*2);
+        cairo_translate(ctx, BUTTONS_PADDING, BUTTONS_PADDING);
+        style->DrawWindowButton(WindowButtonType(button), WidgetState(state), ctx, BUTTONS_SIZE, BUTTONS_SIZE);
+        window_buttons_[button][state] = ctx;
+      }
+    }
+  }
+
+  CompSize glow_size(texture::GLOW_SIZE, texture::GLOW_SIZE);
+  glow_texture_ = std::make_shared<cu::SimpleTexture>(GLTexture::imageDataToTexture(texture::GLOW, glow_size, GL_RGBA, GL_UNSIGNED_BYTE));
+}
+
+cu::SimpleTexture::Ptr const& DataPool::GlowTexture() const
+{
+  return glow_texture_;
+}
+
+cu::SimpleTexture::Ptr const& DataPool::ButtonTexture(WindowButtonType wbt, WidgetState ws) const
+{
+  if (wbt >= WindowButtonType::Size || ws >= WidgetState::Size)
+  {
+    LOG_ERROR(logger) << "It has been requested an invalid button texture "
+                      << "WindowButtonType: " << unsigned(wbt) << ", WidgetState: "
+                      << unsigned(ws);
+    return EMPTY_BUTTON;
+  }
+
+  return window_buttons_[unsigned(wbt)][unsigned(ws)];
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsDataPool.h'
--- decorations/DecorationsDataPool.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsDataPool.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,59 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATIONS_DATA_POOL
+#define UNITY_DECORATIONS_DATA_POOL
+
+#include "DecorationStyle.h"
+#include "DecorationsEdge.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class DataPool : public sigc::trackable
+{
+public:
+  typedef std::shared_ptr<DataPool> Ptr;
+
+  static DataPool::Ptr const& Get();
+  virtual ~DataPool();
+
+  Cursor EdgeCursor(Edge::Type) const;
+  cu::SimpleTexture::Ptr const& GlowTexture() const;
+  cu::SimpleTexture::Ptr const& ButtonTexture(WindowButtonType, WidgetState) const;
+
+private:
+  DataPool();
+  DataPool(DataPool const&) = delete;
+  DataPool& operator=(DataPool const&) = delete;
+
+  void SetupCursors();
+  void SetupTextures();
+
+  std::array<Cursor, size_t(Edge::Type::Size)> edge_cursors_;
+  cu::SimpleTexture::Ptr glow_texture_;
+  std::array<std::array<cu::SimpleTexture::Ptr, size_t(WidgetState::Size)>, size_t(WindowButtonType::Size)> window_buttons_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATIONS_DATA_POOL

=== added file 'decorations/DecorationsEdge.cpp'
--- decorations/DecorationsEdge.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsEdge.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,137 @@
+// -*- 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 <core/atoms.h>
+#include "DecorationsEdge.h"
+#include "DecorationsDataPool.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+
+unsigned TypeToDirection(Edge::Type type)
+{
+  switch (type)
+  {
+    case Edge::Type::TOP:
+      return WmMoveResizeSizeTop;
+    case Edge::Type::TOP_LEFT:
+      return WmMoveResizeSizeTopLeft;
+    case Edge::Type::TOP_RIGHT:
+      return WmMoveResizeSizeTopRight;
+    case Edge::Type::LEFT:
+      return WmMoveResizeSizeLeft;
+    case Edge::Type::RIGHT:
+      return WmMoveResizeSizeRight;
+    case Edge::Type::BOTTOM:
+      return WmMoveResizeSizeBottom;
+    case Edge::Type::BOTTOM_LEFT:
+      return WmMoveResizeSizeBottomLeft;
+    case Edge::Type::BOTTOM_RIGHT:
+      return WmMoveResizeSizeBottomRight;
+    case Edge::Type::GRAB:
+      return WmMoveResizeMove;
+    default:
+      return WmMoveResizeCancel;
+  }
+}
+
+}
+
+Edge::Edge(CompWindow* win, Type t)
+  : win_(win)
+  , type_(t)
+{
+  unsigned mask = (t == Type::GRAB) ? CompWindowActionMoveMask : CompWindowActionResizeMask;
+  sensitive = (win_->actions() & mask);
+  mouse_owner.changed.connect([this] (bool over) {
+    if (over)
+      XDefineCursor(screen->dpy(), win_->frame(), DataPool::Get()->EdgeCursor(type_));
+    else
+      XUndefineCursor(screen->dpy(), win_->frame());
+  });
+}
+
+Edge::Type Edge::GetType() const
+{
+  return type_;
+}
+
+void Edge::ButtonDownEvent(CompPoint const& p, unsigned button)
+{
+  XEvent ev;
+  auto* dpy = screen->dpy();
+
+  ev.xclient.type = ClientMessage;
+  ev.xclient.display = screen->dpy();
+
+  ev.xclient.serial = 0;
+  ev.xclient.send_event = True;
+
+  ev.xclient.window = win_->id();
+  ev.xclient.message_type = Atoms::wmMoveResize;
+  ev.xclient.format = 32;
+
+  ev.xclient.data.l[0] = p.x();
+  ev.xclient.data.l[1] = p.y();
+  ev.xclient.data.l[2] = TypeToDirection(type_);
+  ev.xclient.data.l[3] = button;
+  ev.xclient.data.l[4] = 1;
+
+  XUngrabPointer(dpy, screen->getCurrentTime());
+  XUngrabKeyboard(dpy, screen->getCurrentTime());
+
+  auto mask = SubstructureRedirectMask | SubstructureNotifyMask;
+  XSendEvent(dpy, screen->root(), False, mask, &ev);
+
+  XSync(dpy, False);
+}
+
+std::string Edge::GetName() const
+{
+  switch (type_)
+  {
+    case Type::TOP:
+      return "TopEdge";
+    case Type::TOP_LEFT:
+      return "TopLeftEdge";
+    case Type::TOP_RIGHT:
+      return "TopRightEdge";
+    case Type::LEFT:
+      return "LeftEdge";
+    case Type::RIGHT:
+      return "RightEdge";
+    case Type::BOTTOM:
+      return "BottomEdge";
+    case Type::BOTTOM_LEFT:
+      return "BottomLeftEdge";
+    case Type::BOTTOM_RIGHT:
+      return "BottomRightEdge";
+    case Type::GRAB:
+      return "GrabEdge";
+    default:
+      return "Edge";
+  }
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsEdge.h'
--- decorations/DecorationsEdge.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsEdge.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,64 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATIONS_EDGE
+#define UNITY_DECORATIONS_EDGE
+
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class Edge : public SimpleItem
+{
+public:
+  enum class Type
+  {
+    // The order of this enum is important to define the priority of each Edge
+    // when parsing the input events (in case two areas overlap)
+    GRAB = 0,
+    TOP_LEFT,
+    TOP_RIGHT,
+    TOP,
+    BOTTOM_LEFT,
+    BOTTOM_RIGHT,
+    BOTTOM,
+    LEFT,
+    RIGHT,
+    Size
+  };
+
+  Edge(CompWindow* win, Type t);
+
+  Type GetType() const;
+  void ButtonDownEvent(CompPoint const&, unsigned button);
+
+protected:
+  std::string GetName() const;
+
+  CompWindow* win_;
+  Type type_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATIONS_EDGE

=== added file 'decorations/DecorationsEdgeBorders.cpp'
--- decorations/DecorationsEdgeBorders.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsEdgeBorders.cpp	2014-01-23 15:21:26 +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 "DecorationStyle.h"
+#include "DecorationsEdgeBorders.h"
+#include "DecorationsEdge.h"
+#include "DecorationsGrabEdge.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+const int MIN_CORNER_EDGE = 10;
+}
+
+EdgeBorders::EdgeBorders(CompWindow* win)
+{
+  items_.resize(size_t(Edge::Type::Size));
+
+  for (unsigned i = 0; i < unsigned(Edge::Type::Size); ++i)
+  {
+    auto type = Edge::Type(i);
+
+    if (type == Edge::Type::GRAB)
+      items_[i] = std::make_shared<GrabEdge>(win);
+    else
+      items_[i] = std::make_shared<Edge>(win, type);
+  }
+
+  Relayout();
+}
+
+void EdgeBorders::Relayout()
+{
+  auto const& b = Style::Get()->Border();
+  auto const& ib = Style::Get()->InputBorder();
+
+  Border edges(std::max(b.top, MIN_CORNER_EDGE) + ib.top,
+               std::max(b.left, MIN_CORNER_EDGE) + ib.left,
+               std::max(b.right, MIN_CORNER_EDGE) + ib.right,
+               std::max(b.bottom, MIN_CORNER_EDGE) + ib.bottom);
+
+  auto item = items_[unsigned(Edge::Type::TOP)];
+  item->SetCoords(rect_.x() + edges.left, rect_.y());
+  item->SetSize(rect_.width() - edges.left - edges.right, edges.top - b.top);
+
+  item = items_[unsigned(Edge::Type::TOP_LEFT)];
+  item->SetCoords(rect_.x(), rect_.y());
+  item->SetSize(edges.left, edges.top);
+
+  item = items_[unsigned(Edge::Type::TOP_RIGHT)];
+  item->SetCoords(rect_.x2() - edges.right, rect_.y());
+  item->SetSize(edges.right, edges.top);
+
+  item = items_[unsigned(Edge::Type::LEFT)];
+  item->SetCoords(rect_.x(), rect_.y() + edges.top);
+  item->SetSize(edges.left, rect_.height() - edges.top - edges.bottom);
+
+  item = items_[unsigned(Edge::Type::RIGHT)];
+  item->SetCoords(rect_.x2() - edges.right, rect_.y() + edges.top);
+  item->SetSize(edges.right, rect_.height() - edges.top - edges.bottom);
+
+  item = items_[unsigned(Edge::Type::BOTTOM)];
+  item->SetCoords(rect_.x() + edges.left, rect_.y2() - edges.bottom);
+  item->SetSize(rect_.width() - edges.left - edges.right, edges.bottom);
+
+  item = items_[unsigned(Edge::Type::BOTTOM_LEFT)];
+  item->SetCoords(rect_.x(), rect_.y2() - edges.bottom);
+  item->SetSize(edges.left, edges.bottom);
+
+  item = items_[unsigned(Edge::Type::BOTTOM_RIGHT)];
+  item->SetCoords(rect_.x2() - edges.right, rect_.y2() - edges.bottom);
+  item->SetSize(edges.right, edges.bottom);
+
+  item = items_[unsigned(Edge::Type::GRAB)];
+  item->SetCoords(rect_.x() + ib.left, rect_.y() + ib.top);
+  item->SetSize(rect_.width() - ib.left - ib.right, b.top);
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsEdgeBorders.h'
--- decorations/DecorationsEdgeBorders.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsEdgeBorders.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,43 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATIONS_EDGES
+#define UNITY_DECORATIONS_EDGES
+
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class EdgeBorders : public BasicContainer
+{
+public:
+  EdgeBorders(CompWindow* win);
+  void Relayout();
+
+protected:
+  std::string GetName() const { return "EdgeBorders"; }
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATIONS_EDGES

=== added file 'decorations/DecorationsGrabEdge.cpp'
--- decorations/DecorationsGrabEdge.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsGrabEdge.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,102 @@
+// -*- 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 "DecorationsGrabEdge.h"
+#include "DecorationStyle.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+const int MOUSE_DOWN_TIMEOUT = 150;
+}
+
+GrabEdge::GrabEdge(CompWindow* win)
+  : Edge(win, Edge::Type::GRAB)
+  , last_click_time_(0)
+  , button_down_(-1)
+{}
+
+void GrabEdge::ButtonDownEvent(CompPoint const& p, unsigned button)
+{
+  if (button != 1)
+    return;
+
+  if (!(win_->actions() & (CompWindowActionMaximizeHorzMask|CompWindowActionMaximizeVertMask)))
+  {
+    Edge::ButtonDownEvent(p, button);
+    return;
+  }
+
+  auto const& style = Style::Get();
+  unsigned max_time_delta = std::max(0, style->DoubleClickMaxTimeDelta());
+  bool maximized = false;
+
+  if (screen->getCurrentTime() - last_click_time_ < max_time_delta)
+  {
+    int max_distance = style->DoubleClickMaxDistance();
+
+    if (std::abs(p.x() - last_click_pos_.x()) < max_distance &&
+        std::abs(p.y() - last_click_pos_.y()) < max_distance)
+    {
+      win_->maximize(MAXIMIZE_STATE);
+      maximized = true;
+      button_down_timer_.reset();
+    }
+  }
+
+  if (!maximized)
+  {
+    button_down_timer_.reset(new glib::Timeout(MOUSE_DOWN_TIMEOUT));
+    button_down_timer_->Run([this] {
+      Edge::ButtonDownEvent(CompPoint(pointerX, pointerY), button_down_);
+      button_down_timer_.reset();
+      return false;
+    });
+  }
+
+  button_down_ = button;
+  last_click_pos_ = p;
+  last_click_time_ = screen->getCurrentTime();
+}
+
+void GrabEdge::MotionEvent(CompPoint const& p)
+{
+  if (button_down_timer_)
+  {
+    button_down_timer_.reset();
+    Edge::ButtonDownEvent(p, button_down_);
+  }
+}
+
+void GrabEdge::ButtonUpEvent(CompPoint const&, unsigned button)
+{
+  button_down_timer_.reset();
+}
+
+void GrabEdge::AddProperties(debug::IntrospectionData& data)
+{
+  Edge::AddProperties(data);
+  data.add("button_down", button_down_);
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsGrabEdge.h'
--- decorations/DecorationsGrabEdge.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsGrabEdge.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,53 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATIONS_GRAB_EDGE
+#define UNITY_DECORATIONS_GRAB_EDGE
+
+#include <UnityCore/GLibSource.h>
+#include "DecorationsEdge.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class GrabEdge : public Edge
+{
+public:
+  GrabEdge(CompWindow* win);
+
+  void ButtonDownEvent(CompPoint const&, unsigned button);
+  void ButtonUpEvent(CompPoint const&, unsigned button);
+  void MotionEvent(CompPoint const&);
+
+protected:
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  Time last_click_time_;
+  CompPoint last_click_pos_;
+  int button_down_;
+  glib::Source::UniquePtr button_down_timer_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATIONS_GRAB_EDGE

=== added file 'decorations/DecorationsInputMixer.cpp'
--- decorations/DecorationsInputMixer.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsInputMixer.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,176 @@
+// -*- 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 <NuxCore/Logger.h>
+#include "DecorationsInputMixer.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.decorations.inputmixer");
+}
+
+InputMixer::InputMixer()
+  : mouse_down_(false)
+{}
+
+void InputMixer::PushToFront(Item::Ptr const& item)
+{
+  if (!item)
+    return;
+
+  auto it = std::find(items_.begin(), items_.end(), item);
+  if (it != items_.end())
+    items_.erase(it);
+
+  items_.push_front(item);
+}
+
+void InputMixer::PushToBack(Item::Ptr const& item)
+{
+  if (!item)
+    return;
+
+  auto it = std::find(items_.begin(), items_.end(), item);
+  if (it != items_.end())
+    items_.erase(it);
+
+  items_.push_back(item);
+}
+
+void InputMixer::Remove(Item::Ptr const& item)
+{
+  if (item == last_mouse_owner_)
+    UnsetMouseOwner();
+
+  auto it = std::find(items_.begin(), items_.end(), item);
+  if (it != items_.end())
+    items_.erase(it);
+}
+
+Item::List const& InputMixer::Items() const
+{
+  return items_;
+}
+
+Item::Ptr InputMixer::GetMatchingItemRecursive(Item::List const& items, CompPoint const& point)
+{
+  for (auto const& item : items)
+  {
+    if (item->visible() && item->Geometry().contains(point))
+    {
+      if (!item->IsContainer())
+        return item->sensitive() ? item : nullptr;
+
+      auto const& container = std::static_pointer_cast<BasicContainer>(item);
+      auto const& child = GetMatchingItemRecursive(container->Items(), point);
+
+      if (child)
+        return child;
+    }
+  }
+
+  return nullptr;
+}
+
+Item::Ptr InputMixer::GetMatchingItem(CompPoint const& point)
+{
+  return GetMatchingItemRecursive(items_, point);
+}
+
+void InputMixer::UpdateMouseOwner(CompPoint const& point)
+{
+  if (Item::Ptr const& item = GetMatchingItem(point))
+  {
+    if (item != last_mouse_owner_)
+    {
+      UnsetMouseOwner();
+      last_mouse_owner_ = item;
+      item->mouse_owner = true;
+    }
+  }
+  else
+  {
+    UnsetMouseOwner();
+  }
+}
+
+void InputMixer::UnsetMouseOwner()
+{
+  if (!last_mouse_owner_)
+    return;
+
+  last_mouse_owner_->mouse_owner = false;
+  last_mouse_owner_ = nullptr;
+}
+
+Item::Ptr const& InputMixer::GetMouseOwner() const
+{
+  return last_mouse_owner_;
+};
+
+void InputMixer::EnterEvent(CompPoint const& point)
+{
+  if (!mouse_down_)
+    UpdateMouseOwner(point);
+}
+
+void InputMixer::LeaveEvent(CompPoint const& point)
+{
+  if (!mouse_down_)
+    UnsetMouseOwner();
+}
+
+void InputMixer::MotionEvent(CompPoint const& point)
+{
+  if (!mouse_down_)
+    UpdateMouseOwner(point);
+
+  if (last_mouse_owner_)
+    last_mouse_owner_->MotionEvent(point);
+}
+
+void InputMixer::ButtonDownEvent(CompPoint const& point, unsigned button)
+{
+  mouse_down_ = true;
+
+  if (last_mouse_owner_)
+    last_mouse_owner_->ButtonDownEvent(point, button);
+}
+
+void InputMixer::ButtonUpEvent(CompPoint const& point, unsigned button)
+{
+  mouse_down_ = false;
+
+  if (last_mouse_owner_)
+  {
+    // This event might cause the InputMixer to be deleted, so we protect using a weak_ptr
+    std::weak_ptr<Item> weak_last_mouse_owner(last_mouse_owner_);
+    last_mouse_owner_->ButtonUpEvent(point, button);
+
+    if (!weak_last_mouse_owner.expired() && !last_mouse_owner_->Geometry().contains(point))
+      UpdateMouseOwner(point);
+  }
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsInputMixer.h'
--- decorations/DecorationsInputMixer.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsInputMixer.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,66 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATION_INPUT_MIXER
+#define UNITY_DECORATION_INPUT_MIXER
+
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class InputMixer
+{
+public:
+  typedef std::shared_ptr<InputMixer> Ptr;
+  InputMixer();
+
+  void PushToFront(Item::Ptr const&);
+  void PushToBack(Item::Ptr const&);
+  void Remove(Item::Ptr const&);
+
+  Item::List const& Items() const;
+  Item::Ptr const& GetMouseOwner() const;
+
+  void EnterEvent(CompPoint const&);
+  void MotionEvent(CompPoint const&);
+  void LeaveEvent(CompPoint const&);
+  void ButtonDownEvent(CompPoint const&, unsigned button);
+  void ButtonUpEvent(CompPoint const&, unsigned button);
+
+private:
+  InputMixer(InputMixer const&) = delete;
+  InputMixer& operator=(InputMixer const&) = delete;
+
+  void UpdateMouseOwner(CompPoint const&);
+  void UnsetMouseOwner();
+  Item::Ptr GetMatchingItem(CompPoint const&);
+  Item::Ptr GetMatchingItemRecursive(Item::List const&, CompPoint const&);
+
+  Item::List items_;
+  Item::Ptr last_mouse_owner_;
+  bool mouse_down_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif

=== added file 'decorations/DecorationsManager.cpp'
--- decorations/DecorationsManager.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsManager.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,386 @@
+// -*- 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 "DecorationsPriv.h"
+
+#include <core/atoms.h>
+#include <NuxCore/Logger.h>
+#include <NuxGraphics/CairoGraphics.h>
+#include <X11/Xatom.h>
+#include "WindowManager.h"
+
+namespace unity
+{
+namespace decoration
+{
+Manager* manager_ = nullptr;
+
+namespace
+{
+DECLARE_LOGGER(logger, "unity.decoration.manager");
+
+namespace atom
+{
+Atom _NET_REQUEST_FRAME_EXTENTS = 0;
+Atom _NET_WM_VISIBLE_NAME = 0;
+}
+}
+
+Manager::Impl::Impl(decoration::Manager* parent)
+  : active_window_(0)
+  , enable_add_supported_atoms_(true)
+  , data_pool_(DataPool::Get())
+{
+  if (!manager_)
+    manager_ = parent;
+
+  Display* dpy = screen->dpy();
+  atom::_NET_REQUEST_FRAME_EXTENTS = XInternAtom(dpy, "_NET_REQUEST_FRAME_EXTENTS", False);
+  atom::_NET_WM_VISIBLE_NAME = XInternAtom(dpy, "_NET_WM_VISIBLE_NAME", False);
+  screen->updateSupportedWmHints();
+
+  auto rebuild_cb = sigc::mem_fun(this, &Impl::OnShadowOptionsChanged);
+  manager_->active_shadow_color.changed.connect(sigc::hide(sigc::bind(rebuild_cb, true)));
+  manager_->active_shadow_radius.changed.connect(sigc::hide(sigc::bind(rebuild_cb, true)));
+  manager_->inactive_shadow_color.changed.connect(sigc::hide(sigc::bind(rebuild_cb, false)));
+  manager_->inactive_shadow_radius.changed.connect(sigc::hide(sigc::bind(rebuild_cb, false)));
+  manager_->shadow_offset.changed.connect(sigc::hide(sigc::mem_fun(this, &Impl::UpdateWindowsExtents)));
+
+  BuildInactiveShadowTexture();
+  BuildActiveShadowTexture();
+}
+
+Manager::Impl::~Impl()
+{
+  enable_add_supported_atoms_ = false;
+  screen->updateSupportedWmHints();
+}
+
+cu::PixmapTexture::Ptr Manager::Impl::BuildShadowTexture(unsigned radius, nux::Color const& color)
+{
+  int tex_size = radius * 4;
+
+  nux::CairoGraphics dummy(CAIRO_FORMAT_ARGB32, tex_size, tex_size);
+  auto* dummy_ctx = dummy.GetInternalContext();
+  cairo_rectangle(dummy_ctx, radius*2, radius*2, tex_size, tex_size);
+  cairo_set_source_rgba(dummy_ctx, color.red, color.green, color.blue, color.alpha);
+  cairo_fill(dummy_ctx);
+  dummy.BlurSurface(radius);
+
+  cu::CairoContext shadow_ctx(tex_size, tex_size);
+  cairo_set_source_surface(shadow_ctx, dummy.GetSurface(), 0, 0);
+  cairo_paint(shadow_ctx);
+  return shadow_ctx;
+}
+
+void Manager::Impl::BuildActiveShadowTexture()
+{
+  active_shadow_pixmap_ = BuildShadowTexture(manager_->active_shadow_radius(), manager_->active_shadow_color());
+}
+
+void Manager::Impl::BuildInactiveShadowTexture()
+{
+  inactive_shadow_pixmap_ = BuildShadowTexture(manager_->inactive_shadow_radius(), manager_->inactive_shadow_color());
+}
+
+void Manager::Impl::OnShadowOptionsChanged(bool active)
+{
+  if (active)
+    BuildActiveShadowTexture();
+  else
+    BuildInactiveShadowTexture();
+
+  UpdateWindowsExtents();
+}
+
+void Manager::Impl::UpdateWindowsExtents()
+{
+  for (auto const& win : windows_)
+    win.second->impl_->RedrawDecorations();
+}
+
+bool Manager::Impl::UpdateWindow(::Window xid)
+{
+  auto const& win = GetWindowByXid(xid);
+
+  if (win && !win->impl_->win_->hasUnmapReference())
+  {
+    win->Update();
+    return true;
+  }
+
+  return false;
+}
+
+Window::Ptr Manager::Impl::GetWindowByXid(::Window xid) const
+{
+  for (auto const& pair : windows_)
+  {
+    if (pair.first->id() == xid)
+      return pair.second;
+  }
+
+  return nullptr;
+}
+
+Window::Ptr Manager::Impl::GetWindowByFrame(::Window xid) const
+{
+  auto it = framed_windows_.find(xid);
+  if (it == framed_windows_.end())
+    return nullptr;
+
+  return it->second.lock();
+}
+
+bool Manager::Impl::HandleEventBefore(XEvent* event)
+{
+  active_window_ = screen->activeWindow();
+  switch (event->type)
+  {
+    case ClientMessage:
+      if (event->xclient.message_type == atom::_NET_REQUEST_FRAME_EXTENTS)
+      {
+        if (Window::Ptr const& win = GetWindowByXid(event->xclient.window))
+          win->impl_->Decorate();
+      }
+      break;
+    case MotionNotify:
+    case EnterNotify:
+    case LeaveNotify:
+    case ButtonPress:
+    case ButtonRelease:
+      if (HandleFrameEvent(event))
+        return true;
+      break;
+  }
+
+  return false;
+}
+
+bool Manager::Impl::HandleEventAfter(XEvent* event)
+{
+  if (screen->activeWindow() != active_window_)
+  {
+    // Do this when _NET_ACTIVE_WINDOW changes on root!
+    auto const& old_active = GetWindowByXid(active_window_);
+
+    if (old_active)
+      old_active->impl_->active = false;
+
+    active_window_ = screen->activeWindow();
+
+    auto const& new_active = GetWindowByXid(active_window_);
+
+    if (new_active)
+      new_active->impl_->active = true;
+  }
+
+  switch (event->type)
+  {
+    case PropertyNotify:
+    {
+      if (event->xproperty.atom == Atoms::mwmHints)
+      {
+        if (Window::Ptr const& win = GetWindowByXid(event->xproperty.window))
+        {
+          win->impl_->CleanupWindowControls();
+          win->Update();
+        }
+      }
+      else if (event->xproperty.atom == XA_WM_NAME ||
+               event->xproperty.atom == Atoms::wmName ||
+               event->xproperty.atom == atom::_NET_WM_VISIBLE_NAME)
+      {
+        if (Window::Ptr const& win = GetWindowByXid(event->xproperty.window))
+        {
+          auto& wm = WindowManager::Default();
+          win->title = wm.GetStringProperty(event->xproperty.window, event->xproperty.atom);
+        }
+      }
+      break;
+    }
+    case ConfigureNotify:
+      UpdateWindow(event->xconfigure.window);
+      break;
+    default:
+      if (screen->XShape() && event->type == screen->shapeEvent() + ShapeNotify)
+      {
+        auto window = reinterpret_cast<XShapeEvent*>(event)->window;
+        if (!UpdateWindow(window))
+        {
+          if (Window::Ptr const& win = GetWindowByFrame(window))
+            win->impl_->SyncXShapeWithFrameRegion();
+        }
+      }
+      break;
+  }
+
+  return false;
+}
+
+bool Manager::Impl::HandleFrameEvent(XEvent* event)
+{
+  auto const& win = GetWindowByFrame(event->xany.window);
+
+  // ButtonRelease events might happen also outside the frame window, in this
+  // case we must unset the mouse owner, wherever the event happens.
+  if (!win && event->type != ButtonRelease)
+    return false;
+
+  auto const& input_mixer = win ? win->impl_->input_mixer_ : last_mouse_owner_.lock();
+
+  if (!input_mixer)
+    return false;
+
+  switch (event->type)
+  {
+    case MotionNotify:
+    {
+      input_mixer->MotionEvent(CompPoint(event->xmotion.x_root, event->xmotion.y_root));
+      break;
+    }
+    case EnterNotify:
+    {
+      input_mixer->EnterEvent(CompPoint(event->xcrossing.x_root, event->xcrossing.y_root));
+      break;
+    }
+    case LeaveNotify:
+    {
+      input_mixer->LeaveEvent(CompPoint(event->xcrossing.x_root, event->xcrossing.y_root));
+      break;
+    }
+    case ButtonPress:
+    {
+      input_mixer->ButtonDownEvent(CompPoint(event->xbutton.x_root, event->xbutton.y_root), event->xbutton.button);
+      if (input_mixer->GetMouseOwner())
+        last_mouse_owner_ = input_mixer;
+      break;
+    }
+    case ButtonRelease:
+    {
+      input_mixer->ButtonUpEvent(CompPoint(event->xbutton.x_root, event->xbutton.y_root), event->xbutton.button);
+      last_mouse_owner_.reset();
+      break;
+    }
+  }
+
+  // This causes the Alt+Move not to work, we should probably return this value based on the actual handled state
+  // return true;
+  return false;
+}
+
+Window::Ptr Manager::Impl::HandleWindow(CompWindow* cwin)
+{
+  auto win = std::make_shared<Window>(cwin);
+  auto* wimpl = win->impl_.get();
+
+  std::weak_ptr<decoration::Window> weak_win(win);
+  wimpl->framed.connect(sigc::bind(sigc::mem_fun(this, &Impl::OnWindowFrameChanged), weak_win));
+  windows_[cwin] = win;
+
+  if (wimpl->frame_)
+    framed_windows_[wimpl->frame_] = win;
+
+  return win;
+}
+
+void Manager::Impl::OnWindowFrameChanged(bool framed, ::Window frame, std::weak_ptr<decoration::Window> const& window)
+{
+  if (!framed || !frame)
+    framed_windows_.erase(frame);
+  else
+    framed_windows_[frame] = window;
+}
+
+// Public APIs
+
+Manager::Manager()
+  : shadow_offset(Style::Get()->ShadowOffset())
+  , active_shadow_color(Style::Get()->ActiveShadowColor())
+  , active_shadow_radius(Style::Get()->ActiveShadowRadius())
+  , inactive_shadow_color(Style::Get()->InactiveShadowColor())
+  , inactive_shadow_radius(Style::Get()->InactiveShadowRadius())
+  , impl_(new Impl(this))
+{}
+
+Manager::~Manager()
+{
+  if (manager_ == this)
+    manager_ = nullptr;
+}
+
+void Manager::AddSupportedAtoms(std::vector<Atom>& atoms) const
+{
+  if (impl_->enable_add_supported_atoms_)
+    atoms.push_back(atom::_NET_REQUEST_FRAME_EXTENTS);
+}
+
+bool Manager::HandleEventBefore(XEvent* xevent)
+{
+  return impl_->HandleEventBefore(xevent);
+}
+
+bool Manager::HandleEventAfter(XEvent* xevent)
+{
+  return impl_->HandleEventAfter(xevent);
+}
+
+Window::Ptr Manager::HandleWindow(CompWindow* cwin)
+{
+  return impl_->HandleWindow(cwin);
+}
+
+void Manager::UnHandleWindow(CompWindow* cwin)
+{
+  impl_->windows_.erase(cwin);
+}
+
+Window::Ptr Manager::GetWindowByXid(::Window xid)
+{
+  return impl_->GetWindowByXid(xid);
+}
+
+std::string Manager::GetName() const
+{
+  return "DecorationsManager";
+}
+
+void Manager::AddProperties(debug::IntrospectionData& data)
+{
+  data.add("shadow_offset", shadow_offset())
+  .add("active_shadow_color", active_shadow_color())
+  .add("active_shadow_radius", active_shadow_radius())
+  .add("inactive_shadow_color", inactive_shadow_color())
+  .add("inactive_shadow_radius", inactive_shadow_radius())
+  .add("active_window", impl_->active_window_);
+}
+
+debug::Introspectable::IntrospectableList Manager::GetIntrospectableChildren()
+{
+  IntrospectableList children;
+
+  for (auto const& win : impl_->windows_)
+    children.push_back(win.second.get());
+
+  return children;
+}
+
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsManager.h'
--- decorations/DecorationsManager.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsManager.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,74 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATION_MANAGER
+#define UNITY_DECORATION_MANAGER
+
+#include <NuxCore/Property.h>
+#include "DecoratedWindow.h"
+
+class CompWindow;
+class CompManager;
+
+namespace unity
+{
+namespace decoration
+{
+class Manager : public debug::Introspectable
+{
+public:
+  typedef std::shared_ptr<Manager> Ptr;
+
+  Manager();
+  virtual ~Manager();
+
+  nux::Property<nux::Point> shadow_offset;
+  nux::Property<nux::Color> active_shadow_color;
+  nux::Property<unsigned> active_shadow_radius;
+  nux::Property<nux::Color> inactive_shadow_color;
+  nux::Property<unsigned> inactive_shadow_radius;
+
+  void AddSupportedAtoms(std::vector<Atom>& atoms) const;
+  bool HandleEventBefore(XEvent*);
+  bool HandleEventAfter(XEvent*);
+
+  Window::Ptr HandleWindow(CompWindow*);
+  void UnHandleWindow(CompWindow*);
+
+  Window::Ptr GetWindowByXid(::Window);
+
+protected:
+  std::string GetName() const;
+  void AddProperties(debug::IntrospectionData&);
+  IntrospectableList GetIntrospectableChildren();
+
+private:
+  Manager(Manager const&) = delete;
+  Manager& operator=(Manager const&) = delete;
+
+  friend class Window;
+
+  struct Impl;
+  std::unique_ptr<Impl> impl_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif

=== added file 'decorations/DecorationsPriv.h'
--- decorations/DecorationsPriv.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsPriv.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,165 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATION_MANAGER_PRIV
+#define UNITY_DECORATION_MANAGER_PRIV
+
+#include <unordered_map>
+#include <NuxCore/NuxCore.h>
+#include <NuxCore/Rect.h>
+#include <UnityCore/ConnectionManager.h>
+#include <core/core.h>
+#include <opengl/opengl.h>
+#include <composite/composite.h>
+#include <X11/extensions/shape.h>
+
+#include "DecorationsDataPool.h"
+#include "DecorationsManager.h"
+#include "DecorationsTitle.h"
+#include "DecorationsInputMixer.h"
+
+class CompRegion;
+
+namespace unity
+{
+namespace decoration
+{
+namespace cu = compiz_utils;
+
+extern Manager* manager_;
+
+struct Quads
+{
+  enum class Pos
+  {
+    TOP_LEFT = 0,
+    TOP_RIGHT,
+    BOTTOM_LEFT,
+    BOTTOM_RIGHT,
+    Size
+  };
+
+  cu::TextureQuad& operator[](Pos position) { return inner_vector_[unsigned(position)]; }
+  cu::TextureQuad const& operator[](Pos position) const { return inner_vector_[unsigned(position)]; }
+  std::size_t size() const { return inner_vector_.size(); }
+
+private:
+  std::array<cu::TextureQuad, size_t(Pos::Size)> inner_vector_;
+};
+
+struct Window::Impl
+{
+  Impl(decoration::Window*, CompWindow*);
+  ~Impl();
+
+  nux::Property<bool> active;
+  sigc::signal<void, bool, ::Window> framed;
+
+  void Update();
+  void Decorate();
+  void Undecorate();
+  bool IsMaximized() const;
+  bool FullyDecorated() const;
+  bool ShadowDecorated() const;
+  void RedrawDecorations();
+
+private:
+  void UnsetExtents();
+  void SetupExtents();
+  void UpdateFrame();
+  void CreateFrame(nux::Geometry const&);
+  void UpdateFrameGeo(nux::Geometry const&);
+  void UnsetFrame();
+  void SetupWindowControls();
+  void CleanupWindowControls();
+  void SyncXShapeWithFrameRegion();
+  bool ShouldBeDecorated() const;
+  GLTexture* ShadowTexture() const;
+  unsigned ShadowRadius() const;
+
+  void ComputeShadowQuads();
+  void UpdateDecorationTextures();
+  void RenderDecorationTexture(Side, nux::Geometry const&);
+  void Draw(GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
+
+  friend class Window;
+  friend struct Manager::Impl;
+
+  decoration::Window *parent_;
+  ::CompWindow* win_;
+  ::CompositeWindow* cwin_;
+  ::GLWindow* glwin_;
+  ::Window frame_;
+  bool dirty_geo_;
+
+  CompRect last_shadow_rect_;
+  Quads shadow_quads_;
+  nux::Geometry frame_geo_;
+  CompRegion frame_region_;
+  connection::Wrapper theme_changed_;
+  std::string last_title_;
+  std::vector<cu::SimpleTextureQuad> bg_textures_;
+  InputMixer::Ptr input_mixer_;
+  Layout::Ptr top_layout_;
+  Title::Ptr title_;
+  Item::Ptr edge_borders_;
+};
+
+struct Manager::Impl : sigc::trackable
+{
+  Impl(decoration::Manager*);
+  ~Impl();
+
+  Window::Ptr HandleWindow(CompWindow* cwin);
+  bool HandleEventBefore(XEvent*);
+  bool HandleEventAfter(XEvent*);
+  bool HandleFrameEvent(XEvent*);
+
+private:
+  Window::Ptr GetWindowByXid(::Window) const;
+  Window::Ptr GetWindowByFrame(::Window) const;
+
+  bool UpdateWindow(::Window);
+  void UpdateWindowsExtents();
+
+  void BuildActiveShadowTexture();
+  void BuildInactiveShadowTexture();
+  cu::PixmapTexture::Ptr BuildShadowTexture(unsigned radius, nux::Color const&);
+  void OnShadowOptionsChanged(bool active);
+  void OnWindowFrameChanged(bool, ::Window, std::weak_ptr<decoration::Window> const&);
+
+  friend class Manager;
+  friend struct Window::Impl;
+
+  ::Window active_window_;
+  bool enable_add_supported_atoms_;
+
+  DataPool::Ptr data_pool_;
+  cu::PixmapTexture::Ptr active_shadow_pixmap_;
+  cu::PixmapTexture::Ptr inactive_shadow_pixmap_;
+
+  std::weak_ptr<InputMixer> last_mouse_owner_;
+  std::map<CompWindow*, decoration::Window::Ptr> windows_;
+  std::unordered_map<::Window, std::weak_ptr<decoration::Window>> framed_windows_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif

=== added file 'decorations/DecorationsTitle.cpp'
--- decorations/DecorationsTitle.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsTitle.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,116 @@
+// -*- 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 <sigc++/adaptors/hide.h>
+#include "DecorationsTitle.h"
+#include "DecorationStyle.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+Title::Title()
+{
+  text.changed.connect(sigc::mem_fun(this, &Title::OnTextChanged));
+  focused.changed.connect(sigc::hide(sigc::mem_fun(this, &Title::RenderTexture)));
+  Style::Get()->title_font.changed.connect(sigc::mem_fun(this, &Title::OnFontChanged));
+}
+
+void Title::OnTextChanged(std::string const& new_text)
+{
+  bool damaged = false;
+  auto real_size = Style::Get()->TitleNaturalSize(new_text);
+
+  if (GetNaturalWidth() > real_size.width || GetNaturalHeight() > real_size.height)
+  {
+    Damage();
+    damaged = true;
+  }
+
+  SetSize(real_size.width, real_size.height);
+  texture_size_ = nux::Size();
+
+  if (!damaged)
+    Damage();
+}
+
+void Title::OnFontChanged(std::string const&)
+{
+  text.changed.emit(text());
+}
+
+void Title::RenderTexture()
+{
+  auto state = focused() ? WidgetState::NORMAL : WidgetState::BACKDROP;
+  cu::CairoContext text_ctx(texture_size_.width, texture_size_.height);
+  Style::Get()->DrawTitle(text(), state, text_ctx, texture_size_.width, texture_size_.height);
+  SetTexture(text_ctx);
+}
+
+void Title::SetX(int x)
+{
+  float alignment = Style::Get()->TitleAlignmentValue();
+
+  if (alignment > 0)
+  {
+    if (BasicContainer::Ptr const& top = GetTopParent())
+    {
+      auto const& top_geo = top->ContentGeometry();
+      x = std::max<int>(x, top_geo.x() + (top_geo.width() - GetNaturalWidth()) * alignment);
+    }
+  }
+
+  TexturedItem::SetX(x);
+}
+
+int Title::GetNaturalWidth() const
+{
+  return Item::GetNaturalWidth();
+}
+
+int Title::GetNaturalHeight() const
+{
+  return Item::GetNaturalHeight();
+}
+
+void Title::Draw(GLWindow* ctx, GLMatrix const& transformation, GLWindowPaintAttrib const& attrib,
+                 CompRegion const& clip, unsigned mask)
+{
+  auto const& geo = Geometry();
+  nux::Size tex_size(geo.width(), geo.height());
+
+  if (texture_size_ != tex_size)
+  {
+    texture_size_ = tex_size;
+    RenderTexture();
+  }
+
+  TexturedItem::Draw(ctx, transformation, attrib, clip, mask);
+}
+
+void Title::AddProperties(debug::IntrospectionData& data)
+{
+  TexturedItem::AddProperties(data);
+  data.add("text", text())
+  .add("texture_size", texture_size_);
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsTitle.h'
--- decorations/DecorationsTitle.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsTitle.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,61 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATIONS_TITLE
+#define UNITY_DECORATIONS_TITLE
+
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class Title : public TexturedItem
+{
+public:
+  typedef std::shared_ptr<Title> Ptr;
+
+  nux::Property<std::string> text;
+
+  Title();
+
+  void SetX(int);
+  int GetNaturalWidth() const;
+  int GetNaturalHeight() const;
+
+  void Draw(GLWindow*, GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
+
+protected:
+  std::string GetName() const { return "Title"; }
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  void OnFontChanged(std::string const&);
+  void OnTextChanged(std::string const& new_text);
+  void RenderTexture();
+
+  bool render_texture_;
+  nux::Size texture_size_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATIONS_TITLE

=== added file 'decorations/DecorationsWidgets.cpp'
--- decorations/DecorationsWidgets.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsWidgets.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,493 @@
+// -*- 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 <NuxCore/Logger.h>
+#include <composite/composite.h>
+#include <boost/range/adaptor/reversed.hpp>
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace
+{
+DECLARE_LOGGER(logger, "unity.decoration.widgets");
+CompositeScreen* cscreen_ = CompositeScreen::get(screen);
+
+template <typename T> constexpr T max(T a, T b) { return (a > b) ? a : b; }
+template <typename T> constexpr T min(T a, T b) { return (a < b) ? a : b; }
+constexpr int clamp_size(int v) { return min<int>(max(0, v), std::numeric_limits<short>::max()); }
+}
+
+Item::Item()
+  : visible(true)
+  , focused(false)
+  , sensitive(true)
+  , mouse_owner(false)
+  , max_(std::numeric_limits<short>::max(), std::numeric_limits<short>::max())
+{
+  auto parent_relayout_cb = sigc::mem_fun(this, &Item::RequestRelayout);
+  visible.changed.connect(sigc::hide(parent_relayout_cb));
+  geo_parameters_changed.connect(parent_relayout_cb);
+}
+
+void Item::SetSize(int width, int height)
+{
+  natural_.width = clamp_size(width);
+  natural_.height = clamp_size(height);
+  SetMinWidth(width);
+  SetMaxWidth(width);
+  SetMinHeight(height);
+  SetMaxHeight(height);
+}
+
+void Item::SetCoords(int x, int y)
+{
+  auto& geo = InternalGeo();
+
+  if (geo.x() == x && geo.y() == y)
+    return;
+
+  geo.setX(x);
+  geo.setY(y);
+  geo_parameters_changed.emit();
+}
+
+int Item::GetNaturalWidth() const
+{
+  return natural_.width;
+}
+
+int Item::GetNaturalHeight() const
+{
+  return natural_.height;
+}
+
+int Item::GetMaxWidth() const
+{
+  return max_.width;
+};
+
+int Item::GetMaxHeight() const
+{
+  return max_.height;
+};
+
+int Item::GetMinWidth() const
+{
+  return min_.width;
+};
+
+int Item::GetMinHeight() const
+{
+  return min_.height;
+};
+
+void Item::SetMaxWidth(int value)
+{
+  int clamped = clamp_size(value);
+
+  if (max_.width == clamped)
+    return;
+
+  max_.width = clamped;
+  min_.width = min(min_.width, max_.width);
+
+  if (Geometry().width() > max_.width)
+    InternalGeo().setWidth(min(GetNaturalWidth(), max_.width));
+
+  geo_parameters_changed.emit();
+}
+
+void Item::SetMinWidth(int value)
+{
+  int clamped = clamp_size(value);
+
+  if (min_.width == clamped)
+    return;
+
+  min_.width = clamped;
+  max_.width = max(min_.width, max_.width);
+
+  if (Geometry().width() < min_.width)
+    InternalGeo().setWidth(min_.width);
+
+  geo_parameters_changed.emit();
+}
+
+void Item::SetMaxHeight(int value)
+{
+  int clamped = clamp_size(value);
+
+  if (max_.height == clamped)
+    return;
+
+  max_.height = clamped;
+  min_.height = min(min_.height, max_.height);
+
+  if (Geometry().height() > max_.height)
+    InternalGeo().setHeight(min(GetNaturalHeight(), max_.height));
+
+  geo_parameters_changed.emit();
+}
+
+void Item::SetMinHeight(int value)
+{
+  int clamped = clamp_size(value);
+
+  if (min_.height == clamped)
+    return;
+
+  min_.height = clamped;
+  max_.height = max(min_.height, max_.height);
+
+  if (Geometry().height() < min_.height)
+    InternalGeo().setHeight(min_.height);
+
+  geo_parameters_changed.emit();
+}
+
+void Item::Damage()
+{
+  cscreen_->damageRegion(Geometry());
+}
+
+CompRect const& Item::Geometry() const
+{
+  return const_cast<Item*>(this)->InternalGeo();
+}
+
+void Item::SetParent(BasicContainer::Ptr const& parent)
+{
+  if (parent && !parent_.expired())
+  {
+    LOG_ERROR(logger) << "This item has already a parent!";
+    return;
+  }
+
+  parent_ = parent;
+}
+
+BasicContainer::Ptr Item::GetParent() const
+{
+  return parent_.lock();
+}
+
+BasicContainer::Ptr Item::GetTopParent() const
+{
+  BasicContainer::Ptr parent = GetParent();
+
+  while (parent)
+  {
+    if (parent->parent_.expired())
+      return parent;
+
+    parent = parent->GetParent();
+  }
+
+  return parent;
+}
+
+void Item::RequestRelayout()
+{
+  if (BasicContainer::Ptr const& parent = parent_.lock())
+    parent->Relayout();
+}
+
+void Item::AddProperties(debug::IntrospectionData& data)
+{
+  data.add(Geometry())
+  .add("max_size", max_)
+  .add("min_size", min_)
+  .add("natural_size", nux::Size(GetNaturalWidth(), GetNaturalHeight()))
+  .add("visible", visible())
+  .add("focused", focused())
+  .add("sensitive", sensitive())
+  .add("mouse_owner", mouse_owner())
+  .add("is_container", IsContainer());
+}
+
+//
+
+void TexturedItem::SetTexture(cu::SimpleTexture::Ptr const& tex)
+{
+  if (texture_.st == tex)
+    return;
+
+  auto prev_geo = Geometry();
+  texture_.SetTexture(tex);
+  auto const& actual_geo = Geometry();
+
+  if (prev_geo != actual_geo)
+  {
+    max_ = { actual_geo.width(), actual_geo.height() };
+    min_ = max_;
+    geo_parameters_changed.emit();
+
+    if (!actual_geo.contains(prev_geo))
+      cscreen_->damageRegion(prev_geo);
+  }
+
+  Damage();
+}
+
+void TexturedItem::Draw(GLWindow* ctx, GLMatrix const& transformation, GLWindowPaintAttrib const& attrib,
+                        CompRegion const& clip, unsigned mask)
+{
+  if (!visible || Geometry().isEmpty() || !texture_)
+    return;
+
+  ctx->vertexBuffer()->begin();
+  ctx->glAddGeometry({texture_.quad.matrix}, texture_.quad.box, clip);
+
+  if (ctx->vertexBuffer()->end())
+    ctx->glDrawTexture(texture_, transformation, attrib, mask);
+}
+
+int TexturedItem::GetNaturalWidth() const
+{
+  return (texture_) ? texture_.st->width() : Item::GetNaturalWidth();
+}
+
+int TexturedItem::GetNaturalHeight() const
+{
+  return (texture_) ? texture_.st->height() : Item::GetNaturalHeight();
+}
+
+CompRect& TexturedItem::InternalGeo()
+{
+  return texture_.quad.box;
+}
+
+void TexturedItem::SetCoords(int x, int y)
+{
+  texture_.SetCoords(x, y);
+}
+
+//
+
+BasicContainer::BasicContainer()
+{
+  geo_parameters_changed.connect(sigc::mem_fun(this, &BasicContainer::Relayout));
+  focused.changed.connect([this] (bool focused) {
+    for (auto const& item : items_)
+      item->focused = focused;
+  });
+}
+
+CompRect BasicContainer::ContentGeometry() const
+{
+  return Geometry();
+}
+
+void BasicContainer::AddProperties(debug::IntrospectionData& data)
+{
+  Item::AddProperties(data);
+  data.add(ContentGeometry());
+}
+
+debug::Introspectable::IntrospectableList BasicContainer::GetIntrospectableChildren()
+{
+  IntrospectableList children;
+
+  for (auto const& item : items_)
+    children.push_back(item.get());
+
+  return children;
+}
+
+//
+
+Layout::Layout()
+  : inner_padding(0, sigc::mem_fun(this, &Layout::SetPadding))
+  , left_padding(0, sigc::mem_fun(this, &Layout::SetPadding))
+  , right_padding(0, sigc::mem_fun(this, &Layout::SetPadding))
+  , top_padding(0, sigc::mem_fun(this, &Layout::SetPadding))
+  , bottom_padding(0, sigc::mem_fun(this, &Layout::SetPadding))
+  , relayouting_(false)
+{}
+
+void Layout::Append(Item::Ptr const& item)
+{
+  if (!item || std::find(items_.begin(), items_.end(), item) != items_.end())
+    return;
+
+  if (item->GetParent())
+  {
+    LOG_ERROR(logger) << "Impossible to add an item that has already a parent";
+    return;
+  }
+
+  items_.push_back(item);
+  item->focused = focused();
+  item->SetParent(shared_from_this());
+  Relayout();
+}
+
+void Layout::Remove(Item::Ptr const& item)
+{
+  auto it = std::find(items_.begin(), items_.end(), item);
+
+  if (it == items_.end())
+    return;
+
+  item->SetParent(nullptr);
+  items_.erase(it);
+  Relayout();
+}
+
+CompRect Layout::ContentGeometry() const
+{
+  return CompRect(rect_.x() + min(left_padding(), rect_.width()),
+                  rect_.y() + min(top_padding(), rect_.height()),
+                  clamp_size(rect_.width() - left_padding - right_padding),
+                  clamp_size(rect_.height() - top_padding - bottom_padding));
+}
+
+void Layout::Relayout()
+{
+  if (relayouting_)
+    return;
+
+  relayouting_ = true;
+  int loop = 0;
+  CompRect old_geo(rect_);
+
+  nux::Size available_space(clamp_size(max_.width - left_padding - right_padding),
+                            clamp_size(max_.height - top_padding - bottom_padding));
+
+  do
+  {
+    nux::Size content(min(left_padding(), max_.width), 0);
+
+    for (auto const& item : items_)
+    {
+      if (!item->visible())
+        continue;
+
+      if (loop == 0)
+      {
+        item->SetMinWidth(item->GetNaturalWidth());
+        item->SetMaxWidth(available_space.width);
+        item->SetMinHeight(min(available_space.height, item->GetNaturalHeight()));
+        item->SetMaxHeight(available_space.height);
+      }
+
+      auto const& item_geo = item->Geometry();
+      content.height = max(content.height, item_geo.height());
+      item->SetX(rect_.x() + content.width);
+
+      if (item_geo.width() > 0)
+        content.width += item_geo.width() + inner_padding;
+    }
+
+    if (!items_.empty() && content.width > inner_padding)
+      content.width -= inner_padding;
+
+    int actual_right_padding = max(0, min(right_padding(), max_.width - content.width));
+    int vertical_padding = top_padding + bottom_padding;
+
+    content.width += actual_right_padding;
+    content.height += min(vertical_padding, max_.height);
+
+    if (content.width < min_.width)
+      content.width = min_.width;
+
+    if (content.height < min_.height)
+      content.height = min_.height;
+
+    int exceeding_width = content.width - max_.width + inner_padding + right_padding - actual_right_padding;
+    int content_y = rect_.y() + top_padding;
+
+    for (auto const& item : boost::adaptors::reverse(items_))
+    {
+      if (!item->visible())
+        continue;
+
+      auto const& item_geo = item->Geometry();
+
+      if (exceeding_width > 0)
+        exceeding_width -= inner_padding;
+
+      if (exceeding_width > 0 && item_geo.width() > 0)
+      {
+        int old_width = item_geo.width();
+        int max_item_width = clamp_size(old_width - exceeding_width);
+        item->SetMaxWidth(max_item_width);
+        exceeding_width -= (old_width - max_item_width);
+      }
+
+      item->SetY(content_y + (content.height - vertical_padding - item_geo.height()) / 2);
+    }
+
+    rect_.setWidth(content.width);
+    rect_.setHeight(content.height);
+
+    if (loop > 1)
+    {
+      LOG_ERROR(logger) << "Relayouting is taking more than expected, process should be completed in maximum two loops!";
+      break;
+    }
+
+    ++loop;
+  }
+  while (rect_.width() > max_.width || rect_.height() > max_.height);
+
+  relayouting_ = false;
+
+  if (old_geo != rect_)
+    geo_parameters_changed.emit();
+}
+
+void Layout::Draw(GLWindow* ctx, GLMatrix const& transformation, GLWindowPaintAttrib const& attrib,
+                  CompRegion const& clip, unsigned mask)
+{
+  for (auto const& item : items_)
+  {
+    if (item->visible())
+      item->Draw(ctx, transformation, attrib, clip, mask);
+  }
+}
+
+bool Layout::SetPadding(int& target, int new_value)
+{
+  int padding = clamp_size(new_value);
+
+  if (padding == target)
+    return false;
+
+  target = padding;
+  Relayout();
+
+  return true;
+}
+
+void Layout::AddProperties(debug::IntrospectionData& data)
+{
+  Item::AddProperties(data);
+  data.add("inner_padding", inner_padding())
+  .add("left_padding", left_padding())
+  .add("right_padding", right_padding())
+  .add("top_padding", top_padding())
+  .add("bottom_padding", bottom_padding());
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsWidgets.h'
--- decorations/DecorationsWidgets.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsWidgets.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,190 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATION_WIDGETS
+#define UNITY_DECORATION_WIDGETS
+
+#include <deque>
+#include <NuxCore/Size.h>
+#include <NuxCore/Property.h>
+#include "Introspectable.h"
+#include "CompizUtils.h"
+
+namespace unity
+{
+namespace decoration
+{
+namespace cu = compiz_utils;
+
+class BasicContainer;
+
+class Item : public sigc::trackable, public debug::Introspectable
+{
+public:
+  typedef std::shared_ptr<Item> Ptr;
+  typedef std::deque<Item::Ptr> List;
+
+  Item();
+  virtual ~Item() = default;
+
+  nux::Property<bool> visible;
+  nux::Property<bool> focused;
+  nux::Property<bool> sensitive;
+  nux::Property<bool> mouse_owner;
+
+  CompRect const& Geometry() const;
+  virtual int GetNaturalWidth() const;
+  virtual int GetNaturalHeight() const;
+
+  virtual void SetCoords(int x, int y);
+  virtual void SetX(int x) { SetCoords(x, Geometry().y()); }
+  virtual void SetY(int y) { SetCoords(Geometry().x(), y); }
+  virtual void SetSize(int width, int height);
+  virtual void SetWidth(int width) { SetSize(width, Geometry().height()); }
+  virtual void SetHeight(int height) { SetSize(Geometry().width(), height); };
+
+  virtual void SetMaxWidth(int max_width);
+  virtual void SetMaxHeight(int max_height);
+  virtual void SetMinWidth(int min_width);
+  virtual void SetMinHeight(int min_height);
+
+  int GetMaxWidth() const;
+  int GetMaxHeight() const;
+  int GetMinWidth() const;
+  int GetMinHeight() const;
+
+  void SetParent(std::shared_ptr<BasicContainer> const&);
+  std::shared_ptr<BasicContainer> GetParent() const;
+  std::shared_ptr<BasicContainer> GetTopParent() const;
+
+  void Damage();
+  virtual void Draw(GLWindow*, GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask) {}
+
+protected:
+  virtual CompRect& InternalGeo() = 0;
+  sigc::signal<void> geo_parameters_changed;
+
+  virtual bool IsContainer() const { return false; }
+  void RequestRelayout();
+
+  friend class InputMixer;
+  virtual void MotionEvent(CompPoint const&) {}
+  virtual void ButtonDownEvent(CompPoint const&, unsigned button) {}
+  virtual void ButtonUpEvent(CompPoint const&, unsigned button) {}
+
+  std::string GetName() const { return "Item"; }
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  Item(Item const&) = delete;
+  Item& operator=(Item const&) = delete;
+
+protected:
+  nux::Size max_;
+  nux::Size min_;
+  nux::Size natural_;
+
+private:
+  std::weak_ptr<BasicContainer> parent_;
+};
+
+class SimpleItem : public Item
+{
+protected:
+  CompRect& InternalGeo() { return rect_; }
+  CompRect rect_;
+};
+
+
+class TexturedItem : public Item
+{
+public:
+  typedef std::shared_ptr<TexturedItem> Ptr;
+
+  void SetTexture(cu::SimpleTexture::Ptr const&);
+  void Draw(GLWindow*, GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
+  void SetCoords(int x, int y);
+
+  int GetNaturalWidth() const;
+  int GetNaturalHeight() const;
+
+protected:
+  std::string GetName() const { return "TexturedItem"; }
+
+  CompRect& InternalGeo();
+  cu::SimpleTextureQuad texture_;
+};
+
+
+class BasicContainer : public SimpleItem
+{
+public:
+  typedef std::shared_ptr<BasicContainer> Ptr;
+
+  BasicContainer();
+  Item::List const& Items() const { return items_; }
+
+  virtual CompRect ContentGeometry() const;
+
+protected:
+  friend class Item;
+  virtual void Relayout() = 0;
+  bool IsContainer() const { return true; }
+
+  std::string GetName() const { return "BasicContainer"; }
+  void AddProperties(debug::IntrospectionData&);
+  IntrospectableList GetIntrospectableChildren();
+
+  Item::List items_;
+};
+
+
+class Layout : public std::enable_shared_from_this<Layout>, public BasicContainer
+{
+public:
+  typedef std::shared_ptr<Layout> Ptr;
+
+  Layout();
+
+  nux::Property<int> inner_padding;
+  nux::Property<int> left_padding;
+  nux::Property<int> right_padding;
+  nux::Property<int> top_padding;
+  nux::Property<int> bottom_padding;
+
+  void Append(Item::Ptr const&);
+  void Remove(Item::Ptr const&);
+
+  CompRect ContentGeometry() const;
+  void Draw(GLWindow*, GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
+
+protected:
+  void Relayout();
+  std::string GetName() const { return "Layout"; }
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  bool SetPadding(int& target, int new_value);
+  bool relayouting_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif

=== added file 'decorations/DecorationsWindowButton.cpp'
--- decorations/DecorationsWindowButton.cpp	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsWindowButton.cpp	2014-01-23 15:21:26 +0000
@@ -0,0 +1,216 @@
+// -*- 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 <sigc++/adaptors/hide.h>
+#include "DecorationsWindowButton.h"
+#include "DecorationsDataPool.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+WindowButton::WindowButton(CompWindow* win, WindowButtonType type)
+  : type_(type)
+  , pressed_(false)
+  , was_pressed_(false)
+  , win_(win)
+{
+  auto cb = sigc::hide(sigc::mem_fun(this, &WindowButton::UpdateTexture));
+  mouse_owner.changed.connect(cb);
+  focused.changed.connect(cb);
+  UpdateTexture();
+}
+
+void WindowButton::UpdateTexture()
+{
+  SetTexture(DataPool::Get()->ButtonTexture(type_, GetCurrentState()));
+}
+
+WidgetState WindowButton::GetCurrentState() const
+{
+  if (focused())
+  {
+    if (mouse_owner() && pressed_)
+    {
+      return WidgetState::PRESSED;
+    }
+    else if (mouse_owner() && !was_pressed_)
+    {
+      return WidgetState::PRELIGHT;
+    }
+    else
+    {
+      return WidgetState::NORMAL;
+    }
+  }
+  else
+  {
+    if (mouse_owner() && pressed_)
+    {
+      return WidgetState::BACKDROP_PRESSED;
+    }
+    else if (mouse_owner() && !was_pressed_)
+    {
+      return WidgetState::BACKDROP_PRELIGHT;
+    }
+    else
+    {
+      return WidgetState::BACKDROP;
+    }
+  }
+}
+
+void WindowButton::ButtonDownEvent(CompPoint const& p, unsigned button)
+{
+  if (!pressed_ && button <= Button3)
+  {
+    pressed_ = true;
+    was_pressed_ = true;
+    UpdateTexture();
+  }
+}
+
+void WindowButton::ButtonUpEvent(CompPoint const& p, unsigned button)
+{
+  if (pressed_ && button <= Button3)
+  {
+    pressed_ = false;
+    UpdateTexture();
+
+    switch (type_)
+    {
+      case WindowButtonType::CLOSE:
+        if (win_->actions() & CompWindowActionCloseMask)
+          win_->close(screen->getCurrentTime());
+        break;
+      case WindowButtonType::MINIMIZE:
+        if (win_->actions() & CompWindowActionMinimizeMask)
+          win_->minimize();
+        break;
+      case WindowButtonType::MAXIMIZE:
+        switch (button)
+        {
+          case Button1:
+            if ((win_->state() & CompWindowStateMaximizedVertMask) ||
+                (win_->state() & CompWindowStateMaximizedHorzMask))
+              win_->maximize(0);
+            else if (win_->actions() & (CompWindowActionMaximizeHorzMask|CompWindowActionMaximizeVertMask))
+              win_->maximize(MAXIMIZE_STATE);
+            break;
+          case Button2:
+            if (win_->actions() & CompWindowActionMaximizeVertMask)
+            {
+              if (!(win_->state() & CompWindowStateMaximizedVertMask))
+                win_->maximize(CompWindowStateMaximizedVertMask);
+              else
+                win_->maximize(0);
+            }
+            break;
+          case Button3:
+            if (win_->actions() & CompWindowActionMaximizeHorzMask)
+            {
+              if (!(win_->state() & CompWindowStateMaximizedHorzMask))
+                win_->maximize(CompWindowStateMaximizedHorzMask);
+              else
+                win_->maximize(0);
+            }
+            break;
+        }
+        break;
+      default:
+        break;
+    }
+  }
+
+  was_pressed_ = false;
+}
+
+void WindowButton::MotionEvent(CompPoint const& p)
+{
+  if (pressed_)
+  {
+    if (!Geometry().contains(p))
+    {
+      pressed_ = false;
+      UpdateTexture();
+    }
+  }
+  else if (was_pressed_)
+  {
+    if (Geometry().contains(p))
+    {
+      pressed_ = true;
+      UpdateTexture();
+    }
+  }
+}
+
+std::string WindowButton::GetName() const
+{
+  switch (type_)
+  {
+    case WindowButtonType::CLOSE:
+      return "CloseWindowButton";
+    case WindowButtonType::MINIMIZE:
+      return "MinimizeWindowButton";
+    case WindowButtonType::MAXIMIZE:
+      return "MaximizeWindowButton";
+    case WindowButtonType::UNMAXIMIZE:
+      return "UnmaximizeWindowButton";
+    default:
+      return "WindowButton";
+  }
+}
+
+void WindowButton::AddProperties(debug::IntrospectionData& data)
+{
+  TexturedItem::AddProperties(data);
+  data.add("pressed", pressed_);
+
+  switch(GetCurrentState())
+  {
+    case WidgetState::NORMAL:
+      data.add("state", "normal");
+      break;
+    case WidgetState::PRELIGHT:
+      data.add("state", "prelight");
+      break;
+    case WidgetState::PRESSED:
+      data.add("state", "pressed");
+      break;
+    case WidgetState::DISABLED:
+      data.add("state", "disabled");
+      break;
+    case WidgetState::BACKDROP:
+      data.add("state", "backdrop");
+      break;
+    case WidgetState::BACKDROP_PRELIGHT:
+      data.add("state", "backdrop_prelight");
+      break;
+    case WidgetState::BACKDROP_PRESSED:
+      data.add("state", "backdrop_pressed");
+      break;
+    default:
+      data.add("state", "unknown");
+  }
+}
+
+} // decoration namespace
+} // unity namespace

=== added file 'decorations/DecorationsWindowButton.h'
--- decorations/DecorationsWindowButton.h	1970-01-01 00:00:00 +0000
+++ decorations/DecorationsWindowButton.h	2014-01-23 15:21:26 +0000
@@ -0,0 +1,58 @@
+// -*- 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]>
+ */
+
+#ifndef UNITY_DECORATION_WINDOW_BUTTON
+#define UNITY_DECORATION_WINDOW_BUTTON
+
+#include "DecorationStyle.h"
+#include "DecorationsWidgets.h"
+
+namespace unity
+{
+namespace decoration
+{
+
+class WindowButton : public TexturedItem
+{
+public:
+  WindowButton(CompWindow*, WindowButtonType type);
+
+  WidgetState GetCurrentState() const;
+
+protected:
+  void ButtonDownEvent(CompPoint const&, unsigned button);
+  void ButtonUpEvent(CompPoint const&, unsigned button);
+  void MotionEvent(CompPoint const&);
+
+  std::string GetName() const;
+  void AddProperties(debug::IntrospectionData&);
+
+private:
+  void UpdateTexture();
+
+  WindowButtonType type_;
+  bool pressed_;
+  bool was_pressed_;
+  CompWindow* win_;
+};
+
+} // decoration namespace
+} // unity namespace
+
+#endif // UNITY_DECORATION_WINDOW_BUTTON

=== renamed file 'plugins/unityshell/src/glow_texture.h' => 'decorations/glow_texture.h'
=== added directory 'decorations/pch'
=== added file 'decorations/pch/decorations_pch.hh'
--- decorations/pch/decorations_pch.hh	1970-01-01 00:00:00 +0000
+++ decorations/pch/decorations_pch.hh	2014-01-23 15:21:26 +0000
@@ -0,0 +1,39 @@
+// -*- 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]>
+ */
+
+/*
+ * These are the precompiled header includes for this module.
+ * Only system header files can be listed here.
+ */
+
+#include <deque>
+#include <memory>
+#include <unordered_map>
+
+#include <sigc++/sigc++.h>
+#include <cairo/cairo.h>
+
+#include <core/core.h>
+#include <opengl/opengl.h>
+#include <composite/composite.h>
+
+#include <NuxCore/NuxCore.h>
+#include <NuxCore/Property.h>
+#include <NuxCore/Rect.h>
+#include <NuxCore/Size.h>

=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2013-11-19 18:48:35 +0000
+++ panel/PanelMenuView.cpp	2014-01-23 15:21:26 +0000
@@ -24,6 +24,7 @@
 #include "PanelMenuView.h"
 #include "unity-shared/AnimationUtils.h"
 #include "unity-shared/CairoTexture.h"
+#include "unity-shared/DecorationStyle.h"
 #include "unity-shared/PanelStyle.h"
 #include "unity-shared/UnitySettings.h"
 #include "unity-shared/UBusMessages.h"
@@ -98,8 +99,8 @@
 
   opacity = 0.0f;
 
-  Refresh();
-  FullRedraw();
+  if (Refresh())
+    FullRedraw();
 }
 
 PanelMenuView::~PanelMenuView()
@@ -179,8 +180,6 @@
   wm.window_mapped.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMapped));
   wm.window_moved.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMoved));
   wm.window_resized.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowMoved));
-  wm.window_decorated.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowDecorated));
-  wm.window_undecorated.connect(sigc::mem_fun(this, &PanelMenuView::OnWindowUndecorated));
   wm.initiate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadInitiate));
   wm.terminate_spread.connect(sigc::mem_fun(this, &PanelMenuView::OnSpreadTerminate));
   wm.initiate_expo.connect(sigc::mem_fun(this, &PanelMenuView::OnExpoInitiate));
@@ -334,15 +333,17 @@
 
 bool PanelMenuView::ShouldDrawMenus() const
 {
-  WindowManager& wm = WindowManager::Default();
-  bool screen_grabbed = (wm.IsExpoActive() || wm.IsScaleActive());
-
-  if (we_control_active_ && !screen_grabbed &&
-      !switcher_showing_ && !launcher_keynav_ && !entries_.empty())
+  if (we_control_active_ && !switcher_showing_ && !launcher_keynav_ && !entries_.empty())
   {
-    if (is_inside_ || last_active_view_ || show_now_activated_ || new_application_)
+    WindowManager& wm = WindowManager::Default();
+
+    if (!wm.IsExpoActive() && !wm.IsScaleActive())
     {
-      return true;
+      if (is_inside_ || last_active_view_ || show_now_activated_ || new_application_)
+        return true;
+
+      if (is_maximized_)
+        return (window_buttons_->IsMouseOwner() || titlebar_grab_area_->IsMouseOwner());
     }
   }
 
@@ -351,15 +352,17 @@
 
 bool PanelMenuView::ShouldDrawButtons() const
 {
-  WindowManager& wm = WindowManager::Default();
-  bool screen_grabbed = (wm.IsExpoActive() || wm.IsScaleActive());
-
-  if (we_control_active_ && is_maximized_ && !screen_grabbed &&
-      !launcher_keynav_ && !switcher_showing_)
+  if (we_control_active_ && is_maximized_ && !launcher_keynav_ && !switcher_showing_)
   {
-    if (is_inside_ || show_now_activated_ || new_application_)
+    WindowManager& wm = WindowManager::Default();
+
+    if (!wm.IsExpoActive() && !wm.IsScaleActive())
     {
-      return true;
+      if (is_inside_ || show_now_activated_ || new_application_)
+        return true;
+
+      if (window_buttons_->IsMouseOwner() || titlebar_grab_area_->IsMouseOwner())
+        return true;
     }
   }
 
@@ -709,84 +712,17 @@
   return label;
 }
 
-void PanelMenuView::UpdateTitleTexture(cairo_t *cr_real, nux::Geometry const& geo, std::string const& label) const
+void PanelMenuView::UpdateTitleTexture(cairo_t *cr, nux::Geometry const& geo, std::string const& label) const
 {
-  using namespace panel;
-  cairo_t* cr;
+  using namespace decoration;
+  auto const& style = Style::Get();
+  auto text_size = style->TitleNaturalSize(label);
   int x = MAIN_LEFT_PADDING + TITLE_PADDING + geo.x;
-  int y = geo.y;
-
-  int text_width = 0;
-  int text_height = 0;
-  int text_space = 0;
-
-  // Find out dimensions first
-  GdkScreen* screen = gdk_screen_get_default();
-  PangoContext* cxt;
-  PangoRectangle log_rect;
-  PangoFontDescription* desc;
-
-  nux::CairoGraphics util_cg(CAIRO_FORMAT_ARGB32, 1, 1);
-  cr = util_cg.GetInternalContext();
-
-  int dpi = Style::Instance().GetTextDPI();
-
-  std::string font_description(Style::Instance().GetFontDescription(PanelItem::TITLE));
-  desc = pango_font_description_from_string(font_description.c_str());
-
-  glib::Object<PangoLayout> layout(pango_cairo_create_layout(cr));
-  pango_layout_set_font_description(layout, desc);
-  pango_layout_set_markup(layout, label.c_str(), -1);
-
-  cxt = pango_layout_get_context(layout);
-  pango_cairo_context_set_font_options(cxt, gdk_screen_get_font_options(screen));
-  pango_cairo_context_set_resolution(cxt, dpi / static_cast<float>(PANGO_SCALE));
-  pango_layout_context_changed(layout);
-
-  pango_layout_get_extents(layout, nullptr, &log_rect);
-  text_width = log_rect.width / PANGO_SCALE;
-  text_height = log_rect.height / PANGO_SCALE;
-
-  pango_font_description_free(desc);
-
-  // Draw the text
-  GtkStyleContext* style_context = Style::Instance().GetStyleContext();
-  text_space = geo.width - x;
-  cr = cr_real;
-  cairo_set_operator(cr, CAIRO_OPERATOR_OVER);
-
-  gtk_style_context_save(style_context);
-  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUBAR);
-  gtk_style_context_add_class(style_context, GTK_STYLE_CLASS_MENUITEM);
-
-  y += (geo.height - text_height) / 2;
-
-  pango_cairo_update_layout(cr, layout);
-
-  if (text_width > text_space)
-  {
-    cairo_pattern_t* linpat;
-    int out_pixels = text_width - text_space;
-    const int fading_pixels = 35;
-    int fading_width = out_pixels < fading_pixels ? out_pixels : fading_pixels;
-
-    cairo_push_group(cr);
-    gtk_render_layout(style_context, cr, x, y, layout);
-    cairo_pop_group_to_source(cr);
-
-    linpat = cairo_pattern_create_linear(geo.width - fading_width, y, geo.width, y);
-    cairo_pattern_add_color_stop_rgba(linpat, 0, 0, 0, 0, 1);
-    cairo_pattern_add_color_stop_rgba(linpat, 1, 0, 0, 0, 0);
-    cairo_mask(cr, linpat);
-
-    cairo_pattern_destroy(linpat);
-  }
-  else
-  {
-    gtk_render_layout(style_context, cr, x, y, layout);
-  }
-
-  gtk_style_context_restore(style_context);
+
+  cairo_save(cr);
+  cairo_translate(cr, x, geo.y + (geo.height - text_size.height) / 2);
+  style->DrawTitle(label, WidgetState::NORMAL, cr, geo.width - x, geo.height);
+  cairo_restore(cr);
 }
 
 std::string PanelMenuView::GetCurrentTitle() const
@@ -809,7 +745,7 @@
     }
     else if (!we_control_active_)
     {
-      new_title = "";
+      new_title.clear();
     }
     else
     {
@@ -829,40 +765,36 @@
   }
 }
 
-void PanelMenuView::Refresh(bool force)
+bool PanelMenuView::Refresh(bool force)
 {
   nux::Geometry const& geo = GetGeometry();
 
   // We can get into a race that causes the geometry to be wrong as there hasn't been a
   // layout cycle before the first callback. This is to protect from that.
   if (geo.width > monitor_geo_.width)
-    return;
+    return false;
 
   const std::string& new_title = GetCurrentTitle();
   if (new_title == panel_title_ && !force && last_geo_ == geo && title_texture_)
   {
     // No need to redraw the title, let's save some CPU time!
-    return;
+    return false;
   }
+
   panel_title_ = new_title;
 
   if (panel_title_.empty())
   {
     title_texture_ = nullptr;
-    return;
+    return true;
   }
 
   nux::CairoGraphics cairo_graphics(CAIRO_FORMAT_ARGB32, geo.width, geo.height);
-  cairo_t* cr = cairo_graphics.GetContext();
-
-  cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
-  cairo_paint(cr);
-
+  cairo_t* cr = cairo_graphics.GetInternalContext();
   UpdateTitleTexture(cr, geo, panel_title_);
-
-  cairo_destroy(cr);
-
   title_texture_ = texture_ptr_from_cairo_graphics(cairo_graphics);
+
+  return true;
 }
 
 void PanelMenuView::OnActiveChanged(PanelIndicatorEntryView* view, bool is_active)
@@ -879,8 +811,8 @@
     }
   }
 
-  Refresh();
-  FullRedraw();
+  if (Refresh())
+    FullRedraw();
 }
 
 void PanelMenuView::OnEntryAdded(indicator::Entry::Ptr const& entry)
@@ -908,8 +840,8 @@
 
 void PanelMenuView::OnNameChanged(BamfView* bamf_view, gchar* new_name, gchar* old_name)
 {
-  Refresh();
-  FullRedraw();
+  if (Refresh())
+    FullRedraw();
 }
 
 bool PanelMenuView::OnNewAppShow()
@@ -1032,9 +964,7 @@
   }
 }
 
-void PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher,
-                                          BamfView* old_view,
-                                          BamfView* new_view)
+void PanelMenuView::OnActiveWindowChanged(BamfMatcher *matcher, BamfView* old_view, BamfView* new_view)
 {
   show_now_activated_ = false;
   is_maximized_ = false;
@@ -1044,30 +974,17 @@
 
   if (BAMF_IS_WINDOW(new_view))
   {
-    WindowManager& wm = WindowManager::Default();
     BamfWindow* window = reinterpret_cast<BamfWindow*>(new_view);
-    guint32 xid = bamf_window_get_xid(window);
-    active_xid_ = xid;
-    is_maximized_ = wm.IsWindowMaximized(xid);
+    active_xid_ = bamf_window_get_xid(window);
+    is_maximized_ = (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED);
 
     if (bamf_window_get_window_type(window) == BAMF_WINDOW_DESKTOP)
       we_control_active_ = true;
     else
-      we_control_active_ = IsWindowUnderOurControl(xid);
-
-    if (decor_map_.find(xid) == decor_map_.end())
-    {
-      decor_map_[xid] = true;
-
-      // if we've just started tracking this window and it is maximized, let's
-      // make sure it's undecorated just in case it slipped by us earlier
-      // (I'm looking at you, Chromium!)
-      if (is_maximized_ && wm.HasWindowDecorations(xid))
-      {
-        wm.Undecorate(xid);
-        maximized_set_.insert(xid);
-      }
-    }
+      we_control_active_ = IsWindowUnderOurControl(active_xid_);
+
+    if (is_maximized_)
+      maximized_set_.insert(active_xid_);
 
     // first see if we need to remove and old callback
     view_name_changed_signal_.Disconnect();
@@ -1078,152 +995,112 @@
     window_buttons_->controlled_window = (is_maximized_) ? active_xid_ : 0;
   }
 
-  Refresh();
-  FullRedraw();
+  if (Refresh())
+    FullRedraw();
 }
 
 void PanelMenuView::OnSpreadInitiate()
 {
-  Refresh();
-  QueueDraw();
+  if (Refresh())
+    QueueDraw();
 }
 
 void PanelMenuView::OnSpreadTerminate()
 {
-  Refresh();
-  QueueDraw();
+  if (Refresh())
+    QueueDraw();
 }
 
 void PanelMenuView::OnExpoInitiate()
 {
-  Refresh();
-  QueueDraw();
+  if (Refresh())
+    QueueDraw();
 }
 
 void PanelMenuView::OnExpoTerminate()
 {
-  Refresh();
-  QueueDraw();
-}
-
-void PanelMenuView::OnWindowMinimized(guint32 xid)
-{
-  WindowManager& wm = WindowManager::Default();
-  if (wm.IsWindowMaximized(xid))
-  {
-    wm.Decorate(xid);
-    maximized_set_.erase(xid);
-
-    Refresh();
+  if (Refresh())
     QueueDraw();
+}
+
+void PanelMenuView::OnWindowMinimized(Window xid)
+{
+  maximized_set_.erase(xid);
+
+  if (xid == active_xid_)
+  {
+    if (Refresh())
+      QueueDraw();
   }
 }
 
-void PanelMenuView::OnWindowUnminimized(guint32 xid)
+void PanelMenuView::OnWindowUnminimized(Window xid)
 {
-  WindowManager& wm = WindowManager::Default();
-  if (wm.IsWindowMaximized(xid))
-  {
-    wm.Undecorate(xid);
+  if (WindowManager::Default().IsWindowMaximized(xid))
     maximized_set_.insert(xid);
 
-    Refresh();
-    QueueDraw();
+  if (xid == active_xid_)
+  {
+    if (Refresh())
+      QueueDraw();
   }
 }
 
-void PanelMenuView::OnWindowUnmapped(guint32 xid)
+void PanelMenuView::OnWindowUnmapped(Window xid)
 {
   // FIXME: compiz doesn't give us a valid xid (is always 0 on unmap)
   // we need to do this again on BamfView closed signal.
-  if (maximized_set_.find(xid) != maximized_set_.end())
+  maximized_set_.erase(xid);
+
+  if (xid == active_xid_)
   {
-    WindowManager::Default().Decorate(xid);
-    maximized_set_.erase(xid);
-    decor_map_.erase(xid);
-
-    Refresh();
-    QueueDraw();
+    if (Refresh())
+      QueueDraw();
   }
 }
 
-void PanelMenuView::OnWindowMapped(guint32 xid)
+void PanelMenuView::OnWindowMapped(Window xid)
 {
-  WindowManager& wm = WindowManager::Default();
-  if (wm.IsWindowMaximized(xid))
+  if (WindowManager::Default().IsWindowMaximized(xid))
   {
-    wm.Undecorate(xid);
     maximized_set_.insert(xid);
 
-    Refresh();
-    QueueDraw();
-  }
-}
-
-void PanelMenuView::OnWindowDecorated(guint32 xid)
-{
-  decor_map_[xid] = true;
-
-  if (maximized_set_.find(xid) != maximized_set_.end ())
-  {
-    WindowManager::Default().Undecorate(xid);
-  }
-}
-
-void PanelMenuView::OnWindowUndecorated(guint32 xid)
-{
-  decor_map_[xid] = false;
-}
-
-void PanelMenuView::OnWindowMaximized(guint xid)
-{
-  bool updated = false;
-  bool is_active = (active_xid_ == xid);
-
-  if (is_active)
+    if (xid == active_xid_)
+    {
+      if (Refresh())
+        QueueDraw();
+    }
+  }
+}
+
+void PanelMenuView::OnWindowMaximized(Window xid)
+{
+  maximized_set_.insert(xid);
+
+  if (xid == active_xid_)
   {
     // We need to update the is_inside_ state in the case of maximization by grab
     auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
     is_inside_ = GetAbsoluteGeometry().IsInside(mouse);
-
     is_maximized_ = true;
-    updated = true;
-  }
-
-  // update the state of the window in the decor_map_
-  WindowManager& wm = WindowManager::Default();
-  decor_map_[xid] = wm.HasWindowDecorations(xid);
-
-  if (decor_map_[xid])
-    wm.Undecorate(xid);
-
-  maximized_set_.insert(xid);
-
-  if (updated)
-  {
-    Refresh();
-    FullRedraw();
+
+    if (Refresh())
+      FullRedraw();
   }
 }
 
-void PanelMenuView::OnWindowRestored(guint xid)
+void PanelMenuView::OnWindowRestored(Window xid)
 {
-  if (maximized_set_.find(xid) == maximized_set_.end())
-    return;
+  maximized_set_.erase(xid);
 
   if (active_xid_ == xid)
   {
     is_maximized_ = false;
     is_grabbed_ = false;
+
+    if (Refresh())
+      FullRedraw();
   }
-
-  if (decor_map_[xid])
-    WindowManager::Default().Decorate(xid);
-
-  maximized_set_.erase(xid);
-
-  Refresh();
-  FullRedraw();
 }
 
 bool PanelMenuView::UpdateActiveWindowPosition()
@@ -1234,14 +1111,14 @@
   {
     we_control_active_ = we_control_window;
 
-    Refresh();
-    QueueDraw();
+    if (Refresh())
+      QueueDraw();
   }
 
   return false;
 }
 
-void PanelMenuView::OnWindowMoved(guint xid)
+void PanelMenuView::OnWindowMoved(Window xid)
 {
   if (active_xid_ == xid)
   {
@@ -1468,8 +1345,8 @@
 
       is_inside_ = true;
       is_grabbed_ = true;
-      Refresh();
-      FullRedraw();
+      if (Refresh())
+        FullRedraw();
 
       /* Ungrab the pointer and start the X move, to make the decorator handle it */
       titlebar_grab_area_->SetGrabbed(false);
@@ -1489,8 +1366,8 @@
   if (!is_inside_)
     is_grabbed_ = false;
 
-  Refresh();
-  FullRedraw();
+  if (Refresh())
+    FullRedraw();
 }
 
 // Introspectable
@@ -1546,8 +1423,8 @@
     show_now_activated_ = false;
   }
 
-  Refresh();
-  QueueDraw();
+  if (Refresh())
+    QueueDraw();
 }
 
 void PanelMenuView::OnLauncherKeyNavStarted(GVariant* data)
@@ -1572,8 +1449,8 @@
   auto mouse = nux::GetGraphicsDisplay()->GetMouseScreenCoord();
   is_inside_ = GetAbsoluteGeometry().IsInside(mouse);
 
-  Refresh();
-  QueueDraw();
+  if (Refresh())
+    QueueDraw();
 }
 
 void PanelMenuView::OnLauncherSelectionChanged(GVariant* data)
@@ -1642,7 +1519,6 @@
   maximized_set_.clear();
   GList* windows = bamf_matcher_get_window_stack_for_monitor(matcher_, monitor_);
 
-  WindowManager& wm = WindowManager::Default();
   for (GList* l = windows; l; l = l->next)
   {
     if (!BAMF_IS_WINDOW(l->data))
@@ -1652,21 +1528,10 @@
     auto view = static_cast<BamfView*>(l->data);
 
     if (bamf_view_is_active(view))
-    {
       active_xid_ = bamf_window_get_xid(window);
-    }
 
     if (bamf_window_maximized(window) == BAMF_WINDOW_MAXIMIZED)
-    {
-      Window xid = bamf_window_get_xid(window);
-
-      decor_map_[xid] = wm.HasWindowDecorations(xid);
-
-      if (decor_map_[xid])
-        wm.Undecorate(xid);
-
-      maximized_set_.insert(xid);
-    }
+      maximized_set_.insert(bamf_window_get_xid(window));
   }
 
   Window maximized = GetMaximizedWindow();
@@ -1705,9 +1570,6 @@
   }
 }
 
-void PanelMenuView::OnPanelViewMouseMove(int x, int y, int dx, int dy, unsigned long mouse_button_state, unsigned long special_keys_state)
-{}
-
 void PanelMenuView::SetMousePosition(int x, int y)
 {
   if (last_active_view_ ||

=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2013-09-19 16:44:03 +0000
+++ panel/PanelMenuView.h	2014-01-23 15:21:26 +0000
@@ -92,15 +92,13 @@
   void OnSpreadTerminate();
   void OnExpoInitiate();
   void OnExpoTerminate();
-  void OnWindowMinimized(guint32 xid);
-  void OnWindowUnminimized(guint32 xid);
-  void OnWindowUnmapped(guint32 xid);
-  void OnWindowMapped(guint32 xid);
-  void OnWindowMaximized(guint32 xid);
-  void OnWindowRestored(guint32 xid);
-  void OnWindowMoved(guint32 xid);
-  void OnWindowDecorated(guint32 xid);
-  void OnWindowUndecorated(guint32 xid);
+  void OnWindowMinimized(Window xid);
+  void OnWindowUnminimized(Window xid);
+  void OnWindowUnmapped(Window xid);
+  void OnWindowMapped(Window xid);
+  void OnWindowMaximized(Window xid);
+  void OnWindowRestored(Window xid);
+  void OnWindowMoved(Window xid);
 
   void OnMaximizedActivate(int x, int y);
   void OnMaximizedRestore(int x, int y);
@@ -111,7 +109,7 @@
 
   void FullRedraw();
   std::string GetCurrentTitle() const;
-  void Refresh(bool force = false);
+  bool Refresh(bool force = false);
 
   void UpdateTitleTexture(cairo_t *cr_real, nux::Geometry const& geo, std::string const& label) const;
 
@@ -120,7 +118,6 @@
 
   void OnPanelViewMouseEnter(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state);
   void OnPanelViewMouseLeave(int x, int y, unsigned long mouse_button_state, unsigned long special_keys_state);
-  void OnPanelViewMouseMove(int x, int y, int dx, int dy, unsigned long mouse_button_state, unsigned long special_keys_state);
 
   BamfWindow* GetBamfWindowForXid(Window xid) const;
 
@@ -163,10 +160,8 @@
   bool is_maximized_;
 
   PanelIndicatorEntryView* last_active_view_;
+  std::set<Window> maximized_set_;
   glib::Object<BamfApplication> new_application_;
-
-  std::map<Window, bool> decor_map_;
-  std::set<Window> maximized_set_;
   std::list<glib::Object<BamfApplication>> new_apps_;
   std::string panel_title_;
   nux::Geometry last_geo_;

=== modified file 'plugins/unityshell/CMakeLists.txt'
--- plugins/unityshell/CMakeLists.txt	2013-02-13 02:09:35 +0000
+++ plugins/unityshell/CMakeLists.txt	2014-01-23 15:21:26 +0000
@@ -21,8 +21,33 @@
   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 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)
+add_dependencies(unityshell
+                 dash-lib
+                 decorations-lib
+                 hud-lib
+                 launcher-lib
+                 panel-lib
+                 shortcuts-lib
+                 shutdown-lib
+                 switcher-lib
+                 unity-core-${UNITY_API_VERSION}
+                 unity-shared
+                 unity-shared-compiz)
+
+target_link_libraries(unityshell
+                      dash-lib
+                      decorations-lib
+                      hud-lib
+                      launcher-lib
+                      panel-lib
+                      shortcuts-lib
+                      shutdown-lib
+                      switcher-lib
+                      unity-core-${UNITY_API_VERSION}
+                      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	2014-01-14 16:07:59 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-01-23 15:21:26 +0000
@@ -28,6 +28,7 @@
 #include <UnityCore/ScopeProxyInterface.h>
 #include <UnityCore/GnomeSessionManager.h>
 
+#include "CompizUtils.h"
 #include "BaseWindowRaiserImp.h"
 #include "IconRenderer.h"
 #include "Launcher.h"
@@ -41,7 +42,6 @@
 #include "StartupNotifyService.h"
 #include "Timer.h"
 #include "XKeyboardUtil.h"
-#include "glow_texture.h"
 #include "unityshell.h"
 #include "BackgroundEffectHelper.h"
 #include "UnityGestureBroker.h"
@@ -51,6 +51,9 @@
 #include "launcher/XdndStartStopNotifierImp.h"
 #include "CompizShortcutModeller.h"
 
+#include "decorations/DecorationsDataPool.h"
+#include "decorations/DecorationsManager.h"
+
 #include <glib/gi18n-lib.h>
 #include <gtk/gtk.h>
 #include <gdk/gdk.h>
@@ -119,6 +122,11 @@
   return nux::Geometry(rect.x(), rect.y(), rect.width(), rect.height());
 }
 
+inline nux::Color NuxColorFromCompizColor(unsigned short * color)
+{
+  return nux::Color(color[0]/65535.0f, color[1]/65535.0f, color[2]/65535.0f, color[3]/65535.0f);
+}
+
 namespace local
 {
 // Tap duration in milliseconds.
@@ -131,18 +139,6 @@
 const std::string RELAYOUT_TIMEOUT = "relayout-timeout";
 } // namespace local
 
-namespace win
-{
-namespace decoration
-{
-const unsigned CLOSE_SIZE = 19;
-const unsigned ITEMS_PADDING = 5;
-const unsigned RADIUS = 8;
-const unsigned GLOW = 5;
-const nux::Color GLOW_COLOR(221, 72, 20);
-} // decoration namespace
-} // win namespace
-
 } // anon namespace
 
 UnityScreen::UnityScreen(CompScreen* screen)
@@ -151,6 +147,7 @@
   , screen(screen)
   , cScreen(CompositeScreen::get(screen))
   , gScreen(GLScreen::get(screen))
+  , deco_manager_(std::make_shared<decoration::Manager>())
   , debugger_(this)
   , needsRelayout(false)
   , super_keypressed_(false)
@@ -302,7 +299,13 @@
      uScreen = this;
 
      optionSetLockScreenInitiate(boost::bind(&UnityScreen::LockScreenInitiate, this, _1, _2, _3));
-
+     optionSetOverrideDecorationThemeNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetShadowXOffsetNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetShadowYOffsetNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetActiveShadowRadiusNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetInactiveShadowRadiusNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetActiveShadowColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
+     optionSetInactiveShadowColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetShowHudInitiate(boost::bind(&UnityScreen::ShowHudInitiate, this, _1, _2, _3));
      optionSetShowHudTerminate(boost::bind(&UnityScreen::ShowHudTerminate, this, _1, _2, _3));
      optionSetBackgroundColorNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -377,9 +380,6 @@
      ubus_manager_.RegisterInterest(UBUS_LAUNCHER_END_KEY_SWITCHER,
                    sigc::mem_fun(this, &UnityScreen::OnLauncherEndKeyNav));
 
-     ubus_manager_.RegisterInterest(UBUS_SWITCHER_START,
-                   sigc::mem_fun(this, &UnityScreen::OnSwitcherStart));
-
      ubus_manager_.RegisterInterest(UBUS_SWITCHER_END,
                    sigc::mem_fun(this, &UnityScreen::OnSwitcherEnd));
 
@@ -416,7 +416,11 @@
       force_draw_countdown_ += local::FRAMES_TO_REDRAW_ON_RESUME;
     });
 
-    panel::Style::Instance().changed.connect(sigc::mem_fun(this, &UnityScreen::OnPanelStyleChanged));
+    Introspectable::AddChild(deco_manager_.get());
+    auto const& deco_style = decoration::Style::Get();
+    auto deco_style_cb = sigc::hide(sigc::mem_fun(this, &UnityScreen::OnDecorationStyleChanged));
+    deco_style->theme.changed.connect(deco_style_cb);
+    deco_style->title_font.changed.connect(deco_style_cb);
 
     minimize_speed_controller_.DurationChanged.connect(
       sigc::mem_fun(this, &UnityScreen::OnMinimizeDurationChanged)
@@ -502,8 +506,6 @@
 
 void UnityScreen::OnInitiateSpread()
 {
-  UnityWindow::SetupSharedTextures();
-
   for (auto const& swin : ScaleScreen::get(screen)->getWindows())
     UnityWindow::get(swin->window)->OnInitiateSpread();
 }
@@ -512,8 +514,6 @@
 {
   for (auto const& swin : ScaleScreen::get(screen)->getWindows())
     UnityWindow::get(swin->window)->OnTerminateSpread();
-
-  UnityWindow::CleanupSharedTextures();
 }
 
 void UnityScreen::DamagePanelShadow()
@@ -727,18 +727,17 @@
   wy = y + (last_bound.height - height) / 2;
 }
 
-void UnityScreen::OnPanelStyleChanged()
+void UnityScreen::OnDecorationStyleChanged()
 {
-  // Reload the windows themed textures
-  UnityWindow::CleanupSharedTextures();
-
-  if (!fake_decorated_windows_.empty())
-  {
-    UnityWindow::SetupSharedTextures();
-
-    for (UnityWindow* uwin : fake_decorated_windows_)
-      uwin->CleanupCachedTextures();
-  }
+  for (UnityWindow* uwin : fake_decorated_windows_)
+    uwin->CleanupCachedTextures();
+
+  auto const& style = decoration::Style::Get();
+  deco_manager_->shadow_offset = style->ShadowOffset();
+  deco_manager_->active_shadow_color = style->ActiveShadowColor();
+  deco_manager_->active_shadow_radius = style->ActiveShadowRadius();
+  deco_manager_->inactive_shadow_color = style->InactiveShadowColor();
+  deco_manager_->inactive_shadow_radius = style->InactiveShadowRadius();
 }
 
 void UnityScreen::DamageBlurUpdateRegion(nux::Geometry const& blur_update)
@@ -1141,13 +1140,14 @@
   return window->minimized ();
 }
 
-void UnityWindow::DoOverrideFrameRegion (CompRegion &region)
+void UnityWindow::DoOverrideFrameRegion(CompRegion &region)
 {
-  unsigned int oldUpdateFrameRegionIndex = window->updateFrameRegionGetCurrentIndex ();
+  unsigned int oldUpdateFrameRegionIndex = window->updateFrameRegionGetCurrentIndex();
 
-  window->updateFrameRegionSetCurrentIndex (MAXSHORT);
-  window->updateFrameRegion (region);
-  window->updateFrameRegionSetCurrentIndex (oldUpdateFrameRegionIndex);
+  window->updateFrameRegionSetCurrentIndex(MAXSHORT);
+  window->updateFrameRegion(region);
+  deco_win_->UpdateFrameRegion(region);
+  window->updateFrameRegionSetCurrentIndex(oldUpdateFrameRegionIndex);
 }
 
 void UnityWindow::DoHide ()
@@ -1194,7 +1194,7 @@
 {
   mShowdesktopHandler.reset();
 
-  window->updateFrameRegion ();
+  window->updateFrameRegion();
 }
 
 compiz::WindowInputRemoverLock::Ptr
@@ -1225,17 +1225,17 @@
   switch(event->type)
   {
     case MotionNotify:
-      if (close_icon_state_ != panel::WindowState::PRESSED)
+      if (close_icon_state_ != decoration::WidgetState::PRESSED)
       {
-        panel::WindowState old_state = close_icon_state_;
+        auto old_state = close_icon_state_;
 
         if (close_button_geo_.IsPointInside(event->xmotion.x_root, event->xmotion.y_root))
         {
-          close_icon_state_ = panel::WindowState::PRELIGHT;
+          close_icon_state_ = decoration::WidgetState::PRELIGHT;
         }
         else
         {
-          close_icon_state_ = panel::WindowState::NORMAL;
+          close_icon_state_ = decoration::WidgetState::NORMAL;
         }
 
         if (old_state != close_icon_state_)
@@ -1249,7 +1249,7 @@
       if (event->xbutton.button == Button1 &&
           close_button_geo_.IsPointInside(event->xbutton.x_root, event->xbutton.y_root))
       {
-        close_icon_state_ = panel::WindowState::PRESSED;
+        close_icon_state_ = decoration::WidgetState::PRESSED;
         cWindow->addDamageRect(CompRectFromNuxGeo(close_button_geo_));
         handled = true;
       }
@@ -1264,11 +1264,11 @@
 
     case ButtonRelease:
       {
-        bool was_pressed = (close_icon_state_ == panel::WindowState::PRESSED);
+        bool was_pressed = (close_icon_state_ == decoration::WidgetState::PRESSED);
 
-        if (close_icon_state_ != panel::WindowState::NORMAL)
+        if (close_icon_state_ != decoration::WidgetState::NORMAL)
         {
-          close_icon_state_ = panel::WindowState::NORMAL;
+          close_icon_state_ = decoration::WidgetState::NORMAL;
           cWindow->addDamageRect(CompRectFromNuxGeo(close_button_geo_));
         }
 
@@ -1636,12 +1636,21 @@
   }
 }
 
+void UnityScreen::addSupportedAtoms(std::vector<Atom>& atoms)
+{
+  screen->addSupportedAtoms(atoms);
+  deco_manager_->AddSupportedAtoms(atoms);
+}
+
 /* handle X Events */
 void UnityScreen::handleEvent(XEvent* event)
 {
   bool skip_other_plugins = false;
   PluginAdapter& wm = PluginAdapter::Default();
 
+  if (deco_manager_->HandleEventBefore(event))
+    return;
+
   switch (event->type)
   {
     case FocusIn:
@@ -1873,14 +1882,11 @@
   if (!skip_other_plugins)
     screen->handleEvent(event);
 
+  if (deco_manager_->HandleEventAfter(event))
+    return;
+
   switch (event->type)
   {
-    case PropertyNotify:
-      if (event->xproperty.atom == Atoms::mwmHints)
-      {
-        PluginAdapter::Default().NotifyNewDecorationState(event->xproperty.window);
-      }
-      break;
     case MapRequest:
       ShowdesktopHandler::AllowLeaveShowdesktopMode(event->xmaprequest.window);
       break;
@@ -2121,7 +2127,6 @@
       show_mode = switcher::ShowMode::CURRENT_VIEWPORT;
   }
 
-  UnityWindow::SetupSharedTextures();
   SetUpAndShowSwitcher(show_mode);
 
   return true;
@@ -2323,20 +2328,14 @@
     PluginAdapter::Default().RestoreInputFocus();
 }
 
-void UnityScreen::OnSwitcherStart(GVariant* data)
-{
-  if (switcher_controller_->Visible())
-  {
-    UnityWindow::SetupSharedTextures();
-  }
-}
-
 void UnityScreen::OnSwitcherEnd(GVariant* data)
 {
-  UnityWindow::CleanupSharedTextures();
-
   for (UnityWindow* uwin : fake_decorated_windows_)
+  {
+    uwin->close_icon_state_ = decoration::WidgetState::NORMAL;
+    uwin->middle_clicked_ = false;
     uwin->CleanupCachedTextures();
+  }
 }
 
 bool UnityScreen::SaveInputThenFocus(const guint xid)
@@ -2507,9 +2506,7 @@
 {
   PluginAdapter& adapter = PluginAdapter::Default();
 
-  CompPlugin* p = CompPlugin::find("core");
-
-  if (p)
+  if (CompPlugin* p = CompPlugin::find("core"))
   {
     for (CompOption& option : p->vTable->getOptions())
     {
@@ -2521,9 +2518,7 @@
     }
   }
 
-  p = CompPlugin::find("expo");
-
-  if (p)
+  if (CompPlugin* p = CompPlugin::find("expo"))
   {
     MultiActionList expoActions;
 
@@ -2549,9 +2544,7 @@
     adapter.SetExpoAction(expoActions);
   }
 
-  p = CompPlugin::find("scale");
-
-  if (p)
+  if (CompPlugin* p = CompPlugin::find("scale"))
   {
     MultiActionList scaleActions;
 
@@ -2584,9 +2577,7 @@
     adapter.SetScaleAction(scaleActions);
   }
 
-  p = CompPlugin::find("unitymtgrabhandles");
-
-  if (p)
+  if (CompPlugin* p = CompPlugin::find("unitymtgrabhandles"))
   {
     foreach(CompOption & option, p->vTable->getOptions())
     {
@@ -2599,6 +2590,15 @@
     }
   }
 
+  if (CompPlugin* p = CompPlugin::find("decor"))
+  {
+    LOG_ERROR(logger) << "Decoration plugin is active, disabling it...";
+    screen->finiPluginForScreen(p);
+    p->vTable->finiScreen(screen);
+    CompPlugin::getPlugins().remove(p);
+    CompPlugin::unload(p);
+  }
+
   return false;
 }
 
@@ -2868,6 +2868,7 @@
     uScreen->paintPanelShadow(region);
 
   bool ret = gWindow->glDraw(matrix, attrib, region, mask);
+  deco_win_->Draw(matrix, attrib, region, mask);
 
   if (draw_panel_shadow == DrawPanelShadow::OVER_WINDOW)
     uScreen->paintPanelShadow(region);
@@ -2875,19 +2876,26 @@
   return ret;
 }
 
+bool UnityWindow::damageRect(bool initial, CompRect const& rect)
+{
+  if (initial)
+    deco_win_->Update();
+
+  return cWindow->damageRect(initial, rect);
+}
+
 void
 UnityScreen::OnMinimizeDurationChanged ()
 {
   /* Update the compiz plugin setting with the new computed speed so that it
    * will be used in the following minimizations */
-  CompPlugin *p = CompPlugin::find("animation");
-  if (p)
+  if (CompPlugin* p = CompPlugin::find("animation"))
   {
     CompOption::Vector &opts = p->vTable->getOptions();
 
     for (CompOption &o : opts)
     {
-      if (o.name() == std::string("minimize_durations"))
+      if (o.name() == "minimize_durations")
       {
         /* minimize_durations is a list value, but minimize applies only to
          * normal windows, so there's always one value */
@@ -2979,7 +2987,11 @@
   switch (n)
   {
     case CompWindowNotifyMap:
-      if (window->type() == CompWindowTypeDesktopMask) {
+      deco_win_->Update();
+      deco_win_->UpdateDecorationPosition();
+
+      if (window->type() == CompWindowTypeDesktopMask)
+      {
         if (!focus_desktop_timeout_)
         {
           focus_desktop_timeout_.reset(new glib::Timeout(1000, [this] {
@@ -3001,8 +3013,7 @@
       }
     /* Fall through an re-evaluate wraps on map and unmap too */
     case CompWindowNotifyUnmap:
-      if (UnityScreen::get (screen)->optionGetShowMinimizedWindows () &&
-          window->mapNum () &&
+      if (uScreen->optionGetShowMinimizedWindows() && window->mapNum() &&
           !window->pendingUnmaps())
       {
         bool wasMinimized = window->minimized ();
@@ -3024,18 +3035,27 @@
         window->minimizedSetEnabled (this, false);
       }
 
+      deco_win_->Update();
+      deco_win_->UpdateDecorationPosition();
+
       PluginAdapter::Default().UpdateShowDesktopState();
-        break;
-      case CompWindowNotifyBeforeDestroy:
-        being_destroyed.emit();
-        break;
-      case CompWindowNotifyMinimize:
-        /* Updating the count in dconf will trigger a "changed" signal to which
-         * the method setting the new animation speed is attached */
-        UnityScreen::get(screen)->minimize_speed_controller_.UpdateCount();
-        break;
-      default:
-        break;
+      break;
+    case CompWindowNotifyBeforeDestroy:
+      being_destroyed.emit();
+      break;
+    case CompWindowNotifyMinimize:
+      /* Updating the count in dconf will trigger a "changed" signal to which
+       * the method setting the new animation speed is attached */
+      uScreen->minimize_speed_controller_.UpdateCount();
+      break;
+    case CompWindowNotifyUnreparent:
+      deco_win_->Undecorate();
+      break;
+    case CompWindowNotifyReparent:
+      deco_win_->Update();
+      break;
+    default:
+      break;
   }
 
 
@@ -3057,32 +3077,31 @@
   // We do this after the notify to ensure input focus has actually been moved.
   if (n == CompWindowNotifyFocusChange)
   {
-    UnityScreen* us = UnityScreen::get(screen);
-
-    // If focus gets moved to an external program while the Dash/Hud is open, refocus key input.
-    if (us)
-    {
-      if (us->dash_controller_->IsVisible())
-      {
-        us->dash_controller_->ReFocusKeyInput();
-      }
-      else if (us->hud_controller_->IsVisible())
-      {
-        us->hud_controller_->ReFocusKeyInput();
-      }
+    if (uScreen->dash_controller_->IsVisible())
+    {
+      uScreen->dash_controller_->ReFocusKeyInput();
+    }
+    else if (uScreen->hud_controller_->IsVisible())
+    {
+      uScreen->hud_controller_->ReFocusKeyInput();
     }
   }
 }
 
 void UnityWindow::stateChangeNotify(unsigned int lastState)
 {
-  if (window->state () & CompWindowStateFullscreenMask &&
+  if (window->state() & CompWindowStateFullscreenMask &&
       !(lastState & CompWindowStateFullscreenMask))
-    UnityScreen::get (screen)->fullscreen_windows_.push_back(window);
+  {
+    uScreen->fullscreen_windows_.push_back(window);
+  }
   else if (lastState & CompWindowStateFullscreenMask &&
-     !(window->state () & CompWindowStateFullscreenMask))
-    UnityScreen::get (screen)->fullscreen_windows_.remove(window);
+           !(window->state() & CompWindowStateFullscreenMask))
+  {
+    uScreen->fullscreen_windows_.remove(window);
+  }
 
+  deco_win_->Update();
   PluginAdapter::Default().NotifyStateChange(window, window->state(), lastState);
   window->stateChangeNotify(lastState);
 }
@@ -3094,29 +3113,43 @@
    * does not have a region */
 
   if (mMinimizeHandler)
-    mMinimizeHandler->updateFrameRegion (region);
+  {
+    mMinimizeHandler->updateFrameRegion(region);
+  }
   else if (mShowdesktopHandler)
-    mShowdesktopHandler->UpdateFrameRegion (region);
+  {
+    mShowdesktopHandler->UpdateFrameRegion(region);
+  }
   else
-    window->updateFrameRegion (region);
+  {
+    window->updateFrameRegion(region);
+    deco_win_->UpdateFrameRegion(region);
+  }
+}
+
+void UnityWindow::getOutputExtents(CompWindowExtents& output)
+{
+  window->getOutputExtents(output);
+  deco_win_->UpdateOutputExtents(output);
 }
 
 void UnityWindow::moveNotify(int x, int y, bool immediate)
 {
+  deco_win_->UpdateDecorationPositionDelayed();
   PluginAdapter::Default().NotifyMoved(window, x, y);
   window->moveNotify(x, y, immediate);
 }
 
 void UnityWindow::resizeNotify(int x, int y, int w, int h)
 {
+  deco_win_->UpdateDecorationPositionDelayed();
   PluginAdapter::Default().NotifyResized(window, x, y, w, h);
   window->resizeNotify(x, y, w, h);
 }
 
 CompPoint UnityWindow::tryNotIntersectUI(CompPoint& pos)
 {
-  UnityScreen* us = UnityScreen::get(screen);
-  auto window_geo = window->borderRect ();
+  auto const& window_geo = window->borderRect();
   nux::Geometry target_monitor;
   nux::Point result(pos.x(), pos.y());
 
@@ -3131,7 +3164,7 @@
     }
   }
 
-  auto const& launchers = us->launcher_controller_->launchers();
+  auto const& launchers = uScreen->launcher_controller_->launchers();
 
   for (auto const& launcher : launchers)
   {
@@ -3149,7 +3182,7 @@
     }
   }
 
-  for (nux::Geometry const& geo : us->panel_controller_->GetGeometries())
+  for (nux::Geometry const& geo : uScreen->panel_controller_->GetGeometries())
   {
     if (geo.IsInside(result))
     {
@@ -3172,6 +3205,7 @@
 
   if (!was_maximized)
   {
+    deco_win_->Update();
     bool result = window->place(pos);
 
     if (window->type() & NO_FOCUS_MASK)
@@ -3222,23 +3256,55 @@
       break;
     case UnityshellOptions::BackgroundColor:
     {
-      nux::Color override_color (optionGetBackgroundColorRed() / 65535.0f,
-                                 optionGetBackgroundColorGreen() / 65535.0f,
-                                 optionGetBackgroundColorBlue() / 65535.0f,
-                                 optionGetBackgroundColorAlpha() / 65535.0f);
-
+      auto override_color = NuxColorFromCompizColor(optionGetBackgroundColor());
       override_color.red = override_color.red / override_color.alpha;
       override_color.green = override_color.green / override_color.alpha;
       override_color.blue = override_color.blue / override_color.alpha;
       bghash_->OverrideColor(override_color);
       break;
     }
+    case UnityshellOptions::OverrideDecorationTheme:
+      if (optionGetOverrideDecorationTheme())
+      {
+        deco_manager_->active_shadow_color = NuxColorFromCompizColor(optionGetActiveShadowColor());
+        deco_manager_->inactive_shadow_color = NuxColorFromCompizColor(optionGetInactiveShadowColor());
+        deco_manager_->active_shadow_radius = optionGetActiveShadowRadius();
+        deco_manager_->inactive_shadow_radius = optionGetInactiveShadowRadius();
+        deco_manager_->shadow_offset = nux::Point(optionGetShadowXOffset(), optionGetShadowYOffset());
+      }
+      else
+      {
+        OnDecorationStyleChanged();
+      }
+      break;
+    case UnityshellOptions::ActiveShadowColor: