Merge lp:~3v1n0/unity/wm-click-actions into lp:unity

[Marco Trevisan (Treviño)]

DecorationsGrabEdge, PanelMenuView: perform proper WM action on clicks, based on user settings

[Brandon Schaefer (brandontschaefer)]

LGTM

review: Approve

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:3760
http://jenkins.qa.ubuntu.com/job/unity-ci/849/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/385
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/381
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/383/console

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

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:3760
http://jenkins.qa.ubuntu.com/job/unity-ci/853/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-amd64-ci/389
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-armhf-ci/385
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-trusty-i386-ci/387

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

review: Approve (continuous-integration)

=== modified file 'decorations/DecorationsGrabEdge.cpp'
--- decorations/DecorationsGrabEdge.cpp	2014-04-02 21:44:17 +0000
+++ decorations/DecorationsGrabEdge.cpp	2014-04-02 21:44:17 +0000
@@ -37,8 +37,8 @@
 {
   if (button != 1)
   {
-    if (button == 3)
-      screen->toolkitAction(Atoms::toolkitActionWindowMenu, timestamp, win_->id(), button, p.x(), p.y());
+    if (button == 2 || button == 3)
+      PerformWMAction(p, button, timestamp);
 
     return;
   }
@@ -51,7 +51,7 @@
 
   auto const& style = Style::Get();
   unsigned max_time_delta = std::max(0, style->DoubleClickMaxTimeDelta());
-  bool maximized = false;
+  bool double_clicked = false;
 
   if (timestamp - last_click_time_ < max_time_delta)
   {
@@ -60,13 +60,13 @@
     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;
+      PerformWMAction(p, button, timestamp);
+      double_clicked = true;
       button_down_timer_.reset();
     }
   }
 
-  if (!maximized)
+  if (!double_clicked)
   {
     button_down_timer_.reset(new glib::Timeout(style->grab_wait()));
     button_down_timer_->Run([this] {
@@ -96,6 +96,56 @@
   button_down_ = -1;
 }
 
+void GrabEdge::PerformWMAction(CompPoint const& p, unsigned button, Time timestamp)
+{
+  WMAction action = Style::Get()->WindowManagerAction(WMEvent(button));
+
+  switch (action)
+  {
+    case WMAction::TOGGLE_SHADE:
+      if (win_->state() & CompWindowStateShadedMask)
+        win_->changeState(win_->state() & ~CompWindowStateShadedMask);
+      else
+        win_->changeState(win_->state() | CompWindowStateShadedMask);
+
+      win_->updateAttributes(CompStackingUpdateModeNone);
+      break;
+    case WMAction::TOGGLE_MAXIMIZE:
+      if ((win_->state() & MAXIMIZE_STATE) == MAXIMIZE_STATE)
+        win_->maximize(0);
+      else
+        win_->maximize(MAXIMIZE_STATE);
+      break;
+    case WMAction::TOGGLE_MAXIMIZE_HORIZONTALLY:
+      if (win_->state() & CompWindowStateMaximizedHorzMask)
+        win_->maximize(0);
+      else
+        win_->maximize(CompWindowStateMaximizedHorzMask);
+      break;
+    case WMAction::TOGGLE_MAXIMIZE_VERTICALLY:
+    if (win_->state() & CompWindowStateMaximizedVertMask)
+        win_->maximize(0);
+      else
+        win_->maximize(CompWindowStateMaximizedVertMask);
+      break;
+    case WMAction::MINIMIZE:
+      win_->minimize();
+      break;
+    case WMAction::SHADE:
+      win_->changeState(win_->state() | CompWindowStateShadedMask);
+      win_->updateAttributes(CompStackingUpdateModeNone);
+      break;
+    case WMAction::MENU:
+      screen->toolkitAction(Atoms::toolkitActionWindowMenu, timestamp, win_->id(), button, p.x(), p.y());
+      break;
+    case WMAction::LOWER:
+      win_->lower();
+      break;
+    default:
+      break;
+  }
+}
+
 bool GrabEdge::IsGrabbed() const
 {
   return !button_down_timer_;

=== modified file 'decorations/DecorationsGrabEdge.h'
--- decorations/DecorationsGrabEdge.h	2014-02-13 04:45:22 +0000
+++ decorations/DecorationsGrabEdge.h	2014-04-02 21:44:17 +0000
@@ -44,6 +44,7 @@
 
 protected:
   void AddProperties(debug::IntrospectionData&);
+  void PerformWMAction(CompPoint const&, unsigned button, Time);
 
 private:
   Time last_click_time_;

=== modified file 'panel/PanelMenuView.cpp'
--- panel/PanelMenuView.cpp	2014-03-31 21:09:08 +0000
+++ panel/PanelMenuView.cpp	2014-04-02 21:44:17 +0000
@@ -173,10 +173,10 @@
 {
   titlebar_grab_area_ = new PanelTitlebarGrabArea();
   titlebar_grab_area_->SetParentObject(this);
-  titlebar_grab_area_->activate_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedActivate));
-  titlebar_grab_area_->restore_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedRestore));
-  titlebar_grab_area_->lower_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedLower));
-  titlebar_grab_area_->menu_request.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedShowActionMenu));
+  titlebar_grab_area_->clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedActivate));
+  titlebar_grab_area_->double_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedDoubleClicked));
+  titlebar_grab_area_->middle_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedMiddleClicked));
+  titlebar_grab_area_->right_clicked.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedRightClicked));
   titlebar_grab_area_->grab_started.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabStart));
   titlebar_grab_area_->grab_move.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabMove));
   titlebar_grab_area_->grab_end.connect(sigc::mem_fun(this, &PanelMenuView::OnMaximizedGrabEnd));
