Merge lp:~3v1n0/unity/decoration-edges-improvements into lp:unity

[Marco Trevisan (Treviño)]

DecoratedWindow: make edges independent from borders and properly update them on actions changed

Now windows can have edges (handles) also if they are not fully decorated, and
the other way around.
Improved the logic to detect which kind of decorations are supported by windows
(so now we add shadows to windows with borders, and we do not to shaped ones).
Removed a lot of duplicated matrix/region computations.
Properly rebuild decorations when _NET_WM_ALLOWED_ACTIONS changes
Fixes to the ForceQuit dialog shadows (and support for backdrop mode).

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3835
http://jenkins.qa.ubuntu.com/job/unity-ci/1088/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/175
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/175
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/175

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

review: Approve (continuous-integration)

[Brandon Schaefer (brandontschaefer)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3836
http://jenkins.qa.ubuntu.com/job/unity-ci/1089/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/176
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/176
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/176

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

review: Approve (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3837
http://jenkins.qa.ubuntu.com/job/unity-ci/1095/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-amd64-ci/182
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-armhf-ci/182
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-utopic-i386-ci/182

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

review: Approve (continuous-integration)

=== modified file 'UnityCore/DesktopUtilities.cpp'
--- UnityCore/DesktopUtilities.cpp	2014-08-26 22:59:57 +0000
+++ UnityCore/DesktopUtilities.cpp	2014-10-10 14:56:03 +0000
@@ -71,8 +71,6 @@
   const char *config_dir = g_get_user_config_dir();
   auto unity_config = glib::gchar_to_string(config_dir).append(G_DIR_SEPARATOR_S "unity" G_DIR_SEPARATOR_S);
 
-  printf("CONFIG %s\n", unity_config.c_str());
-
   if (g_mkdir_with_parents(unity_config.c_str(), 0700) >= 0)
     return unity_config;
 
 
=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2014-07-30 00:49:35 +0000
+++ decorations/DecoratedWindow.cpp	2014-10-10 14:56:03 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2013 Canonical Ltd
+ * Copyright (C) 2013-2014 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
@@ -44,8 +44,12 @@
   , cwin_(CompositeWindow::get(win_))
   , glwin_(GLWindow::get(win_))
   , frame_(0)
+  , monitor_(0)
   , dirty_geo_(true)
-  , monitor_(0)
+  , dirty_frame_(false)
+  , deco_elements_(cu::DecorationElement::NONE)
+  , last_mwm_decor_(win_->mwmDecor())
+  , last_actions_(win_->actions())
   , cv_(Settings::Instance().em())
 {
   active.changed.connect([this] (bool active) {
@@ -105,14 +109,27 @@
 
 void Window::Impl::Update()
 {
-  ShouldBeDecorated() ? Decorate() : Undecorate();
+  UpdateElements();
+  (deco_elements_ & (cu::DecorationElement::EDGE | cu::DecorationElement::BORDER)) ? Decorate() : Undecorate();
+  last_mwm_decor_ = win_->mwmDecor();
+  last_actions_ = win_->actions();
 }
 
 void Window::Impl::Decorate()
 {
   SetupExtents();
   UpdateFrame();
-  SetupWindowControls();
+  SetupWindowEdges();
+
+  if (deco_elements_ & cu::DecorationElement::BORDER)
+  {
+    SetupWindowControls();
+  }
+  else
+  {
+    CleanupWindowControls();
+    bg_textures_.clear();
+  }
 }
 
 void Window::Impl::Undecorate()
@@ -120,6 +137,7 @@
   UnsetExtents();
   UnsetFrame();
   CleanupWindowControls();
+  CleanupWindowEdges();
   bg_textures_.clear();
 }
 
@@ -139,17 +157,27 @@
   if (win_->hasUnmapReference())
     return;
 
-  auto const& sb = Style::Get()->Border();
-  CompWindowExtents border(cv_->CP(sb.left),
-                           cv_->CP(sb.right),
-                           cv_->CP(sb.top),
-                           cv_->CP(sb.bottom));
-
-  auto const& ib = Style::Get()->InputBorder();
-  CompWindowExtents input(cv_->CP(sb.left + ib.left),
-                          cv_->CP(sb.right + ib.right),
-                          cv_->CP(sb.top + ib.top),
-                          cv_->CP(sb.bottom + ib.bottom));
+  CompWindowExtents border;
+
+  if (deco_elements_ & cu::DecorationElement::BORDER)
+  {
+    auto const& sb = Style::Get()->Border();
+    border.left = cv_->CP(sb.left);
+    border.right = cv_->CP(sb.right);
+    border.top = cv_->CP(sb.top);
+    border.bottom = cv_->CP(sb.bottom);
+  }
+
+  CompWindowExtents input(border);
+
+  if (deco_elements_ & cu::DecorationElement::EDGE)
+  {
+    auto const& ib = Style::Get()->InputBorder();
+    input.left += cv_->CP(ib.left);
+    input.right += cv_->CP(ib.right);
+    input.top += cv_->CP(ib.top);
+    input.bottom += cv_->CP(ib.bottom);
+  }
 
   if (win_->border() != border || win_->input() != input)
     win_->setWindowFrameExtents(&border, &input);
@@ -183,6 +211,15 @@
     UpdateFrameGeo(frame_geo);
 }
 
+void Window::Impl::UpdateFrameActions()
+{
+  if (!dirty_frame_ && (win_->mwmDecor() != last_mwm_decor_ || win_->actions() != last_actions_))
+  {
+    dirty_frame_ = true;
+    Damage();
+  }
+}
+
 void Window::Impl::CreateFrame(nux::Geometry const& frame_geo)
 {
   /* Since we're reparenting windows here, we need to grab the server
@@ -280,6 +317,42 @@
   win_->updateFrameRegion();
 }
 
+void Window::Impl::SetupWindowEdges()
+{
+  if (input_mixer_)
+    return;
+
+  dpi_changed_ = Settings::Instance().dpi_changed.connect([this] {
+    Update();
+    edge_borders_->scale = cv_->DPIScale();
+    if (top_layout_) top_layout_->scale = cv_->DPIScale();
+  });
+
+  input_mixer_ = std::make_shared<InputMixer>();
+  edge_borders_ = std::make_shared<EdgeBorders>(win_);
+  edge_borders_->scale = cv_->DPIScale();
+  input_mixer_->PushToFront(edge_borders_);
+
+  UpdateWindowEdgesGeo();
+}
+
+void Window::Impl::UpdateWindowEdgesGeo()
+{
+  if (!edge_borders_)
+    return;
+
+  auto const& input = win_->inputRect();
+  edge_borders_->SetCoords(input.x(), input.y());
+  edge_borders_->SetSize(input.width(), input.height());
+}
+
+void Window::Impl::CleanupWindowEdges()
+{
+  input_mixer_.reset();
+  edge_borders_.reset();
+  dpi_changed_->disconnect();
+}
+
 void Window::Impl::SetupWindowControls()
 {
   if (top_layout_)
@@ -291,26 +364,7 @@
     Decorate();
   });
 
-  dpi_changed_ = Settings::Instance().dpi_changed.connect([this] {
-    Update();
-    top_layout_->scale = cv_->DPIScale();
-  });
-
-  input_mixer_ = std::make_shared<InputMixer>();
-
-  if (win_->actions() & CompWindowActionResizeMask)
-  {
-    auto edges = std::make_shared<EdgeBorders>(win_);
-    grab_edge_ = edges->GetEdge(Edge::Type::GRAB);
-    edge_borders_ = edges;
-  }
-  else /*if (win_->actions() & CompWindowActionMoveMask)*/
-  {
-    edge_borders_ = std::make_shared<GrabEdge>(win_);
-    grab_edge_ = edge_borders_;
-  }
-
-  input_mixer_->PushToFront(edge_borders_);
+  grab_edge_ = std::static_pointer_cast<EdgeBorders>(edge_borders_)->GetEdge(Edge::Type::GRAB);
 
   auto padding = style->Padding(Side::TOP);
   top_layout_ = std::make_shared<Layout>();
@@ -345,6 +399,7 @@
   top_layout_->Append(title_layout);
 
   input_mixer_->PushToFront(top_layout_);
+  dirty_frame_ = false;
 
   SetupAppMenu();
   RedrawDecorations();
@@ -355,12 +410,12 @@
   if (title_)
     last_title_ = title_->text();
 
+  if (input_mixer_)
+    input_mixer_->Remove(top_layout_);
+
   UnsetAppMenu();
   theme_changed_->disconnect();
-  dpi_changed_->disconnect();
   top_layout_.reset();
-  input_mixer_.reset();
-  edge_borders_.reset();
 }
 
 bool Window::Impl::IsMaximized() const
@@ -368,26 +423,25 @@
   return (win_->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE;
 }
 
+void Window::Impl::UpdateElements()
+{
+  if (!parent_->scaled() && IsMaximized())
+  {
+    deco_elements_ = cu::DecorationElement::NONE;
+    return;
+  }
+
+  deco_elements_ = cu::WindowDecorationElements(win_);
+}
+
 bool Window::Impl::ShadowDecorated() const
 {
-  if (!parent_->scaled() && IsMaximized())
-    return false;
-
-  if (!cu::IsWindowShadowDecorable(win_))
-    return false;
-
-  return true;
+  return deco_elements_ & cu::DecorationElement::SHADOW;
 }
 
 bool Window::Impl::FullyDecorated() const
 {
-  if (!parent_->scaled() && IsMaximized())
-    return false;
-
-  if (!cu::IsWindowFullyDecorable(win_))
-    return false;
-
-  return true;
+  return deco_elements_ & cu::DecorationElement::BORDER;
 }
 
 bool Window::Impl::ShouldBeDecorated() const
@@ -429,6 +483,7 @@
   }
 
   deco_tex.SetCoords(geo.x, geo.y);
+  deco_tex.quad.region = deco_tex.quad.box;
 }
 
 void Window::Impl::UpdateDecorationTextures()
@@ -440,7 +495,6 @@
   }
 
   auto const& geo = win_->borderRect();
