api: deprecate is_positioned in view-mapped

Instead, we can use startup-x and startup-y properties

Author: ammen99

plugins/single_plugins/place.cpp

@@ -1,96 +1,139 @@
 #include "wayfire/signal-provider.hpp"
 #include "wayfire/toplevel-view.hpp"
+#include "wayfire/txn/transaction-manager.hpp"
 #include <wayfire/per-output-plugin.hpp>
 #include <wayfire/view.hpp>
 #include <wayfire/core.hpp>
 #include <wayfire/workarea.hpp>
 #include <wayfire/window-manager.hpp>
 #include <wayfire/signal-definitions.hpp>
 
-class wayfire_place_window : public wf::per_output_plugin_instance_t
+class wayfire_place_cascade_data : public wf::custom_data_t
 {
-    wf::signal::connection_t<wf::view_mapped_signal> on_view_mapped = [=] (wf::view_mapped_signal *ev)
+  public:
+    int x = 0;
+    int y = 0;
+};
+
+class wayfire_place_window : public wf::plugin_interface_t
+{
+    wf::signal::connection_t<wf::txn::new_transaction_signal> on_new_tx =
+        [=] (wf::txn::new_transaction_signal *ev)
     {
-        auto toplevel = wf::toplevel_cast(ev->view);
+        // For each transaction, we need to consider what happens with participating views
+        for (const auto& obj : ev->tx->get_objects())
+        {
+            auto toplevel = std::dynamic_pointer_cast<wf::toplevel_t>(obj);
+            if (!toplevel || !map_pending(toplevel))
+            {
+                continue;
+            }
+
+            auto view = wf::find_view_for_toplevel(toplevel);
+            if (!view || !should_place(view))
+            {
+                continue;
+            }
+        }
+    };
 
-        if (!toplevel || toplevel->parent || toplevel->pending_fullscreen() ||
-            toplevel->pending_tiled_edges() || ev->is_positioned)
+    bool map_pending(std::shared_ptr<wf::toplevel_t> toplevel)
+    {
+        return !toplevel->current().mapped && toplevel->pending().mapped;
+    }
+
+    bool should_place(wayfire_toplevel_view toplevel)
+    {
+        if (toplevel->parent)
         {
-            return;
+            return false;
+        }
+
+        if (toplevel->pending_fullscreen() || toplevel->pending_tiled_edges())
+        {
+            return false;
+        }
+
+        if (toplevel->has_property("startup-x") || toplevel->has_property("startup-y"))
+        {
+            return false;
         }
 
-        ev->is_positioned = true;
+        if (!toplevel->get_output())
+        {
+            return false;
+        }
+
+        return true;
+    }
+
+    void do_place(wayfire_toplevel_view view)
+    {
+        auto output   = view->get_output();
         auto workarea = output->workarea->get_workarea();
 
         std::string mode = placement_mode;
         if (mode == "cascade")
         {
-            cascade(toplevel, workarea);
+            cascade(view, workarea);
         } else if (mode == "maximize")
         {
-            maximize(toplevel, workarea);
+            maximize(view, workarea);
         } else if (mode == "random")
         {
-            random(toplevel, workarea);
+            random(view, workarea);
         } else
         {
-            center(toplevel, workarea);
+            center(view, workarea);
         }
-    };
+    }
 
-    wf::signal::connection_t<wf::workarea_changed_signal> workarea_changed_cb = [=] (auto)
+    void adjust_cascade_for_workarea(nonstd::observer_ptr<wayfire_place_cascade_data> cascade,
+        wf::geometry_t workarea)
     {
-        auto workarea = output->workarea->get_workarea();
-        if ((cascade_x < workarea.x) ||
-            (cascade_x > workarea.x + workarea.width))
+        if ((cascade->x < workarea.x) || (cascade->x > workarea.x + workarea.width))
         {
-            cascade_x = workarea.x;
+            cascade->x = workarea.x;
         }
 
-        if ((cascade_y < workarea.y) ||
-            (cascade_y > workarea.y + workarea.height))
+        if ((cascade->y < workarea.y) || (cascade->y > workarea.y + workarea.height))
         {
-            cascade_y = workarea.y;
+            cascade->y = workarea.y;
         }
-    };
+    }
 
     wf::option_wrapper_t<std::string> placement_mode{"place/mode"};
 
