rbgl 0.1.0 → 1.0.1

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

@@ -1,329 +1,286 @@
 # frozen_string_literal: true
 
 require "socket"
+require "io/wait"
+require_relative "protocol_objects"
+require_relative "codec"
+require_relative "event_dispatcher"
+require_relative "global_binder"
 
 module RBGL
   module GUI
     module Wayland
-      class WaylandObject
-        attr_reader :id, :connection
+      class Connection
+        DEFAULT_ROUNDTRIP_TIMEOUT = 1.0
+        ROUNDTRIP_POLL_INTERVAL = 0.01
+        READ_CHUNK_SIZE = 16_384
 
-        def initialize(connection, id)
-          @connection = connection
-          @id = id
-        end
+        attr_reader :compositor, :shm, :xdg_wm_base, :seat, :registry, :globals
 
-        def send_request(opcode, *args)
-          @connection.send_request(@id, opcode, *args)
-        end
-      end
+        def initialize(env: ENV, socket_path: nil, roundtrip_timeout: DEFAULT_ROUNDTRIP_TIMEOUT)
+          @env = env
+          @roundtrip_timeout = roundtrip_timeout
+          @socket = UNIXSocket.new(resolve_socket_path(socket_path))
+          @objects = {}
+          @next_id = 2
+          @globals = {}
+          @pending_events = []
+          @received_fds = []
+          @read_buffer = String.new(encoding: Encoding::BINARY)
+          @closed = false
 
-      class Display < WaylandObject
-        def initialize(connection)
-          super(connection, 1)
-        end
+          @display = Display.new(self)
+          register_object(@display)
 
-        def sync
-          callback_id = @connection.allocate_id
-          send_request(0, callback_id)
-          Callback.new(@connection, callback_id)
-        end
+          @registry = @display.get_registry
+          flush
+          roundtrip
 
-        def get_registry
-          registry_id = @connection.allocate_id
-          send_request(1, registry_id)
-          Registry.new(@connection, registry_id)
+          bind_globals
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
-      end
 
-      class Registry < WaylandObject
-        def bind(name, interface, version)
-          new_id = @connection.allocate_id
-          send_request(0, name, interface, version, new_id)
-          new_id
+        def allocate_id
+          id = @next_id
+          @next_id += 1
+          id
         end
-      end
 
-      class Callback < WaylandObject
-        def initialize(connection, id)
-          super
-          @done = false
+        def register_object(object)
+          @objects[object.id] = object
+          object
         end
 
-        def done?
-          @done
+        def object_for(object_id)
+          @objects[object_id]
         end
 
-        def handle_done
-          @done = true
+        def unregister_object(object_id)
+          @objects.delete(object_id)
         end
-      end
 
-      class Compositor < WaylandObject
-        def create_surface
-          surface_id = @connection.allocate_id
-          send_request(0, surface_id)
-          Surface.new(@connection, surface_id)
+        def store_global(interface, name:, version:)
+          @globals[interface] = { name: name, version: version }
         end
-      end
 
-      class Surface < WaylandObject
-        def attach(buffer, x, y)
-          send_request(1, buffer.id, x, y)
+        def remove_global(name)
+          @globals.delete_if { |_interface, global| global[:name] == name }
         end
 
-        def damage(x, y, width, height)
-          send_request(2, x, y, width, height)
+        def consume_received_fd
+          @received_fds.shift
         end
 
-        def commit
-          send_request(6)
+        def queue_event(event)
+          @pending_events << event
         end
 
-        def destroy
-          send_request(0)
+        def send_request(object_id, opcode, *args)
+          payload = pack_args(args)
+          header = [object_id, ((payload.bytesize + 8) << 16) | opcode].pack("VV")
+          @socket.write(header + payload)
         end
-      end
 