-  auto const& input = win_->inputRect();
   auto const& border = win_->border();
 
   bg_textures_.resize(4);
@@ -452,19 +506,18 @@
   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());
-  }
-
   SyncMenusGeometries();
 }
 
 void Window::Impl::ComputeShadowQuads()
 {
-  if (last_shadow_rect_.isEmpty() && !ShadowDecorated())
+  if (!(deco_elements_ & cu::DecorationElement::SHADOW))
+  {
+    if (!last_shadow_rect_.isEmpty())
+      last_shadow_rect_.setGeometry(0, 0, 0, 0);
+
     return;
+  }
 
   const auto* texture = ShadowTexture();
 
@@ -552,6 +605,12 @@
 
   if (shadows_rect != last_shadow_rect_)
   {
+    auto const& win_region = win_->region();
+    quads[Quads::Pos::TOP_LEFT].region = CompRegion(quads[Quads::Pos::TOP_LEFT].box) - win_region;
+    quads[Quads::Pos::TOP_RIGHT].region = CompRegion(quads[Quads::Pos::TOP_RIGHT].box) - win_region;
+    quads[Quads::Pos::BOTTOM_LEFT].region = CompRegion(quads[Quads::Pos::BOTTOM_LEFT].box) - win_region;
+    quads[Quads::Pos::BOTTOM_RIGHT].region = CompRegion(quads[Quads::Pos::BOTTOM_RIGHT].box) - win_region;
+
     last_shadow_rect_ = shadows_rect;
     win_->updateWindowOutputExtents();
   }
@@ -561,15 +620,26 @@
                          GLWindowPaintAttrib const& attrib,
                          CompRegion const& region, unsigned mask)
 {
+  if (win_->defaultViewport() != screen->vp())
+    return;
+
   if (dirty_geo_)
     parent_->UpdateDecorationPosition();
+
+  if (dirty_frame_)
+  {
+    dirty_frame_ = false;
+    CleanupWindowControls();
+    CleanupWindowEdges();
+    Update();
+  }
 }
 
 void Window::Impl::Draw(GLMatrix const& transformation,
                         GLWindowPaintAttrib const& attrib,
                         CompRegion const& region, unsigned mask)
 {
-  if (last_shadow_rect_.isEmpty())
+  if (last_shadow_rect_.isEmpty() || win_->defaultViewport() != screen->vp())
     return;
 
   auto const& clip_region = (mask & PAINT_WINDOW_TRANSFORMED_MASK) ? infiniteRegion : region;
@@ -580,7 +650,7 @@
   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);
