rbgl 1.0.0 → 1.0.2

data/lib/rbgl/gui/file_backend/bmp_writer.rb

@@ -17,7 +17,7 @@ module RBGL
         def encode(framebuffer)
           width = framebuffer.width
           height = framebuffer.height
-          row_size = ((24 * width + 31) / 32) * 4
+          row_size = (((24 * width) + 31) / 32) * 4
           pixel_data_size = row_size * height
           file_size = 54 + pixel_data_size
 
@@ -51,7 +51,7 @@ module RBGL
               bytes = framebuffer.get_pixel(x, y).to_bytes
               row << [bytes[2], bytes[1], bytes[0]].pack("CCC")
             end
-            row << "\x00" * (row_size - width * 3)
+            row << ("\x00" * (row_size - (width * 3)))
             pixels << row
           end
 

data/lib/rbgl/gui/file_backend/frame_writer.rb

@@ -10,6 +10,13 @@ module RBGL
             PpmWriter.new(binary: ppm_mode == :binary)
           when :bmp
             BmpWriter.new
+          when :png
+            begin
+              require "tessel"
+            rescue LoadError
+              raise ArgumentError, "format: :png requires the tessel gem"
+            end
+            PngWriter.new
           else
             raise ArgumentError, "Unsupported file backend format: #{format}"
           end

data/lib/rbgl/gui/file_backend/png_writer.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    class FileBackend
+      class PngWriter < FrameWriter
+        def extension
+          "png"
+        end
+
+        def write(filename, framebuffer)
+          image = Tessel::Image.from_rgba(framebuffer.width, framebuffer.height, framebuffer.to_rgba_bytes)
+          image.write(filename)
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/file_backend/ppm_writer.rb

@@ -5,6 +5,7 @@ module RBGL
     class FileBackend < Backend
       class PpmWriter < FrameWriter
         def initialize(binary:)
+          super()
           @binary = binary
         end
 

data/lib/rbgl/gui/file_backend.rb

@@ -1,24 +1,29 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "file_backend/frame_writer"
 require_relative "file_backend/ppm_writer"
 require_relative "file_backend/bmp_writer"
+require_relative "file_backend/png_writer"
 
 module RBGL
   module GUI
     class FileBackend < Backend
-      SUPPORTED_FORMATS = %i[ppm bmp].freeze
+      SUPPORTED_FORMATS = %i[ppm bmp png].freeze
       PPM_MODES = %i[ascii binary].freeze
 
-      def initialize(width, height, title = "RBGL", format: :ppm, ppm_mode: :ascii, output_dir: ".")
+      attr_reader :max_frames, :output_dir
+
+      def initialize(width, height, title = "RBGL", format: :ppm, ppm_mode: :ascii, output_dir: ".", max_frames: 1)
         super(width, height, title)
         @format = normalize_format(format)
         @ppm_mode = normalize_ppm_mode(ppm_mode, @format)
         @writer = FrameWriter.build(@format, ppm_mode: @ppm_mode)
-        @output_dir = output_dir
+        @output_dir = File.expand_path(output_dir)
+        FileUtils.mkdir_p(@output_dir)
         @frame_count = 0
         @should_close = false
-        @max_frames = nil
+        self.max_frames = max_frames
       end
 
       def present(framebuffer)
@@ -43,10 +48,12 @@ module RBGL
         @should_close = true
       end
 
-      def set_max_frames(count)
-        @max_frames = count
+      def max_frames=(count)
+        @max_frames = normalize_max_frames(count)
       end
 
+      alias set_max_frames max_frames=
+
       private
 
       def normalize_format(format)
@@ -63,6 +70,17 @@ module RBGL
 
         raise ArgumentError, "PPM mode is only supported with :ppm format"
       end
+
+      def normalize_max_frames(count)
+        return nil if count.nil?
+
+        normalized = Integer(count)
+        return normalized if normalized.positive?
+
+        raise ArgumentError, "max_frames must be a positive integer or nil"
+      rescue TypeError
+        raise ArgumentError, "max_frames must be a positive integer or nil"
+      end
     end
   end
 end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "connection"
+require "tempfile"
 
 module RBGL
   module GUI
@@ -11,9 +12,17 @@ module RBGL
 
         def initialize(width, height, title = "RBGL", env: ENV, roundtrip_timeout: Connection::DEFAULT_ROUNDTRIP_TIMEOUT)
           super(width, height, title)
+          @window = nil
+          @retired_buffers = []
           @connection = Connection.new(env: env, roundtrip_timeout: roundtrip_timeout)
-          @windows = {}
           setup_window(width, height, title)
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
 
         private def setup_window(w, h, t)
@@ -22,42 +31,52 @@ module RBGL
           toplevel = xdg_surface.get_toplevel
           toplevel.set_title(t)
 