-      class Shm < WaylandObject
-        def create_pool(fd, size)
-          pool_id = @connection.allocate_id
-          @connection.send_request_with_fd(@id, 0, pool_id, size, fd)
-          ShmPool.new(@connection, pool_id)
-        end
-      end
+        def send_request_with_fd(object_id, opcode, *args, fd)
+          io = fd.respond_to?(:to_io) ? fd.to_io : fd
+          unless io.is_a?(IO)
+            raise ArgumentError, "Wayland file descriptor arguments must be IO objects"
+          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 0
-                       end
-          send_request(0, buffer_id, offset, width, height, stride, format_val)
-          WlBuffer.new(@connection, buffer_id)
-        end
+          payload = pack_args(args)
+          header = [object_id, ((payload.bytesize + 8) << 16) | opcode].pack("VV")
 
-        def destroy
-          send_request(1)
+          @socket.sendmsg(header + payload, 0, nil, Socket::AncillaryData.unix_rights(io))
         end
-      end
 
-      class WlBuffer < WaylandObject
-        def destroy
-          send_request(0)
+        def flush
+          @socket.flush
         end
-      end
 
-      class XdgWmBase < WaylandObject
-        def get_xdg_surface(surface)
-          xdg_surface_id = @connection.allocate_id
-          send_request(2, xdg_surface_id, surface.id)
-          XdgSurface.new(@connection, xdg_surface_id)
-        end
+        def dispatch_pending
+          pump_events(timeout: 0)
 
-        def pong(serial)
-          send_request(3, serial)
+          events = @pending_events
+          @pending_events = []
+          events
         end
-      end
 
-      class XdgSurface < WaylandObject
-        def get_toplevel
-          toplevel_id = @connection.allocate_id
-          send_request(1, toplevel_id)
-          XdgToplevel.new(@connection, toplevel_id)
-        end
+        def pump_events(timeout: nil)
+          read_from_socket(timeout) unless complete_message?
+          drain_messages
+          read_from_socket(0) if @socket.wait_readable(0)
+          drain_messages
 
-        def ack_configure(serial)
-          send_request(4, serial)
+          @pending_events.length
         end
 
-        def destroy
-          send_request(0)
-        end
-      end
+        def roundtrip
+          callback = @display.sync
+          flush
+          deadline = monotonic_time + @roundtrip_timeout
 
-      class XdgToplevel < WaylandObject
-        def set_title(title)
-          send_request(2, title)
-        end
+          until callback.done?
+            raise BackendUnavailable, "Wayland roundtrip timed out" if monotonic_time >= deadline
 
-        def destroy
-          send_request(0)
+            pump_events(timeout: roundtrip_poll_interval(deadline))
+          end
         end
-      end
 
-      class Connection
-        attr_reader :compositor, :shm, :xdg_wm_base
+        def wait_until(timeout: @roundtrip_timeout)
+          deadline = monotonic_time + timeout
+
+          until yield
+            return false if monotonic_time >= deadline
 
-        def initialize
-          socket_path = ENV["WAYLAND_DISPLAY"] || "wayland-0"
-          unless socket_path.start_with?("/")
-            runtime_dir = ENV["XDG_RUNTIME_DIR"] || "/run/user/#{Process.uid}"
-            socket_path = File.join(runtime_dir, socket_path)
+            pump_events(timeout: roundtrip_poll_interval(deadline))
           end
 
-          @socket = UNIXSocket.new(socket_path)
-          @objects = {}
-          @next_id = 2
-          @globals = {}
+          true
+        end
 
-          @display = Display.new(self)
-          @objects[1] = @display
+        def close
+          return if @closed
 
-          registry = @display.get_registry
-          @objects[registry.id] = registry
-          flush
-          roundtrip
+          error = nil
+          @received_fds&.each do |fd|
+            fd.close unless fd.closed?
+          rescue StandardError => close_error
+            error ||= close_error
+          end
+          @received_fds&.reject!(&:closed?)
 
-          bind_globals
+          begin
+            @socket&.close unless @socket&.closed?
+          rescue StandardError => close_error
+            error ||= close_error
+          end
+
+          @closed = @received_fds.to_a.empty? && (!@socket || @socket.closed?)
+          raise error if error
         end
 