@@ -1455,44 +1455,79 @@
   }
 }
 
-void PanelMenuView::OnMaximizedRestore(int x, int y)
-{
-  Window maximized = GetMaximizedWindow();
-
-  if (maximized != 0)
-  {
-    WindowManager::Default().Restore(maximized);
-    is_inside_ = true;
-  }
-}
-
-void PanelMenuView::OnMaximizedLower(int x, int y)
-{
-  Window maximized = GetMaximizedWindow();
-
-  if (maximized != 0)
-  {
-    WindowManager::Default().Lower(maximized);
-  }
-}
-
-void PanelMenuView::OnMaximizedShowActionMenu(int x, int y)
-{
-  Window maximized = GetMaximizedWindow();
-
-  if (maximized != 0)
-  {
-    auto const& event = nux::GetGraphicsDisplay()->GetCurrentEvent();
-    auto const& abs_geo = titlebar_grab_area_->GetAbsoluteGeometry();
-    int button = event.GetEventButton();
-    nux::Point click(abs_geo.x + x, abs_geo.y + y);
-    auto& wm = WindowManager::Default();
-    wm.UnGrabMousePointer(event.x11_timestamp, button, click.x, click.y);
-    wm.ShowActionMenu(event.x11_timestamp, maximized, button, click);
-
-    is_inside_ = false;
-    QueueDraw();
-  }
+void PanelMenuView::MaximizedWindowWMAction(int x, int y, unsigned button)
+{
+  Window maximized = GetMaximizedWindow();
+
+  if (!maximized)
+    return;
+
+  using namespace decoration;
+  auto& wm = WindowManager::Default();
+  auto action = decoration::Style::Get()->WindowManagerAction(WMEvent(button));
+
+  switch (action)
+  {
+    case WMAction::TOGGLE_SHADE:
+      if (wm.IsWindowShaded(maximized))
+        wm.UnShade(maximized);
+      else
+        wm.Shade(maximized);
+      break;
+    case WMAction::TOGGLE_MAXIMIZE:
+      wm.Restore(maximized);
+      is_inside_ = true;
+      break;
+    case WMAction::TOGGLE_MAXIMIZE_HORIZONTALLY:
+      wm.HorizontallyMaximize(maximized);
+      is_inside_ = true;
+      break;
+    case WMAction::TOGGLE_MAXIMIZE_VERTICALLY:
+      wm.VerticallyMaximize(maximized);
+      is_inside_ = true;
+      break;
+    case WMAction::MINIMIZE:
+      wm.Minimize(maximized);
+      is_inside_ = true;
+      break;
+    case WMAction::SHADE:
+      wm.Shade(maximized);
+      break;
+    case WMAction::MENU:
+    {
+      auto const& event = nux::GetGraphicsDisplay()->GetCurrentEvent();
+      auto const& abs_geo = titlebar_grab_area_->GetAbsoluteGeometry();
+      int button = event.GetEventButton();
+      nux::Point click(abs_geo.x + x, abs_geo.y + y);
+      auto& wm = WindowManager::Default();
+      wm.UnGrabMousePointer(event.x11_timestamp, button, click.x, click.y);
+      wm.ShowActionMenu(event.x11_timestamp, maximized, button, click);
+
+      is_inside_ = false;
+      QueueDraw();
+      break;
+    }
+    case WMAction::LOWER:
+      wm.Lower(maximized);
+      break;
+    default:
+      break;
+  }
+}
+
+void PanelMenuView::OnMaximizedDoubleClicked(int x, int y)
+{
+  MaximizedWindowWMAction(x, y, 1);
+}
+
+void PanelMenuView::OnMaximizedMiddleClicked(int x, int y)
+{
+  MaximizedWindowWMAction(x, y, 2);
+}
+
+void PanelMenuView::OnMaximizedRightClicked(int x, int y)
+{
+  MaximizedWindowWMAction(x, y, 3);
 }
 
 void PanelMenuView::OnMaximizedGrabStart(int x, int y)

=== modified file 'panel/PanelMenuView.h'
--- panel/PanelMenuView.h	2014-03-06 09:26:03 +0000
+++ panel/PanelMenuView.h	2014-04-02 21:44:17 +0000
@@ -105,12 +105,13 @@
   void OnWindowMoved(Window xid);
 
   void OnMaximizedActivate(int x, int y);
-  void OnMaximizedRestore(int x, int y);
-  void OnMaximizedLower(int x, int y);
-  void OnMaximizedShowActionMenu(int x, int y);
+  void OnMaximizedDoubleClicked(int x, int y);
+  void OnMaximizedMiddleClicked(int x, int y);
+  void OnMaximizedRightClicked(int x, int y);
   void OnMaximizedGrabStart(int x, int y);
   void OnMaximizedGrabMove(int x, int y);
   void OnMaximizedGrabEnd(int x, int y);
+  void MaximizedWindowWMAction(int x, int y, unsigned button);
 
   void FullRedraw();
   std::string GetCurrentTitle() const;

=== modified file 'panel/PanelTitlebarGrabAreaView.cpp'
--- panel/PanelTitlebarGrabAreaView.cpp	2014-02-14 19:01:49 +0000
+++ panel/PanelTitlebarGrabAreaView.cpp	2014-04-02 21:44:17 +0000
@@ -44,7 +44,7 @@
   mouse_double_click.connect([this] (int x, int y, unsigned long button_flags, unsigned long)
   {
     if (nux::GetEventButton(button_flags) == 1)
-      restore_request.emit(x, y);
+      double_clicked.emit(x, y);
   });
 }
 
