Subsurface ordering

src/server/frontend_wayland/wl_subcompositor.cpp

@@ -137,14 +137,22 @@ void mf::WlSubsurface::set_position(int32_t x, int32_t y)
 
 void mf::WlSubsurface::place_above(struct wl_resource* sibling)
 {
-    (void)sibling;
-    log_warning("TODO: wl_subsurface.place_above not implemented");
+    if (parent)
+    {
+        auto const sibling_surface = WlSurface::from(sibling);
+        parent.value().reorder_subsurface(this, sibling_surface, true);
+    }
+    surface->pending_invalidate_surface_data();
 }
 
 void mf::WlSubsurface::place_below(struct wl_resource* sibling)
 {
-    (void)sibling;
-    log_warning("TODO: wl_subsurface.place_below not implemented");
+    if (parent)
+    {
+        auto const sibling_surface = WlSurface::from(sibling);
+        parent.value().reorder_subsurface(this, sibling_surface, false);
+    }
+    surface->pending_invalidate_surface_data();
 }
 
 void mf::WlSubsurface::set_sync()

src/server/frontend_wayland/wl_subcompositor.h

@@ -67,6 +67,8 @@ class WlSubsurface: public WlSurfaceRole, wayland::Subsurface
 
     auto subsurface_at(geometry::Point point) -> std::optional<WlSurface*>;
 
+    WlSurface* const surface;
+
 private:
     void set_position(int32_t x, int32_t y) override;
     void place_above(struct wl_resource* sibling) override;
@@ -78,7 +80,6 @@ class WlSubsurface: public WlSurfaceRole, wayland::Subsurface
     virtual void commit(WlSurfaceState const& state) override;
     void surface_destroyed() override;
 
-    WlSurface* const surface;
     /// This class is responsible for removing itself from the parent's children list when needed
     wayland::Weak<WlSurface> const parent;
     bool synchronized_;

src/server/frontend_wayland/wl_surface.cpp

@@ -96,6 +96,7 @@ mf::WlSurface::WlSurface(
         null_role{this},
         role{&null_role}
 {
+    children.push_back(nullptr);
     // wl_surface is specified to act in mailbox mode
     stream->allow_framedropping(true);
 }
@@ -131,10 +132,15 @@ auto mf::WlSurface::subsurface_at(geom::Point point) -> std::optional<WlSurface*
     }
     point = point - offset_;
     // loop backwards so the first subsurface we find that accepts the input is the topmost one
-    for (auto child_it = children.rbegin(); child_it != children.rend(); ++child_it)
+    for (auto const& child : children)
     {
-        if (auto result = (*child_it)->subsurface_at(point))
-            return result;
+        if (child)
+        {
+            if (auto const result = child->subsurface_at(point))
+            {
+                return result;
+            }
+        }
     }
     geom::Rectangle surface_rect = {geom::Point{}, buffer_size_.value_or(geom::Size{})};
     for (auto& rect : input_shape.value_or(std::vector<geom::Rectangle>{surface_rect}))
@@ -181,6 +187,11 @@ void mf::WlSurface::set_pending_offset(std::optional<geom::Displacement> const&
 
 void mf::WlSurface::add_subsurface(WlSubsurface* child)
 {
+    if (!child)
+    {
+        // Unlikely, but resulting error would be hard to catch otherwise
+        fatal_error("subsurface null");
+    }
     if (std::find(children.begin(), children.end(), child) != children.end())
     {
         log_warning("Subsurface %p added to surface %p multiple times", static_cast<void*>(child), static_cast<void*>(this));
@@ -192,6 +203,11 @@ void mf::WlSurface::add_subsurface(WlSubsurface* child)
 
 void mf::WlSurface::remove_subsurface(WlSubsurface* child)
 {
+    if (!child)
+    {
+        // Unlikely, but resulting error would be hard to catch otherwise
+        fatal_error("subsurface null");
+    }
     children.erase(
         std::remove(
             children.begin(),
@@ -200,6 +216,26 @@ void mf::WlSurface::remove_subsurface(WlSubsurface* child)
         children.end());
 }
 
+void mf::WlSurface::reorder_subsurface(WlSubsurface* child, WlSurface* sibling, bool above)
+{
+    if (!child)
+    {
+        // Unlikely, but resulting error would be hard to catch otherwise
+        fatal_error("subsurface null");
+    }
+    auto iter = std::find_if(begin(children), end(children), [&](WlSubsurface* subsurface)
+        {
+            auto const surface = subsurface ? subsurface->surface : this;
+            return surface == sibling;
+        });
+    if (!above)
+    {
+        // place below
+        iter--;
+    }
+    children.insert(iter, child);
+}
+
 void mf::WlSurface::refresh_surface_data_now()
 {
     role->refresh_surface_data_now();
@@ -211,6 +247,14 @@ void mf::WlSurface::populate_surface_data(std::vector<shell::StreamSpecification
 {
     geometry::Displacement offset = parent_offset + offset_;
 
+    // Loops through all children until the nullptr that represents the current (parent) surface
+    auto child_it = begin(children);
+    for (; *child_it; child_it++)
+    {
+        (*child_it)->populate_surface_data(buffer_streams, input_shape_accumulator, offset);
+    }
+    child_it++;
+
     buffer_streams.push_back(msh::StreamSpecification{stream, offset, {}});
     geom::Rectangle surface_rect = {geom::Point{} + offset, buffer_size_.value_or(geom::Size{})};
     if (input_shape)
@@ -236,9 +280,10 @@ void mf::WlSurface::populate_surface_data(std::vector<shell::StreamSpecification
         input_shape_accumulator.push_back(surface_rect);
     }
 
-    for (WlSubsurface* subsurface : children)
+    // Loop through remaining subsurfaces
+    for (; child_it != end(children); child_it++)
     {
-        subsurface->populate_surface_data(buffer_streams, input_shape_accumulator, offset);
+        (*child_it)->populate_surface_data(buffer_streams, input_shape_accumulator, offset);
     }
 }
 
@@ -412,7 +457,10 @@ void mf::WlSurface::commit(WlSurfaceState const& state)
 
     for (WlSubsurface* child: children)
     {
-        child->parent_has_committed();
+        if (child)
+        {
+            child->parent_has_committed();
+        }
     }
 }
 

src/server/frontend_wayland/wl_surface.h

@@ -130,6 +130,8 @@ class WlSurface : public wayland::Surface
     void set_pending_offset(std::optional<geometry::Displacement> const& offset);
     void add_subsurface(WlSubsurface* child);
     void remove_subsurface(WlSubsurface* child);
+    /// Place a subsurface directly above or below the sibling surface
+    void reorder_subsurface(WlSubsurface* child, WlSurface* sibling, bool above);
     void refresh_surface_data_now();
     void pending_invalidate_surface_data() { pending.invalidate_surface_data(); }
     void populate_surface_data(std::vector<shell::StreamSpecification>& buffer_streams,
@@ -150,7 +152,8 @@ class WlSurface : public wayland::Surface
 
     NullWlSurfaceRole null_role;
     WlSurfaceRole* role;
-    std::vector<WlSubsurface*> children; // ordering is from bottom to top
+    /// Ordering is from bottom to top. A null value represents the parent (this surface)
+    std::vector<WlSubsurface*> children;
 
     WlSurfaceState pending;
     geometry::Displacement offset_;