Merge lp:~alan-griffiths/miral/improved-tiling-wm into lp:miral

[Alan Griffiths]

[miral-shell --window-manager tiling] implement the layout suggested in "Tasks for the interested reader"

[Gerry Boland (gerboland)]

Works as suggested

review: Approve

[lp:~alan-griffiths/miral/improved-tiling-wm]

441. By Alan Griffiths on 2016-11-10

[miral-shell --window-manager tiling] implement the layout suggested in "Tasks for the interested reader"

=== modified file 'miral-shell/tiling_window_manager.cpp'
--- miral-shell/tiling_window_manager.cpp	2016-10-10 10:43:42 +0000
+++ miral-shell/tiling_window_manager.cpp	2016-11-09 12:42:38 +0000
@@ -35,17 +35,37 @@
 struct TilingWindowManagerPolicyData
 {
     Rectangle tile;
+    Rectangle old_tile;
 };
 
-inline Rectangle& tile_for(miral::ApplicationInfo& app_info)
-{
-    return std::static_pointer_cast<TilingWindowManagerPolicyData>(app_info.userdata())->tile;
-}
-
-inline Rectangle const& tile_for(miral::ApplicationInfo const& app_info)
-{
-    return std::static_pointer_cast<TilingWindowManagerPolicyData>(app_info.userdata())->tile;
-}
+template<class Info>
+inline Rectangle& tile_for(Info& info)
+{
+    return std::static_pointer_cast<TilingWindowManagerPolicyData>(info.userdata())->tile;
+}
+
+template<class Info>
+inline Rectangle const& tile_for(Info const& info)
+{
+    return std::static_pointer_cast<TilingWindowManagerPolicyData>(info.userdata())->tile;
+}
+}
+
+void TilingWindowManagerPolicy::MRUTileList::push(std::shared_ptr<void> const& tile)
+{
+    tiles.erase(remove(begin(tiles), end(tiles), tile), end(tiles));
+    tiles.push_back(tile);
+}
+
+void TilingWindowManagerPolicy::MRUTileList::erase(std::shared_ptr<void> const& tile)
+{
+    tiles.erase(remove(begin(tiles), end(tiles), tile), end(tiles));
+}
+
+void TilingWindowManagerPolicy::MRUTileList::enumerate(Enumerator const& enumerator) const
+{
+    for (auto i = tiles.rbegin(); i != tiles.rend(); ++i)
+        enumerator(const_cast<std::shared_ptr<void> const&>(*i));
 }
 
 // Demonstrate implementing a simple tiling algorithm
@@ -95,6 +115,7 @@
 {
     auto parameters = request_parameters;
 
+    parameters.userdata() = app_info.userdata();
     parameters.state() = parameters.state().is_set() ?
                          transform_set_state(parameters.state().value()) : mir_surface_state_restored;
 
@@ -126,13 +147,29 @@
 
 void TilingWindowManagerPolicy::advise_new_window(WindowInfo const& window_info)
 {
-    if (spinner.session() == window_info.window().application())
-        dirty_tiles = true;
+    if (window_info.type() == mir_surface_type_normal &&
+        !window_info.parent() &&
+        window_info.state() == mir_surface_state_restored)
+    {
+        WindowSpecification specification;
+
+        specification.state() = mir_surface_state_maximized;
+
+        tools.place_and_size_for_state(specification, window_info);
+        constrain_size_and_place(specification, window_info.window(), tile_for(window_info));
+        tools.modify_window(window_info.window(), specification);
+    }
 }
 
 void TilingWindowManagerPolicy::handle_window_ready(WindowInfo& window_info)
 {
     tools.select_active_window(window_info.window());
+
+    if (spinner.session() != window_info.window().application())
+    {
+        tiles.push(window_info.userdata());
+        dirty_tiles = true;
+    }
 }
 
 namespace
@@ -149,7 +186,7 @@
     miral::WindowSpecification const& modifications)
 {
     auto const window = window_info.window();
-    auto const tile = tile_for(tools.info_for(window.application()));
+    auto const tile = tile_for(window_info);
     auto mods = modifications;
 
     constrain_size_and_place(mods, window, tile);
@@ -426,24 +463,51 @@
 
     auto index = 0;
 
+    if (applications < 3)
+    {
+        tiles.enumerate([&](std::shared_ptr<void> const& userdata)
+            {
+                auto const tile_data = std::static_pointer_cast<TilingWindowManagerPolicyData>(userdata);
+                tile_data->old_tile = tile_data->tile;
+
+                auto const x = (total_width * index) / applications;
+                ++index;
+                auto const dx = (total_width * index) / applications - x;
+
+                tile_data->tile = Rectangle{{x,  0}, {dx, total_height}};
+            });
+    }
+    else
+    {
+        tiles.enumerate([&](std::shared_ptr<void> const& userdata)
+            {
+                auto const tile_data = std::static_pointer_cast<TilingWindowManagerPolicyData>(userdata);
+                tile_data->old_tile = tile_data->tile;
+
+                auto const dx = total_width/2;
+                if (!index)
+                {
+                    tile_data->tile = Rectangle{{0,  0}, {dx, total_height}};
+                }
+                else
+                {
+                    auto const x = dx;
+                    auto const y = total_height*(index-1) / (applications-1);
+                    auto const dy = total_height / (applications-1);
+                    tile_data->tile = Rectangle{{x,  y}, {dx, dy}};
+                }
+
+                ++index;
+            });
+    }
+
     tools.for_each_application([&](ApplicationInfo& info)
         {
             if (spinner.session() == info.application())
                 return;
 
-            auto& tile = tile_for(info);
-
-            auto const x = (total_width * index) / applications;
-            ++index;
-            auto const dx = (total_width * index) / applications - x;
-
-            auto const old_tile = tile;
-            Rectangle const new_tile{{x,  0},
-                                     {dx, total_height}};
-
-            update_surfaces(info, old_tile, new_tile);
-
-            tile = new_tile;
+            auto const tile_data = std::static_pointer_cast<TilingWindowManagerPolicyData>(info.userdata());
+            update_surfaces(info, tile_data->old_tile, tile_data->tile);
         });
 }
 