-    int cascade_x, cascade_y;
-
   public:
     void init() override
     {
-        auto workarea = output->workarea->get_workarea();
-        cascade_x = workarea.x;
-        cascade_y = workarea.y;
-
-        output->connect(&workarea_changed_cb);
-        output->connect(&on_view_mapped);
+        wf::get_core().tx_manager->connect(&on_new_tx);
     }
 
-    void cascade(wayfire_toplevel_view & view, wf::geometry_t workarea)
+    void cascade(wayfire_toplevel_view view, wf::geometry_t workarea)
     {
         wf::geometry_t window = view->get_pending_geometry();
+        auto cascade = view->get_output()->get_data_safe<wayfire_place_cascade_data>();
+        adjust_cascade_for_workarea(cascade, workarea);
 
-        if ((cascade_x + window.width > workarea.x + workarea.width) ||
-            (cascade_y + window.height > workarea.y + workarea.height))
+        if ((cascade->x + window.width > workarea.x + workarea.width) ||
+            (cascade->y + window.height > workarea.y + workarea.height))
         {
-            cascade_x = workarea.x;
-            cascade_y = workarea.y;
+            cascade->x = workarea.x;
+            cascade->y = workarea.y;
         }
 
-        view->move(cascade_x, cascade_y);
+        view->toplevel()->pending().geometry.x = cascade->x;
+        view->toplevel()->pending().geometry.y = cascade->y;
 
-        cascade_x += workarea.width * .03;
-        cascade_y += workarea.height * .03;
+        cascade->x += workarea.width * .03;
+        cascade->y += workarea.height * .03;
     }
 
     void random(wayfire_toplevel_view & view, wf::geometry_t workarea)
     {
         wf::geometry_t window = view->get_pending_geometry();
         wf::geometry_t area;
-        int pos_x, pos_y;
 
         area.x     = workarea.x;
         area.y     = workarea.y;
@@ -104,18 +147,15 @@ class wayfire_place_window : public wf::per_output_plugin_instance_t
             return;
         }
 
-        pos_x = rand() % area.width + area.x;
-        pos_y = rand() % area.height + area.y;
-
-        view->move(pos_x, pos_y);
+        view->toplevel()->pending().geometry.x = rand() % area.width + area.x;
+        view->toplevel()->pending().geometry.y = rand() % area.height + area.y;
     }
 
     void center(wayfire_toplevel_view & view, wf::geometry_t workarea)
     {
         wf::geometry_t window = view->get_pending_geometry();
-        window.x = workarea.x + (workarea.width / 2) - (window.width / 2);
-        window.y = workarea.y + (workarea.height / 2) - (window.height / 2);
-        view->move(window.x, window.y);
+        view->toplevel()->pending().geometry.x = workarea.x + (workarea.width / 2) - (window.width / 2);
+        view->toplevel()->pending().geometry.y = workarea.y + (workarea.height / 2) - (window.height / 2);
     }
 
     void maximize(wayfire_toplevel_view & view, wf::geometry_t workarea)

src/api/wayfire/signal-definitions.hpp

@@ -348,6 +348,7 @@ struct view_mapped_signal
     wayfire_view view;
 
     /* Indicates whether the position already has its initial position */
+    [[deprecated("Use startup-x and startup-y properties instead")]]
     bool is_positioned = false;
 };
 

src/api/wayfire/view-helpers.hpp

@@ -5,6 +5,7 @@
 #include "wayfire/scene.hpp"
 #include <initializer_list>
 #include <wayfire/view.hpp>
+#include <wayfire/toplevel-view.hpp>
 
 // This file contains helper functions which are helpful when working with views. Most of the operations are
 // simply wrappers around more low-level functionality provided by views, scenegraph, etc.
