Merge lp:~3v1n0/unity/super-arrows-shortcuts into lp:unity

[Marco Trevisan (Treviño)]

UnityScreen: add support for Super+Arrows shortcuts to manage the focused window

Super+Arrows shortcut allows to move and maximize / restore / minimize
the focused window on the screen.

Added the Super+Left/Right arrows shortcuts support to manage the focused window, as defined on bug #751050

This branch requires lp:~3v1n0/autopilot/window-left+right-maximize-keys in order to make the tests pass.
The fixes is also complete when lp:~3v1n0/compiz/unity-wm-shortcuts-0.9.11 merges

[Alex Launi (alexlauni)]

These tests could be written with autopilot. Please make the necessary adjustments to automate these tests.

review: Needs Fixing

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:1886
http://jenkins.qa.ubuntu.com/job/unity-ci/358/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-amd64-ci/247/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/unity-saucy-armhf-ci/245/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/unity-saucy-i386-ci/246

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

review: Needs Fixing (continuous-integration)

[Christopher Townsend (townsend)]

Works great!

review: Approve

[PS Jenkins bot (ps-jenkins)]

review: Approve (continuous-integration)

=== modified file 'plugins/unityshell/src/unityshell.cpp'
--- plugins/unityshell/src/unityshell.cpp	2013-09-12 03:12:04 +0000
+++ plugins/unityshell/src/unityshell.cpp	2013-09-16 16:11:09 +0000
@@ -349,6 +349,9 @@
      optionSetLauncherSwitcherPrevInitiate(boost::bind(&UnityScreen::launcherSwitcherPrevInitiate, this, _1, _2, _3));
      optionSetLauncherSwitcherForwardTerminate(boost::bind(&UnityScreen::launcherSwitcherTerminate, this, _1, _2, _3));
 
+     optionSetWindowRightMaximizeInitiate(boost::bind(&UnityScreen::rightMaximizeKeyInitiate, this, _1, _2, _3));
+     optionSetWindowLeftMaximizeInitiate(boost::bind(&UnityScreen::leftMaximizeKeyInitiate, this, _1, _2, _3));
+
      optionSetStopVelocityNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetRevealPressureNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
      optionSetEdgeResponsivenessNotify(boost::bind(&UnityScreen::optionChanged, this, _1, _2));
@@ -2136,12 +2139,14 @@
   action->setState(action->state() | CompAction::StateTermKey);
   return true;
 }
+
 bool UnityScreen::launcherSwitcherPrevInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
 {
   launcher_controller_->KeyNavPrevious();
 
   return true;
 }
+
 bool UnityScreen::launcherSwitcherTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options)
 {
   bool accept_state = (state & CompAction::StateCancel) == 0;
@@ -2164,6 +2169,20 @@
   return true;
 }
 
