rbgl 0.1.0 → 1.0.1

data/lib/rbgl/gui/wayland/global_binder.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative "../backend"
+
+module RBGL
+  module GUI
+    module Wayland
+      class GlobalBinder
+        BINDINGS = {
+          "wl_compositor" => [:compositor, Compositor, 4],
+          "wl_shm" => [:shm, Shm, 1],
+          "xdg_wm_base" => [:xdg_wm_base, XdgWmBase, 2],
+          "wl_seat" => [:seat, Seat, 5]
+        }.freeze
+        REQUIRED_INTERFACES = %w[wl_compositor wl_shm xdg_wm_base].freeze
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def bind!(registry, globals)
+          validate_required_globals!(globals)
+
+          BINDINGS.each_with_object({}) do |(interface, binding), bound|
+            slot, klass, max_version = binding
+            global = globals[interface]
+            next unless global
+
+            version = [global[:version], max_version].min
+            object_id = registry.bind(global[:name], interface, version)
+            bound[slot] = @connection.register_object(klass.new(@connection, object_id, version: version))
+          end
+        end
+
+        private
+
+        def validate_required_globals!(globals)
+          missing = REQUIRED_INTERFACES - globals.keys
+          return if missing.empty?
+
+          raise GUI::BackendUnavailable, "Wayland globals missing: #{missing.join(', ')}"
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/input_mapper.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      module InputMapper
+        KEY_NAMES = {
+          1 => :escape,
+          14 => :backspace,
+          15 => :tab,
+          28 => :enter,
+          29 => :left_control,
+          42 => :left_shift,
+          54 => :right_shift,
+          56 => :left_alt,
+          57 => :space,
+          58 => :caps_lock,
+          87 => :f11,
+          88 => :f12,
+          97 => :right_control,
+          100 => :right_alt,
+          102 => :home,
+          103 => :up,
+          104 => :page_up,
+          105 => :left,
+          106 => :right,
+          107 => :end,
+          108 => :down,
+          109 => :page_down,
+          110 => :insert,
+          111 => :delete,
+          125 => :left_meta,
+          126 => :right_meta
+        }.merge(
+          (2..10).zip(%i[one two three four five six seven eight nine]).to_h,
+          { 11 => :zero },
+          (16..25).zip(%i[q w e r t y u i o p]).to_h,
+          (30..38).zip(%i[a s d f g h j k l]).to_h,
+          (44..50).zip(%i[z x c v b n m]).to_h,
+          (59..68).zip(%i[f1 f2 f3 f4 f5 f6 f7 f8 f9 f10]).to_h
+        ).freeze
+
+        POINTER_BUTTONS = {
+          0x110 => 1,
+          0x111 => 3,
+          0x112 => 2
+        }.freeze
+
+        module_function
+
+        def key(code)
+          KEY_NAMES.fetch(code, code)
+        end
+
+        def button(code)
+          POINTER_BUTTONS.fetch(code, code)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/arguments.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      TypedArgument = Struct.new(:type, :value)
+
+      module Arguments
+        module_function
+
+        def uint(value)
+          TypedArgument.new(:uint, Integer(value))
+        end
+
+        def int(value)
+          TypedArgument.new(:int, Integer(value))
+        end
+
+        def fixed(value)
+          TypedArgument.new(:fixed, Float(value))
+        end
+
+        def string(value)
+          TypedArgument.new(:string, value.to_s)
+        end
+
+        def object(value)
+          object_id = value.respond_to?(:id) ? value.id : value
+          TypedArgument.new(:object, Integer(object_id))
+        end
+
+        def new_id(value)
+          TypedArgument.new(:new_id, Integer(value))
+        end
+      end
+
+      class WaylandObject
+        attr_reader :id, :connection, :version
+
+        def initialize(connection, id, version: 1)
+          @connection = connection
+          @id = id
+          @version = version
+          @destroyed = false
+        end
+
+        def send_request(opcode, *args)
+          @connection.send_request(@id, opcode, *args)
+        end
+
+        private
+
+        def release(opcode, since: 1)
+          return if @destroyed
+
+          send_request(opcode) if @version >= since
+          @connection.unregister_object(@id) if @connection.respond_to?(:unregister_object)
+          @destroyed = true
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/display.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Display < WaylandObject
+        def initialize(connection)
+          super(connection, 1)
+        end
+
+        def sync
+          callback_id = @connection.allocate_id
+          send_request(0, Arguments.new_id(callback_id))
+          @connection.register_object(Callback.new(@connection, callback_id))
+        end
+
+        def get_registry
+          registry_id = @connection.allocate_id
+          send_request(1, Arguments.new_id(registry_id))
+          @connection.register_object(Registry.new(@connection, registry_id))
+        end
+      end
+
+      class Registry < WaylandObject
+        def bind(name, interface, version)
+          new_id = @connection.allocate_id
+          send_request(
+            0,
+            Arguments.uint(name),
+            Arguments.string(interface),
+            Arguments.uint(version),
+            Arguments.new_id(new_id)
+          )
+          new_id
+        end
+      end
+
+      class Callback < WaylandObject
+        def initialize(connection, id)
+          super
+          @done = false
+        end
+
+        def done?
+          @done
+        end
+
+        def handle_done
+          @done = true
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/seat.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Seat < WaylandObject
+        POINTER_CAPABILITY = 1
+        KEYBOARD_CAPABILITY = 2
+
+        attr_reader :keyboard, :pointer
+
+        def handle_capabilities(capabilities)
+          update_pointer(capabilities & POINTER_CAPABILITY != 0)
+          update_keyboard(capabilities & KEYBOARD_CAPABILITY != 0)
+        end
+
+        def destroy
+          @pointer&.destroy
+          @keyboard&.destroy
+          release(3, since: 5)
+        end
+
+        private
+
+        def update_pointer(available)
+          @pointer ||= create_pointer if available
+          return if available || !@pointer
+
+          @pointer.destroy
+          @pointer = nil
+        end
+
+        def update_keyboard(available)
+          @keyboard ||= create_keyboard if available
+          return if available || !@keyboard
+
+          @keyboard.destroy
+          @keyboard = nil
+        end
+
+        def create_pointer
+          object_id = @connection.allocate_id
+          send_request(0, Arguments.new_id(object_id))
+          @connection.register_object(Pointer.new(@connection, object_id, version: @version))
+        end
+
+        def create_keyboard
+          object_id = @connection.allocate_id
+          send_request(1, Arguments.new_id(object_id))
+          @connection.register_object(Keyboard.new(@connection, object_id, version: @version))
+        end
+      end
+
+      class Keyboard < WaylandObject
+        attr_reader :focused_surface_id, :keymap, :keymap_format, :modifiers
+
+        def initialize(...)
+          super
+          @modifiers = {}
+        end
+
+        def focus(surface_id)
+          @focused_surface_id = surface_id
+        end
+
+        def blur
+          @focused_surface_id = nil
+        end
+
+        def handle_keymap(format, size, io)
+          raise GUI::BackendUnavailable, "Wayland keymap event did not include a file descriptor" unless io
+
+          @keymap_format = { 0 => :none, 1 => :xkb_v1 }.fetch(format, format)
+          @keymap = io.read(size)&.delete_suffix("\x00")
+        ensure
+          io&.close
+        end
+
+        def handle_modifiers(depressed:, latched:, locked:, group:)
+          @modifiers = {
+            depressed: depressed,
+            latched: latched,
+            locked: locked,
+            group: group
+          }
+        end
+
+        def destroy
+          release(0, since: 3)
+        end
+      end
+
+      class Pointer < WaylandObject
+        attr_reader :focused_surface_id, :x, :y
+
+        def focus(surface_id)
+          @focused_surface_id = surface_id
+        end
+
+        def blur
+          @focused_surface_id = nil
+        end
+
+        def move(x, y)
+          @x = x
+          @y = y
+        end
+
+        def destroy
+          release(1, since: 3)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/shm.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Shm < WaylandObject
+        def create_pool(file, size)
+          pool_id = @connection.allocate_id
+          @connection.send_request_with_fd(@id, 0, Arguments.new_id(pool_id), Arguments.int(size), file)
+          @connection.register_object(ShmPool.new(@connection, pool_id))
+        end
+      end
+
+      class ShmPool < WaylandObject
+        def create_buffer(offset, width, height, stride, format)
+          buffer_id = @connection.allocate_id
+          format_val = case format
+                       when :argb8888 then 0
+                       when :xrgb8888 then 1
+                       else
+                         raise ArgumentError, "Unsupported Wayland SHM format: #{format}"
+                       end
+          send_request(
+            0,
+            Arguments.new_id(buffer_id),
+            Arguments.int(offset),
+            Arguments.int(width),
+            Arguments.int(height),
+            Arguments.int(stride),
+            Arguments.uint(format_val)
+          )
+          @connection.register_object(WlBuffer.new(@connection, buffer_id))
+        end
+
+        def destroy
+          send_request(1)
+        end
+      end
+
+      class WlBuffer < WaylandObject
+        def initialize(connection, id)
+          super
+          @busy = false
+          @destroy_requested = false
+          @destroyed = false
+          @release_callbacks = []
+        end
+
+        def on_release(&block)
+          @release_callbacks << block if block
+        end
+
+        def mark_in_use
+          @busy = true
+        end
+
+        def available?
+          !@busy && !@destroy_requested && !@destroyed
+        end
+
+        def busy?
+          @busy
+        end
+
+        def handle_release
+          @busy = false
+          @release_callbacks.each(&:call)
+          finalize_destroy if @destroy_requested
+        end
+
+        def destroy(force: false)
+          return if @destroyed || (@destroy_requested && !force)
+
+          if @busy && !force
+            @destroy_requested = true
+          else
+            finalize_destroy
+          end
+        end
+
+        private
+
+        def finalize_destroy
+          return if @destroyed
+
+          send_request(0)
+          @destroyed = true
+        end
+      end
+
+      class ShmBuffer
+        attr_reader :wl_buffer
+
+        def initialize(file, pool, wl_buffer)
+          @file = file
+          @pool = pool
+          @wl_buffer = wl_buffer
+          @destroy_requested = false
+          @destroyed = false
+          @file.binmode
+          @file.seek(0)
+          @wl_buffer.on_release { handle_release }
+        end
+
+        def write(data)
+          @file.seek(0)
+          @file.write(data)
+          @file.flush
+        end
+
+        def available?
+          @wl_buffer.available?
+        end
+
+        def mark_in_use
+          @wl_buffer.mark_in_use
+        end
+
+        def id
+          @wl_buffer.id
+        end
+
+        def destroy(force: false)
+          return if @destroyed
+
+          @destroy_requested = true
+          begin
+            force ? @wl_buffer.destroy(force: true) : @wl_buffer.destroy
+          ensure
+            finalize_destroy if force || !@wl_buffer.busy?
+          end
+        end
+
+        def destroyed?
+          @destroyed
+        end
+
+        private
+
+        def handle_release
+          finalize_destroy if @destroy_requested
+        end
+
+        def finalize_destroy
+          return if @destroyed
+
+          begin
+            @pool.destroy
+          ensure
+            @file.close unless @file.closed?
+            @destroyed = true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/surface.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class Compositor < WaylandObject
+        def create_surface
+          surface_id = @connection.allocate_id
+          send_request(0, Arguments.new_id(surface_id))
+          @connection.register_object(Surface.new(@connection, surface_id))
+        end
+      end
+
+      class Surface < WaylandObject
+        def attach(buffer, x, y)
+          send_request(1, Arguments.object(buffer), Arguments.int(x), Arguments.int(y))
+        end
+
+        def damage(x, y, width, height)
+          send_request(2, Arguments.int(x), Arguments.int(y), Arguments.int(width), Arguments.int(height))
+        end
+
+        def commit
+          send_request(6)
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects/xdg_shell.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module Wayland
+      class XdgWmBase < WaylandObject
+        def get_xdg_surface(surface)
+          xdg_surface_id = @connection.allocate_id
+          send_request(2, Arguments.new_id(xdg_surface_id), Arguments.object(surface))
+          @connection.register_object(XdgSurface.new(@connection, xdg_surface_id))
+        end
+
+        def pong(serial)
+          send_request(3, Arguments.uint(serial))
+        end
+      end
+
+      class XdgSurface < WaylandObject
+        def initialize(connection, id)
+          super
+          @configured = false
+        end
+
+        def configured?
+          @configured
+        end
+
+        def get_toplevel
+          toplevel_id = @connection.allocate_id
+          send_request(1, Arguments.new_id(toplevel_id))
+          @connection.register_object(XdgToplevel.new(@connection, toplevel_id))
+        end
+
+        def ack_configure(serial)
+          send_request(4, Arguments.uint(serial))
+        end
+
+        def handle_configure(serial)
+          ack_configure(serial)
+          @connection.flush
+          @configured = true
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+
+      class XdgToplevel < WaylandObject
+        def set_title(title)
+          send_request(2, Arguments.string(title))
+        end
+
+        def destroy
+          send_request(0)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/wayland/protocol_objects.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative "protocol_objects/arguments"
+require_relative "protocol_objects/display"
+require_relative "protocol_objects/surface"
+require_relative "protocol_objects/shm"
+require_relative "protocol_objects/seat"
+require_relative "protocol_objects/xdg_shell"

data/lib/rbgl/gui/window/event_dispatcher.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class Window
+      class EventDispatcher
+        def initialize(backend:, event_handlers:, on_resize:)
+          @backend = backend
+          @event_handlers = event_handlers
+          @on_resize = on_resize
+        end
+
+        def process
+          Array(poll_events).each do |event|
+            next unless event.is_a?(Event)
+
+            @on_resize.call(event) if event.type == :resize
+            @event_handlers[event.type].each { |handler| handler.call(event) }
+          end
+        end
+
+        private
+
+        def poll_events
+          @backend.poll_events
+        end
+      end
+    end
+  end
+end