@@ -105,11 +105,11 @@
   }
   else if (mouse_down_button_ == 2)
   {
-    lower_request.emit(x, y);
+    middle_clicked.emit(x, y);
   }
   else if (mouse_down_button_ == 3)
   {
-    menu_request.emit(x, y);
+    right_clicked.emit(x, y);
   }
 }
 
@@ -122,7 +122,7 @@
     if (mouse_down_timer_)
     {
       mouse_down_timer_.reset();
-      activate_request.emit(x, y);
+      clicked.emit(x, y);
     }
 
     if (grab_started_)

=== modified file 'panel/PanelTitlebarGrabAreaView.h'
--- panel/PanelTitlebarGrabAreaView.h	2014-02-14 03:10:56 +0000
+++ panel/PanelTitlebarGrabAreaView.h	2014-04-02 21:44:17 +0000
@@ -43,10 +43,10 @@
   void SetGrabbed(bool enabled);
   bool IsGrabbed();
 
-  sigc::signal<void, int, int> lower_request;
-  sigc::signal<void, int, int> activate_request;
-  sigc::signal<void, int, int> restore_request;
-  sigc::signal<void, int, int> menu_request;
+  sigc::signal<void, int, int> clicked;
+  sigc::signal<void, int, int> middle_clicked;
+  sigc::signal<void, int, int> double_clicked;
+  sigc::signal<void, int, int> right_clicked;
   sigc::signal<void, int, int> grab_started;
   sigc::signal<void, int, int> grab_move;
   sigc::signal<void, int, int> grab_end;

