roxane 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e5b9afbc87612a9f5e97a4f57fea36a3556e988bd193cc72f624fdcaed7cabe1
-  data.tar.gz: c5870e5c200f2deaedfb5e3a55f00b172d68611df04d2c0e2722dd75093bcf76
+  metadata.gz: 949821f1324cd761b172fc4b4f7519459b3d70c3a53db0bc9ba3ad694ffe3e80
+  data.tar.gz: dd6ea3c05680732a4c6d8cb08702626735675b2035d6cdc1c7822a08e43fac93
 SHA512:
-  metadata.gz: 9a71c4851681187f76a8e1ac1675962a8eef44df6b25908c8b05d628441ef8c3e3a7b1290dfbf64fd0b37c5c556827932c05944e2b2f483a71f1048ffd47c421
-  data.tar.gz: aeb62cb2ea3659aa06b7faaf911d9b269026f64998842ef9818b53b33a60472d38608597c6fd6d46cdc333e040365c4a3bc63c775a021c3453998409db6054fe
+  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/ffi.rb

@@ -15,6 +15,12 @@ module Roxane
     HINT_MAX   = 2
     HINT_FIXED = 3
 
+    # webview_native_handle_kind_t — BROWSER_CONTROLLER is the engine view
+    # (WebKitWebView* on GTK), the door to engine calls webview doesn't wrap.
+    NATIVE_HANDLE_UI_WINDOW = 0
+    NATIVE_HANDLE_UI_WIDGET = 1
+    NATIVE_HANDLE_BROWSER_CONTROLLER = 2
+
     begin
       ffi_lib Roxane.library_path
 
@@ -31,6 +37,7 @@ module Roxane
       attach_function :webview_set_html,  [:pointer, :string],          :int
       attach_function :webview_init,      [:pointer, :string],          :int
       attach_function :webview_eval,      [:pointer, :string],          :int
+      attach_function :webview_get_native_handle, [:pointer, :int],     :pointer
 
       callback :bind_fn, [:string, :string, :pointer], :void
       attach_function :webview_bind,   [:pointer, :string, :bind_fn, :pointer], :int

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.1"
+  VERSION = "0.0.3"
 end

data/lib/roxane/webkit.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Roxane
+  # Direct WebKitGTK bindings for the few affordances the webview C API doesn't
+  # wrap (today: full-content zoom). On Linux the library is already linked into
+  # the process by libwebview — we bind the soname libwebview itself links (4.1,
+  # falling back to 4.0). Where neither loads (macOS/Windows — their engines get
+  # their own bindings later), AVAILABLE is false and callers no-op gracefully.
+  module WebKit
+    extend ::FFI::Library
+
+    begin
+      ffi_lib ["libwebkit2gtk-4.1.so.0", "libwebkit2gtk-4.0.so.37"]
+      attach_function :webkit_web_view_set_zoom_level, [:pointer, :double], :void
+      attach_function :webkit_web_view_get_zoom_level, [:pointer], :double
+      AVAILABLE = true
+    rescue LoadError, ::FFI::NotFoundError
+      AVAILABLE = false
+    end
+  end
+
+  # 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
+
+    begin
+      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
+    end
+  end
+end

data/lib/roxane/window.rb

@@ -26,6 +26,7 @@ module Roxane
       @on_close  = nil
       @server    = nil
       @ui_queue  = Queue.new # procs to run on the UI thread
+      @zoom      = 1.0
 
       @w = FFI.webview_create(debug ? 1 : 0, nil)
       raise Error, "could not create webview" if @w.null?
@@ -83,6 +84,31 @@ module Roxane
       self
     end
 
+    # Full-content zoom, like a browser's Ctrl+± (1.0 = natural size). Backed by
+    # the engine's native zoom (WebKitGTK today); where that binding isn't
+    # available the setter no-ops and the reader reports the last requested
+    # level. Safe from any thread: scheduled with g_idle_add, which runs on the
+    # UI thread as a TOP-LEVEL loop iteration — never nested inside a webview
+    # dispatch callback, where a layout-triggering WebKit call can reenter the
+    # engine mid-resolve and crash it. Rapid calls coalesce (each application
+    # reads the latest requested level; extra idles are harmless).
+    def zoom
+      @zoom
+    end
+
+    def zoom=(factor)
+      @zoom = Float(factor)
+      return unless WebKit::AVAILABLE && GLib::AVAILABLE
+
+      @apply_zoom ||= ::FFI::Function.new(:int, [:pointer]) do |_data|
+        view = FFI.webview_get_native_handle(@w, FFI::NATIVE_HANDLE_BROWSER_CONTROLLER)
+        WebKit.webkit_web_view_set_zoom_level(view, @zoom) unless view.null?
+        0 # G_SOURCE_REMOVE
+      end
+      @callbacks << @apply_zoom unless @callbacks.include?(@apply_zoom)
+      GLib.g_idle_add(@apply_zoom, nil)
+    end
+
     def on_close(&block)
       @on_close = block
       self
@@ -106,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

@@ -36,5 +36,7 @@ module Roxane
 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.1
+  version: 0.0.3
 platform: ruby
 authors:
 - BKK Riese
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-06-18 00:00:00.000000000 Z
+date: 2026-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -39,8 +39,10 @@ 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
 - lib/roxane/window.rb
 homepage: https://github.com/quarterstack/roxane
 licenses: