rbgl 0.1.0 → 1.0.0

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

@@ -1,6 +1,11 @@
 # frozen_string_literal: true
 
 require "socket"
+require_relative "../backend"
+require_relative "atom_cache"
+require_relative "event_parser"
+require_relative "request_encoder"
+require_relative "transport"
 
 module RBGL
   module GUI
@@ -12,7 +17,7 @@ module RBGL
         def initialize(display_name)
           host, display_num, _screen_num = parse_display_name(display_name)
           @socket = connect(host, display_num)
-          @next_seq = 1
+          @transport = Transport.new(@socket)
           @resource_id_counter = 0
           @pending_events = []
 
@@ -20,66 +25,54 @@ module RBGL
         end
 
         def generate_id
-          id = @resource_id_base | @resource_id_counter
+          masked_counter = @resource_id_counter & @resource_id_mask
+          raise GUI::BackendUnavailable, "X11 resource ID space exhausted" if masked_counter != @resource_id_counter
+
+          id = @resource_id_base | masked_counter
           @resource_id_counter += 1
           id
         end
 
         def flush
-          @socket.flush
+          transport.flush
         end
 
-        def pending
-          ready = IO.select([@socket], nil, nil, 0)
-          ready ? 1 : 0
+        def atom(name)
+          atom_cache.fetch(name)
         end
 
-        def create_window(depth:, wid:, parent:, x:, y:, width:, height:,
-                          border_width:, window_class:, visual:, value_mask:, values:)
-          class_val = case window_class
-                      when :input_output then 1
-                      when :input_only then 2
-                      else 0
-                      end
-
-          mask = 0
-          value_list = []
-
-          if value_mask.include?(:back_pixel)
-            mask |= 0x0002
-            value_list << values[:back_pixel]
-          end
+        def wm_delete_window_atom
+          atom(:wm_delete_window)
+        end
 
-          if value_mask.include?(:event_mask)
-            mask |= 0x0800
-            event_mask = 0
-            values[:event_mask].each do |ev|
-              event_mask |= case ev
-                            when :exposure then 0x8000
-                            when :key_press then 0x0001
-                            when :key_release then 0x0002
-                            when :button_press then 0x0004
-                            when :button_release then 0x0008
-                            when :pointer_motion then 0x0040
-                            when :structure_notify then 0x020000
-                            else 0
-                            end
-            end
-            value_list << event_mask
-          end
+        def wm_protocols_atom
+          atom(:wm_protocols)
+        end
 
-          request = [
-            depth,
-            wid,
-            parent,
-            x, y,
-            width, height,
-            border_width,
-            class_val,
-            visual,
-            mask
-          ].pack("CVVSSSSSVV") + value_list.pack("V*")
+        def enable_wm_delete_window(window)
+          change_property(window, :wm_protocols, :atom, [wm_delete_window_atom], format: 32)
+        end
 
+        def pending
+          transport.pending
+        end
+
+        def create_window(depth:, wid:, parent:, x:, y:, width:, height:,
+                          border_width:, window_class:, visual:, value_mask:, values:)
+          request = request_encoder.create_window_data(
+            depth: depth,
+            wid: wid,
+            parent: parent,
+            x: x,
+            y: y,
+            width: width,
+            height: height,
+            border_width: border_width,
+            window_class: window_class,
+            visual: visual,
+            value_mask: value_mask,
+            values: values
+          )
           send_request(1, request)
         end
 
@@ -92,76 +85,41 @@ module RBGL
         end
 
         def create_gc(gc_id, drawable, values = {})
-          mask = 0
-          value_list = []
-
-          if values[:foreground]
-            mask |= 0x0004
-            value_list << values[:foreground]
-          end
-
-          if values[:background]
-            mask |= 0x0008
-            value_list << values[:background]
-          end
-
-          request = [gc_id, drawable, mask].pack("VVV") + value_list.pack("V*")
+          request = request_encoder.create_gc_data(gc_id, drawable, values)
           send_request(55, request)
         end
 
         def put_image(format:, drawable:, gc:, width:, height:, dst_x:, dst_y:, depth:, data:)
