rbgl 0.1.0 → 1.0.1

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

@@ -1,86 +1,106 @@
 # frozen_string_literal: true
 
 require "socket"
+require_relative "../backend"
+require_relative "atom_cache"
+require_relative "event_parser"
+require_relative "key_mapper"
+require_relative "request_encoder"
+require_relative "setup_parser"
+require_relative "transport"
+require_relative "x_authority"
 
 module RBGL
   module GUI
     module X11
       class Connection
+        DEFAULT_REPLY_TIMEOUT = 5.0
+
+        ATOM_NAMES = {
+          wm_protocols: "WM_PROTOCOLS",
+          wm_delete_window: "WM_DELETE_WINDOW"
+        }.freeze
+
         attr_reader :default_screen, :resource_id_base, :resource_id_mask
         attr_reader :root, :root_depth, :root_visual, :white_pixel, :black_pixel
+        attr_reader :maximum_request_length, :bits_per_pixel, :scanline_pad
+        attr_reader :visual_class, :red_mask, :green_mask, :blue_mask, :image_byte_order
 
-        def initialize(display_name)
-          host, display_num, _screen_num = parse_display_name(display_name)
+        def initialize(display_name, env: ENV, reply_timeout: DEFAULT_REPLY_TIMEOUT)
+          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 = []
-
-          handshake
+          @pending_replies = {}
+          @sequence = 0
+          @default_screen = screen_num
+          @reply_timeout = reply_timeout
+
+          handshake(host: host, display_num: display_num, env: env)
+          load_keyboard_mapping
+        rescue StandardError
+          @transport&.close
+          raise
         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
+
+        def enable_wm_delete_window(window)
+          change_property(window, :wm_protocols, :atom, [wm_delete_window_atom], format: 32)
+        end
+
+        def key_for_keycode(keycode)
+          load_keyboard_mapping unless @keyboard_mapping
+          keysyms = @keyboard_mapping[keycode]
+          keysym = keysyms&.find { |candidate| !candidate.zero? }
+          KeyMapper.key(keysym, fallback: keycode)
+        end
 
-          request = [
-            depth,
-            wid,
-            parent,
-            x, y,
-            width, height,
-            border_width,
-            class_val,
-            visual,
-            mask
-          ].pack("CVVSSSSSVV") + value_list.pack("V*")
+        def pending
+          @pending_events.length + @transport.pending
+        end
 
-          send_request(1, request)
+        def create_window(depth:, wid:, parent:, x:, y:, width:, height:,
+                          border_width:, window_class:, visual:, value_mask:, values:)
+          depth_byte, 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, depth_byte)
         end
 
         def map_window(wid)
@@ -92,82 +112,56 @@ 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"
+        def put_image(format:, drawable:, gc:, width:, height:, dst_x:, dst_y:, depth:, data:, bytes_per_line:)
+          maximum_data = (@maximum_request_length * 4) - 24
+          if bytes_per_line > maximum_data
+            raise GUI::BackendUnavailable, "An X11 image row exceeds the server request limit"
+          end
 
-          send_request_with_data(72, format_byte, header, data)
+          rows_per_request = [maximum_data / bytes_per_line, 1].max
+          offset_y = 0
+          while offset_y < height
+            row_count = [rows_per_request, height - offset_y].min
+            chunk = data.byteslice(offset_y * bytes_per_line, row_count * bytes_per_line)
+            send_image_chunk(
+              format: format,
+              drawable: drawable,
+              gc: gc,
+              width: width,
+              height: row_count,
+              dst_x: dst_x,
+              dst_y: dst_y + offset_y,
+              depth: depth,
+              data: chunk
+            )
+            offset_y += row_count
+          end
         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 = [
+        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)
-
-          send_request(16, request, only_if_exists ? 1 : 0)
+          request = request_encoder.intern_atom_data(name)
+          sequence = send_request(16, request, only_if_exists ? 1 : 0)
           flush
 
-          reply = read_reply
-          return 0 unless reply
-
+          reply = read_reply(sequence)
           reply[8, 4].unpack1("V")
         end
 
@@ -179,19 +173,25 @@ module RBGL
         end
 
         def read_events
-          while pending > 0
+          while @transport.pending > 0
             event = read_event
             @pending_events << event if event
           end
         end
 
+        def close
+          @transport.close
+        end
+
         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 && 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
 
@@ -204,140 +204,205 @@ module RBGL
           end
         end
 