-        def allocate_id
-          id = @next_id
-          @next_id += 1
-          id
+        def closed?
+          @closed || !@socket || @socket.closed?
         end
 
-        def send_request(object_id, opcode, *args)
-          payload = pack_args(args)
-          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
-          @socket.write(header + payload)
+        private
+
+        def resolve_socket_path(socket_path = nil)
+          socket_path ||= @env["WAYLAND_DISPLAY"] || "wayland-0"
+          return socket_path if socket_path.start_with?("/")
+
+          runtime_dir = @env["XDG_RUNTIME_DIR"] || "/run/user/#{Process.uid}"
+          File.join(runtime_dir, socket_path)
         end
 
-        def send_request_with_fd(object_id, opcode, *args, fd)
-          payload = pack_args(args)
-          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
+        def roundtrip_poll_interval(deadline)
+          [deadline - monotonic_time, ROUNDTRIP_POLL_INTERVAL].min.clamp(0.0, ROUNDTRIP_POLL_INTERVAL)
+        end
 
-          @socket.sendmsg(header + payload, 0, nil, Socket::AncillaryData.unix_rights(fd))
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
         end
 
-        def flush
-          @socket.flush
+        def handle_event(object_id, opcode, payload)
+          event_dispatcher.handle_event(object_id, opcode, payload)
         end
 
-        def dispatch_pending
-          while IO.select([@socket], nil, nil, 0)
-            header = @socket.read(8)
-            break unless header && header.bytesize == 8
+        def complete_message?
+          return false if @read_buffer.bytesize < 8
+
+          size = @read_buffer.byteslice(4, 4).unpack1("V") >> 16
+          raise GUI::BackendUnavailable, "Invalid Wayland message size: #{size}" if size < 8
+
+          @read_buffer.bytesize >= size
+        end
 
-            object_id, size_and_opcode = header.unpack("VV")
+        def drain_messages
+          while complete_message?
+            object_id, size_and_opcode = @read_buffer.byteslice(0, 8).unpack("VV")
             size = size_and_opcode >> 16
             opcode = size_and_opcode & 0xFFFF
-
-            payload = size > 8 ? @socket.read(size - 8) : ""
-            handle_event(object_id, opcode, payload)
+            message = @read_buffer.slice!(0, size)
+            handle_event(object_id, opcode, message.byteslice(8, size - 8))
           end
         end
 
-        def roundtrip
-          callback = @display.sync
-          @objects[callback.id] = callback
-          flush
+        def read_from_socket(timeout)
+          return false unless @socket.wait_readable(timeout)
 
-          until callback.done?
-            dispatch_pending
-            sleep 0.001
-          end
-        end
+          read_any = false
+          loop do
+            message = receive_message
+            break if message == :wait_readable
 
-        private
+            chunk, ancillary_data = message
+            raise GUI::BackendUnavailable, "Wayland compositor closed the connection" if chunk.nil?
 
-        def handle_event(object_id, opcode, payload)
-          case object_id
-          when 2
-            if opcode == 0
-              name = payload[0, 4].unpack1("V")
-              interface_len = payload[4, 4].unpack1("V")
-              interface = payload[8, interface_len - 1]
-              version = payload[8 + pad_length(interface_len), 4].unpack1("V")
-              @globals[interface] = { name: name, version: version }
-            end
-          else
-            obj = @objects[object_id]
-            if obj.is_a?(Callback) && opcode == 0
-              obj.handle_done
+            @read_buffer << chunk
+            ancillary_data.each do |control|
+              @received_fds.concat(control.unix_rights)
+            rescue TypeError
+              next
             end
+            read_any = true
           end
+          read_any
         end
 
-        def bind_globals
-          if @globals["wl_compositor"]
-            id = allocate_id
-            g = @globals["wl_compositor"]
-            @objects[2].bind(g[:name], "wl_compositor", [g[:version], 4].min)
-            @compositor = Compositor.new(self, id)
-            @objects[id] = @compositor
-          end
+        def receive_message
+          unless @socket.respond_to?(:recvmsg_nonblock)
+            chunk = @socket.read_nonblock(READ_CHUNK_SIZE, exception: false)
+            return :wait_readable if chunk == :wait_readable
 
