rbgl 1.0.0 → 1.0.2

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

@@ -4,24 +4,44 @@ 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)
           @transport = Transport.new(@socket)
           @resource_id_counter = 0
           @pending_events = []
+          @pending_replies = {}
+          @sequence = 0
+          @default_screen = screen_num
+          @reply_timeout = reply_timeout
 
-          handshake
+          handshake(host: host, display_num: display_num, env: env)
+          load_keyboard_mapping
+        rescue StandardError
+          @transport&.close
+          raise
         end
 
         def generate_id
@@ -34,7 +54,7 @@ module RBGL
         end
 
         def flush
-          transport.flush
+          @transport.flush
         end
 
         def atom(name)
@@ -53,13 +73,20 @@ module RBGL
           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
+
         def pending
-          transport.pending
+          @pending_events.length + @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_byte, request = request_encoder.create_window_data(
             depth: depth,
             wid: wid,
             parent: parent,
@@ -73,7 +100,7 @@ module RBGL
             value_mask: value_mask,
             values: values
           )
-          send_request(1, request)
+          send_request(1, request, depth_byte)
         end
 
         def map_window(wid)
@@ -89,19 +116,30 @@ module RBGL
           send_request(55, request)
         end
 
-        def put_image(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)
+        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
+
+          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, format: 8)
@@ -120,12 +158,10 @@ module RBGL
 
         def intern_atom(name, only_if_exists: false)
           request = request_encoder.intern_atom_data(name)
-          send_request(16, request, only_if_exists ? 1 : 0)
+          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
 
@@ -137,18 +173,22 @@ 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+))?$/
             host = ::Regexp.last_match(1)
-            host = nil if host&.empty?
+            host = nil if host && host.empty?
             [host, ::Regexp.last_match(2).to_i, (::Regexp.last_match(3) || 0).to_i]
           else
             raise GUI::BackendUnavailable, "Invalid X11 display name: #{name}"
@@ -164,102 +204,160 @@ 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)
+          header = @transport.read_exact(8, timeout: @reply_timeout)
           raise GUI::BackendUnavailable, "X11 connection closed during handshake" unless header&.bytesize == 8
 
           status = header.unpack1("C")
-
-          raise GUI::BackendUnavailable, "X11 connection failed" unless status == 1
+          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)
-          transport.write(request_encoder.request_packet(opcode, data, extra))
+          @transport.write(request_encoder.request_packet(opcode, data, extra))
+          next_sequence
         end
 
         def send_request_with_data(opcode, extra, header_data, bulk_data)
-          transport.write(request_encoder.request_packet_with_data(opcode, extra, header_data, bulk_data))
+          @transport.write(request_encoder.request_packet_with_data(opcode, extra, header_data, bulk_data))
+          next_sequence
         end
 
-        def read_reply
-          header = transport.read(32)
-          return nil unless header && header.bytesize == 32
+        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
 
-          additional = header[4, 4].unpack1("V")
-          if additional > 0
-            header + transport.read(additional * 4)
-          else
-            header
+        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_event
-          event_parser.parse(transport.read(32))
-        end
+        def read_reply(expected_sequence = nil)
+          return @pending_replies.delete(expected_sequence) if expected_sequence && @pending_replies.key?(expected_sequence)
 
-        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
-            name.is_a?(Integer) ? name : intern_atom(name.to_s)
+          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 pack_property_data(data, format)
-          request_encoder.pack_property_data(data, format)
+        def read_event
+          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
+
+          parse_event(packet)
         end
 
-        def pad_to_4(str)
-          request_encoder.pad_to_4(str)
+        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 transport
-          return @transport if @transport&.socket.equal?(@socket)
-
-          @transport = Transport.new(@socket)
+        def local_display_host?(host)
+          host.nil? || host.empty? || host == "unix"
         end
 
         def request_encoder
@@ -273,6 +371,38 @@ module RBGL
         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

@@ -19,7 +19,7 @@ module RBGL
           when 5
             button_event(:button_release, data)
           when 6
