rbgl 0.1.0 → 1.0.1

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

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

@@ -0,0 +1,155 @@
+# 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
+
+          data = [
+            wid,
+            parent,
+            x, y,
+            width, height,
+            border_width,
+            WINDOW_CLASSES.fetch(window_class),
+            visual,
+            mask
+          ].pack("VVs<s<vvvvVV") + value_list.pack("V*")
+
+          [depth, data]
+        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)
+          header = [
+            drawable,
+            gc,
+            width, height,
+            dst_x, dst_y,
+            0,
+            depth
+          ].pack("VVvvs<s<CC") + "\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].pack("VVVC") +
+                    "\x00\x00\x00" +
+                    [value_count].pack("V") +
+                    pad_to_4(data_bytes)
+
+          [PROPERTY_MODES.fetch(mode), request]
+        end
+
+        def intern_atom_data(name)
+          [name.bytesize, 0].pack("vv") + pad_to_4(name)
+        end
+
+        def request_packet(opcode, data, extra = 0)
+          encode_packet(opcode, extra, data)
+        end
+
+        def request_packet_with_data(opcode, extra, header_data, bulk_data)
+          encode_packet(opcode, extra, header_data + bulk_data)
+        end
+
+        def pack_property_data(data, format)
+          case format
+          when 8
+            bytes = data.to_s.b
+            [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)
+          bytes = str.b
+          padding = (4 - (bytes.bytesize % 4)) % 4
+          bytes + ("\x00" * padding)
+        end
+
+        private
+
+        def encode_packet(opcode, extra, data)
+          length = (4 + data.bytesize + 3) / 4
+          raise ArgumentError, "X11 request exceeds the 16-bit core protocol limit" if length > 65_535
+
+          header = [opcode, extra, length].pack("CCv")
+          padding = "\x00" * ((length * 4) - 4 - data.bytesize)
+          header + data + padding
+        end
+
+        def encode_event_mask(events)
+          Array(events).sum { |event| EVENT_MASKS.fetch(event) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module RBGL
+  module GUI
+    module X11
+      class SetupParser
+        Setup = Struct.new(
+          :resource_id_base,
+          :resource_id_mask,
+          :maximum_request_length,
+          :image_byte_order,
+          :minimum_keycode,
+          :maximum_keycode,
+          :pixmap_formats,
+          :screens,
+          keyword_init: true
+        )
+        PixmapFormat = Struct.new(:depth, :bits_per_pixel, :scanline_pad, keyword_init: true)
+        Depth = Struct.new(:depth, :visuals, keyword_init: true)
+        Screen = Struct.new(
+          :root,
+          :white_pixel,
+          :black_pixel,
+          :root_visual,
+          :root_depth,
+          :depths,
+          keyword_init: true
+        ) do
+          def visuals
+            depths.flat_map(&:visuals)
+          end
+        end
+        Visual = Struct.new(:id, :visual_class, :red_mask, :green_mask, :blue_mask, keyword_init: true)
+
+        def parse(data)
+          raise ArgumentError, "Truncated X11 setup response" if data.bytesize < 32
+
+          vendor_length = data.byteslice(16, 2).unpack1("v")
+          screen_count = data.getbyte(20)
+          format_count = data.getbyte(21)
+          format_offset = 32 + padded_length(vendor_length)
+          formats = parse_formats(data, format_offset, format_count)
+          screens = parse_screens(data, format_offset + (format_count * 8), screen_count)
+
+          Setup.new(
+            resource_id_base: data.byteslice(4, 4).unpack1("V"),
+            resource_id_mask: data.byteslice(8, 4).unpack1("V"),
+            maximum_request_length: data.byteslice(18, 2).unpack1("v"),
+            image_byte_order: parse_image_byte_order(data.getbyte(22)),
+            minimum_keycode: data.getbyte(26),
+            maximum_keycode: data.getbyte(27),
+            pixmap_formats: formats,
+            screens: screens
+          )
+        end
+
+        private
+
+        def parse_formats(data, offset, count)
+          count.times.map do |index|
+            bytes = required_slice(data, offset + (index * 8), 8)
+            PixmapFormat.new(
+              depth: bytes.getbyte(0),
+              bits_per_pixel: bytes.getbyte(1),
+              scanline_pad: bytes.getbyte(2)
+            )
+          end
+        end
+
+        def parse_screens(data, offset, count)
+          screens = []
+          count.times do
+            screen, offset = parse_screen(data, offset)
+            screens << screen
+          end
+          screens
+        end
+
+        def parse_screen(data, offset)
+          header = required_slice(data, offset, 40)
+          depth_count = header.getbyte(39)
+          cursor = offset + 40
+          depths = []
+
+          depth_count.times do
+            depth_header = required_slice(data, cursor, 8)
+            depth_value = depth_header.getbyte(0)
+            visual_count = depth_header.byteslice(2, 2).unpack1("v")
+            cursor += 8
+            visuals = []
+            visual_count.times do
+              visuals << parse_visual(required_slice(data, cursor, 24))
+              cursor += 24
+            end
+            depths << Depth.new(depth: depth_value, visuals: visuals)
+          end
+
+          screen = Screen.new(
+            root: header.byteslice(0, 4).unpack1("V"),
+            white_pixel: header.byteslice(8, 4).unpack1("V"),
+            black_pixel: header.byteslice(12, 4).unpack1("V"),
+            root_visual: header.byteslice(32, 4).unpack1("V"),
+            root_depth: header.getbyte(38),
+            depths: depths
+          )
+          [screen, cursor]
+        end
+
+        def parse_visual(bytes)
+          Visual.new(
+            id: bytes.byteslice(0, 4).unpack1("V"),
+            visual_class: bytes.getbyte(4),
+            red_mask: bytes.byteslice(8, 4).unpack1("V"),
+            green_mask: bytes.byteslice(12, 4).unpack1("V"),
+            blue_mask: bytes.byteslice(16, 4).unpack1("V")
+          )
+        end
+
+        def required_slice(data, offset, length)
+          bytes = data.byteslice(offset, length)
+          raise ArgumentError, "Truncated X11 setup response" unless bytes&.bytesize == length
+
+          bytes
+        end
+
+        def padded_length(length)
+          (length + 3) & ~3
+        end
+
+        def parse_image_byte_order(value)
+          { 0 => :little, 1 => :big }.fetch(value) do
+            raise ArgumentError, "Unsupported X11 image byte order: #{value}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "io/wait"
+
+module RBGL
+  module GUI
+    module X11
+      class Transport
+        READ_CHUNK_SIZE = 16_384
+
+        attr_reader :socket
+
+        def initialize(socket)
+          @socket = socket
+          @read_buffer = String.new(encoding: Encoding::BINARY)
+        end
+
+        def write(data)
+          @socket.write(data)
+        end
+
+        def read(length)
+          read_exact(length)
+        end
+
+        def read_exact(length, timeout: nil)
+          fill_buffer(length, timeout: timeout)
+          @read_buffer.slice!(0, length)
+        end
+
+        def flush
+          @socket.flush
+        end
+
+        def pending
+          read_available
+          return 0 if @read_buffer.bytesize < 32
+
+          packet_size = 32
+          if @read_buffer.getbyte(0) == 1
+            packet_size += @read_buffer.byteslice(4, 4).unpack1("V") * 4
+          end
+          @read_buffer.bytesize >= packet_size ? 1 : 0
+        end
+
+        def close
+          @socket.close unless @socket.closed?
+        end
+
+        private
+
+        def fill_buffer(length, timeout:)
+          deadline = timeout && (monotonic_time + timeout)
+
+          while @read_buffer.bytesize < length
+            wait = deadline && [deadline - monotonic_time, 0].max
+            raise IO::EAGAINWaitReadable unless @socket.wait_readable(wait)
+
+            read_available
+          end
+        end
+
+        def read_available
+          return unless @socket.wait_readable(0)
+
+          loop do
+            chunk = @socket.read_nonblock(READ_CHUNK_SIZE, exception: false)
+            break if chunk == :wait_readable
+            raise EOFError, "X11 server closed the connection" if chunk.nil?
+
+            @read_buffer << chunk
+          end
+        end
+
+        def monotonic_time
+          Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "socket"
+require "ipaddr"
+
+module RBGL
+  module GUI
+    module X11
+      class XAuthority
+        FAMILY_INTERNET = 0
+        FAMILY_INTERNET6 = 6
+        FAMILY_LOCAL = 256
+        FAMILY_WILD = 65_535
+        AUTH_NAME = "MIT-MAGIC-COOKIE-1"
+
+        Entry = Struct.new(:family, :address, :display_number, :name, :data, keyword_init: true)
+
+        def self.cookie_for(host:, display_number:, env: ENV)
+          path = env["XAUTHORITY"] || default_path(env)
+          return nil unless path && File.file?(path)
+
+          new(File.binread(path)).cookie_for(host: host, display_number: display_number)
+        rescue ArgumentError, EOFError
+          nil
+        end
+
+        def self.default_path(env)
+          home = env["HOME"] || Dir.home
+          File.join(home, ".Xauthority")
+        rescue ArgumentError
+          nil
+        end
+
+        def initialize(data)
+          @entries = parse(data)
+        end
+
+        def cookie_for(host:, display_number:)
+          candidates = @entries.select do |entry|
+            (entry.display_number.empty? || entry.display_number == display_number.to_s) && entry.name == AUTH_NAME
+          end
+          candidates.find { |entry| address_matches?(entry, host) }&.data
+        end
+
+        private
+
+        def parse(data)
+          offset = 0
+          entries = []
+
+          while offset < data.bytesize
+            family, offset = read_u16(data, offset)
+            address, offset = read_field(data, offset)
+            display_number, offset = read_field(data, offset)
+            name, offset = read_field(data, offset)
+            cookie, offset = read_field(data, offset)
+            entries << Entry.new(
+              family: family,
+              address: address,
+              display_number: display_number,
+              name: name,
+              data: cookie
+            )
+          end
+
+          entries
+        end
+
+        def read_u16(data, offset)
+          bytes = data.byteslice(offset, 2)
+          raise EOFError, "Truncated Xauthority entry" unless bytes&.bytesize == 2
+
+          [bytes.unpack1("n"), offset + 2]
+        end
+
+        def read_field(data, offset)
+          length, offset = read_u16(data, offset)
+          value = data.byteslice(offset, length)
+          raise EOFError, "Truncated Xauthority field" unless value&.bytesize == length
+
+          [value, offset + length]
+        end
+
+        def address_matches?(entry, host)
+          return true if entry.family == FAMILY_WILD
+          return local_address_matches?(entry.address) if host.nil? && entry.family == FAMILY_LOCAL
+          return false unless [FAMILY_INTERNET, FAMILY_INTERNET6].include?(entry.family)
+
+          family = entry.family == FAMILY_INTERNET ? :INET : :INET6
+          Addrinfo.getaddrinfo(host, nil, family).any? do |address|
+            IPAddr.new(address.ip_address).hton == entry.address
+          end
+        rescue SocketError
+          false
+        end
+
+        def local_address_matches?(address)
+          return true if address.empty?
+
+          expected = address.downcase
+          actual = Socket.gethostname.downcase
+          expected == actual || expected.split(".", 2).first == actual.split(".", 2).first
+        end
+      end
+    end
+  end
+end