+bool UnityScreen::rightMaximizeKeyInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
+{
+  auto& WM = WindowManager::Default();
+  WM.RightMaximize(WM.GetActiveWindow());
+  return true;
+}
+
+bool UnityScreen::leftMaximizeKeyInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options)
+{
+  auto& WM = WindowManager::Default();
+  WM.LeftMaximize(WM.GetActiveWindow());
+  return true;
+}
+
 void UnityScreen::OnLauncherStartKeyNav(GVariant* data)
 {
   // Put the launcher BaseWindow at the top of the BaseWindow stack. The
@@ -3554,6 +3573,10 @@
     .add("xid", (uint64_t)xid)
     .add("title", wm.GetWindowName(xid))
     .add("fake_decorated", uScreen->fake_decorated_windows_.find(this) != uScreen->fake_decorated_windows_.end())
+    .add("maximized", wm.IsWindowVerticallyMaximized(xid))
+    .add("horizontally_maximized", wm.IsWindowHorizontallyMaximized(xid))
+    .add("vertically_maximized", wm.IsWindowVerticallyMaximized(xid))
+    .add("minimized", wm.IsWindowMinimized(xid))
     .add("scaled", scaled)
     .add("scaled_close_x", close_button_geo_.x)
     .add("scaled_close_y", close_button_geo_.y)
 
=== modified file 'plugins/unityshell/src/unityshell.h'
--- plugins/unityshell/src/unityshell.h	2013-08-08 23:04:44 +0000
+++ plugins/unityshell/src/unityshell.h	2013-09-16 16:11:09 +0000
@@ -165,6 +165,8 @@
   bool launcherSwitcherForwardInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool launcherSwitcherPrevInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
   bool launcherSwitcherTerminate(CompAction* action, CompAction::State state, CompOption::Vector& options);
+  bool rightMaximizeKeyInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
+  bool leftMaximizeKeyInitiate(CompAction* action, CompAction::State state, CompOption::Vector& options);
 
   /* handle option changes and change settings inside of the
    * panel and dock views */
 
=== modified file 'plugins/unityshell/unityshell.xml.in'
--- plugins/unityshell/unityshell.xml.in	2013-09-11 19:32:34 +0000
+++ plugins/unityshell/unityshell.xml.in	2013-09-16 16:11:09 +0000
@@ -68,6 +68,18 @@
                     <default>&lt;Alt&gt;F10</default>
                 </option>
 
+                <option name="window_right_maximize" type="key">
+                    <_short>Key to vertically maximize the focused window to the right</_short>
+                    <_long>Semi-maximize vertically the focused window on the half right width of the screen</_long>
+                    <default>&lt;Control&gt;&lt;Super&gt;Right</default>
+                </option>
+
+                <option name="window_left_maximize" type="key">
+                    <_short>Key to vertically maximize the focused window to the left</_short>
+                    <_long>Semi-maximize vertically the focused window to the half left width of the screen</_long>
+                    <default>&lt;Control&gt;&lt;Super&gt;Left</default>
+                </option>
+
                 <option name="panel_opacity" type="float">
                     <_short>Panel Opacity</_short>
                     <_long>The opacity of the Panel background.</_long>
 
=== modified file 'shortcuts/CompizShortcutModeller.cpp'
--- shortcuts/CompizShortcutModeller.cpp	2013-07-07 02:46:28 +0000
+++ shortcuts/CompizShortcutModeller.cpp	2013-09-16 16:11:09 +0000
@@ -32,7 +32,6 @@
   // Compiz' plug-in names
   const std::string CORE_PLUGIN_NAME = "core";
   const std::string EXPO_PLUGIN_NAME = "expo";
-  const std::string GRID_PLUGIN_NAME = "grid";
   const std::string MOVE_PLUGIN_NAME = "move";
   const std::string RESIZE_PLUGIN_NAME = "resize";
   const std::string SCALE_PLUGIN_NAME = "scale";
@@ -41,17 +40,14 @@
 
   // Compiz Core Options
   const std::string CORE_OPTION_SHOW_DESKTOP_KEY = "show_desktop_key";
-  const std::string CORE_OPTION_MAXIMIZE_WINDOW_KEY = "maximize_window_key";
-  const std::string CORE_OPTION_UNMAXIMIZE_OR_MINIMIZE_WINDOW_KEY = "unmaximize_or_minimize_window_key";
+  const std::string CORE_OPTION_MAXIMIZE_KEY = "maximize_window_key";
+  const std::string CORE_OPTION_RESTORE_MINIMIZE_KEY = "unmaximize_or_minimize_window_key";
   const std::string CORE_OPTION_CLOSE_WINDOW_KEY = "close_window_key";
   const std::string CORE_OPTION_WINDOW_MENU_KEY = "window_menu_key";
 
   // Compiz Expo Options
   const std::string EXPO_OPTION_EXPO_KEY = "expo_key";
 
-  // Compiz Grid Options
-  const std::string GRID_OPTION_PUT_LEFT_KEY = "put_left_key";
-
   // Compiz Move Options
   const std::string MOVE_OPTION_INITIATE_BUTTON = "initiate_button";
 
@@ -69,6 +65,10 @@
   const std::string UNITYSHELL_OPTION_PANEL_FIRST_MENU = "panel_first_menu";
   const std::string UNITYSHELL_OPTION_ALT_TAB_FORWARD = "alt_tab_forward";
   const std::string UNITYSHELL_OPTION_ALT_TAB_NEXT_WINDOW = "alt_tab_next_window";
+  const std::string UNITYSHELL_OPTION_MAXIMIZE = "window_maximize";
+  const std::string UNITYSHELL_OPTION_LEFT_MAXIMIZE = "window_left_maximize";
+  const std::string UNITYSHELL_OPTION_RIGHT_MAXIMIZE = "window_right_maximize";
+  const std::string UNITYSHELL_OPTION_RESTORE_MINIMIZE = "window_restore_minimize";
 
   // Compiz Wall Options
   const std::string WALL_OPTION_LEFT_KEY = "left_key";
@@ -304,19 +304,19 @@
                                                    _("Maximises the current window."),
                                                    shortcut::OptionType::COMPIZ_KEY,
                                                    CORE_PLUGIN_NAME,
-                                                   CORE_OPTION_MAXIMIZE_WINDOW_KEY));
+                                                   CORE_OPTION_MAXIMIZE_KEY));
 
   hints.push_back(std::make_shared<shortcut::Hint>(windows, "", "",
                                                    _("Restores or minimises the current window."),
                                                    shortcut::OptionType::COMPIZ_KEY,
                                                    CORE_PLUGIN_NAME,
-                                                   CORE_OPTION_UNMAXIMIZE_OR_MINIMIZE_WINDOW_KEY));
+                                                   CORE_OPTION_RESTORE_MINIMIZE_KEY));
 
   hints.push_back(std::make_shared<shortcut::Hint>(windows, "", _(" or Right"),
                                                    _("Semi-maximise the current window."),
                                                    shortcut::OptionType::COMPIZ_KEY,
-                                                   GRID_PLUGIN_NAME,
-                                                   GRID_OPTION_PUT_LEFT_KEY));
+                                                   UNITYSHELL_PLUGIN_NAME,
+                                                   UNITYSHELL_OPTION_LEFT_MAXIMIZE));
 
   hints.push_back(std::make_shared<shortcut::Hint>(windows, "", "",
                                                    _("Closes the current window."),
@@ -333,7 +333,7 @@
   hints.push_back(std::make_shared<shortcut::Hint>(windows, "", "",
                                                    _("Places the window in corresponding position."),
                                                    shortcut::OptionType::HARDCODED,
-                                                   _("Ctrl + Alt + Num")));
+                                                   _("Ctrl + Alt + Num (keypad)")));
 
   hints.push_back(std::make_shared<shortcut::Hint>(windows, "", _(" Drag"),
                                                    _("Moves the window."),
 
=== added file 'tests/autopilot/unity/tests/test_wm_keybindings.py'
--- tests/autopilot/unity/tests/test_wm_keybindings.py	1970-01-01 00:00:00 +0000
+++ tests/autopilot/unity/tests/test_wm_keybindings.py	2013-09-16 16:11:09 +0000
@@ -0,0 +1,110 @@
+# -*- Mode: Python; coding: utf-8; indent-tabs-mode: nil; tab-width: 4 -*-
+# Copyright 2013 Canonical
+# Author: Marco Trevisan (Treviño)
+#
+# 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.
+
+from __future__ import absolute_import
+
+from autopilot.matchers import Eventually
+from testtools.matchers import Equals, NotEquals
+from unity.tests import UnityTestCase
+
+class WindowManagerKeybindings(UnityTestCase):
+    """Window Manager keybindings tests"""
+
+    scenarios = [('Restored Window', {'start_restored': True}),
+                 ('Maximized Window', {'start_restored': False})]
+
+    def setUp(self):
+        super(WindowManagerKeybindings, self).setUp()
+        self.start_test_window()
+
+    def keybinding_if_not_minimized(self, keybinding):
+        if not self.screen_win.minimized:
+            self.keybinding(keybinding)
+
+    def keybinding_if_not_restored(self, keybinding):
+        if self.screen_win.vertically_maximized or self.screen_win.horizontally_maximized:
+            self.keybinding(keybinding)
+
+    def start_test_window(self, app_name="Character Map"):
+        """Start a restored/maximized window of the requested application"""
+        self.process_manager.close_all_app(app_name)
+        self.bamf_win = self.process_manager.start_app_window(app_name)
+        win_fn = lambda: self.unity.screen.window(self.bamf_win.x_id)
+        self.assertThat(win_fn, Eventually(NotEquals(None)))
+        self.screen_win = win_fn()
+
+        if self.start_restored:
+            if self.screen_win.vertically_maximized or self.screen_win.horizontally_maximized:
+                self.addCleanup(self.keybinding_if_not_minimized, "window/maximize")
+                self.keybinding("window/restore")
+        else:
+            if not self.screen_win.vertically_maximized and not self.screen_win.horizontally_maximized:
+                self.addCleanup(self.keybinding_if_not_restored, "window/restore")
+                self.keybinding("window/maximize")
+
+    def get_window_workarea(self):
+        monitor = self.bamf_win.monitor
+        monitor_geo = self.display.get_screen_geometry(monitor)
+        launcher = self.unity.launcher.get_launcher_for_monitor(monitor)
+        launcher_w = 0 if launcher.hidemode else launcher.geometry[2]
+        panel_h = self.unity.panels.get_panel_for_monitor(monitor).geometry[3]
+        return (monitor_geo[0] + launcher_w, monitor_geo[1] + panel_h,
+                monitor_geo[2] - launcher_w, monitor_geo[3] - panel_h)
+
+    def test_maximize_window(self):
+        if self.start_restored:
+            self.addCleanup(self.keybinding, "window/restore")
+        self.keybinding("window/maximize")
+        self.assertThat(self.screen_win.maximized, Eventually(Equals(True)))
+
+    def test_restore_maximized_window(self):
+        if self.start_restored:
+            self.keybinding("window/maximize")
+        self.keybinding("window/restore")
+        self.assertThat(self.screen_win.maximized, Eventually(Equals(False)))
+        self.assertThat(self.screen_win.minimized, Eventually(Equals(False)))
+
+    def test_restore_vertically_maximized_window(self):
+        if not self.start_restored:
+            self.addCleanup(self.keybinding, "window/maximize")
+            self.keybinding("window/restore")
+        self.keyboard.press_and_release("Ctrl+Super+Right")
+        self.keybinding("window/restore")
+        self.assertThat(self.screen_win.vertically_maximized, Eventually(Equals(False)))
+        self.assertThat(self.screen_win.minimized, Eventually(Equals(False)))
+
+    def test_minimize_restored_window(self):
+        if not self.start_restored:
+            self.addCleanup(self.keybinding_if_not_minimized, "window/maximize")
+            self.keybinding("window/restore")
+        self.keybinding("window/restore")
+        self.assertThat(self.screen_win.minimized, Eventually(Equals(True)))
+
+    def test_left_maximize(self):
+        self.addCleanup(self.keybinding, "window/restore" if self.start_restored else "window/maximize")
+        self.keyboard.press_and_release("Ctrl+Super+Left")
+        self.assertThat(self.screen_win.vertically_maximized, Eventually(Equals(True)))
+        self.assertThat(self.screen_win.horizontally_maximized, Eventually(Equals(False)))
+
+        workarea_geo = self.get_window_workarea()
+        self.assertThat(self.screen_win.x, Eventually(Equals(workarea_geo[0])))
+        self.assertThat(self.screen_win.y, Eventually(Equals(workarea_geo[1])))
+        self.assertThat(self.screen_win.width, Eventually(Equals(workarea_geo[2]/2)))
+        self.assertThat(self.screen_win.height, Eventually(Equals(workarea_geo[3])))
+
+    def test_right_maximize(self):
+        self.addCleanup(self.keybinding, "window/restore" if self.start_restored else "window/maximize")
+        self.keyboard.press_and_release("Ctrl+Super+Right")
+        self.assertThat(self.screen_win.vertically_maximized, Eventually(Equals(True)))
+        self.assertThat(self.screen_win.horizontally_maximized, Eventually(Equals(False)))
+
+        workarea_geo = self.get_window_workarea()
+        self.assertThat(self.screen_win.x, Eventually(Equals(workarea_geo[0]+workarea_geo[2]/2)))
+        self.assertThat(self.screen_win.y, Eventually(Equals(workarea_geo[1])))
+        self.assertThat(self.screen_win.width, Eventually(Equals(workarea_geo[2]/2)))
+        self.assertThat(self.screen_win.height, Eventually(Equals(workarea_geo[3])))
 
=== modified file 'unity-shared/PluginAdapter.cpp'
--- unity-shared/PluginAdapter.cpp	2013-08-08 14:43:50 +0000
+++ unity-shared/PluginAdapter.cpp	2013-09-16 16:11:09 +0000
@@ -461,6 +461,22 @@
   return false;
 }
 
+bool PluginAdapter::IsWindowVerticallyMaximized(Window window_id) const
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    return (window->state() & CompWindowStateMaximizedVertMask);
+
+  return false;
+}
+
+bool PluginAdapter::IsWindowHorizontallyMaximized(Window window_id) const
+{
+  if (CompWindow* window = m_Screen->findWindow(window_id))
+    return (window->state() & CompWindowStateMaximizedHorzMask);
+
+  return false;
+}
+
 unsigned long PluginAdapter::GetMwnDecorations(Window window_id) const
 {
   Display* display = m_Screen->dpy();
@@ -697,6 +713,59 @@
     window->maximize(MAXIMIZE_STATE);
 }
 
