libui 0.3.0.pre2-x86_64-linux → 0.3.0.pre3-x86_64-linux

data/lib/libui.rb

@@ -2,6 +2,7 @@ require_relative 'libui/version'
 require_relative 'libui/utils'
 require_relative 'libui/error'
 require_relative 'libui/platform'
+require 'date'
 
 module LibUI
   class << self
@@ -20,11 +21,200 @@ module LibUI
     end
 
   require_relative 'libui/ffi'
+  require_relative 'libui/callback_registry'
   require_relative 'libui/libui_base'
+  require_relative 'libui/font'
+  require_relative 'libui/area_handler'
+  require_relative 'libui/table_model'
+  require_relative 'libui/draw_values'
+  require_relative 'libui/path'
 
   extend LibUIBase
 
   class << self
+    def control_on_destroyed(control, callback = nil, data = nil, &block)
+      callback = block if block
+      unless callback.nil? || callback.respond_to?(:call)
+        raise TypeError, 'expected a callable destruction callback'
+      end
+      CallbackRegistry.on_destroyed(control, callback, data)
+      nil
+    end
+
+    def queue_main(callback = nil, data = nil, &block)
+      callback = block if block
+      raise TypeError, 'expected a callable callback' unless callback.respond_to?(:call)
+
+      key = Object.new
+      closure = nil
+      closure = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_VOID, [Fiddle::TYPE_VOIDP]) do |native_data|
+        begin
+          callback.call(native_data)
+        rescue StandardError => e
+          CallbackRegistry.report(e)
+        ensure
+          CallbackRegistry.release_global(key)
+          closure.to_i
+        end
+      end
+      CallbackRegistry.global(key, closure)
+      FFI.uiQueueMain(closure, data)
+    rescue StandardError
+      CallbackRegistry.release_global(key) if key
+      raise
+    end
+
+    def timer(milliseconds, callback = nil, data = nil, &block)
+      callback = block if block
+      raise TypeError, 'expected a callable callback' unless callback.respond_to?(:call)
+
+      key = Object.new
+      closure = nil
+      closure = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_INT, [Fiddle::TYPE_VOIDP]) do |native_data|
+        result = begin
+          value = callback.call(native_data)
+          value == true ? 1 : (value == false || value.nil? ? 0 : Integer(value))
+        rescue StandardError => e
+          CallbackRegistry.report(e)
+          0
+        end
+        CallbackRegistry.release_global(key) if result.zero?
+        closure.to_i
+        result
+      end
+      CallbackRegistry.global(key, closure)
+      FFI.uiTimer(milliseconds, closure, data)
+    rescue StandardError
+      CallbackRegistry.release_global(key) if key
+      raise
+    end
+
+    def uninit
+      result = super
+      CallbackRegistry.clear
+      result
+    end
+
+    def toolbar_append_button(toolbar, text, icon = nil)
+      item = super(toolbar, text, icon)
+      CallbackRegistry.track_other_child(toolbar, item)
+      item
+    end
+
+    def toolbar_append_toggle_button(toolbar, text, icon = nil)
+      item = super(toolbar, text, icon)
+      CallbackRegistry.track_other_child(toolbar, item)
+      item
+    end
+
+    def free_toolbar(toolbar)
+      raise RuntimeError, 'detach toolbar from its window before freeing it' if CallbackRegistry.toolbar_attached?(toolbar)
+
+      result = super(toolbar)
+      CallbackRegistry.release_other(toolbar)
+      result
+    end
+
+    def window_set_toolbar(window, toolbar)
+      result = super(window, toolbar)
+      CallbackRegistry.attach_toolbar(window, toolbar)
+      result
+    end
+
+    def new_area(handler)
+      return super(handler) unless handler.is_a?(AreaHandler)
+
+      area = super(handler.to_ptr)
+      CallbackRegistry.control(area, :area_handler, handler)
+      area
+    end
+
+    def new_scrolling_area(handler, width, height)
+      return super(handler, width, height) unless handler.is_a?(AreaHandler)
+
+      area = super(handler.to_ptr, width, height)
+      CallbackRegistry.control(area, :area_handler, handler)
+      area
+    end
+
+    def new_table_model(handler)
+      return super(handler) unless handler.is_a?(TableModelHandler)
+
+      model = super(handler.to_ptr)
+      raise RuntimeError, 'libui-ng could not create table model' if model.nil? || model.null?
+
+      CallbackRegistry.other(model, :table_model_handler, handler)
+      model
+    end
+
+    def free_table_model(model)
+      return model.free if model.is_a?(TableModel)
+
+      result = super(model)
+      CallbackRegistry.release_other(model)
+      result
+    end
+
+    def new_table(params = nil, model: nil, row_background_color_model_column: -1)
+      return super(params) if model.nil?
+      raise ArgumentError, 'provide params or model, not both' unless params.nil?
+      raise TypeError, 'expected LibUI::TableModel' unless model.is_a?(TableModel)
+
+      native = FFI::TableParams.malloc
+      native.to_ptr.free = Fiddle::RUBY_FREE
+      native.Model = model.to_ptr
+      native.RowBackgroundColorModelColumn = row_background_color_model_column
+      table = super(native)
+      CallbackRegistry.control(table, :table_model, model)
+      CallbackRegistry.on_cleanup(table) { model.detach_table }
+      model.attach_table
+      table
+    end
+
+    def table_append_text_column(table, name, text_column, editable_column, options = nil,
+                                 color_model_column: nil)
+      super(table, name, text_column, editable_column,
+            table_text_params(options, color_model_column))
+    end
+
+    def table_append_image_text_column(table, name, image_column, text_column,
+                                       editable_column, options = nil, color_model_column: nil)
+      super(table, name, image_column, text_column, editable_column,
+            table_text_params(options, color_model_column))
+    end
+
+    def table_append_checkbox_text_column(table, name, checkbox_column,
+                                          checkbox_editable_column, text_column,
+                                          text_editable_column, options = nil,
+                                          color_model_column: nil)
+      super(table, name, checkbox_column, checkbox_editable_column,
+            text_column, text_editable_column,
+            table_text_params(options, color_model_column))
+    end
+
+    def draw_fill(context, path, brush)
+      super(context, path.is_a?(Path) ? path.to_ptr : path,
+            brush.is_a?(Brush) ? brush.to_ptr : brush)
+    end
+
+    def draw_stroke(context, path, brush, stroke_params)
+      super(context, path.is_a?(Path) ? path.to_ptr : path,
+            brush.is_a?(Brush) ? brush.to_ptr : brush,
+            stroke_params.is_a?(StrokeParams) ? stroke_params.to_ptr : stroke_params)
+    end
+
+    def draw_clip(context, path)
+      super(context, path.is_a?(Path) ? path.to_ptr : path)
+    end
+
+    def draw_transform(context, matrix)
+      super(context, matrix.is_a?(Matrix) ? matrix.to_ptr : matrix)
+    end
+
+    def version
+      super.to_s
+    end
+
     def init(opt = nil)
       # Allocate uiInitOptions if not provided
       unless opt