-          buffers = create_shm_buffers(w, h)
-          shm_buffer = buffers.first
-
-          surface.attach(shm_buffer, 0, 0)
-          shm_buffer.mark_in_use
-          surface.commit
-          @connection.flush
-
-          handle = surface.id
-          @windows[handle] = {
+          @window = {
             surface: surface,
             xdg_surface: xdg_surface,
             toplevel: toplevel,
-            buffers: buffers,
-            shm_buffer: shm_buffer,
+            buffers: [],
+            shm_buffer: nil,
             width: w,
             height: h,
             should_close: false
           }
 
-          @handle = handle
+          surface.commit
+          @connection.flush
+          wait_for_initial_configure(xdg_surface)
+
+          buffers = create_shm_buffers(w, h)
+          @window[:buffers] = buffers
+          @window[:shm_buffer] = buffers.first
         end
 
         def present(framebuffer)
-          return false unless @handle
+          return false unless @window
+
+          present_bytes(convert_to_wayland_format(framebuffer), framebuffer.width, framebuffer.height)
+        end
+
+        def set_pixels(buffer, width, height)
+          return false unless @window
 
-          window = @windows[@handle]
+          bytes = validate_rgba_buffer(buffer, width, height)
+          present_bytes(rgba_to_wayland_bytes(bytes), width, height)
+        end
+
+        private def present_bytes(buffer, width, height)
+          window = @window
           return false unless window
+          unless width == window[:width] && height == window[:height]
+            raise ArgumentError, "Framebuffer dimensions must match the Wayland window"
+          end
 
           buffer_object = wait_for_available_buffer(window)
           return false unless buffer_object
 
-          buffer = convert_to_wayland_format(framebuffer)
           buffer_object.write(buffer)
 
-          window[:surface].damage(0, 0, framebuffer.width, framebuffer.height)
+          window[:surface].damage(0, 0, width, height)
           window[:surface].attach(buffer_object, 0, 0)
           buffer_object.mark_in_use
           window[:shm_buffer] = buffer_object
@@ -71,12 +90,9 @@ module RBGL
         end
 
         def resize(width, height)
-          super
-          return unless @handle
-
-          window = @windows[@handle]
-          return unless window
-          return if window[:width] == width && window[:height] == height
+          window = @window
+          return super unless window
+          return super if window[:width] == width && window[:height] == height
 
           old_buffers = window.fetch(:buffers, [window[:shm_buffer]].compact)
           new_buffers = create_shm_buffers(width, height)
@@ -84,28 +100,39 @@ module RBGL
           window[:shm_buffer] = new_buffers.first
           window[:width] = width
           window[:height] = height
+          super
+          (@retired_buffers ||= []).concat(old_buffers)
           old_buffers.each(&:destroy)
+          @retired_buffers.reject! { |buffer| buffer.respond_to?(:destroyed?) && buffer.destroyed? }
         end
 
         def should_close?
-          return false unless @handle
-
-          @windows[@handle]&.[](:should_close) || false
+          @window.nil? || @window[:should_close]
         end
 
         def close
-          return unless @handle
-
-          window = @windows[@handle]
-          return unless window
+          window = @window
+          operations = []
+          if window
+            window[:should_close] = true
+            operations << -> { window[:toplevel].destroy }
+            operations << -> { window[:xdg_surface].destroy }
+            operations << -> { window[:surface].destroy }
+            buffers = window.fetch(:buffers, [window[:shm_buffer]].compact) + Array(@retired_buffers)
+            operations.concat(buffers.uniq.map { |buffer| -> { buffer.destroy(force: true) } })
+            operations << -> { @connection.flush }
+          end
+          operations << -> { @connection&.close }
 
-          window[:should_close] = true
-          window[:toplevel].destroy
-          window[:xdg_surface].destroy
-          window[:surface].destroy
-          window.fetch(:buffers, [window[:shm_buffer]].compact).each(&:destroy)
-          @windows.delete(@handle)
-          @handle = nil
+          error = nil
+          operations.each do |operation|
+            operation.call
+          rescue StandardError => cleanup_error
+            error ||= cleanup_error
+          end
+          @window = nil
+          @retired_buffers = []
+          raise error if error
         end
 
         private
@@ -114,8 +141,19 @@ module RBGL
           framebuffer.to_bgra_bytes
         end
 
+        def rgba_to_wayland_bytes(buffer)
+          output = String.new(capacity: buffer.bytesize, encoding: Encoding::BINARY)
+          byte_index = 0
+          while byte_index < buffer.bytesize
+            output << buffer.getbyte(byte_index + 2) << buffer.getbyte(byte_index + 1) <<
+                      buffer.getbyte(byte_index) << buffer.getbyte(byte_index + 3)
+            byte_index += 4
+          end
+          output
+        end
+
         def convert_event(raw)
-          window = window_for_event(raw[:object_id])
+          window = window_for_event(raw[:surface_id] || raw[:object_id])
           return nil unless window
 
           case raw[:type]
@@ -127,14 +165,23 @@ module RBGL
             height = raw[:height]
             return nil unless width.positive? && height.positive?
 
-            window[:width] = width
-            window[:height] = height
             Event.new(:resize, width: width, height: height)
+          when :key_press, :key_release
+            Event.new(raw[:type], key: raw[:key], keycode: raw[:keycode], modifiers: raw[:modifiers])
+          when :pointer_motion
+            Event.new(:mouse_move, x: raw[:x], y: raw[:y])
+          when :pointer_button_press
+            Event.new(:mouse_press, button: raw[:button], x: raw[:x], y: raw[:y])
+          when :pointer_button_release
+            Event.new(:mouse_release, button: raw[:button], x: raw[:x], y: raw[:y])
+          when :pointer_axis
+            Event.new(:mouse_scroll, x: raw[:x], y: raw[:y], axis: raw[:axis], value: raw[:value])
           end
         end
 
         def window_for_event(object_id)
-          @windows.values.find { |window| window[:toplevel].id == object_id }
+          return unless @window
+          return @window if @window[:toplevel].id == object_id || @window[:surface].id == object_id
         end
 
         def next_available_buffer(window)
@@ -174,32 +221,57 @@ module RBGL
         end
 
         def create_shm_buffers(width, height, count = 2)
-          Array.new(count) { create_shm_buffer(width, height) }
+          buffers = []
+          count.times { buffers << create_shm_buffer(width, height) }
+          buffers
+        rescue StandardError => error
+          buffers&.each do |buffer|
+            begin
+              buffer.destroy(force: true)
+            rescue StandardError
+              nil
+            end
+          end
+          raise error
         end
 
         def create_shm_buffer(width, height)
           size = width * height * 4
 
           file = create_anonymous_file(size)
-          pool = @connection.shm.create_pool(file.fileno, size)
-          buffer = pool.create_buffer(0, width, height, width * 4, :argb8888)
+          pool = @connection.shm.create_pool(file, size)
+          buffer = pool.create_buffer(0, width, height, width * 4, :xrgb8888)
 
           ShmBuffer.new(file, pool, buffer)
+        rescue StandardError => error
+          begin
+            buffer&.destroy(force: true)
+          rescue StandardError
+            nil
+          end
+          begin
+            pool&.destroy
+          rescue StandardError
+            nil
+          end
+          file&.close unless file&.closed?
+          raise error
         end
 
         def create_anonymous_file(size)
-          name = "rbgl-#{Process.pid}-#{rand(10000)}"
-          path = "/dev/shm/#{name}"
-
-          file = File.open(path, File::RDWR | File::CREAT | File::EXCL, 0o600)
+          file = Tempfile.new("rbgl-wayland")
+          file.binmode
+          file.chmod(0o600)
           file.truncate(size)
-          File.unlink(path)
+          file.unlink
           file
-        rescue Errno::ENOENT
-          require "tempfile"
-          tmpfile = Tempfile.new("rbgl")
-          tmpfile.truncate(size)
-          tmpfile
+        end
+
+        def wait_for_initial_configure(xdg_surface)
+          configured = @connection.wait_until { xdg_surface.configured? }
+          return if configured
+
+          raise GUI::BackendUnavailable, "Wayland compositor did not configure the surface"
         end
 
       end

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

@@ -8,16 +8,11 @@ module RBGL
           result = String.new
 
           args.each do |arg|
-            case arg
-            when TypedArgument
-              result << pack_typed_argument(arg)
-            when Integer
-              result << [arg].pack("V")
-            when String
-              result << pack_string(arg)
-            when Float
-              result << [(arg * 256).to_i].pack("V")
+            unless arg.is_a?(TypedArgument)
+              raise ArgumentError, "Wayland requests require typed arguments"
             end
+
+            result << pack_typed_argument(arg)
           end
 
           result
@@ -45,8 +40,9 @@ module RBGL
         end
 
         def pack_string(value)
-          length = value.bytesize + 1
-          [length].pack("V") + value + "\x00" + ("\x00" * ((4 - length % 4) % 4))
+          bytes = value.to_s.encode(Encoding::UTF_8).b
+          length = bytes.bytesize + 1
+          [length].pack("V") + bytes + "\x00" + ("\x00" * ((4 - (length % 4)) % 4))
         end
       end
     end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "socket"
+require "io/wait"
 require_relative "protocol_objects"
 require_relative "codec"
 require_relative "event_dispatcher"
@@ -12,8 +13,9 @@ module RBGL
       class Connection
         DEFAULT_ROUNDTRIP_TIMEOUT = 1.0
         ROUNDTRIP_POLL_INTERVAL = 0.01
+        READ_CHUNK_SIZE = 16_384
 
-        attr_reader :compositor, :shm, :xdg_wm_base, :registry, :globals
+        attr_reader :compositor, :shm, :xdg_wm_base, :seat, :registry, :globals
 
         def initialize(env: ENV, socket_path: nil, roundtrip_timeout: DEFAULT_ROUNDTRIP_TIMEOUT)
           @env = env
@@ -23,6 +25,9 @@ module RBGL
           @next_id = 2
           @globals = {}
           @pending_events = []
+          @received_fds = []
+          @read_buffer = String.new(encoding: Encoding::BINARY)
+          @closed = false
 
           @display = Display.new(self)
           register_object(@display)
@@ -32,6 +37,13 @@ module RBGL
           roundtrip
 
           bind_globals
+        rescue StandardError => error
+          begin
+            close
+          rescue StandardError
+            nil
+          end
+          raise error
         end
 
         def allocate_id
@@ -49,25 +61,42 @@ module RBGL
           @objects[object_id]
         end
 
+        def unregister_object(object_id)
+          @objects.delete(object_id)
+        end
+
         def store_global(interface, name:, version:)
           @globals[interface] = { name: name, version: version }
         end
 
+        def remove_global(name)
+          @globals.delete_if { |_interface, global| global[:name] == name }
+        end
+
+        def consume_received_fd
+          @received_fds.shift
+        end
+
         def queue_event(event)
           @pending_events << event
         end
 
         def send_request(object_id, opcode, *args)
           payload = pack_args(args)
-          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
+          header = [object_id, ((payload.bytesize + 8) << 16) | opcode].pack("VV")
           @socket.write(header + payload)
         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
+
           payload = pack_args(args)
-          header = [object_id, (payload.bytesize + 8) << 16 | opcode].pack("VV")
+          header = [object_id, ((payload.bytesize + 8) << 16) | opcode].pack("VV")
 
-          @socket.sendmsg(header + payload, 0, nil, Socket::AncillaryData.unix_rights(fd))
+          @socket.sendmsg(header + payload, 0, nil, Socket::AncillaryData.unix_rights(io))
         end
 
         def flush
@@ -83,28 +112,16 @@ module RBGL
         end
 
         def pump_events(timeout: nil)
-          ready = IO.select([@socket], nil, nil, timeout)
-          return 0 unless ready
-
-          loop do
-            header = @socket.read(8)
-            break unless header && header.bytesize == 8
-
-            object_id, size_and_opcode = header.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)
-            break unless IO.select([@socket], nil, nil, 0)
-          end
+          read_from_socket(timeout) unless complete_message?
+          drain_messages
+          read_from_socket(0) if @socket.wait_readable(0)
+          drain_messages
 
           @pending_events.length
         end
 
         def roundtrip
           callback = @display.sync