=== modified file 'unity-shared/DecorationStyle.cpp'
--- unity-shared/DecorationStyle.cpp	2014-03-31 19:02:32 +0000
+++ unity-shared/DecorationStyle.cpp	2014-04-02 21:44:17 +0000
@@ -61,6 +61,9 @@
 const std::string SETTINGS_NAME = "org.gnome.desktop.wm.preferences";
 const std::string FONT_KEY = "titlebar-font";
 const std::string USE_SYSTEM_FONT_KEY = "titlebar-uses-system-font";
+const std::string ACTION_DOUBLE_CLICK = "action-double-click-titlebar";
+const std::string ACTION_MIDDLE_CLICK = "action-middle-click-titlebar";
+const std::string ACTION_RIGHT_CLICK = "action-right-click-titlebar";
 
 const std::string UNITY_SETTINGS_NAME = "com.canonical.Unity.Decorations";
 const std::string GRAB_WAIT_KEY = "grab-wait";
@@ -299,6 +302,49 @@
     return value;
   }
 
+  WMAction WMActionFromString(std::string const& action) const
+  {
+    if (action == "toggle-shade")
+      return WMAction::TOGGLE_SHADE;
+    else if (action == "toggle-maximize")
+      return WMAction::TOGGLE_MAXIMIZE;
+    else if (action == "toggle-maximize-horizontally")
+      return WMAction::TOGGLE_MAXIMIZE_HORIZONTALLY;
+    else if (action == "toggle-maximize-vertically")
+      return WMAction::TOGGLE_MAXIMIZE_VERTICALLY;
+    else if (action == "minimize")
+      return WMAction::MINIMIZE;
+    else if (action == "shade")
+      return WMAction::SHADE;
+    else if (action == "menu")
+      return WMAction::MENU;
+    else if (action == "lower")
+      return WMAction::LOWER;
+
+    return WMAction::NONE;
+  }
+
+  WMAction WindowManagerAction(WMEvent event) const
+  {
+    std::string action_setting;
+
+    switch (event)
+    {
+      case WMEvent::DOUBLE_CLICK:
+        action_setting = ACTION_DOUBLE_CLICK;
+        break;
+      case WMEvent::MIDDLE_CLICK:
+        action_setting = ACTION_MIDDLE_CLICK;
+        break;
+      case WMEvent::RIGHT_CLICK:
+        action_setting = ACTION_RIGHT_CLICK;
+        break;
+    }
+
+    glib::String action_string(g_settings_get_string(settings_, action_setting.c_str()));
+    return WMActionFromString(action_string.Str());
+  }
+
   inline GtkStateFlags GtkStateFromWidgetState(WidgetState ws)
   {
     switch (ws)
@@ -776,6 +822,11 @@
   return impl_->glow_color_;
 }
 
+WMAction Style::WindowManagerAction(WMEvent event) const
+{
+  return impl_->WindowManagerAction(event);
+}
+
 int Style::DoubleClickMaxDistance() const
 {
   return impl_->GetSettingValue<int>("gtk-double-click-distance");

=== modified file 'unity-shared/DecorationStyle.h'
--- unity-shared/DecorationStyle.h	2014-03-31 19:02:32 +0000
+++ unity-shared/DecorationStyle.h	2014-04-02 21:44:17 +0000
@@ -68,6 +68,26 @@
   Size
 };
 