+void PluginAdapter::VerticallyMaximizeWindowAt(CompWindow* window, nux::Geometry const& geo)
+{
+  if (window && ((window->type() & CompWindowTypeNormalMask) ||
+      ((window->actions() & CompWindowActionMaximizeVertMask) &&
+        window->actions() & CompWindowActionResizeMask)))
+  {
+    /* First we unmaximize the Window */
+    if (window->state() & MAXIMIZE_STATE)
+      window->maximize(0);
+
+    /* Then we vertically maximize the it so it can be unminimized correctly */
+    if (!(window->state() & CompWindowStateMaximizedVertMask))
+      window->maximize(CompWindowStateMaximizedVertMask);
+
+    /* Then we resize and move it on the requested place */
+    MoveResizeWindow(window->id(), geo);
+  }
+}
+
+void PluginAdapter::LeftMaximize(Window window_id)
+{
+  CompWindow* window = m_Screen->findWindow(window_id);
+
+  if (!window)
+    return;
+
+  /* Let's compute the area where the window should stay */
+  CompRect workarea = m_Screen->getWorkareaForOutput(window->outputDevice());
+  nux::Geometry win_geo(workarea.x() + window->border().left,
+                        workarea.y() + window->border().top,
+                        workarea.width() / 2 - (window->border().left + window->border().right),
+                        workarea.height() - (window->border().top + window->border().bottom));
+
+  VerticallyMaximizeWindowAt(window, win_geo);
+}
+
+void PluginAdapter::RightMaximize(Window window_id)
+{
+  CompWindow* window = m_Screen->findWindow(window_id);
+
+  if (!window)
+    return;
+
+  /* Let's compute the area where the window should stay */
+  CompRect workarea = m_Screen->getWorkareaForOutput(window->outputDevice());
+  nux::Geometry win_geo(workarea.x() + workarea.width() / 2 + window->border().left,
+                        workarea.y() + window->border().top,
+                        workarea.width() / 2 - (window->border().left + window->border().right),
+                        workarea.height() - (window->border().top + window->border().bottom));
+
+  VerticallyMaximizeWindowAt(window, win_geo);
+}
+
 void PluginAdapter::Restore(Window window_id)
 {
   CompWindow* window = m_Screen->findWindow(window_id);
 
=== modified file 'unity-shared/PluginAdapter.h'
--- unity-shared/PluginAdapter.h	2013-08-08 14:43:50 +0000
+++ unity-shared/PluginAdapter.h	2013-09-16 16:11:09 +0000
@@ -130,6 +130,8 @@
 
   // WindowManager implementation
   bool IsWindowMaximized(Window window_id) const;
+  bool IsWindowVerticallyMaximized(Window window_id) const;
+  bool IsWindowHorizontallyMaximized(Window window_id) const;
   bool IsWindowDecorated(Window window_id) const;
   bool IsWindowOnCurrentDesktop(Window window_id) const;
   bool IsWindowObscured(Window window_id) const;
@@ -143,6 +145,8 @@
   bool HasWindowDecorations(Window window_id) const;
 
   void Maximize(Window window_id);
+  void LeftMaximize(Window window_id);
+  void RightMaximize(Window window_id);
   void Restore(Window window_id);
   void RestoreAt(Window window_id, int x, int y);
   void Minimize(Window window_id);
@@ -196,6 +200,8 @@
 
   Window GetTopWindowAbove(Window xid) const;
 
+  void MoveResizeWindow(guint32 xid, nux::Geometry geometry);
+
 protected:
   PluginAdapter(CompScreen* screen);
   void AddProperties(GVariantBuilder* builder);
@@ -215,6 +221,8 @@
   std::string GetUtf8Property(Window xid, Atom atom) const;
   std::vector<long> GetCardinalProperty(Window xid, Atom atom) const;
 
+  void VerticallyMaximizeWindowAt(CompWindow* window, nux::Geometry const& geo);
+
   CompScreen* m_Screen;
   MultiActionList m_ExpoActionList;
   MultiActionList m_ScaleActionList;
 
=== modified file 'unity-shared/StandaloneWindowManager.cpp'
--- unity-shared/StandaloneWindowManager.cpp	2013-08-08 14:43:50 +0000
+++ unity-shared/StandaloneWindowManager.cpp	2013-09-16 16:11:09 +0000
@@ -43,7 +43,8 @@
   , active(false)
   , mapped(true)
   , visible(true)
-  , maximized(false)
+  , v_maximized(false)
+  , h_maximized(false)
   , minimized(false)
   , decorated(true)
   , has_decorations(true)
@@ -67,6 +68,20 @@
 
     return false;
   });
