rbgl 1.0.0 → 1.0.2

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

@@ -46,17 +46,18 @@ module RBGL
             value_list << encode_event_mask(values[:event_mask])
           end
 
-          [
-            depth,
+          data = [
             wid,
             parent,
             x, y,
             width, height,
             border_width,
-            WINDOW_CLASSES.fetch(window_class, 0),
+            WINDOW_CLASSES.fetch(window_class),
             visual,
             mask
-          ].pack("CVVSSSSSVV") + value_list.pack("V*")
+          ].pack("VVs<s<vvvvVV") + value_list.pack("V*")
+
+          [depth, data]
         end
 
         def create_gc_data(gc_id, drawable, values = {})
@@ -77,7 +78,7 @@ module RBGL
         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])
+          format_byte = IMAGE_FORMATS.fetch(format)
           header = [
             drawable,
             gc,
@@ -85,22 +86,19 @@ module RBGL
             dst_x, dst_y,
             0,
             depth
-          ].pack("VVvvvvCC") + "\x00\x00"
+          ].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,
-            value_count
-          ].pack("VVVCV") + "\x00\x00\x00" + pad_to_4(data_bytes)
-
-          [PROPERTY_MODES.fetch(mode, 0), request]
+          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)
@@ -108,24 +106,17 @@ module RBGL
         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
+          encode_packet(opcode, extra, data)
         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
+          encode_packet(opcode, extra, header_data + bulk_data)
         end
 
         def pack_property_data(data, format)
           case format
           when 8
-            bytes = data.to_s
+            bytes = data.to_s.b
             [bytes, bytes.bytesize]
           when 16
             values = Array(data)
@@ -139,14 +130,24 @@ module RBGL
         end
 
         def pad_to_4(str)
-          padding = (4 - str.bytesize % 4) % 4
-          str + ("\x00" * padding)
+          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, 0) }
+          Array(events).sum { |event| EVENT_MASKS.fetch(event) }
         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

@@ -1,13 +1,18 @@
 # 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)
@@ -15,7 +20,12 @@ module RBGL
         end
 
         def read(length)
-          @socket.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
@@ -23,7 +33,47 @@ module RBGL
         end
 
         def pending
-          IO.select([@socket], nil, nil, 0) ? 1 : 0
+          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

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

data/lib/rbgl/gui.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "version"
 require_relative "gui/event"
 require_relative "gui/backend"
 require_relative "gui/backend_factory"
@@ -8,10 +9,6 @@ require_relative "gui/window"
 
 module RBGL
   module GUI
-    VERSION = "0.1.0"
-
-    def self.load_tk_backend
-      require_relative "gui/tk_backend"
-    end
+    VERSION = RBGL::VERSION
   end
 end

data/lib/rbgl/version.rb

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

metadata

@@ -1,77 +1,81 @@
 --- !ruby/object:Gem::Specification
 name: rbgl
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.2
 platform: ruby
 authors:
 - Yudai Takada
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: larb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rlsl
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '1.0'
 description: A pure Ruby graphics library with software rendering engine and cross-platform
   GUI support (X11, Wayland, Cocoa).
 email:
 - t.yudai92@gmail.com
-executables: []
+executables:
+- rbgl
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codespellignore"
+- ".rubocop.yml"
+- ".yamllint"
 - CHANGELOG.md
 - LICENSE
 - README.md
 - Rakefile
+- bench/renderer_bench.rb
+- docs/.nojekyll
+- docs/index.html
 - examples/array_test.rb
-- examples/chemical_heartbeat.rb
 - examples/color_test.rb
 - examples/cube_spinning.rb
-- examples/dark_transit.rb
-- examples/fractured_orb.rb
-- examples/fractured_orb_rb.rb
 - examples/gradient.rb
-- examples/hexagonal_flow.rb
 - examples/multi_return_test.rb
 - examples/plasma.rb
 - examples/sphere_raymarch.rb
-- examples/teapot.rb
-- examples/teapot_mcu.rb
 - examples/triangle_basic.rb
 - examples/triangle_window.rb
 - examples/window_test.rb
+- exe/rbgl
 - lib/rbgl.rb
+- lib/rbgl/cli/doctor.rb
 - lib/rbgl/engine.rb
 - lib/rbgl/engine/buffer.rb
 - lib/rbgl/engine/clip_space_clipper.rb
 - lib/rbgl/engine/context.rb
 - lib/rbgl/engine/framebuffer.rb
+- lib/rbgl/engine/immutable_color.rb
 - lib/rbgl/engine/pipeline.rb
 - lib/rbgl/engine/rasterizer.rb
 - lib/rbgl/engine/rasterizer/attribute_interpolator.rb
@@ -87,19 +91,23 @@ files:
 - lib/rbgl/gui/backend.rb
 - lib/rbgl/gui/backend_factory.rb
 - lib/rbgl/gui/cocoa/backend.rb
+- lib/rbgl/gui/cocoa/key_mapper.rb
 - lib/rbgl/gui/event.rb
 - lib/rbgl/gui/file_backend.rb
 - lib/rbgl/gui/file_backend/bmp_writer.rb
 - lib/rbgl/gui/file_backend/frame_writer.rb
+- lib/rbgl/gui/file_backend/png_writer.rb
 - lib/rbgl/gui/file_backend/ppm_writer.rb
 - lib/rbgl/gui/wayland/backend.rb
 - lib/rbgl/gui/wayland/codec.rb
 - lib/rbgl/gui/wayland/connection.rb
 - lib/rbgl/gui/wayland/event_dispatcher.rb
 - lib/rbgl/gui/wayland/global_binder.rb
+- lib/rbgl/gui/wayland/input_mapper.rb
 - lib/rbgl/gui/wayland/protocol_objects.rb
 - lib/rbgl/gui/wayland/protocol_objects/arguments.rb
 - lib/rbgl/gui/wayland/protocol_objects/display.rb
+- lib/rbgl/gui/wayland/protocol_objects/seat.rb
 - lib/rbgl/gui/wayland/protocol_objects/shm.rb
 - lib/rbgl/gui/wayland/protocol_objects/surface.rb
 - lib/rbgl/gui/wayland/protocol_objects/xdg_shell.rb
@@ -110,16 +118,21 @@ files:
 - lib/rbgl/gui/x11/backend.rb
 - lib/rbgl/gui/x11/connection.rb
 - lib/rbgl/gui/x11/event_parser.rb
+- lib/rbgl/gui/x11/key_mapper.rb
+- lib/rbgl/gui/x11/pixel_encoder.rb
 - lib/rbgl/gui/x11/request_encoder.rb
+- lib/rbgl/gui/x11/setup_parser.rb
 - lib/rbgl/gui/x11/transport.rb
+- lib/rbgl/gui/x11/x_authority.rb
 - lib/rbgl/version.rb
-homepage: https://github.com/ydah/rbgl
+homepage: https://rbgfx.github.io/rbgl/
 licenses:
 - MIT
 metadata:
-  homepage_uri: https://github.com/ydah/rbgl
-  source_code_uri: https://github.com/ydah/rbgl
-  changelog_uri: https://github.com/ydah/rbgl/blob/main/CHANGELOG.md
+  homepage_uri: https://rbgfx.github.io/rbgl/
+  source_code_uri: https://github.com/rbgfx/rbgl/tree/main
+  changelog_uri: https://github.com/rbgfx/rbgl/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -134,7 +147,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 3.4.19
+signing_key:
 specification_version: 4
 summary: RuBy Graphics Library - Pure Ruby software rendering with cross-platform
   GUI