roxane 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0ef9393493008dcc4763293fa6ebd36ebb6fdd891b1e2358100eb442ed729ec
-  data.tar.gz: 1fbfe739d81d37b48fcaf9ac428db7d60319c864a63e6b3a9ef9819cb305a65f
+  metadata.gz: 949821f1324cd761b172fc4b4f7519459b3d70c3a53db0bc9ba3ad694ffe3e80
+  data.tar.gz: dd6ea3c05680732a4c6d8cb08702626735675b2035d6cdc1c7822a08e43fac93
 SHA512:
-  metadata.gz: 2a84c3f0dc6f20488b7d1bfea51a327fafa1b77e4cd393685645b64e843dc8609c3eeb2a5fc6ab7cff8ec810610cd36afafc8766860003732073b8111464e11f
-  data.tar.gz: 100d61215f9c9c821da5c76648ac6bebd4b59a19aabf342f8928246fe8530243730a73128c013cdb094d3555f4d9933e5bb5e1ff115b2506dcbdcb4891bb4a8c
+  metadata.gz: edbfde719e7560dcd6f2e68c8509be66d44118035fe02009f6d285482583abf14c5f6bcdfc8bb577c62f60db7cd615c720b9ca18f13c7259269fb8bb52b341bf
+  data.tar.gz: c70573dc5ad95b1d59ab06ed5714dd88a420410857e5c3fcad2c974834429f19a8679a85b2933408a40f821374064ea675d6f3980e3f7f93a9d720797fdaf243

data/README.md