+    glwin_->glAddGeometry(quad.matrices, quad.region, clip_region);
   }
 
   if (glwin_->vertexBuffer()->end())
@@ -592,7 +662,7 @@
       continue;
 
     glwin_->vertexBuffer()->begin();
-    glwin_->glAddGeometry({dtex.quad.matrix}, dtex.quad.box, clip_region);
+    glwin_->glAddGeometry(dtex.quad.matrices, dtex.quad.region, clip_region);
 
     if (glwin_->vertexBuffer()->end())
       glwin_->glDrawTexture(dtex, transformation, attrib, mask);
@@ -705,6 +775,9 @@
 
     if (top_layout_)
       top_layout_->scale = cv_->DPIScale();
+
+    if (edge_borders_)
+      edge_borders_->scale = cv_->DPIScale();
   }
 }
 
@@ -787,6 +860,7 @@
 {
   impl_->UpdateMonitor();
   impl_->ComputeShadowQuads();
+  impl_->UpdateWindowEdgesGeo();
   impl_->UpdateDecorationTextures();
   impl_->UpdateForceQuitDialogPosition();
   impl_->dirty_geo_ = false;
@@ -806,7 +880,8 @@
 {
   data.add(impl_->win_->borderRect())
   .add("input_geo", impl_->win_->inputRect())
-  .add("content_geo", impl_->win_->region().boundingRect())
+  .add("content_geo", impl_->win_->geometry())
+  .add("region", impl_->win_->region().boundingRect())
   .add("title", title())
   .add("active", impl_->active())
   .add("scaled", scaled())
 
=== modified file 'decorations/DecorationsEdgeBorders.cpp'
--- decorations/DecorationsEdgeBorders.cpp	2014-02-18 23:01:33 +0000
+++ decorations/DecorationsEdgeBorders.cpp	2014-10-10 14:56:03 +0000
@@ -26,21 +26,31 @@
 {
 namespace
 {
-const int MIN_CORNER_EDGE = 10;
+const RawPixel MIN_CORNER_EDGE = 10_em;
 }
 
 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);
+  scale.changed.connect(sigc::hide(sigc::mem_fun(this, &EdgeBorders::Relayout)));
+
+  if (win->actions() & CompWindowActionResizeMask)
+  {
+    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);
+    }
+  }
+  else /*if (win->actions() & CompWindowActionMoveMask)*/
+  {
+    items_.resize(size_t(Edge::Type::GRAB) + 1);
+    items_[unsigned(Edge::Type::GRAB)] = std::make_shared<GrabEdge>(win);
   }
 
   Relayout();