-        def handshake
-          init_request = [
-            0x6C,
-            0,
-            11, 0,
-            0, 0,
-            0, 0
-          ].pack("CCvvvvvv")
+        def handshake(host: nil, display_num: 0, env: ENV)
+          auth_host = local_display_host?(host) ? nil : host
+          cookie = XAuthority.cookie_for(host: auth_host, display_number: display_num, env: env)
+          auth_name = cookie ? XAuthority::AUTH_NAME : ""
+          auth_data = cookie || ""
+          init_request = [0x6C, 0, 11, 0, auth_name.bytesize, auth_data.bytesize, 0].pack("CCvvvvv")
+          init_request << request_encoder.pad_to_4(auth_name)
+          init_request << request_encoder.pad_to_4(auth_data)
 
-          @socket.write(init_request)
-          @socket.flush
+          @transport.write(init_request)
+          @transport.flush
 
-          header = @socket.read(8)
-          status = header.unpack1("C")
+          header = @transport.read_exact(8, timeout: @reply_timeout)
+          raise GUI::BackendUnavailable, "X11 connection closed during handshake" unless header&.bytesize == 8
 
-          raise "X11 connection failed" unless status == 1
+          status = header.unpack1("C")
+          unless status == 1
+            reason_length = header.getbyte(1)
+            reason = if reason_length.positive?
+                       @transport.read_exact(pad_length(reason_length), timeout: @reply_timeout)
+                                 .byteslice(0, reason_length)
+                     end
+            detail = reason && !reason.empty? ? ": #{reason}" : ""
+            raise GUI::BackendUnavailable, "X11 connection failed#{detail}"
+          end
 
           additional_length = header[6, 2].unpack1("v")
-          data = @socket.read(additional_length * 4)
+          data = @transport.read_exact(additional_length * 4, timeout: @reply_timeout)
 
           parse_server_info(data)
+        rescue EOFError, IO::WaitReadable => error
+          raise GUI::BackendUnavailable, "X11 handshake failed: #{error.message}"
         end
 
         def parse_server_info(data)
-          @resource_id_base = data[4, 4].unpack1("V")
-          @resource_id_mask = data[8, 4].unpack1("V")
-
-          vendor_length = data[16, 2].unpack1("v")
-          num_screens = data[20, 1].unpack1("C")
-          num_formats = data[21, 1].unpack1("C")
-
-          offset = 32 + pad_length(vendor_length) + num_formats * 8
-
-          if num_screens > 0
-            @root = data[offset, 4].unpack1("V")
-            @root_depth = data[offset + 38, 1].unpack1("C")
-            @root_visual = data[offset + 32, 4].unpack1("V")
-            @white_pixel = data[offset + 8, 4].unpack1("V")
-            @black_pixel = data[offset + 12, 4].unpack1("V")
-          end
+          setup = SetupParser.new.parse(data)
+          screen = setup.screens.fetch(@default_screen)
+          format = setup.pixmap_formats.find { |candidate| candidate.depth == screen.root_depth }
+          depth = screen.depths.find { |candidate| candidate.depth == screen.root_depth }
+          visual = depth&.visuals&.find { |candidate| candidate.id == screen.root_visual }
+          raise GUI::BackendUnavailable, "No X11 pixmap format for root depth #{screen.root_depth}" unless format
+          raise GUI::BackendUnavailable, "No X11 visual group for root depth #{screen.root_depth}" unless depth
+          raise GUI::BackendUnavailable, "No X11 root visual metadata for #{screen.root_visual}" unless visual
+
+          @resource_id_base = setup.resource_id_base
+          @resource_id_mask = setup.resource_id_mask
+          @maximum_request_length = setup.maximum_request_length
+          @minimum_keycode = setup.minimum_keycode
+          @maximum_keycode = setup.maximum_keycode
+          @image_byte_order = setup.image_byte_order
+          @root = screen.root
+          @root_depth = screen.root_depth
+          @root_visual = screen.root_visual
+          @white_pixel = screen.white_pixel
+          @black_pixel = screen.black_pixel
+          @bits_per_pixel = format.bits_per_pixel
+          @scanline_pad = format.scanline_pad
+          @visual_class = visual.visual_class
+          @red_mask = visual.red_mask
+          @green_mask = visual.green_mask
+          @blue_mask = visual.blue_mask
+        rescue IndexError
+          raise GUI::BackendUnavailable, "X11 screen #{@default_screen} is unavailable"
         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))
+          next_sequence
         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
+          @transport.write(request_encoder.request_packet_with_data(opcode, extra, header_data, bulk_data))
+          next_sequence
+        end
 
-          header = [opcode, extra, length].pack("CCv")
-          padding_size = length * 4 - 4 - total_data.bytesize
-          padded = total_data + ("\x00" * padding_size)
+        def send_image_chunk(format:, drawable:, gc:, width:, height:, dst_x:, dst_y:, depth:, data:)
+          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
 
