Merge lp:~unity-team/unity/trusty-1276177 into lp:unity/7.2

[Stephen M. Webb]

Fix edge decorations for windows with client-side decorations.

This change is cherry-picked from trunk for SRUing to Ubuntu 14.04 LTS.

Unmerged revisions

=== modified file 'debian/changelog'
--- debian/changelog	2014-08-26 13:49:00 +0000
+++ debian/changelog	2014-12-08 22:42:16 +0000
@@ -1,3 +1,11 @@
+unity (7.2.3+14.04.20140826-0ubuntu2) UNRELEASED; urgency=medium
+
+  * DecoratedWindow: make edges independent from borders and properly update
+    them on actions change (lp: #1276177), (lp: #1299741), (lp: #1301776),
+    (lp: #1324104), (lp: #1364225), (lp: #1373695)
+
+ -- Marco Trevisan (Treviño) <[e-mail]>  Mon, 08 Dec 2014 17:35:27 -0500
+
 unity (7.2.3+14.04.20140826-0ubuntu1) trusty; urgency=medium
 
   [ Andrea Azzarone ]

=== modified file 'decorations/DecoratedWindow.cpp'
--- decorations/DecoratedWindow.cpp	2014-04-02 12:26:14 +0000
+++ decorations/DecoratedWindow.cpp	2014-12-08 22:42:16 +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
@@ -46,8 +46,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) {
@@ -107,14 +111,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()
@@ -122,6 +139,7 @@
   UnsetExtents();
   UnsetFrame();
   CleanupWindowControls();
+  CleanupWindowEdges();
   bg_textures_.clear();
 }
 
@@ -141,17 +159,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);
@@ -185,6 +213,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
@@ -282,6 +319,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_)
@@ -293,26 +366,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>();
@@ -347,6 +401,7 @@
   top_layout_->Append(title_layout);
 
   input_mixer_->PushToFront(top_layout_);
+  dirty_frame_ = false;
 
   SetupAppMenu();
   RedrawDecorations();
@@ -357,12 +412,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
@@ -370,26 +425,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
@@ -431,6 +485,7 @@
   }
 
   deco_tex.SetCoords(geo.x, geo.y);
+  deco_tex.quad.region = deco_tex.quad.box;
 }
 
 void Window::Impl::UpdateDecorationTextures()
@@ -442,7 +497,6 @@
   }
 
   auto const& geo = win_->borderRect();
-  auto const& input = win_->inputRect();
   auto const& border = win_->border();
 
   bg_textures_.resize(4);
@@ -454,19 +508,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();
 
@@ -554,6 +607,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();
   }
@@ -563,15 +622,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;
@@ -582,7 +652,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())
@@ -594,7 +664,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);
@@ -707,6 +777,9 @@
 
     if (top_layout_)
       top_layout_->scale = cv_->DPIScale();
+
+    if (edge_borders_)
+      edge_borders_->scale = cv_->DPIScale();
   }
 }
 
@@ -789,6 +862,7 @@
 {
   impl_->UpdateMonitor();
   impl_->ComputeShadowQuads();
+  impl_->UpdateWindowEdgesGeo();
   impl_->UpdateDecorationTextures();
   impl_->UpdateForceQuitDialogPosition();
   impl_->dirty_geo_ = false;
@@ -808,7 +882,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-12-08 22:42:16 +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-04-02 13:14:43 +0000
+++ decorations/DecorationsForceQuitDialog.cpp	2014-12-08 22:42:16 +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-04-02 09:04:37 +0000
+++ decorations/DecorationsManager.cpp	2014-12-08 22:42:16 +0000
@@ -44,8 +44,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)
 {
@@ -55,7 +54,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)));
@@ -208,8 +206,6 @@
 
 bool Manager::Impl::HandleEventBefore(XEvent* event)
 {
-  active_window_ = screen->activeWindow();
-
   switch (event->type)
   {
     case ClientMessage:
@@ -254,31 +250,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 ||
@@ -445,7 +436,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-12-08 22:42:16 +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-12-08 22:42:16 +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-12-08 22:42:16 +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-12-08 22:42:16 +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-08-06 14:19:10 +0000
+++ plugins/unityshell/src/unityshell.cpp	2014-12-08 22:42:16 +0000
@@ -278,6 +278,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-12-08 22:42:16 +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-12-08 22:42:16 +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-12-08 22:42:16 +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();
   }