@@ -54,10 +64,17 @@
   auto const& ib = win->input();
 
   using namespace compiz::window::extents;
-  Extents edges(std::max(ib.left, MIN_CORNER_EDGE),
-                std::max(ib.right, MIN_CORNER_EDGE),
-                std::max(ib.top, MIN_CORNER_EDGE),
-                std::max(ib.bottom, MIN_CORNER_EDGE));
+  int min_corner_edge = MIN_CORNER_EDGE.CP(scale);
+  Extents edges(std::max(ib.left, min_corner_edge),
+                std::max(ib.right, min_corner_edge),
+                std::max(ib.top, min_corner_edge),
+                std::max(ib.bottom, min_corner_edge));
+
+  grab_edge->SetCoords(rect_.x() + ib.left, rect_.y() + ib.top - b.top);
+  grab_edge->SetSize(rect_.width() - ib.left - ib.right, b.top);
+
+  if (items_.size() != size_t(Edge::Type::Size))
+    return;
 
   auto item = items_[unsigned(Edge::Type::TOP)];
   item->SetCoords(rect_.x() + edges.left, rect_.y());
@@ -90,10 +107,6 @@
   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 - b.top);
-  item->SetSize(rect_.width() - ib.left - ib.right, b.top);
 }
 
 Item::Ptr const& EdgeBorders::GetEdge(Edge::Type type) const
 
=== modified file 'decorations/DecorationsForceQuitDialog.cpp'
--- decorations/DecorationsForceQuitDialog.cpp	2014-06-13 15:23:12 +0000
+++ decorations/DecorationsForceQuitDialog.cpp	2014-10-10 14:56:03 +0000
@@ -141,7 +141,7 @@
 
   auto const& deco_style = decoration::Style::Get();
   auto const& offset = deco_style->ShadowOffset();
-  int max_offset = std::max(std::abs(offset.x), std::abs(offset.y));
+  int max_offset = std::max(std::abs(offset.x * 4), std::abs(offset.y * 4));
   gtk_container_set_border_width(GTK_CONTAINER(self), deco_style->ActiveShadowRadius()+max_offset);
 
   auto* screen = gtk_window_get_screen(self);
@@ -259,18 +259,32 @@
   auto const& radius = deco_style->CornerRadius();
   auto const& offset = deco_style->ShadowOffset();
   auto const& color = deco_style->ActiveShadowColor();
+  auto const& backcolor = deco_style->InactiveShadowColor();
   int decoration_radius = std::max({radius.top, radius.left, radius.right, radius.bottom});
 