+
+  maximized.SetGetterFunction([this] { return v_maximized && h_maximized; });
+  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()); });
 }
 
 WindowManagerPtr create_window_manager()
@@ -125,6 +140,24 @@
   return false;
 }
 
+bool StandaloneWindowManager::IsWindowVerticallyMaximized(Window window_id) const
+{
+  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;
+}
+
 bool StandaloneWindowManager::IsWindowDecorated(Window window_id) const
 {
   auto window = GetWindowByXid(window_id);
@@ -249,20 +282,51 @@
 {
   auto window = GetWindowByXid(window_id);
   if (window)
-  {
     window->maximized = true;
-    Undecorate(window_id);
-  }
+}
+
+void StandaloneWindowManager::LeftMaximize(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+
+  if (!window)
+    return;
+
+  /* Let's compute the area where the window should be put */
+  auto workarea = GetWorkAreaGeometry(window_id);
+  workarea.width /= 2;
+
+  if (window->maximized)
+    window->maximized = false;
+
+  window->v_maximized = true;
+  MoveResizeWindow(window_id, workarea);
+}
+
+void StandaloneWindowManager::RightMaximize(Window window_id)
+{
+  auto window = GetWindowByXid(window_id);
+
+  if (!window)
+    return;
+
+  /* Let's compute the area where the window should be put */
+  auto workarea = GetWorkAreaGeometry(window_id);
+  workarea.width /= 2;
+  workarea.x += workarea.width;
+
+  if (window->maximized)
+    window->maximized = false;
+
+  window->v_maximized = true;
+  MoveResizeWindow(window_id, workarea);
 }
 
 void StandaloneWindowManager::Restore(Window window_id)
 {
   auto window = GetWindowByXid(window_id);
   if (window)
-  {
     window->maximized = false;
-    Decorate(window_id);
-  }
 }
 
 void StandaloneWindowManager::RestoreAt(Window window_id, int x, int y)
 
=== modified file 'unity-shared/StandaloneWindowManager.h'
--- unity-shared/StandaloneWindowManager.h	2013-08-08 14:43:50 +0000
+++ unity-shared/StandaloneWindowManager.h	2013-09-16 16:11:09 +0000
@@ -48,7 +48,9 @@
   nux::Property<bool> active;
   nux::Property<bool> mapped;
   nux::Property<bool> visible;
-  nux::Property<bool> maximized;
+  nux::RWProperty<bool> maximized;
+  nux::Property<bool> v_maximized;
+  nux::Property<bool> h_maximized;
   nux::Property<bool> minimized;
   nux::Property<bool> decorated;
   nux::Property<bool> has_decorations;
@@ -70,6 +72,8 @@
   std::vector<Window> GetWindowsInStackingOrder() const override;
 
   virtual bool IsWindowMaximized(Window window_id) const;
+  virtual bool IsWindowVerticallyMaximized(Window window_id) const;
+  virtual bool IsWindowHorizontallyMaximized(Window window_id) const;
   virtual bool IsWindowDecorated(Window window_id) const;
   virtual bool IsWindowOnCurrentDesktop(Window window_id) const;
   virtual bool IsWindowObscured(Window window_id) const;
@@ -86,6 +90,8 @@
   virtual bool InShowDesktop() const;
 
   virtual void Maximize(Window window_id);
+  virtual void LeftMaximize(Window window_id);
+  virtual void RightMaximize(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);
 
=== modified file 'unity-shared/WindowManager.h'
--- unity-shared/WindowManager.h	2013-08-08 14:43:50 +0000
+++ unity-shared/WindowManager.h	2013-09-16 16:11:09 +0000
@@ -77,6 +77,9 @@
   virtual std::vector<Window> GetWindowsInStackingOrder() const = 0;
 
   virtual bool IsWindowMaximized(Window window_id) const = 0;
+  virtual bool IsWindowVerticallyMaximized(Window window_id) const = 0;
+  virtual bool IsWindowHorizontallyMaximized(Window window_id) const = 0;
+  virtual bool IsWindowMaximizable(Window window_id) const = 0;
   virtual bool IsWindowDecorated(Window window_id) const = 0;
   virtual bool IsWindowOnCurrentDesktop(Window window_id) const = 0;
   virtual bool IsWindowObscured(Window window_id) const = 0;
@@ -86,13 +89,14 @@
   virtual bool IsWindowClosable(Window window_id) const = 0;
   virtual bool IsWindowMinimized(Window window_id) const = 0;
   virtual bool IsWindowMinimizable(Window window_id) const = 0;
-  virtual bool IsWindowMaximizable(Window window_id) const = 0;
   virtual bool HasWindowDecorations(Window window_id) const = 0;
 
   virtual void ShowDesktop() = 0;
   virtual bool InShowDesktop() const = 0;
 
   virtual void Maximize(Window window_id) = 0;
+  virtual void LeftMaximize(Window window_id) = 0;
+  virtual void RightMaximize(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;