-          if @globals["wl_shm"]
-            id = allocate_id
-            g = @globals["wl_shm"]
-            @objects[2].bind(g[:name], "wl_shm", [g[:version], 1].min)
-            @shm = Shm.new(self, id)
-            @objects[id] = @shm
+            return [chunk, []]
           end
 
-          if @globals["xdg_wm_base"]
-            id = allocate_id
-            g = @globals["xdg_wm_base"]
-            @objects[2].bind(g[:name], "xdg_wm_base", [g[:version], 2].min)
-            @xdg_wm_base = XdgWmBase.new(self, id)
-            @objects[id] = @xdg_wm_base
-          end
+          result = @socket.recvmsg_nonblock(
+            READ_CHUNK_SIZE,
+            0,
+            nil,
+            scm_rights: true,
+            exception: false
+          )
+          return :wait_readable if result == :wait_readable
+          return [nil, []] if !result || result[0].empty?
 
+          [result[0], result.drop(3)]
+        end
+
+        def bind_globals
+          bound = global_binder.bind!(@registry, @globals)
+          @compositor = bound[:compositor]
+          @shm = bound[:shm]
+          @xdg_wm_base = bound[:xdg_wm_base]
+          @seat = bound[:seat]
           flush
           roundtrip
         end
 
         def pack_args(args)
-          result = String.new
-          args.each do |arg|
-            case arg
-            when Integer
-              result << [arg].pack("V")
-            when String
-              len = arg.bytesize + 1
-              result << [len].pack("V")
-              result << arg << "\x00"
-              result << "\x00" * ((4 - len % 4) % 4)
-            when Float
-              result << [(arg * 256).to_i].pack("V")
-            end
-          end
-          result
-        end
-
-        def pad_length(len)
-          ((len + 3) / 4) * 4
+          codec.pack_args(args)
         end
-      end
-
-      class ShmBuffer
-        attr_reader :wl_buffer
 
-        def initialize(fd, size, wl_buffer)
-          @fd = fd
-          @size = size
-          @wl_buffer = wl_buffer
-          @file = File.open("/proc/self/fd/#{fd}", "r+b")
-          @file.seek(0)
+        def pad_length(length)
+          codec.pad_length(length)
         end
 
-        def write(data)
-          @file.seek(0)
-          @file.write(data)
-          @file.flush
+        def codec
+          @codec ||= Codec.new
         end
 
-        def id
-          @wl_buffer.id
+        def event_dispatcher
+          @event_dispatcher ||= EventDispatcher.new(self, codec: codec)
         end
 
-        def destroy
-          @wl_buffer.destroy
-          @file.close
+        def global_binder
+          @global_binder ||= GlobalBinder.new(self)
         end
       end
     end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "input_mapper"