@@ -65,6 +65,15 @@ rake test       # host: unit tests only (the asset server); the windowed
                 # smoke test self-skips unless ROXANE_INTEGRATION=1
 ```
 
+## Linux / Wayland note (window size)
+
+On GTK3, upstream `libwebview` implements `WEBVIEW_HINT_NONE` with
+`gtk_window_resize`. Under Wayland that does **not** set the initial xdg
+geometry, so floating compositors (e.g. Hyprland) often map the window at a
+tiny 200×200 square; GNOME hides the same bug. Roxane compensates on Linux by
+calling `gtk_window_set_default_size` and briefly pinning a size-request through
+first map (then releasing it so the window stays resizable).
+
 ## Status
 
 Early but working. The runtime (window + system webview + invoke/emit bridge +

data/lib/roxane/gtk.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Roxane
+  # Direct GTK3 bindings for window-size affordances the webview C API gets wrong
+  # on Wayland. libwebview 0.12 (GTK3) implements WEBVIEW_HINT_NONE with
+  # gtk_window_resize only; on Wayland that does not set the initial xdg
+  # geometry, so the client commits 200×200 and floating compositors (Hyprland,
+  # etc.) keep the tiny square. GNOME/Mutter is more forgiving, which hides the
+  # bug there. GTK4 webview already uses gtk_window_set_default_size — we do the
+  # same from Ruby, plus a brief size-request so the first map advertises the
+  # right min/geometry, then release it so the window stays user-resizable.
+  #
+  # Where libgtk-3 isn't loadable (macOS/Windows — their backends are separate),
+  # AVAILABLE is false and callers no-op.
+  module Gtk
+    extend ::FFI::Library
+
+    begin
+      ffi_lib "libgtk-3.so.0"
+      attach_function :gtk_window_set_default_size, [:pointer, :int, :int], :void
+      attach_function :gtk_window_resize, [:pointer, :int, :int], :void
+      attach_function :gtk_widget_set_size_request, [:pointer, :int, :int], :void
+      attach_function :gtk_widget_get_realized, [:pointer], :int
+      AVAILABLE = true
+    rescue LoadError, ::FFI::NotFoundError
+      AVAILABLE = false
+    end
+  end
+end

data/lib/roxane/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Roxane
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/roxane/webkit.rb

@@ -19,10 +19,11 @@ module Roxane
     end
   end
 
-  # GLib main-loop scheduling. g_idle_add is thread-safe and runs the callback
-  # as a TOP-LEVEL main-loop iteration — a clean stack, never nested inside a
-  # webview dispatch callback (layout-triggering WebKit calls made from inside
-  # one can reenter the engine and crash; see the zoom work, 2026-07-03).
+  # GLib main-loop scheduling. g_idle_add / g_timeout_add are thread-safe and
+  # run the callback as a TOP-LEVEL main-loop iteration — a clean stack, never
+  # nested inside a webview dispatch callback (layout-triggering WebKit calls
+  # made from inside one can reenter the engine and crash; see the zoom work,
+  # 2026-07-03).
   module GLib
     extend ::FFI::Library
 
@@ -30,6 +31,7 @@ module Roxane
       ffi_lib "libglib-2.0.so.0"
       callback :g_source_func, [:pointer], :int
       attach_function :g_idle_add, [:g_source_func, :pointer], :uint
+      attach_function :g_timeout_add, [:uint, :g_source_func, :pointer], :uint
       AVAILABLE = true
     rescue LoadError, ::FFI::NotFoundError
       AVAILABLE = false

data/lib/roxane/window.rb

@@ -132,9 +132,59 @@ module Roxane
     private
 
     def apply_size(size, min_size, resizable)
-      width, height = size
+      width, height = Integer(size[0]), Integer(size[1])
       FFI.webview_set_size(@w, width, height, resizable ? FFI::HINT_NONE : FFI::HINT_FIXED)
       FFI.webview_set_size(@w, min_size[0], min_size[1], FFI::HINT_MIN) if min_size && resizable
+      # GTK3/Wayland: compensate for libwebview using gtk_window_resize (ignored
+      # as initial geometry). No-ops on macOS/Windows where Gtk is unavailable.
+      apply_gtk_wayland_size(width, height, min_size, resizable)
+    end
+
+    # See Roxane::Gtk — set_default_size + a temporary size-request so the first
+    # xdg configure isn't 200×200 under floating Wayland compositors.
+    def apply_gtk_wayland_size(width, height, min_size, resizable)
+      return unless Gtk::AVAILABLE && GLib::AVAILABLE
+
+      handle = FFI.webview_get_native_handle(@w, FFI::NATIVE_HANDLE_UI_WINDOW)
+      return if handle.null?
+
+      Gtk.gtk_window_set_default_size(handle, width, height)
+      return unless resizable
+
+      # Pin geometry through the first map, then release so the user can shrink.
+      # (Non-resizable windows keep webview's FIXED size-request permanently.)
+      Gtk.gtk_widget_set_size_request(handle, width, height)
+      release_initial_gtk_size_request(width, height, min_size)
+    end
+
+    # Poll until the GtkWindow is realized (shown), then drop the temporary
+    # size-request. Scheduled from construction — safe if run() is delayed;
+    # continues until realize or the window is destroyed.
+    def release_initial_gtk_size_request(width, height, min_size)
+      state = { seen_realized: false }
+      cb = ::FFI::Function.new(:int, [:pointer]) do |_data|
+        handle = FFI.webview_get_native_handle(@w, FFI::NATIVE_HANDLE_UI_WINDOW)
+        if handle.null?
+          0 # G_SOURCE_REMOVE — window gone
+        elsif Gtk.gtk_widget_get_realized(handle) == 0
+          1 # G_SOURCE_CONTINUE — not mapped yet
+        elsif !state[:seen_realized]
+          # One extra tick after realize so the compositor has acked min_size.
+          state[:seen_realized] = true
+          1
+        else
+          if min_size
+            Gtk.gtk_widget_set_size_request(handle, Integer(min_size[0]), Integer(min_size[1]))
+          else
+            Gtk.gtk_widget_set_size_request(handle, -1, -1)
+          end
+          Gtk.gtk_window_set_default_size(handle, width, height)
+          Gtk.gtk_window_resize(handle, width, height)
+          0 # G_SOURCE_REMOVE
+        end
+      end
+      @callbacks << cb
+      GLib.g_timeout_add(50, cb, nil)
     end
 
     # One persistent dispatch callback drains a queue of procs on the UI thread —

data/lib/roxane.rb

@@ -37,5 +37,6 @@ end
 
 require_relative "roxane/ffi"
 require_relative "roxane/webkit"
+require_relative "roxane/gtk"
 require_relative "roxane/static_server"
 require_relative "roxane/window"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: roxane
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - BKK Riese
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-03 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -39,6 +39,7 @@ files:
 - assets/bridge.js
 - lib/roxane.rb
 - lib/roxane/ffi.rb
+- lib/roxane/gtk.rb
 - lib/roxane/static_server.rb
 - lib/roxane/version.rb
 - lib/roxane/webkit.rb