strata-shell: Added support for window resize.

Author: sleepy-monax

project.lock

@@ -47,12 +47,12 @@
             "tag": "main"
         },
         "skift-org/hideo": {
-            "commit": "49bce7e695d1801c17e3e394010586b6bf99461e",
+            "commit": "d48f33ae1ed8c43a5c59aed9a3defb107c6fbb4b",
             "git": "https://github.com/skift-org/hideo.git",
             "tag": "main"
         },
         "skift-org/karm": {
-            "commit": "91b368c73f1f09e313660982d84a37a37b034e21",
+            "commit": "f215f08199b37862d8e95e05a4eceeccba1c1142",
             "git": "https://github.com/skift-org/karm.git",
             "tag": "main"
         },

src/impls/impl-skift/app/app.cpp

@@ -8,6 +8,7 @@ import Karm.Core;
 import Karm.Gfx;
 import Karm.Sys;
 import Strata.Protos;
+import Karm.Logger;
 
 namespace Karm::App::_Embed {
 
@@ -19,6 +20,7 @@ struct SkiftWindow : Window {
     Rc<Strata::Protos::Surface> _surface;
     bool _dirty = false;
     bool _closed = false;
+    Opt<Math::Vec2i> _shouldResize;
 
     SkiftWindow(SkiftApplication& application, Strata::IShell::WindowId id, Rc<Strata::Protos::Surface> surface)
         : _application(application), _id(id), _surface(surface) {}
@@ -72,8 +74,6 @@ struct SkiftApplication : Application {
     }
 
     Async::Task<Rc<Window>> createWindowAsync(WindowProps const& props, Async::CancellationToken ct) override {
-        // NOTE: The Window API is synchronous, but Strata is async.
-        // We use Sys::run to block until the window is created by the shell.
         auto [id, actual] = co_trya$(_endpoint->callAsync(
             _shell,
             Strata::IShell::WindowCreate{
@@ -102,23 +102,38 @@ struct SkiftApplication : Application {
         co_return Ok(window);
     }
 
-    void pollMessage(Rc<Handler> handler) {
-        while (auto maybeMessage = _endpoint->tryRecv()) {
-            if (maybeMessage->is<Strata::IShell::WindowEvent>()) {
-                auto m = maybeMessage->unpack<Strata::IShell::WindowEvent>().unwrap();
-                auto windowId = WindowId{m.window};
-
-                m.event.visit([&](auto const& event) {
-                    using T = Meta::RemoveConstVolatileRef<decltype(event)>;
-
-                    if constexpr (Meta::Contains<T, MouseEvent, KeyboardEvent, TypeEvent>) {
-                        handler->handle<T>(windowId, event);
-                    } else if constexpr (Meta::Same<T, RequestCloseEvent>) {
-                        _exited = true;
-                    }
-                });
+    Res<> _handleWindowEvent(Sys::Message& message, Rc<Handler> handler) {
+        auto [windowId, payload] = try$(message.unpack<Strata::IShell::WindowEvent>());
+        payload.visit([&]<typename E>(E const& event) {
+            using T = Meta::RemoveConstVolatileRef<E>;
+
+            if constexpr (Meta::Contains<T, MouseEvent, KeyboardEvent, TypeEvent>) {
+                handler->handle<T>(App::WindowId{windowId}, event);
+            } else if constexpr (Meta::Same<T, RequestCloseEvent>) {
+                _exited = true;
             }
+        });
+        return Ok();
+    }
+
+    Res<> _handleWindowUpdate(Sys::Message& message) {
+        auto [windowId, props] = try$(message.unpack<Strata::IShell::WindowUpdate>());
+        auto* window = try$(_windows.tryGet(windowId).okOr(Error::invalidInput("no such window")));
+        // FIXME: We should probably have a separated hello message that pass stuff like color scheme and form factor
+        App::formFactor = props.formFactor;
+        window->_shouldResize = props.size;
+        return Ok();
+    }
+
+    Res<> _pollMessages(Rc<Handler> handler) {
+        while (auto maybeMessage = _endpoint->tryRecv()) {
+            auto& message = maybeMessage.unwrap();
+            if (message.is<Strata::IShell::WindowEvent>())
+                try$(_handleWindowEvent(message, handler));
+            else if (message.is<Strata::IShell::WindowUpdate>())
+                try$(_handleWindowUpdate(message));
         }
+        return Ok();
     }
 
     bool exited() {
@@ -128,15 +143,45 @@ struct SkiftApplication : Application {
         return true;
     }
 
+    Async::Task<> _handleWindowResizeAsync(Rc<Handler> handler, Async::CancellationToken ct) {
+        for (auto [id, window] : _windows.iterUnordered()) {
+            if (not window->_shouldResize)
+                continue;
+
+            auto size = window->_shouldResize.unwrap();
+            logDebug("new size {}", size);
+
+            auto newSurface = co_try$(Strata::Protos::Surface::create(size));
+
+            co_trya$(_endpoint->callAsync(
+                _shell,
+                Strata::IShell::WindowAttach{
+                    id,
+                    newSurface,
+                },
+                ct
+            ));
+
+            window->_surface = newSurface;
+            window->_shouldResize = NONE;
+            handler->handle<ResizeEvent>(window->id(), size);
+        }
+
+        co_return Ok();
+    }
+
     Async::Task<> runAsync(Rc<Handler> handler, Async::CancellationToken ct) override {
         Duration const frameDuration = Duration::fromMSecs(16);
         Instant nextFrameTime = Sys::instant();
 
         while (not exited()) {
             nextFrameTime = nextFrameTime + frameDuration;
 
-            pollMessage(handler);
+            if (auto res = _pollMessages(handler); not res) {
+                logError("failed to pull message from server: {}", res);
+            }
 
+            co_trya$(_handleWindowResizeAsync(handler, ct));
             handler->update();
 
             for (auto [id, window] : _windows.iterUnordered()) {

src/srvs/strata-protos/ishell.cpp

@@ -40,7 +40,7 @@ export struct WindowAttach {
 
 export struct WindowEvent {
     WindowId window;
-    Union<None, App::MouseEvent> event;
+    Union<None, App::MouseEvent, App::KeyboardEvent> event;
 };
 
 export struct WindowFlip {

src/srvs/strata-shell/main.cpp

@@ -129,9 +129,33 @@ struct ClientWindow : Hideo::Shell::Window {
             (void)_endpoint.send(_client, IShell::WindowEvent{_windowId, *it});
     }
 
+    void resize(Math::Vec2i size) override {
+        if (size != bound.wh) {
+            logDebug("resize: {}", size);
+            _frontbuffer = Gfx::Surface::alloc(size);
+            (void)_endpoint.send(
+                _client,
+                IShell::WindowUpdate{
+                    _windowId,
+                    {
+                        .size = size,
+                        .formFactor = App::formFactor,
+                    },
+                }
+            );
+        }
+        Window::resize(size);
+    }
+
     void attach(Rc<Protos::Surface> backbuffer) {
         _backbuffer = backbuffer;
-        Gfx::blitUnsafe(_frontbuffer->mutPixels(), _backbuffer.unwrap()->pixels());
+        flip();
+    }
+
+    void flip() {
+        // FIXME: Only blit the region that was updated
+        auto region = _frontbuffer->mutPixels().bound().clipTo(_backbuffer.unwrap()->pixels().bound());
+        Gfx::blitUnsafe(_frontbuffer->mutPixels().clip(region), _backbuffer.unwrap()->pixels().clip(region));
     }
 };
 
@@ -230,6 +254,7 @@ struct Server {
 
         auto instance = makeRc<ClientWindow>(_endpoint, message.header().from, windowSurface);
         instance->bound = Math::Recti{want.size}.center(_framebuffer->bound());
+        instance->_windowId = windowId;
         _windows.put(windowId, instance);
         Hideo::Shell::Model::event(*_root, Hideo::Shell::AddInstance{instance});
 
@@ -265,8 +290,7 @@ struct Server {
         auto [windowId, region] = try$(message.unpack<IShell::WindowFlip>());
 
         auto instance = _windows.get(windowId);
-        // FIXME: Only blit the region that was updated
-        Gfx::blitUnsafe(instance->_frontbuffer->mutPixels(), instance->_backbuffer.unwrap()->pixels());
+        instance->flip();
         Ui::shouldRepaint(*_root);
 
         return Ok();