+
+module RBGL
+  module GUI
+    module Wayland
+      class EventDispatcher
+        def initialize(connection, codec:)
+          @connection = connection
+          @codec = codec
+        end
+
+        def handle_event(object_id, opcode, payload)
+          object = @connection.object_for(object_id)
+
+          case object
+          when Display
+            handle_display_event(opcode, payload)
+          when Registry
+            handle_registry_event(opcode, payload)
+          when Callback
+            object.handle_done if opcode == 0
+          when WlBuffer
+            object.handle_release if opcode == 0
+          when Seat
+            object.handle_capabilities(payload.unpack1("V")) if opcode == 0
+          when Keyboard
+            handle_keyboard_event(object, opcode, payload)
+          when Pointer
+            handle_pointer_event(object, opcode, payload)
+          when XdgWmBase
+            handle_xdg_wm_base_event(object, opcode, payload)
+          when XdgSurface
+            object.handle_configure(payload.unpack1("V")) if opcode == 0
+          when XdgToplevel
+            handle_xdg_toplevel_event(object_id, opcode, payload)
+          end
+        end
+
+        private
+
+        def handle_display_event(opcode, payload)
+          case opcode
+          when 0
+            failed_object, code, length = payload.byteslice(0, 12).unpack("VVV")
+            message = payload.byteslice(12, length - 1)
+            raise GUI::BackendUnavailable,
+                  "Wayland protocol error #{code} on object #{failed_object}: #{message}"
+          when 1
+            @connection.unregister_object(payload.unpack1("V"))
+          end
+        end
+
+        def handle_registry_event(opcode, payload)
+          case opcode
+          when 0
+            name = payload[0, 4].unpack1("V")
+            interface_length = payload[4, 4].unpack1("V")
+            interface = payload[8, interface_length - 1]
+            version = payload[8 + @codec.pad_length(interface_length), 4].unpack1("V")
+            @connection.store_global(interface, name: name, version: version)
+          when 1
+            @connection.remove_global(payload.unpack1("V"))
+          end
+        end
+
+        def handle_xdg_wm_base_event(object, opcode, payload)
+          return unless opcode == 0
+
+          object.pong(payload.unpack1("V"))
+          @connection.flush
+        end
+
+        def handle_keyboard_event(keyboard, opcode, payload)
+          case opcode
+          when 0
+            format, size = payload.unpack("V2")
+            keyboard.handle_keymap(format, size, @connection.consume_received_fd)
+          when 1
+            keyboard.focus(payload.byteslice(4, 4).unpack1("V"))
+          when 2
+            keyboard.blur
+          when 3
+            _serial, _time, keycode, state = payload.unpack("V4")
+            event = {
+              type: state == 1 ? :key_press : :key_release,
+              surface_id: keyboard.focused_surface_id,
+              key: InputMapper.key(keycode),
+              keycode: keycode
+            }
+            event[:modifiers] = keyboard.modifiers.dup unless keyboard.modifiers.empty?
+            @connection.queue_event(event)
+          when 4
+            _serial, depressed, latched, locked, group = payload.unpack("V5")
+            keyboard.handle_modifiers(
+              depressed: depressed,
+              latched: latched,
+              locked: locked,
+              group: group
+            )
+          end
+        end
+
+        def handle_pointer_event(pointer, opcode, payload)
+          case opcode
+          when 0
+            _serial, surface_id, x, y = payload.unpack("VVl<l<")
+            pointer.focus(surface_id)
+            queue_pointer_motion(pointer, x, y)
+          when 1
+            pointer.blur
+          when 2
+            _time, x, y = payload.unpack("Vl<l<")
+            queue_pointer_motion(pointer, x, y)
+          when 3
+            _serial, _time, button, state = payload.unpack("V4")
+            @connection.queue_event(
+              type: state == 1 ? :pointer_button_press : :pointer_button_release,
+              surface_id: pointer.focused_surface_id,
+              button: InputMapper.button(button),
+              x: pointer.x,
+              y: pointer.y
+            )
+          when 4
+            _time, axis, value = payload.unpack("VVl<")
+            @connection.queue_event(
+              type: :pointer_axis,
+              surface_id: pointer.focused_surface_id,
+              axis: { 0 => :vertical, 1 => :horizontal }.fetch(axis, axis),
+              value: value / 256.0,
+              x: pointer.x,
+              y: pointer.y
+            )
+          end
+        end
+
+        def queue_pointer_motion(pointer, fixed_x, fixed_y)
+          pointer.move(fixed_x / 256.0, fixed_y / 256.0)
+          @connection.queue_event(
+            type: :pointer_motion,
+            surface_id: pointer.focused_surface_id,
+            x: pointer.x,
+            y: pointer.y
+          )
+        end
+
+        def handle_xdg_toplevel_event(object_id, opcode, payload)
+          case opcode
+          when 0
+            width, height = payload[0, 8].unpack("l<l<")
+            @connection.queue_event(
+              type: :xdg_toplevel_configure,
+              object_id: object_id,
+              width: width,
+              height: height
+            )
+          when 1
+            @connection.queue_event(type: :xdg_toplevel_close, object_id: object_id)
+          end
+        end
+      end
+    end
+  end
+end