@@ -143,6 +333,246 @@ module LibUI
       super(str)
     end
 
+    def load_control_font(descriptor = nil)
+      return super(descriptor) if descriptor
+
+      read_font_descriptor { |native| super(native) }
+    end
+
+    def font_button_font(button, descriptor = nil)
+      return super(button, descriptor) if descriptor
+
+      read_font_descriptor { |native| super(button, native) }
+    end
+
+    def draw_new_text_layout(string_or_params, font: nil, width: -1, align: DrawTextAlignLeft)
+      return super(string_or_params) if font.nil?
+      raise TypeError, 'expected LibUI::Font' unless font.is_a?(Font)
+
+      native_family = Fiddle::Pointer.malloc(font.family.bytesize + 1, Fiddle::RUBY_FREE)
+      native_family[0, font.family.bytesize + 1] = font.family + "\0"
+      native_font = FFI::FontDescriptor.malloc
+      native_font.to_ptr.free = Fiddle::RUBY_FREE
+      native_font.Family = native_family
+      native_font.Size = font.size
+      native_font.Weight = font.weight
+      native_font.Italic = font.italic
+      native_font.Stretch = font.stretch
+
+      params = FFI::DrawTextLayoutParams.malloc
+      params.to_ptr.free = Fiddle::RUBY_FREE
+      params.String = string_or_params
+      params.DefaultFont = native_font
+      params.Width = width
+      params.Align = align
+      result = super(params)
+      # Keep both native allocations alive through the native call.
+      native_font.to_ptr.to_i
+      native_family.to_i
+      result
+    end
+
+    def window_title(window)
+      read_owned_text(super(window))
+    end
+
+    def button_text(button)
+      read_owned_text(super(button))
+    end
+
+    def checkbox_text(checkbox)
+      read_owned_text(super(checkbox))
+    end
+
+    def entry_text(entry)
+      read_owned_text(super(entry))
+    end
+
+    def label_text(label)
+      read_owned_text(super(label))
+    end
+
+    def group_title(group)
+      read_owned_text(super(group))
+    end
+
+    def editable_combobox_text(combobox)
+      read_owned_text(super(combobox))
+    end
+
+    def multiline_entry_text(entry)
+      read_owned_text(super(entry))
+    end
+
+    def open_file(window)
+      read_owned_text(super(window))
+    end
+
+    def open_folder(window)
+      read_owned_text(super(window))
+    end
+
+    def save_file(window)
+      read_owned_text(super(window))
+    end
+
+    def attribute_family(attribute)
+      read_borrowed_text(super(attribute))
+    end
+
+    def attributed_string_string(attributed_string)
+      read_borrowed_text(super(attributed_string))
+    end
+
+    def table_value_string(value)
+      read_borrowed_text(super(value))
+    end
+
+    def date_time_picker_time(picker)
+      tm = FFI::TM.malloc
+      tm.to_ptr.free = Fiddle::RUBY_FREE
+      super(picker, tm)
+      if tm.tm_isdst.negative?
+        Time.local(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+                   tm.tm_hour, tm.tm_min, tm.tm_sec)
+      else
+        # The ten-argument form preserves which side of a repeated DST hour was selected.
+        Time.local(tm.tm_sec, tm.tm_min, tm.tm_hour, tm.tm_mday,
+                   tm.tm_mon + 1, tm.tm_year + 1900, 0, 0,
+                   tm.tm_isdst != 0, nil)
+      end
+    end
+
+    def date_time_picker_set_time(picker, value)
+      local_time = case value
+                   when Time, DateTime then value.to_time.getlocal
+                   when Date then Time.local(value.year, value.month, value.day)
+                   else raise TypeError, 'expected Time, DateTime, or Date'
+                   end
+      tm = FFI::TM.malloc
+      tm.to_ptr.free = Fiddle::RUBY_FREE
+      tm.to_ptr[0, FFI::TM.size] = "\0" * FFI::TM.size
+      tm.tm_sec = local_time.sec
+      tm.tm_min = local_time.min
+      tm.tm_hour = local_time.hour
+      tm.tm_mday = local_time.day
+      tm.tm_mon = local_time.month - 1
+      tm.tm_year = local_time.year - 1900
+      tm.tm_wday = local_time.wday
+      tm.tm_yday = local_time.yday - 1
+      tm.tm_isdst = Fiddle::WINDOWS ? -1 : (local_time.dst? ? 1 : 0)
+      super(picker, tm)
+    end
+
+    def toolbar_item_text(item)
+      read_owned_text(super(item))
+    end
+
+    def toolbar_item_tooltip(item)
+      read_owned_text(super(item))
+    end
+
+    def window_content_size(window)
+      read_outputs('i', 2) { |width, height| super(window, width, height) }
+    end
+
+    def color_button_color(button)
+      read_outputs('d', 4) { |r, g, b, a| super(button, r, g, b, a) }
+    end
+
+    def table_value_color(value)
+      read_outputs('d', 4) { |r, g, b, a| super(value, r, g, b, a) }
+    end
+
+    def attribute_color(attribute)
+      read_outputs('d', 4) { |r, g, b, a| super(attribute, r, g, b, a) }
+    end
+
+    def attribute_underline_color(attribute)
+      color = nil
+      underline = read_outputs('i', 1) do |type|
+        color = read_outputs('d', 4) do |r, g, b, a|
+          super(attribute, type, r, g, b, a)
+        end
+      end
+      underline + color
+    end
+
+    def draw_text_layout_extents(layout)
+      read_outputs('d', 2) { |width, height| super(layout, width, height) }
+    end
+
+    def draw_matrix_transform_point(matrix, x, y)
+      matrix = matrix.to_ptr if matrix.is_a?(Matrix)
+      x_pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+      y_pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+      x_pointer[0, Fiddle::SIZEOF_DOUBLE] = [x].pack('d')
+      y_pointer[0, Fiddle::SIZEOF_DOUBLE] = [y].pack('d')
+      super(matrix, x_pointer, y_pointer)
+      [x_pointer[0, Fiddle::SIZEOF_DOUBLE].unpack1('d'),
+       y_pointer[0, Fiddle::SIZEOF_DOUBLE].unpack1('d')]
+    end
+
+    def draw_matrix_transform_size(matrix, x, y)
+      matrix = matrix.to_ptr if matrix.is_a?(Matrix)
+      x_pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+      y_pointer = Fiddle::Pointer.malloc(Fiddle::SIZEOF_DOUBLE, Fiddle::RUBY_FREE)
+      x_pointer[0, Fiddle::SIZEOF_DOUBLE] = [x].pack('d')
+      y_pointer[0, Fiddle::SIZEOF_DOUBLE] = [y].pack('d')
+      super(matrix, x_pointer, y_pointer)
+      [x_pointer[0, Fiddle::SIZEOF_DOUBLE].unpack1('d'),
+       y_pointer[0, Fiddle::SIZEOF_DOUBLE].unpack1('d')]
+    end
+
+    def table_get_selection(table)
+      selection = super(table)
+      return nil if selection.nil? || selection.null?
+
+      data = FFI::TableSelection.new(selection)
+      rows = data.Rows
+      Array.new(data.NumRows) do |index|
+        rows[index * Fiddle::SIZEOF_INT, Fiddle::SIZEOF_INT].unpack1('i')
+      end
+    ensure
+      free_table_selection(selection) if selection && !selection.null?
+    end
+
+    def table_set_selection(table, rows)
+      unless rows.is_a?(Array)
+        valid_native = rows.is_a?(FFI::TableSelection) ||
+                       (rows.is_a?(Fiddle::Pointer) && !rows.null?)
+        raise TypeError, 'expected an Array or native uiTableSelection' unless valid_native
+
+        return super(table, rows)
+      end
+
+      max_int = (1 << (Fiddle::SIZEOF_INT * 8 - 1)) - 1
+      raise RangeError, 'too many selected rows' if rows.length > max_int
+
+      rows.each do |row|
+        raise TypeError, 'row index must be an Integer' unless row.is_a?(Integer)
+        raise RangeError, 'row index is out of range' unless row.between?(0, max_int)
+      end
+
+      native_rows = if rows.empty?
+                      Fiddle::Pointer.new(0)
+                    else
+                      packed = rows.pack('i*')
+                      pointer = Fiddle::Pointer.malloc(packed.bytesize, Fiddle::RUBY_FREE)
+                      pointer[0, packed.bytesize] = packed
+                      pointer
+                    end
+      selection = FFI::TableSelection.malloc
+      selection.to_ptr.free = Fiddle::RUBY_FREE
+      selection.NumRows = rows.length
+      selection.Rows = native_rows
+      result = super(table, selection)
+      # Keep both native allocations alive until libui-ng copies the rows.
+      selection.to_ptr.to_i
+      native_rows.to_i
+      result
+    end
+
     # Gets the window position.
     # Coordinates are measured from the top left corner of the screen.
     # @param w [Fiddle::Pointer] Pointer of uiWindow instance.