-          format_byte = case format
-                        when :bitmap then 0
-                        when :xy_pixmap then 1
-                        when :z_pixmap then 2
-                        else 2
-                        end
-
-          left_pad = 0
-
-          header = [
-            drawable,
-            gc,
-            width, height,
-            dst_x, dst_y,
-            left_pad,
-            depth
-          ].pack("VVvvvvCC") + "\x00\x00"
-
-          send_request_with_data(72, format_byte, header, data)
-        end
-
-        def change_property(window, property, type, data, mode: :replace)
-          mode_val = case mode
-                     when :replace then 0
-                     when :prepend then 1
-                     when :append then 2
-                     else 0
-                     end
-
-          property_atom = get_atom(property)
-          type_atom = get_atom(type)
-
-          format = 8
-          data_bytes = data.to_s
-
-          request = [
+          format_byte, header, image_data = request_encoder.put_image_data(
+            format: format,
+            drawable: drawable,
+            gc: gc,
+            width: width,
+            height: height,
+            dst_x: dst_x,
+            dst_y: dst_y,
+            depth: depth,
+            data: data
+          )
+          send_request_with_data(72, format_byte, header, image_data)
+        end
+
+        def change_property(window, property, type, data, mode: :replace, format: 8)
+          property_atom = atom(property)
+          type_atom = atom(type)
+          mode_val, request = request_encoder.change_property_data(
             window,
             property_atom,
             type_atom,
-            format,
-            data_bytes.bytesize
-          ].pack("VVVCV") + "\x00\x00\x00" + pad_to_4(data_bytes)
-
+            data,
+            mode: mode,
+            format: format
+          )
           send_request(18, request, mode_val)
         end
 
         def intern_atom(name, only_if_exists: false)
-          request = [
-            name.bytesize,
-            0
-          ].pack("vv") + pad_to_4(name)
-
+          request = request_encoder.intern_atom_data(name)
           send_request(16, request, only_if_exists ? 1 : 0)
           flush
 
@@ -188,10 +146,12 @@ module RBGL
         private
 
         def parse_display_name(name)
-          if name =~ /^(?:(.+):)?(\d+)(?:\.(\d+))?$/
-            [::Regexp.last_match(1), ::Regexp.last_match(2).to_i, (::Regexp.last_match(3) || 0).to_i]
+          if name =~ /^(?:(.*):)?(\d+)(?:\.(\d+))?$/
+            host = ::Regexp.last_match(1)
+            host = nil if host&.empty?
+            [host, ::Regexp.last_match(2).to_i, (::Regexp.last_match(3) || 0).to_i]
           else
-            raise "Invalid display name: #{name}"
+            raise GUI::BackendUnavailable, "Invalid X11 display name: #{name}"
           end
         end
 
@@ -217,9 +177,11 @@ module RBGL
           @socket.flush
 
           header = @socket.read(8)
+          raise GUI::BackendUnavailable, "X11 connection closed during handshake" unless header&.bytesize == 8
+
           status = header.unpack1("C")
 
-          raise "X11 connection failed" unless status == 1
+          raise GUI::BackendUnavailable, "X11 connection failed" unless status == 1
 
           additional_length = header[6, 2].unpack1("v")
           data = @socket.read(additional_length * 4)
@@ -247,82 +209,34 @@ module RBGL
         end
 
         def send_request(opcode, data, extra = 0)
-          length = (4 + data.bytesize + 3) / 4
-          header = [opcode, extra, length].pack("CCv")
-
-          padding_size = length * 4 - 4 - data.bytesize
-          padded_data = data + ("\x00" * padding_size)
-
-          @socket.write(header + padded_data)
-          @next_seq += 1
+          transport.write(request_encoder.request_packet(opcode, data, extra))
         end
 
         def send_request_with_data(opcode, extra, header_data, bulk_data)
-          total_data = header_data + bulk_data
-          length = (4 + total_data.bytesize + 3) / 4
-
-          header = [opcode, extra, length].pack("CCv")
-          padding_size = length * 4 - 4 - total_data.bytesize
-          padded = total_data + ("\x00" * padding_size)
-
-          @socket.write(header + padded)
-          @next_seq += 1
+          transport.write(request_encoder.request_packet_with_data(opcode, extra, header_data, bulk_data))
         end
 
         def read_reply
-          header = @socket.read(32)
+          header = transport.read(32)
           return nil unless header && header.bytesize == 32
 
           additional = header[4, 4].unpack1("V")
           if additional > 0
-            header + @socket.read(additional * 4)
+            header + transport.read(additional * 4)
           else
             header
           end
         end
 
         def read_event