-          @socket.write(header + padded)
-          @next_seq += 1
+        def load_keyboard_mapping
+          count = @maximum_keycode - @minimum_keycode + 1
+          request = [@minimum_keycode, count, 0].pack("CCv")
+          sequence = send_request(101, request)
+          flush
+          reply = read_reply(sequence)
+          keysyms_per_keycode = reply.getbyte(1)
+          keysyms = reply.byteslice(32..).unpack("V*")
+          @keyboard_mapping = {}
+
+          count.times do |index|
+            offset = index * keysyms_per_keycode
+            @keyboard_mapping[@minimum_keycode + index] = keysyms.slice(offset, keysyms_per_keycode)
+          end
         end
 
-        def read_reply
-          header = @socket.read(32)
-          return nil unless header && header.bytesize == 32
+        def read_reply(expected_sequence = nil)
+          return @pending_replies.delete(expected_sequence) if expected_sequence && @pending_replies.key?(expected_sequence)
 
-          additional = header[4, 4].unpack1("V")
-          if additional > 0
-            header + @socket.read(additional * 4)
-          else
-            header
+          loop do
+            packet = read_packet
+            type = packet.getbyte(0)
+            sequence = packet.byteslice(2, 2).unpack1("v")
+
+            case type
+            when 0
+              raise_protocol_error(packet)
+            when 1
+              return packet if expected_sequence.nil? || sequence == expected_sequence
+
+              @pending_replies[sequence] = packet
+            else
+              event = parse_event(packet)
+              @pending_events << event if event
+            end
           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 }
+          packet = read_packet
+          type = packet.getbyte(0)
+          return raise_protocol_error(packet) if type.zero?
+
+          if type == 1
+            sequence = packet.byteslice(2, 2).unpack1("v")
+            @pending_replies[sequence] = packet
+            return nil
           end
-        end
 
-        def get_atom(name)
-          case name
-          when :wm_name then 39
-          when :string then 31
-          when :wm_protocols then intern_atom("WM_PROTOCOLS")
-          when :wm_delete_window then intern_atom("WM_DELETE_WINDOW")
-          else
-            name.is_a?(Integer) ? name : intern_atom(name.to_s)
-          end
+          parse_event(packet)
         end
 
-        def pad_to_4(str)
-          padding = (4 - str.bytesize % 4) % 4
-          str + ("\x00" * padding)
+        def resolve_atom(name)
+          return name if name.is_a?(Integer)
+
+          intern_atom(ATOM_NAMES.fetch(name, name.to_s))
         end
 
         def pad_length(len)
           ((len + 3) / 4) * 4
         end
+
+        def local_display_host?(host)
+          host.nil? || host.empty? || host == "unix"
+        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
+
+        def read_packet
+          header = @transport.read_exact(32, timeout: @reply_timeout)
+          return header unless header.getbyte(0) == 1
+
+          additional = header.byteslice(4, 4).unpack1("V")
+          additional.positive? ? header + @transport.read_exact(additional * 4, timeout: @reply_timeout) : header
+        rescue EOFError, IO::WaitReadable => error
+          raise GUI::BackendUnavailable, error.message
+        end
+
+        def parse_event(packet)
+          event = event_parser.parse(packet)
+          @keyboard_mapping = nil if event&.[](:type) == :mapping_notify && event[:request] == :keyboard
+          event
+        end
+
+        def raise_protocol_error(packet)
+          error_code = packet.getbyte(1)
+          sequence = packet.byteslice(2, 2).unpack1("v")
+          bad_value = packet.byteslice(4, 4).unpack1("V")
+          minor_opcode = packet.byteslice(8, 2).unpack1("v")
+          major_opcode = packet.getbyte(10)
+          raise GUI::BackendUnavailable,
+                "X11 protocol error #{error_code} for request #{sequence} " \
+                "(opcode #{major_opcode}.#{minor_opcode}, value #{bad_value})"
+        end
+
+        def next_sequence
+          @sequence = (@sequence + 1) & 0xFFFF
+        end
+
       end
     end
   end

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

@@ -0,0 +1,71 @@
+# 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("s<s<")
+            { 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")
+            }
+          when 34
+            {
+              type: :mapping_notify,
+              request: mapping_request(data.getbyte(1)),
+              first_keycode: data.getbyte(4),
+              count: data.getbyte(5)
+            }
+          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("s<s<")
+          {
+            type: type,
+            x: x,
+            y: y,
+            button: data[1, 1].unpack1("C")
+          }
+        end
+
+        def mapping_request(code)
+          { 0 => :modifier, 1 => :keyboard, 2 => :pointer }.fetch(code, :unknown)
+        end
+      end
+    end
+  end
+end