+enum class WMEvent
+{
+  DOUBLE_CLICK = 1,
+  MIDDLE_CLICK = 2,
+  RIGHT_CLICK = 3
+};
+
+enum class WMAction
+{
+  TOGGLE_SHADE,
+  TOGGLE_MAXIMIZE,
+  TOGGLE_MAXIMIZE_HORIZONTALLY,
+  TOGGLE_MAXIMIZE_VERTICALLY,
+  MINIMIZE,
+  SHADE,
+  MENU,
+  LOWER,
+  NONE
+};
+
 struct Border
 {
   Border(int top, int left, int right, int bottom)
@@ -127,6 +147,7 @@
   std::string WindowButtonFile(WindowButtonType, WidgetState) const;
   void DrawWindowButton(WindowButtonType, WidgetState, cairo_t*, double width, double height);
 
+  WMAction WindowManagerAction(WMEvent) const;
   int DoubleClickMaxDistance() const;
   int DoubleClickMaxTimeDelta() const;
 

=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2014-03-12 23:45:48 +0000
+++ unity-shared/PluginAdapter.cpp	2014-04-02 21:44:17 +0000
@@ -573,6 +573,14 @@
   return false;
 }
 
+bool PluginAdapter::IsWindowShaded(Window window_id) const
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    return (window->state() & CompWindowStateShadedMask);
+
+  return false;
+}
+
 bool PluginAdapter::IsWindowOnTop(Window window_id) const
 {
   if (window_id == GetTopMostValidWindowInViewport())
@@ -683,7 +691,19 @@
 void PluginAdapter::Maximize(Window window_id)
 {
   if (CompWindow* window = m_Screen->findWindow(window_id))
-    window->maximize(MAXIMIZE_STATE);
+    window->maximize(CompWindowStateMaximizedVertMask);
+}
+
+void PluginAdapter::VerticallyMaximize(Window window_id)
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    window->maximize(CompWindowStateMaximizedVertMask);
+}
+
+void PluginAdapter::HorizontallyMaximize(Window window_id)
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    window->maximize(CompWindowStateMaximizedHorzMask);
 }
 
 void PluginAdapter::Restore(Window window_id)
@@ -730,6 +750,26 @@
     window->unminimize();
 }
 
+void PluginAdapter::Shade(Window window_id)
+{
+  CompWindow* window = m_Screen->findWindow(window_id);
+  if (window && (window->actions() & CompWindowActionShadeMask))
+  {
+    window->changeState(window->state() | CompWindowStateShadedMask);
+    window->updateAttributes(CompStackingUpdateModeNone);
+  }
+}
+
+void PluginAdapter::UnShade(Window window_id)
+{
+  CompWindow* window = m_Screen->findWindow(window_id);
+  if (window && (window->actions() & CompWindowActionShadeMask))
+  {
+    window->changeState(window->state() & ~CompWindowStateShadedMask);
+    window->updateAttributes(CompStackingUpdateModeNone);
+  }
+}
+
 void PluginAdapter::Close(Window window_id)
 {
   CompWindow* window = m_Screen->findWindow(window_id);

=== modified file 'unity-shared/PluginAdapter.h'
--- unity-shared/PluginAdapter.h	2014-02-19 02:16:22 +0000
+++ unity-shared/PluginAdapter.h	2014-04-02 21:44:17 +0000
@@ -128,6 +128,7 @@
   bool IsWindowMapped(Window window_id) const;
   bool IsWindowVisible(Window window_id) const;
   bool IsWindowOnTop(Window window_id) const;
+  bool IsWindowShaded(Window window_id) const;
   bool IsWindowClosable(Window window_id) const;
   bool IsWindowMinimized(Window window_id) const;
   bool IsWindowMinimizable(Window window_id) const;
@@ -136,10 +137,14 @@
 
   void ShowActionMenu(Time, Window, unsigned button, nux::Point const&);
   void Maximize(Window window_id);
+  void VerticallyMaximize(Window window_id);
+  void HorizontallyMaximize(Window window_id);
   void Restore(Window window_id);
   void RestoreAt(Window window_id, int x, int y);
   void Minimize(Window window_id);
   void UnMinimize(Window window_id);
+  void Shade(Window window_id);
+  void UnShade(Window window_id);
   void Close(Window window_id);
   void Activate(Window window_id);
   void Raise(Window window_id);

=== modified file 'unity-shared/StandaloneDecorationStyle.cpp'
--- unity-shared/StandaloneDecorationStyle.cpp	2014-01-21 12:19:42 +0000
+++ unity-shared/StandaloneDecorationStyle.cpp	2014-04-02 21:44:17 +0000
@@ -40,6 +40,33 @@
   return os;
 }
 