-          data = @socket.read(32)
-          return nil unless data && data.bytesize == 32
-
-          event_type = data.unpack1("C") & 0x7F
-
-          case event_type
-          when 2
-            keycode = data[1, 1].unpack1("C")
-            { type: :key_press, keycode: keycode }
-          when 3
-            keycode = data[1, 1].unpack1("C")
-            { type: :key_release, keycode: keycode }
-          when 4
-            x, y = data[24, 4].unpack("ss")
-            button = data[1, 1].unpack1("C")
-            { type: :button_press, x: x, y: y, button: button }
-          when 5
-            x, y = data[24, 4].unpack("ss")
-            button = data[1, 1].unpack1("C")
-            { type: :button_release, x: x, y: y, button: button }
-          when 6
-            x, y = data[24, 4].unpack("ss")
-            { type: :motion_notify, x: x, y: y }
-          when 12
-            { type: :exposure }
-          when 22
-            width, height = data[20, 4].unpack("vv")
-            { type: :configure_notify, width: width, height: height }
-          when 33
-            window = data[4, 4].unpack1("V")
-            atom = data[8, 4].unpack1("V")
-            { type: :client_message, window: window, data: atom }
-          else
-            { type: :unknown, code: event_type }
-          end
+          event_parser.parse(transport.read(32))
         end
 
-        def get_atom(name)
+        def resolve_atom(name)
           case name
           when :wm_name then 39
           when :string then 31
+          when :atom then 4
           when :wm_protocols then intern_atom("WM_PROTOCOLS")
           when :wm_delete_window then intern_atom("WM_DELETE_WINDOW")
           else
@@ -330,14 +244,35 @@ module RBGL
           end
         end
 
+        def pack_property_data(data, format)
+          request_encoder.pack_property_data(data, format)
+        end
+
         def pad_to_4(str)
-          padding = (4 - str.bytesize % 4) % 4
-          str + ("\x00" * padding)
+          request_encoder.pad_to_4(str)
         end
 
         def pad_length(len)
           ((len + 3) / 4) * 4
         end
+
+        def transport
+          return @transport if @transport&.socket.equal?(@socket)
+
+          @transport = Transport.new(@socket)
+        end
+
+        def request_encoder
+          @request_encoder ||= RequestEncoder.new
+        end
+
+        def event_parser
+          @event_parser ||= EventParser.new
+        end
+
+        def atom_cache
+          @atom_cache ||= AtomCache.new { |name| resolve_atom(name) }
+        end
       end
     end
   end