@@ -524,6 +588,11 @@
         if (spinner_info.windows().size() > 0)
             tools.raise_tree(spinner_info.windows()[0]);
     }
+    else
+    {
+        tiles.push(info.userdata());
+        dirty_tiles = true;
+    }
 }
 
 void TilingWindowManagerPolicy::advise_new_app(miral::ApplicationInfo& application)
@@ -532,6 +601,7 @@
         return;
 
     application.userdata(std::make_shared<TilingWindowManagerPolicyData>());
+    tiles.push(application.userdata());
     dirty_tiles = true;
 }
 
@@ -540,6 +610,7 @@
     if (spinner.session() == application.application())
         return;
 
+    tiles.erase(application.userdata());
     dirty_tiles = true;
 }
 void TilingWindowManagerPolicy::advise_end()

=== modified file 'miral-shell/tiling_window_manager.h'
--- miral-shell/tiling_window_manager.h	2016-10-10 10:43:42 +0000
+++ miral-shell/tiling_window_manager.h	2016-11-09 12:42:38 +0000
@@ -29,6 +29,10 @@
 #include <mir/geometry/displacement.h>
 #include <miral/internal_client.h>
 
+
+#include <functional>
+#include <vector>
+
 using namespace mir::geometry;
 
 // Demonstrate implementing a simple tiling algorithm
@@ -107,6 +111,24 @@
     Rectangles displays;
     bool dirty_tiles = false;
 
+    class MRUTileList
+    {
+    public:
+
+        void push(std::shared_ptr<void> const& tile);
+        void erase(std::shared_ptr<void> const& tile);
+        auto top() const -> std::shared_ptr<void> const&;
+
+        using Enumerator = std::function<void(std::shared_ptr<void> const& tile)>;
+
+        void enumerate(Enumerator const& enumerator) const;
+
+    private:
+        std::vector<std::shared_ptr<void>> tiles;
+    };
+
+    MRUTileList tiles;
+
     // These two variables are used by the advise_display methods which are
     // NOT guarded by the usual WM mutex
     bool dirty_displays = false;

=== modified file 'tasks_for_the_interested_reader.md'
--- tasks_for_the_interested_reader.md	2016-10-20 20:47:13 +0000
+++ tasks_for_the_interested_reader.md	2016-11-09 12:42:38 +0000
@@ -79,22 +79,6 @@
 possible, without much consideration of being useful. Here are some suggestions
 for a better approach:
 
- - top level windows ought to fill the tile when created
- 
- - the tiling algorithm ought to lay windows out as follows:
- 
-    - Single window: takes up the whole screen
-    
-    - Two windows: The screen is split in two tiles of equal width (half the
-      screen’s width) and full height. Each window is placed in a tile (left
-      or right), with the newest window occupying the left tile.
-      
-    - Three or more windows: The screen is split in two tiles of equal width
-      and full height, as in the previous case. The newest window occupies
-      the left tile. The right part is now further divided vertically into
-      smaller tiles having equal height, to host the remaining windows, with
-      older windows being closer to the bottom.
-
  - Add a titlebar to the top of the screen. The titlebar should be split evenly
    into horizontal blocks, one per tile. Each block containing the title of the
    top-level window. The focussed tile is highlighted. Clicking on a title