+std::ostream& operator<<(std::ostream &os, WMAction const& a)
+{
+  switch (a)
+  {
+    case WMAction::TOGGLE_SHADE:
+      return os << "toggle-shade";
+    case WMAction::TOGGLE_MAXIMIZE:
+      return os << "toggle-maximize";
+    case WMAction::TOGGLE_MAXIMIZE_HORIZONTALLY:
+      return os << "toggle-maximize_horizontally";
+    case WMAction::TOGGLE_MAXIMIZE_VERTICALLY:
+      return os << "toggle-maximize_vertically";
+    case WMAction::MINIMIZE:
+      return os << "minimize";
+    case WMAction::SHADE:
+      return os << "shade";
+    case WMAction::MENU:
+      return os << "menu";
+    case WMAction::LOWER:
+      return os << "lower";
+    case WMAction::NONE:
+      return os << "none";
+  }
+
+  return os;
+}
+
 std::ostream& operator<<(std::ostream &os, Border const& b)
 {
   return os << "top " << b.top << ", left " << b.left << ", right " << b.right << ", bottom " << b.bottom;
@@ -132,6 +159,13 @@
   std::cout << "Button 'maximize' state 'backdrop_pressed' '" << style->WindowButtonFile(WindowButtonType::MAXIMIZE, WidgetState::BACKDROP_PRESSED) << "'" << std::endl;
   std::cout << "---" << std::endl;
 
+  std::cout << "---" << std::endl;
+
+  std::cout << "Double click action " << style->WindowManagerAction(WMEvent::DOUBLE_CLICK) << std::endl;
+  std::cout << "Middle click action " << style->WindowManagerAction(WMEvent::MIDDLE_CLICK) << std::endl;
+  std::cout << "Right click action " << style->WindowManagerAction(WMEvent::RIGHT_CLICK) << std::endl;
+  std::cout << "---" << std::endl;
+
   std::cout << "Maximum Double click distance " << style->DoubleClickMaxDistance() << "px" << std::endl;
   std::cout << "Maximum Double click Time delta " << style->DoubleClickMaxTimeDelta() << "ms " << std::endl;
   std::cout << "---" << std::endl;

=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2014-02-19 02:16:22 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2014-04-02 21:44:17 +0000
@@ -45,6 +45,7 @@
   , v_maximized(false)
   , h_maximized(false)
   , minimized(false)
+  , shaded(false)
   , decorated(true)
   , has_decorations(true)
   , on_top(false)
@@ -72,15 +73,16 @@
   maximized.SetSetterFunction([this] (bool value) {
     if (maximized() == value)
       return false;
- 
+
     v_maximized = value;
     h_maximized = value;
     decorated = !value;
     return true;
   });
- 
+
   v_maximized.changed.connect([this] (bool value) { maximized.changed.emit(maximized()); });
   h_maximized.changed.connect([this] (bool value) { maximized.changed.emit(maximized()); });
+  shaded.changed.connect([this] (bool value) { minimized = value; });
 }
 
 WindowManagerPtr create_window_manager()
@@ -156,16 +158,16 @@
   auto window = GetWindowByXid(window_id);
   if (window)
     return window->v_maximized;
- 
+
   return false;
 }
- 
+
 bool StandaloneWindowManager::IsWindowHorizontallyMaximized(Window window_id) const
 {
   auto window = GetWindowByXid(window_id);
   if (window)
     return window->h_maximized;
- 
+
   return false;
 }
 
@@ -285,6 +287,28 @@
   }
 }
 