@@ -172,9 +602,172 @@ module LibUI
       super(otf, a, b, c, d)
     end
 
-    def open_type_features_get(otf, a, b, c, d, value)
+    def open_type_features_get(otf, a, b, c, d)
       a, b, c, d = [a, b, c, d].map { |s| s.is_a?(String) ? s.ord : s }
-      super(otf, a, b, c, d, value)
+      value = Fiddle::Pointer.malloc(Fiddle::SIZEOF_INT, Fiddle::RUBY_FREE)
+      return nil if super(otf, a, b, c, d, value).zero?
+
+      value[0, Fiddle::SIZEOF_INT].unpack1('L')
+    end
+
+    # The native function copies the pixels before returning. The input must be
+    # premultiplied RGBA, with rows separated by byte_stride bytes.
+    def image_append(image, pixels, width, height, byte_stride)
+      [width, height, byte_stride].each do |number|
+        raise TypeError, 'image dimensions and stride must be Integers' unless number.is_a?(Integer)
+      end
+      raise ArgumentError, 'image dimensions must be positive' if width <= 0 || height <= 0
+      max_int = (1 << (Fiddle::SIZEOF_INT * 8 - 1)) - 1
+      raise RangeError, 'image dimensions or stride exceed C int' if [width, height, byte_stride].any? { |number| number > max_int }
+      raise ArgumentError, 'byte stride is too small' if byte_stride < width * 4
+      raise TypeError, 'pixels must be a String or Fiddle::Pointer' unless pixels.is_a?(String) || pixels.is_a?(Fiddle::Pointer)
+      if pixels.is_a?(String) && pixels.bytesize < byte_stride * height
+        raise ArgumentError, 'pixel buffer is shorter than stride * height'
+      end
+      if pixels.is_a?(Fiddle::Pointer) && pixels.size.positive? && pixels.size < byte_stride * height
+        raise ArgumentError, 'pixel buffer is shorter than stride * height'
+      end
+
+      super(image, pixels, width, height, byte_stride)
+    end
+
+    # Convert straight RGBA (as used by PNG libraries) to premultiplied RGBA.
+    def image_append_rgba(image, pixels, width, height, byte_stride = width * 4)
+      raise TypeError, 'pixels must be a String' unless pixels.is_a?(String)
+      [width, height, byte_stride].each do |number|
+        raise TypeError, 'image dimensions and stride must be Integers' unless number.is_a?(Integer)
+      end
+      raise ArgumentError, 'image dimensions must be positive' if width <= 0 || height <= 0
+      raise ArgumentError, 'byte stride is too small' if byte_stride < width * 4
+      raise ArgumentError, 'pixel buffer is shorter than stride * height' if pixels.bytesize < byte_stride * height
+
+      converted = pixels.b.dup
+      height.times do |y|
+        width.times do |x|
+          offset = y * byte_stride + x * 4
+          alpha = converted.getbyte(offset + 3)
+          3.times do |channel|
+            converted.setbyte(offset + channel, (converted.getbyte(offset + channel) * alpha + 127) / 255)
+          end
+        end
+      end
+      image_append(image, converted, width, height, byte_stride)
+    end
+
+    def open_type_features_for_each(features)
+      return enum_for(__method__, features) unless block_given?
+
+      error = nil
+      callback = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_INT,
+                                                  [Fiddle::TYPE_VOIDP] + [Fiddle::TYPE_CHAR] * 4 +
+                                                  [Fiddle::TYPE_UINT32_T, Fiddle::TYPE_VOIDP]) do |_features, a, b, c, d, value, _data|
+        begin
+          tag = [a, b, c, d].pack('C*').force_encoding(Encoding::ASCII_8BIT)
+          yield(tag, value) == ForEachStop ? ForEachStop : ForEachContinue
+        rescue StandardError => e
+          error = e
+          ForEachStop
+        end
+      end
+      FFI.uiOpenTypeFeaturesForEach(features, callback, nil)
+      raise error if error
+
+      features
+    end
+
+    def attribute_features(attribute)
+      borrowed = super(attribute)
+      return nil if borrowed.nil? || borrowed.null?
+
+      open_type_features_for_each(borrowed).to_h
+    end
+
+    # Values are copied during the callback; native attribute pointers expire
+    # as soon as the callback returns.
+    def attributed_string_for_each_attribute(string)
+      return enum_for(__method__, string) unless block_given?
+
+      error = nil
+      callback = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_INT,
+                                                  [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP,
+                                                   Fiddle::TYPE_SIZE_T, Fiddle::TYPE_SIZE_T,
+                                                   Fiddle::TYPE_VOIDP]) do |_string, attribute, first, last, _data|
+        begin
+          yield(attribute_snapshot(attribute), first, last) == ForEachStop ? ForEachStop : ForEachContinue
+        rescue StandardError => e
+          error = e
+          ForEachStop
+        end
+      end
+      FFI.uiAttributedStringForEachAttribute(string, callback, nil)
+      raise error if error
+
+      string
+    end
+
+    private
+
+    def table_text_params(options, color_model_column)
+      return options if color_model_column.nil?
+      raise ArgumentError, 'provide options or color_model_column, not both' unless options.nil?
+
+      native = FFI::TableTextColumnOptionalParams.malloc
+      native.to_ptr.free = Fiddle::RUBY_FREE
+      native.ColorModelColumn = Integer(color_model_column)
+      native
+    end
+
+    def attribute_snapshot(attribute)
+      type = attribute_get_type(attribute)
+      value = case type
+              when AttributeTypeFamily then attribute_family(attribute)
+              when AttributeTypeSize then attribute_size(attribute)
+              when AttributeTypeWeight then attribute_weight(attribute)
+              when AttributeTypeItalic then attribute_italic(attribute)
+              when AttributeTypeStretch then attribute_stretch(attribute)
+              when AttributeTypeColor then attribute_color(attribute)
+              # libui-ng exposes no getter for a background attribute's color.
+              when AttributeTypeBackground then nil
+              when AttributeTypeUnderline then attribute_underline(attribute)
+              when AttributeTypeUnderlineColor then attribute_underline_color(attribute)
+              when AttributeTypeFeatures then attribute_features(attribute)
+              else raise ArgumentError, "unknown attribute type: #{type}"
+              end
+      { type: type, value: value }
+    end
+
+    def read_font_descriptor
+      descriptor = FFI::FontDescriptor.malloc
+      descriptor.to_ptr.free = Fiddle::RUBY_FREE
+      filled = false
+      yield(descriptor)
+      filled = true
+      Font.new(family: descriptor.Family.to_s.force_encoding(Encoding::UTF_8),
+               size: descriptor.Size, weight: descriptor.Weight,
+               italic: descriptor.Italic, stretch: descriptor.Stretch)
+    ensure
+      free_font_descriptor(descriptor) if filled
+    end
+
+    def read_owned_text(pointer)
+      return nil if pointer.nil? || pointer.null?
+
+      pointer.to_s.force_encoding(Encoding::UTF_8)
+    ensure
+      free_text(pointer) if pointer && !pointer.null?
+    end
+
+    def read_borrowed_text(pointer)
+      return nil if pointer.nil? || pointer.null?
+
+      pointer.to_s.force_encoding(Encoding::UTF_8)
+    end
+
+    def read_outputs(format, count)
+      size = format == 'd' ? Fiddle::SIZEOF_DOUBLE : Fiddle::SIZEOF_INT
+      pointers = Array.new(count) { Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE) }
+      yield(*pointers)
+      pointers.map { |pointer| pointer[0, size].unpack1(format) }
     end
   end
 