@@ -47,7 +48,9 @@ wayfire_toplevel_view find_topmost_parent(wayfire_toplevel_view v);
 namespace view_implementation
 {
 void emit_toplevel_state_change_signals(wayfire_toplevel_view view, const wf::toplevel_state_t& old_state);
+[[deprecated("has position has been deprecated, use emit_view_map_signal(wayfire_view) instead")]]
 void emit_view_map_signal(wayfire_view view, bool has_position);
+void emit_view_map_signal(wayfire_view view);
 void emit_ping_timeout_signal(wayfire_view view);
 void emit_geometry_changed_signal(wayfire_toplevel_view view, wf::geometry_t old_geometry);
 void emit_title_changed_signal(wayfire_view view);

src/view/compositor-view.cpp

@@ -119,7 +119,7 @@ std::shared_ptr<wf::color_rect_view_t> wf::color_rect_view_t::create(view_role_t
         }
     }
 
-    wf::view_implementation::emit_view_map_signal(self, true);
+    wf::view_implementation::emit_view_map_signal(self);
     return self;
 }
 

src/view/view-impl.cpp

@@ -11,7 +11,7 @@
 #include "wayfire/output-layout.hpp"
 #include "wayfire/window-manager.hpp"
 #include "wayfire/workarea.hpp"
-#include "wayfire/workspace-set.hpp"
+#include "wayfire/workspace-set.hpp" // IWYU pragma: keep
 #include <memory>
 #include <wayfire/util/log.hpp>
 #include <wayfire/view-helpers.hpp>
@@ -32,6 +32,20 @@ void wf::view_implementation::emit_view_map_signal(wayfire_view view, bool has_p
     wf::get_core().emit(&data);
 }
 
+void wf::view_implementation::emit_view_map_signal(wayfire_view view)
+{
+    wf::view_mapped_signal data;
+    data.view = view;
+
+    view->emit(&data);
+    if (view->get_output())
+    {
+        view->get_output()->emit(&data);
+    }
+
+    wf::get_core().emit(&data);
+}
+
 void wf::view_implementation::emit_ping_timeout_signal(wayfire_view view)
 {
     wf::view_ping_timeout_signal data;
@@ -56,7 +70,7 @@ void wf::view_implementation::emit_geometry_changed_signal(wayfire_toplevel_view
 
 void wf::view_interface_t::emit_view_map()
 {
-    view_implementation::emit_view_map_signal(self(), false);
+    view_implementation::emit_view_map_signal(self());
 }
 
 void wf::view_interface_t::emit_view_unmap()

src/view/xwayland/xwayland-toplevel-view.hpp

@@ -53,9 +53,12 @@ class wayfire_xwayland_view : public wf::toplevel_view_interface_t, public wayfi
             wlr_xwayland_surface_configure(xw, ev->x, ev->y, ev->width, ev->height);
             if ((ev->mask & XCB_CONFIG_WINDOW_X) && (ev->mask & XCB_CONFIG_WINDOW_Y))
             {
-                this->self_positioned = true;
-                toplevel->pending().geometry.x = ev->x - output_origin.x;
-                toplevel->pending().geometry.y = ev->y - output_origin.y;
+                int sx = ev->x - output_origin.x;
+                int sy = ev->y - output_origin.y;
+                this->set_property<int>("startup-x", sx);
+                this->set_property<int>("startup-y", sy);
+                toplevel->pending().geometry.x = sx;
+                toplevel->pending().geometry.y = sy;
             }
 
             return;
@@ -305,8 +308,7 @@ class wayfire_xwayland_view : public wf::toplevel_view_interface_t, public wayfi
          * manager determine this. We try to heuristically guess which of the
          * two cases we're dealing with by checking whether we have received
          * a valid ConfigureRequest before mapping */
-        bool client_self_positioned = self_positioned;
-        wf::view_implementation::emit_view_map_signal(self(), client_self_positioned);
+        wf::view_implementation::emit_view_map_signal(self());
     }
 
     void store_xw_geometry_unmapped()

src/view/xwayland/xwayland-view-base.hpp

@@ -19,9 +19,6 @@ class wayfire_xwayland_view_internal_base : public wf::xwayland_view_base_t
   protected:
     wf::wl_listener_wrapper on_configure;
 
-    /** The geometry requested by the client */
-    bool self_positioned = false;
-
   public:
     wayfire_xwayland_view_internal_base(wlr_xwayland_surface *xww) : xwayland_view_base_t(xww)
     {}