+void StandaloneWindowManager::VerticallyMaximize(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+  if (window)
+  {
+    window->h_maximized = false;
+    window->v_maximized = true;
+    window->decorated = true;
+  }
+}
+
+void StandaloneWindowManager::HorizontallyMaximize(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+  if (window)
+  {
+    window->v_maximized = false;
+    window->h_maximized = true;
+    window->decorated = true;
+  }
+}
+
 void StandaloneWindowManager::Restore(Window window_id)
 {
   auto window = GetWindowByXid(window_id);
@@ -589,6 +613,30 @@
   return std::vector<long>();
 }
 
+bool StandaloneWindowManager::IsWindowShaded(Window window_id) const
+{
+  auto window = GetWindowByXid(window_id);
+  if (window)
+    return window->shaded;
+
+  return false;
+}
+
+void StandaloneWindowManager::Shade(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+  if (window)
+    window->shaded = true;
+}
+
+void StandaloneWindowManager::UnShade(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+  if (window)
+    window->shaded = false;
+}
+
+
 
 // Mock functions
 

=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2014-02-17 21:17:51 +0000
+++ unity-shared/StandaloneWindowManager.h	2014-04-02 21:44:17 +0000
@@ -52,6 +52,7 @@
   nux::Property<bool> v_maximized;
   nux::Property<bool> h_maximized;
   nux::Property<bool> minimized;
+  nux::Property<bool> shaded;
   nux::Property<bool> decorated;
   nux::Property<bool> has_decorations;
   nux::Property<bool> on_top;
@@ -83,6 +84,7 @@
   virtual bool IsWindowMapped(Window window_id) const;
   virtual bool IsWindowVisible(Window window_id) const;
   virtual bool IsWindowOnTop(Window window_id) const;
+  virtual bool IsWindowShaded(Window window_id) const;
   virtual bool IsWindowClosable(Window window_id) const;
   virtual bool IsWindowMinimized(Window window_id) const;
   virtual bool IsWindowMinimizable(Window window_id) const;
@@ -94,10 +96,14 @@
 
   virtual void ShowActionMenu(Time, Window, unsigned button, nux::Point const&) {}
   virtual void Maximize(Window window_id);
+  virtual void VerticallyMaximize(Window window_id);
+  virtual void HorizontallyMaximize(Window window_id);
   virtual void Restore(Window window_id);
   virtual void RestoreAt(Window window_id, int x, int y);
   virtual void Minimize(Window window_id);
   virtual void UnMinimize(Window window_id);
+  virtual void Shade(Window window_id);
+  virtual void UnShade(Window window_id);
   virtual void Close(Window window_id);
 
   virtual void Activate(Window window_id);

=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2014-03-06 20:49:14 +0000
+++ unity-shared/WindowManager.h	2014-04-02 21:44:17 +0000
@@ -89,6 +89,7 @@
   virtual bool IsWindowMapped(Window window_id) const = 0;
   virtual bool IsWindowVisible(Window window_id) const = 0;
   virtual bool IsWindowOnTop(Window window_id) const = 0;
+  virtual bool IsWindowShaded(Window window_id) const = 0;
   virtual bool IsWindowClosable(Window window_id) const = 0;
   virtual bool IsWindowMinimized(Window window_id) const = 0;
   virtual bool IsWindowMinimizable(Window window_id) const = 0;
@@ -100,10 +101,14 @@
 
   virtual void ShowActionMenu(Time, Window, unsigned button, nux::Point const&) = 0;
   virtual void Maximize(Window window_id) = 0;
+  virtual void VerticallyMaximize(Window window_id) = 0;
+  virtual void HorizontallyMaximize(Window window_id) = 0;
   virtual void Restore(Window window_id) = 0;
   virtual void RestoreAt(Window window_id, int x, int y) = 0;
   virtual void Minimize(Window window_id) = 0;
   virtual void UnMinimize(Window window_id) = 0;
+  virtual void Shade(Window window_id) = 0;
+  virtual void UnShade(Window window_id) = 0;
   virtual void Close(Window window_id) = 0;
 
   virtual void Activate(Window window_id) = 0;