-  gtk_css_provider_load_from_data(style, (R"(SheetStyleDialog {
+  gtk_css_provider_load_from_data(style, (R"(
+  SheetStyleDialog {
     background-color: #f7f6f5;
     color: #4a4a4a;
     border-radius: )"+std::to_string(decoration_radius)+R"(px;
-    box-shadow: )"+std::to_string(offset.x)+"px "+std::to_string(offset.y)+"px "+
+    box-shadow: )"+std::to_string(2 * offset.x)+"px "+std::to_string(2 * offset.y)+"px "+
                    std::to_string(deco_style->ActiveShadowRadius())+"px "+
                    "rgba("+std::to_string(int(color.red * 255.0))+", "+
                            std::to_string(int(color.green * 255.0))+", "+
                            std::to_string(int(color.blue * 255.0))+", "+
                            std::to_string(int(color.alpha))+'.'+std::to_string(int(color.alpha*10000.0))+')'+R"(;
+  }
+
+  SheetStyleDialog:backdrop {
+    background-color: shade(#f7f6f5, 1.2);
+    color: shade(#4a4a4a, 1.5);
+    border-radius: )"+std::to_string(decoration_radius)+R"(px;
+    box-shadow: )"+std::to_string(2 * offset.x)+"px "+std::to_string(2 * offset.y)+"px "+
+                   std::to_string(deco_style->InactiveShadowRadius())+"px "+
+                   "rgba("+std::to_string(int(backcolor.red * 255.0))+", "+
+                           std::to_string(int(backcolor.green * 255.0))+", "+
+                           std::to_string(int(backcolor.blue * 255.0))+", "+
+                           std::to_string(int(backcolor.alpha))+'.'+std::to_string(int(backcolor.alpha*10000.0))+')'+R"(;
   })").c_str(), -1, nullptr);
 
   auto* style_ctx = gtk_widget_get_style_context(self);
 
=== modified file 'decorations/DecorationsManager.cpp'
--- decorations/DecorationsManager.cpp	2014-07-30 00:49:35 +0000
+++ decorations/DecorationsManager.cpp	2014-10-10 14:56:03 +0000
@@ -41,8 +41,7 @@
 }
 
 Manager::Impl::Impl(decoration::Manager* parent, menu::Manager::Ptr const& menu)
-  : active_window_(0)
-  , enable_add_supported_atoms_(true)
+  : enable_add_supported_atoms_(true)
   , data_pool_(DataPool::Get())
   , menu_manager_(menu)
 {
@@ -52,7 +51,6 @@
   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)));