-          @objects[callback.id] = callback
           flush
           deadline = monotonic_time + @roundtrip_timeout
 
@@ -115,6 +132,43 @@ module RBGL
           end
         end
 
+        def wait_until(timeout: @roundtrip_timeout)
+          deadline = monotonic_time + timeout
+
+          until yield
+            return false if monotonic_time >= deadline
+
+            pump_events(timeout: roundtrip_poll_interval(deadline))
+          end
+
+          true
+        end
+
+        def close
+          return if @closed
+
+          error = nil
+          @received_fds&.each do |fd|
+            fd.close unless fd.closed?
+          rescue StandardError => close_error
+            error ||= close_error
+          end
+          @received_fds&.reject!(&:closed?)
+
+          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 closed?
+          @closed || !@socket || @socket.closed?
+        end
+
         private
 
         def resolve_socket_path(socket_path = nil)
@@ -137,11 +191,74 @@ module RBGL
           event_dispatcher.handle_event(object_id, opcode, payload)
         end
 
+        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
+
+        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
+            message = @read_buffer.slice!(0, size)
+            handle_event(object_id, opcode, message.byteslice(8, size - 8))
+          end
+        end
+
+        def read_from_socket(timeout)
+          return false unless @socket.wait_readable(timeout)
+
+          read_any = false
+          loop do
+            message = receive_message
+            break if message == :wait_readable
+
+            chunk, ancillary_data = message
+            raise GUI::BackendUnavailable, "Wayland compositor closed the connection" if chunk.nil?
+
+            @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 receive_message
+          unless @socket.respond_to?(:recvmsg_nonblock)
+            chunk = @socket.read_nonblock(READ_CHUNK_SIZE, exception: false)
+            return :wait_readable if chunk == :wait_readable
+
+            return [chunk, []]
+          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