-            x, y = data[24, 4].unpack("ss")
+            x, y = data[24, 4].unpack("s<s<")
             { type: :motion_notify, x: x, y: y }
           when 12
             { type: :exposure }
@@ -34,6 +34,13 @@ module RBGL
               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
@@ -46,7 +53,7 @@ module RBGL
         end
 
         def button_event(type, data)
-          x, y = data[24, 4].unpack("ss")
+          x, y = data[24, 4].unpack("s<s<")
           {
             type: type,
             x: x,
@@ -54,6 +61,10 @@ module RBGL
             button: data[1, 1].unpack1("C")
           }
         end
+
+        def mapping_request(code)
+          { 0 => :modifier, 1 => :keyboard, 2 => :pointer }.fetch(code, :unknown)
+        end
       end
     end
   end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      module KeyMapper
+        SPECIAL_KEYSYMS = {
+          0xFF08 => :backspace,
+          0xFF09 => :tab,
+          0xFF0D => :enter,
+          0xFF1B => :escape,
+          0xFF50 => :home,
+          0xFF51 => :left,
+          0xFF52 => :up,
+          0xFF53 => :right,
+          0xFF54 => :down,
+          0xFF55 => :page_up,
+          0xFF56 => :page_down,
+          0xFF57 => :end,
+          0xFF63 => :insert,
+          0xFFFF => :delete,
+          0xFFE1 => :left_shift,
+          0xFFE2 => :right_shift,
+          0xFFE3 => :left_control,
+          0xFFE4 => :right_control,
+          0xFFE7 => :left_meta,
+          0xFFE8 => :right_meta,
+          0xFFE9 => :left_alt,
+          0xFFEA => :right_alt
+        }.merge((0xFFBE..0xFFC9).zip((1..12).map { |number| :"f#{number}" }).to_h).freeze
+
+        DIGIT_NAMES = %i[zero one two three four five six seven eight nine].freeze
+
+        module_function
+
+        def key(keysym, fallback:)
+          return fallback if keysym.nil? || keysym.zero?
+          return SPECIAL_KEYSYMS[keysym] if SPECIAL_KEYSYMS.key?(keysym)
+          return :space if keysym == 0x20
+          return DIGIT_NAMES[keysym - 0x30] if keysym.between?(0x30, 0x39)
+          return keysym.chr.downcase.to_sym if keysym.between?(0x41, 0x5A) || keysym.between?(0x61, 0x7A)
+
+          fallback
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class PixelEncoder
+        TRUE_COLOR_CLASSES = [4, 5].freeze
+        IMAGE_BYTE_ORDERS = %i[little big].freeze
+
+        attr_reader :bytes_per_pixel
+
+        def initialize(bits_per_pixel:, scanline_pad:, visual_class:, red_mask:, green_mask:, blue_mask:,
+                       image_byte_order: :little)
+          unless TRUE_COLOR_CLASSES.include?(visual_class)
+            raise GUI::BackendUnavailable, "X11 root visual must be TrueColor or DirectColor"
+          end
+          unless [16, 24, 32].include?(bits_per_pixel)
+            raise GUI::BackendUnavailable, "Unsupported X11 pixel width: #{bits_per_pixel}"
+          end
+          unless IMAGE_BYTE_ORDERS.include?(image_byte_order)
+            raise GUI::BackendUnavailable, "Unsupported X11 image byte order: #{image_byte_order}"
+          end
+
+          @bytes_per_pixel = bits_per_pixel / 8
+          @scanline_alignment = scanline_pad / 8
+          @image_byte_order = image_byte_order
+          @red_lut = channel_lut(red_mask)
+          @green_lut = channel_lut(green_mask)
+          @blue_lut = channel_lut(blue_mask)
+          @standard_bgra = bits_per_pixel == 32 && image_byte_order == :little &&
+                           red_mask == 0x00FF0000 && green_mask == 0x0000FF00 && blue_mask == 0x000000FF
+        end
+
+        def bytes_per_line(width)
+          aligned_length(width * @bytes_per_pixel)
+        end
+
+        def encode(framebuffer)
+          stride = bytes_per_line(framebuffer.width)
+          if @standard_bgra
+            return pad_rows(framebuffer.to_bgra_bytes, framebuffer.width * 4, stride, framebuffer.height)
+          end
+
+          output = String.new(capacity: stride * framebuffer.height, encoding: Encoding::BINARY)
+          row_pixels = 0
+
+          framebuffer.each_packed_pixel do |color|
+            append_pixel(
+              output,
+              @red_lut[(color >> 16) & 0xFF] |
+              @green_lut[(color >> 8) & 0xFF] |
+              @blue_lut[color & 0xFF]
+            )
+            row_pixels += 1
+            next unless row_pixels == framebuffer.width
+
+            append_padding(output, stride - (framebuffer.width * @bytes_per_pixel))
+            row_pixels = 0
+          end
+
+          output
+        end
+
+        def encode_rgba(buffer, width, height)
+          if @standard_bgra
+            output = String.new(capacity: bytes_per_line(width) * height, encoding: Encoding::BINARY)
+            encode_standard_rgba(output, buffer, width, height)
+            return output
+          end
+
+          encode_arbitrary_rgba(buffer, width, height)
+        end
+
+        private
+
+        def encode_standard_rgba(output, buffer, width, height)
+          stride = bytes_per_line(width)
+          row_bytes = width * 4
+          byte_index = 0
+
+          height.times do
+            width.times do
+              output << buffer.getbyte(byte_index + 2) << buffer.getbyte(byte_index + 1) <<
+                        buffer.getbyte(byte_index) << buffer.getbyte(byte_index + 3)
+              byte_index += 4
+            end
+            append_padding(output, stride - row_bytes)
+          end
+        end
+
+        def encode_arbitrary_rgba(buffer, width, height)
+          stride = bytes_per_line(width)
+          output = String.new(capacity: stride * height, encoding: Encoding::BINARY)
+          byte_index = 0
+
+          height.times do
+            width.times do
+              append_pixel(
+                output,
+                @red_lut[buffer.getbyte(byte_index)] |
+                @green_lut[buffer.getbyte(byte_index + 1)] |
+                @blue_lut[buffer.getbyte(byte_index + 2)]
+              )
+              byte_index += 4
+            end
+            append_padding(output, stride - (width * @bytes_per_pixel))
+          end
+
+          output
+        end
+
+        def append_pixel(output, pixel)
+          if @image_byte_order == :little
+            index = 0
+            while index < @bytes_per_pixel
+              output << ((pixel >> (index * 8)) & 0xFF)
+              index += 1
+            end
+          else
+            index = @bytes_per_pixel - 1
+            while index >= 0
+              output << ((pixel >> (index * 8)) & 0xFF)
+              index -= 1
+            end
+          end
+        end
+
+        def append_padding(output, length)
+          output << ("\x00" * length) if length.positive?
+        end
+
+        def channel_lut(mask)
+          raise GUI::BackendUnavailable, "X11 visual has an empty color mask" if mask.zero?
+
+          shift = 0
+          shifted = mask
+          while shifted & 1 == 0
+            shifted >>= 1
+            shift += 1
+          end
+          maximum = shifted
+          Array.new(256) { |value| ((value * maximum / 255.0).round << shift) }.freeze
+        end
+
+        def pad_rows(bytes, row_bytes, stride, height)
+          return bytes if row_bytes == stride
+
+          output = String.new(capacity: stride * height, encoding: Encoding::BINARY)
+          height.times do |row|
+            output << bytes.byteslice(row * row_bytes, row_bytes)
+            append_padding(output, stride - row_bytes)
+          end
+          output
+        end
+
+        def aligned_length(length)
+          return length if @scanline_alignment <= 1
+
+          ((length + @scanline_alignment - 1) / @scanline_alignment) * @scanline_alignment
+        end
+      end
+    end
+  end
+end