@@ -205,8 +203,6 @@
 
 bool Manager::Impl::HandleEventBefore(XEvent* event)
 {
-  active_window_ = screen->activeWindow();
-
   switch (event->type)
   {
     case ClientMessage:
@@ -251,31 +247,26 @@
 
 bool Manager::Impl::HandleEventAfter(XEvent* event)
 {
-  if (screen->activeWindow() != active_window_)
-  {
-    // Do this when _NET_ACTIVE_WINDOW changes on root!
-    if (active_deco_win_)
-      active_deco_win_->impl_->active = false;
-
-    active_window_ = screen->activeWindow();
-    auto const& new_active = GetWindowByXid(active_window_);
-    active_deco_win_ = new_active;
-
-    if (new_active)
-      new_active->impl_->active = true;
-  }
-
   switch (event->type)
   {
     case PropertyNotify:
     {
-      if (event->xproperty.atom == Atoms::mwmHints)
+      if (event->xproperty.atom == Atoms::winActive)
+      {
+        if (active_deco_win_)
+          active_deco_win_->impl_->active = false;
+
+        auto const& new_active = GetWindowByXid(screen->activeWindow());
+        active_deco_win_ = new_active;
+
+        if (new_active)
+          new_active->impl_->active = true;
+      }
+      else if (event->xproperty.atom == Atoms::mwmHints ||
+               event->xproperty.atom == Atoms::wmAllowedActions)
       {
         if (Window::Ptr const& win = GetWindowByXid(event->xproperty.window))
-        {
-          win->impl_->CleanupWindowControls();
-          win->Update();
-        }
+          win->impl_->UpdateFrameActions();
       }
       else if (event->xproperty.atom == XA_WM_NAME ||
                event->xproperty.atom == Atoms::wmName ||
@@ -442,7 +433,7 @@
   .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_);
+  .add("active_window", screen->activeWindow());
 }
 
 debug::Introspectable::IntrospectableList Manager::GetIntrospectableChildren()
 
=== modified file 'decorations/DecorationsPriv.h'
--- decorations/DecorationsPriv.h	2014-04-02 09:05:59 +0000
+++ decorations/DecorationsPriv.h	2014-10-10 14:56:03 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
- * Copyright (C) 2013 Canonical Ltd
+ * Copyright (C) 2013-2014 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
@@ -92,11 +92,15 @@
 private:
   void UnsetExtents();
   void SetupExtents();
+  void UpdateElements();
   void UpdateMonitor();
   void UpdateFrame();
   void CreateFrame(nux::Geometry const&);
   void UpdateFrameGeo(nux::Geometry const&);
+  void UpdateFrameActions();
   void UnsetFrame();
+  void SetupWindowEdges();
+  void CleanupWindowEdges();
   void SetupWindowControls();
   void CleanupWindowControls();
   void UnsetAppMenu();
@@ -109,6 +113,7 @@
 
   void ComputeShadowQuads();
   void UpdateDecorationTextures();
+  void UpdateWindowEdgesGeo();
   void UpdateForceQuitDialogPosition();
   void RenderDecorationTexture(Side, nux::Geometry const&);
   void Paint(GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
@@ -122,8 +127,12 @@
   ::CompositeWindow* cwin_;
   ::GLWindow* glwin_;
   ::Window frame_;
+  int monitor_;
   bool dirty_geo_;
-  int monitor_;
+  bool dirty_frame_;
+  unsigned deco_elements_;
+  unsigned last_mwm_decor_;
+  unsigned last_actions_;
 
   CompRect last_shadow_rect_;
   Quads shadow_quads_;
@@ -176,7 +185,6 @@
   friend class Manager;
   friend struct Window::Impl;
 
-  ::Window active_window_;
   bool enable_add_supported_atoms_;
 
   DataPool::Ptr data_pool_;
 
=== modified file 'decorations/DecorationsTitle.cpp'
--- decorations/DecorationsTitle.cpp	2014-03-31 18:36:07 +0000
+++ decorations/DecorationsTitle.cpp	2014-10-10 14:56:03 +0000
@@ -80,6 +80,7 @@
 
   Style::Get()->DrawTitle(text(), state, text_ctx, texture_size_.width / scale(), texture_size_.height / scale(), bg_geo * (1.0/scale));
   SetTexture(text_ctx);
+  texture_.UpdateMatrix();
 }
 
 void Title::SetX(int x)
 
=== modified file 'decorations/DecorationsWidgets.cpp'
--- decorations/DecorationsWidgets.cpp	2014-02-27 07:10:31 +0000
+++ decorations/DecorationsWidgets.cpp	2014-10-10 14:56:03 +0000
@@ -226,6 +226,12 @@
 
 //
 
+TexturedItem::TexturedItem()
+  : dirty_region_(false)
+{
+  geo_parameters_changed.connect([this] { dirty_region_ = true; });
+}
+
 void TexturedItem::SetTexture(cu::SimpleTexture::Ptr const& tex)
 {
   auto prev_geo = Geometry();
@@ -254,8 +260,14 @@
   if (!visible || Geometry().isEmpty() || !texture_)
     return;
 
+  if (dirty_region_)
+  {
+    texture_.quad.region = texture_.quad.box;
+    dirty_region_ = false;
+  }
+
   ctx->vertexBuffer()->begin();
-  ctx->glAddGeometry({texture_.quad.matrix}, texture_.quad.box, clip);
+  ctx->glAddGeometry(texture_.quad.matrices, texture_.quad.region, clip);
 
   if (ctx->vertexBuffer()->end())
     ctx->glDrawTexture(texture_, transformation, attrib, mask);
 
=== modified file 'decorations/DecorationsWidgets.h'
--- decorations/DecorationsWidgets.h	2014-02-27 07:10:31 +0000
+++ decorations/DecorationsWidgets.h	2014-10-10 14:56:03 +0000
@@ -121,6 +121,8 @@
 public:
   typedef std::shared_ptr<TexturedItem> Ptr;
 
+  TexturedItem();
+
   void SetTexture(cu::SimpleTexture::Ptr const&);
   void Draw(GLWindow*, GLMatrix const&, GLWindowPaintAttrib const&, CompRegion const&, unsigned mask);
   void SetCoords(int x, int y);
@@ -133,6 +135,9 @@
 
   CompRect& InternalGeo();
   cu::SimpleTextureQuad texture_;
+
+private:
+  bool dirty_region_;
 };
 
 
 
=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2014-09-04 22:12:01 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-10-10 14:56:03 +0000
@@ -281,6 +281,7 @@
      CompositeScreenInterface::setHandler(cScreen);
      GLScreenInterface::setHandler(gScreen);
      ScaleScreenInterface::setHandler(sScreen);
+     screen->updateSupportedWmHints();
 
      PluginAdapter::Initialize(screen);
      AddChild(&WindowManager::Default());
 
=== modified file 'unity-shared/CompizUtils.cpp'
--- unity-shared/CompizUtils.cpp	2014-04-14 13:51:58 +0000
+++ unity-shared/CompizUtils.cpp	2014-10-10 14:56:03 +0000
@@ -1,6 +1,6 @@
 // -*- Mode: C++; indent-tabs-mode: nil; tab-width: 2 -*-
 /*
-* Copyright (C) 2013 Canonical Ltd
+* Copyright (C) 2013-2014 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
@@ -30,6 +30,11 @@
 {
   const unsigned PIXMAP_DEPTH  = 32;
   const float    DEFAULT_SCALE = 1.0f;
+  const unsigned DECORABLE_WINDOW_TYPES = CompWindowTypeDialogMask |
+                                          CompWindowTypeModalDialogMask |
+                                          CompWindowTypeUtilMask |
+                                          CompWindowTypeMenuMask |
+                                          CompWindowTypeNormalMask;
 }
 
 SimpleTexture::SimpleTexture(GLTexture::List const& tex)
@@ -39,7 +44,7 @@
 //
 
 SimpleTextureQuad::SimpleTextureQuad()
-  : scale(DEFAULT_SCALE)
+  : scale_(DEFAULT_SCALE)
 {}
 
 bool SimpleTextureQuad::SetTexture(SimpleTexture::Ptr const& simple_texture)
@@ -52,24 +57,27 @@
   if (st && st->texture())
   {
     auto* tex = st->texture();
-    CompPoint old_coords(quad.box.x(), quad.box.y());
-    short invalid = std::numeric_limits<short>::min();
-    quad.box.setGeometry(invalid, invalid, tex->width() * scale, tex->height() * scale);
-    SetCoords(old_coords.x(), old_coords.y());
+    CompSize size(tex->width() * scale_, tex->height() * scale_);
+
+    if (quad.box.width() != size.width() || quad.box.height() != size.height())
+    {
+      quad.box.setSize(size);
+      UpdateMatrix();
+    }
   }
 
   return true;
 }
 
-bool SimpleTextureQuad::SetScale(float s)
+bool SimpleTextureQuad::SetScale(double s)
 {
-  if (!st || scale == s)
+  if (!st || scale_ == s)
     return false;
 
-  scale = s;
+  scale_ = s;
   auto* tex = st->texture();
-  quad.box.setWidth(tex->width() * scale);
-  quad.box.setHeight(tex->height() * scale);
+  quad.box.setWidth(tex->width() * scale_);
+  quad.box.setHeight(tex->height() * scale_);
   UpdateMatrix();
   return true;
 }
@@ -91,8 +99,8 @@
   int y = quad.box.y();
 
   quad.matrix = (st && st->texture()) ? st->texture()->matrix() : GLTexture::Matrix();
-  quad.matrix.xx /= scale;
-  quad.matrix.yy /= scale;
+  quad.matrix.xx /= scale_;
+  quad.matrix.yy /= scale_;
   quad.matrix.x0 = 0.0f - COMP_TEX_COORD_X(quad.matrix, x);
   quad.matrix.y0 = 0.0f - COMP_TEX_COORD_Y(quad.matrix, y);
 }
@@ -166,57 +174,68 @@
   return cairo_xlib_surface_get_height(surface_);
 }
 
-bool IsWindowShadowDecorable(CompWindow* win)
+//
+//
+
+unsigned WindowDecorationElements(CompWindow* win)
 {
+  unsigned elements = DecorationElement::NONE;
+
   if (!win)
-    return false;
+    return elements;
 
   if (!win->isViewable())
-    return false;
+    return elements;
 
   if (win->wmType() & (CompWindowTypeDockMask | CompWindowTypeDesktopMask))
-    return false;
-
-  if (win->region().numRects() != 1) // Non rectangular windows
-    return false;
-
-  if (win->alpha())
-    return WindowHasMotifDecorations(win);
-
-  return true;
+    return elements;
+
+  if (win->inShowDesktopMode())
+    return elements;
+
+  auto const& region = win->region();
+  bool rectangular = (region.numRects() == 1);
+  bool alpha = win->alpha();
+
+  if (!rectangular && alpha) // Non-rectangular windows with alpha channel
+    return elements;
+
+  if (region.boundingRect() != win->geometry()) // Shaped windows
+    return elements;
+
+  if (rectangular)
+    elements |= DecorationElement::SHADOW;
+
+  if (!win->overrideRedirect() &&
+      (win->type() & DECORABLE_WINDOW_TYPES) &&
+      (win->frame() || win->hasUnmapReference()))
+  {
+    if (win->actions() & CompWindowActionResizeMask)
+      elements |= DecorationElement::EDGE;
+
+    if (rectangular && (win->mwmDecor() & (MwmDecorAll | MwmDecorTitle)))
+      elements |= DecorationElement::BORDER;
+  }
+
+  if (alpha && !(elements & DecorationElement::BORDER) && !(win->mwmDecor() & MwmDecorBorder))
+    elements &= ~DecorationElement::SHADOW;
+
+  return elements;
+}
+
+bool IsWindowEdgeDecorable(CompWindow* win)
+{
+  return WindowDecorationElements(win) & DecorationElement::EDGE;
+}
+
+bool IsWindowShadowDecorable(CompWindow* win)
+{
+  return WindowDecorationElements(win) & DecorationElement::SHADOW;
 }
 
 bool IsWindowFullyDecorable(CompWindow* win)
 {
-  if (!win)
-    return false;
-
-  if (!IsWindowShadowDecorable(win))
-    return false;
-
-  return WindowHasMotifDecorations(win);
-}
-
-bool WindowHasMotifDecorations(CompWindow* win)
-{
-  if (!win)
-    return false;
-
-  if (win->overrideRedirect())
-    return false;
-
-  switch (win->type())
-  {
-    case CompWindowTypeDialogMask:
-    case CompWindowTypeModalDialogMask:
-    case CompWindowTypeUtilMask:
-    case CompWindowTypeMenuMask:
-    case CompWindowTypeNormalMask:
-      if (win->mwmDecor() & (MwmDecorAll | MwmDecorTitle))
-        return true;
-  }
-
-  return false;
+  return WindowDecorationElements(win) & DecorationElement::BORDER;
 }
 
 } // compiz_utils namespace
 
=== modified file 'unity-shared/CompizUtils.h'
--- unity-shared/CompizUtils.h	2014-04-14 13:51:58 +0000
+++ unity-shared/CompizUtils.h	2014-10-10 14:56:03 +0000
@@ -31,8 +31,15 @@
 
 struct TextureQuad
 {
+  TextureQuad()
+  : matrices(1)
+  , matrix(matrices[0])
+  {}
+
   CompRect box;
-  GLTexture::Matrix matrix;
+  CompRegion region;
+  GLTexture::MatrixList matrices;
+  GLTexture::Matrix& matrix;
 };
 
 struct SimpleTexture
@@ -59,11 +66,13 @@
 {
   SimpleTextureQuad();
   bool SetTexture(SimpleTexture::Ptr const&);
-  bool SetScale(float scale);
+  bool SetScale(double scale);
   bool SetCoords(int x, int y);
   bool SetX(int x);
   bool SetY(int y);
 
+  void UpdateMatrix();
+
   operator SimpleTexture::Ptr() const { return st; }
   operator bool() const { return st && st->texture(); }
   operator GLTexture*() const { return st ? st->texture() : nullptr; }
@@ -73,8 +82,7 @@
   TextureQuad quad;
 
 private:
-  void UpdateMatrix();
-  float scale;
+  double scale_;
 };
 
 struct PixmapTexture : SimpleTexture
@@ -111,9 +119,20 @@
   cairo_t *cr_;
 };
 
+enum DecorationElement
+{
+  NONE = 0,
+  EDGE = (1 << 0),
+  SHADOW = (1 << 1),
+  BORDER = (1 << 2),
+  FULL = EDGE|SHADOW|BORDER
+};
+
+unsigned WindowDecorationElements(CompWindow*);
+
+bool IsWindowEdgeDecorable(CompWindow*);
 bool IsWindowShadowDecorable(CompWindow*);
 bool IsWindowFullyDecorable(CompWindow*);
-bool WindowHasMotifDecorations(CompWindow*);
 
 } // compiz_utils namespace
 } // unity namespace
 
=== modified file 'unity-shared/XWindowManager.cpp'
--- unity-shared/XWindowManager.cpp	2014-02-14 03:05:02 +0000
+++ unity-shared/XWindowManager.cpp	2014-10-10 14:56:03 +0000
@@ -83,7 +83,7 @@
   {
     LOG_ERROR(logger) << "Impossible to get the property " << gdk_x11_get_xatom_name(atom)
                       << " for window " << window_id << ": invalid string type: "
-                      << gdk_x11_get_xatom_name(Atoms::utf8String);
+                      << gdk_x11_get_xatom_name(type);
     return std::string();
   }