data/lib/rbgl/gui/x11/event_parser.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class EventParser
+        def parse(data)
+          return nil unless data && data.bytesize == 32
+
+          event_type = data.unpack1("C") & 0x7F
+
+          case event_type
+          when 2
+            key_event(:key_press, data)
+          when 3
+            key_event(:key_release, data)
+          when 4
+            button_event(:button_press, data)
+          when 5
+            button_event(:button_release, data)
+          when 6
+            x, y = data[24, 4].unpack("ss")
+            { type: :motion_notify, x: x, y: y }
+          when 12
+            { type: :exposure }
+          when 22
+            width, height = data[20, 4].unpack("vv")
+            { type: :configure_notify, width: width, height: height }
+          when 33
+            {
+              type: :client_message,
+              format: data[1, 1].unpack1("C"),
+              window: data[4, 4].unpack1("V"),
+              message_type: data[8, 4].unpack1("V"),
+              data32: data[12, 20].unpack("V5")
+            }
+          else
+            { type: :unknown, code: event_type }
+          end
+        end
+
+        private
+
+        def key_event(type, data)
+          { type: type, keycode: data[1, 1].unpack1("C") }
+        end
+
+        def button_event(type, data)
+          x, y = data[24, 4].unpack("ss")
+          {
+            type: type,
+            x: x,
+            y: y,
+            button: data[1, 1].unpack1("C")
+          }
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/x11/request_encoder.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class RequestEncoder
+        EVENT_MASKS = {
+          exposure: 0x8000,
+          key_press: 0x0001,
+          key_release: 0x0002,
+          button_press: 0x0004,
+          button_release: 0x0008,
+          pointer_motion: 0x0040,
+          structure_notify: 0x020000
+        }.freeze
+
+        WINDOW_CLASSES = {
+          input_output: 1,
+          input_only: 2
+        }.freeze
+
+        PROPERTY_MODES = {
+          replace: 0,
+          prepend: 1,
+          append: 2
+        }.freeze
+
+        IMAGE_FORMATS = {
+          bitmap: 0,
+          xy_pixmap: 1,
+          z_pixmap: 2
+        }.freeze
+
+        def create_window_data(depth:, wid:, parent:, x:, y:, width:, height:,
+                               border_width:, window_class:, visual:, value_mask:, values:)
+          mask = 0
+          value_list = []
+
+          if value_mask.include?(:back_pixel)
+            mask |= 0x0002
+            value_list << values[:back_pixel]
+          end
+
+          if value_mask.include?(:event_mask)
+            mask |= 0x0800
+            value_list << encode_event_mask(values[:event_mask])
+          end
+
+          [
+            depth,
+            wid,
+            parent,
+            x, y,
+            width, height,
+            border_width,
+            WINDOW_CLASSES.fetch(window_class, 0),
+            visual,
+            mask
+          ].pack("CVVSSSSSVV") + value_list.pack("V*")
+        end
+
+        def create_gc_data(gc_id, drawable, values = {})
+          mask = 0
+          value_list = []
+
+          if values[:foreground]
+            mask |= 0x0004
+            value_list << values[:foreground]
+          end
+
+          if values[:background]
+            mask |= 0x0008
+            value_list << values[:background]
+          end
+
+          [gc_id, drawable, mask].pack("VVV") + value_list.pack("V*")
+        end
+
+        def put_image_data(format:, drawable:, gc:, width:, height:, dst_x:, dst_y:, depth:, data:)
+          format_byte = IMAGE_FORMATS.fetch(format, IMAGE_FORMATS[:z_pixmap])
+          header = [
+            drawable,
+            gc,
+            width, height,
+            dst_x, dst_y,
+            0,
+            depth
+          ].pack("VVvvvvCC") + "\x00\x00"
+
+          [format_byte, header, data]
+        end
+
+        def change_property_data(window, property_atom, type_atom, data, mode: :replace, format: 8)
+          data_bytes, value_count = pack_property_data(data, format)
+          request = [
+            window,
+            property_atom,
+            type_atom,
+            format,
+            value_count
+          ].pack("VVVCV") + "\x00\x00\x00" + pad_to_4(data_bytes)
+
+          [PROPERTY_MODES.fetch(mode, 0), request]
+        end
+
+        def intern_atom_data(name)
+          [name.bytesize, 0].pack("vv") + pad_to_4(name)
+        end
+
+        def request_packet(opcode, data, extra = 0)
+          length = (4 + data.bytesize + 3) / 4
+          header = [opcode, extra, length].pack("CCv")
+          padding = "\x00" * (length * 4 - 4 - data.bytesize)
+          header + data + padding
+        end
+
+        def request_packet_with_data(opcode, extra, header_data, bulk_data)
+          total_data = header_data + bulk_data
+          length = (4 + total_data.bytesize + 3) / 4
+          header = [opcode, extra, length].pack("CCv")
+          padding = "\x00" * (length * 4 - 4 - total_data.bytesize)
+          header + total_data + padding
+        end
+
+        def pack_property_data(data, format)
+          case format
+          when 8
+            bytes = data.to_s
+            [bytes, bytes.bytesize]
+          when 16
+            values = Array(data)
+            [values.pack("v*"), values.size]
+          when 32
+            values = Array(data)
+            [values.pack("V*"), values.size]
+          else
+            raise ArgumentError, "Unsupported property format: #{format}"
+          end
+        end
+
+        def pad_to_4(str)
+          padding = (4 - str.bytesize % 4) % 4
+          str + ("\x00" * padding)
+        end
+
+        private
+
+        def encode_event_mask(events)
+          Array(events).sum { |event| EVENT_MASKS.fetch(event, 0) }
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui/x11/transport.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class Transport
+        attr_reader :socket
+
+        def initialize(socket)
+          @socket = socket
+        end
+
+        def write(data)
+          @socket.write(data)
+        end
+
+        def read(length)
+          @socket.read(length)
+        end
+
+        def flush
+          @socket.flush
+        end
+
+        def pending
+          IO.select([@socket], nil, nil, 0) ? 1 : 0
+        end
+      end
+    end
+  end
+end

data/lib/rbgl/gui.rb

@@ -2,6 +2,7 @@
 
 require_relative "gui/event"
 require_relative "gui/backend"
+require_relative "gui/backend_factory"
 require_relative "gui/file_backend"
 require_relative "gui/window"
 

data/lib/rbgl/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RBGL
-  VERSION = "0.1.0"
+  VERSION = "1.0.0"
 end