@@ -335,6 +928,12 @@ module LibUI
   AtTrailing = 2
   AtBottom   = 3
 
+  # ToolbarDisplayMode
+  ToolbarDisplayModeIconOnly              = 0
+  ToolbarDisplayModeIconAndTextHorizontal = 1
+  ToolbarDisplayModeIconAndTextVertical   = 2
+  ToolbarDisplayModeTextOnly              = 3
+
   # ImageViewContentMode
   ImageViewContentCenter = 0
   ImageViewContentFit    = 1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: libui
 version: !ruby/object:Gem::Version
-  version: 0.3.0.pre2
+  version: 0.3.0.pre3
 platform: x86_64-linux
 authors:
 - kojix2
@@ -32,11 +32,17 @@ files:
 - LICENSE.txt
 - README.md
 - lib/libui.rb
+- lib/libui/area_handler.rb
+- lib/libui/callback_registry.rb
+- lib/libui/draw_values.rb
 - lib/libui/error.rb
 - lib/libui/ffi.rb
 - lib/libui/fiddle_patch.rb
+- lib/libui/font.rb
 - lib/libui/libui_base.rb
+- lib/libui/path.rb
 - lib/libui/platform.rb
+- lib/libui/table_model.rb
 - lib/libui/utils.rb
 - lib/libui/version.rb
 - vendor/LICENSE.md
@@ -60,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Ruby bindings to libui
 test_files: []