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

data/lib/libui/callback_registry.rb

@@ -0,0 +1,123 @@
+module LibUI
+  # Native controls can outlive the Ruby pointer returned by their constructor.
+  # Keep closures by native address until libui-ng reports destruction.
+  module CallbackRegistry
+    @controls = {}
+    @destroy_hooks = {}
+    @other = {}
+    @other_children = {}
+    @attached_toolbars = {}
+    @toolbar_window_hooks = {}
+    @global = {}
+
+    class << self
+      def control(pointer, key, callback)
+        raise ArgumentError, 'control pointer is null' if pointer.nil? || pointer.to_i.zero?
+
+        address = pointer.to_i
+        callbacks = (@controls[address] ||= {})
+        unless @destroy_hooks.key?(address)
+          hook = nil
+          hook = Fiddle::Closure::BlockCaller.new(Fiddle::TYPE_VOID,
+                                                   [Fiddle::TYPE_VOIDP, Fiddle::TYPE_VOIDP]) do |native, _data|
+            destroyed_address = native.to_i
+            begin
+              callbacks = @controls[destroyed_address]
+              callbacks&.fetch(:cleanup, [])&.each do |cleanup|
+                begin
+                  cleanup.call
+                rescue StandardError => e
+                  report(e)
+                end
+              end
+              user = callbacks&.delete(:on_destroyed)
+              user[0].call(native, user[1]) if user && user[0]
+            rescue StandardError => e
+              report(e)
+            ensure
+              @controls.delete(destroyed_address)
+              @destroy_hooks.delete(destroyed_address)
+              hook.to_i
+            end
+          end
+          @destroy_hooks[address] = hook
+          begin
+            FFI.uiControlOnDestroyed(pointer, hook, nil)
+          rescue StandardError
+            @destroy_hooks.delete(address)
+            @controls.delete(address) if callbacks.empty?
+            raise
+          end
+        end
+        callbacks[key] = callback
+      end
+
+      def on_destroyed(pointer, callback, data)
+        control(pointer, :on_destroyed, [callback, data])
+      end
+
+      def on_cleanup(pointer, &block)
+        control(pointer, :cleanup, []) unless @controls.dig(pointer.to_i, :cleanup)
+        @controls[pointer.to_i][:cleanup] << block
+      end
+
+      def other(pointer, key, callback)
+        (@other[pointer.to_i] ||= {})[key] = callback
+      end
+
+      def release_other(pointer)
+        address = pointer.to_i
+        @other.delete(address)
+        (@other_children.delete(address) || []).each { |child| @other.delete(child) }
+        @attached_toolbars.delete(address)
+      end
+
+      def track_other_child(parent, child)
+        (@other_children[parent.to_i] ||= []) << child.to_i
+      end
+
+      def attach_toolbar(window, toolbar)
+        window_address = window.to_i
+        @attached_toolbars.delete_if { |_toolbar, owner| owner == window_address }
+        return if toolbar.nil? || toolbar.to_i.zero?
+
+        @attached_toolbars[toolbar.to_i] = window_address
+        return if @toolbar_window_hooks[window_address]
+
+        on_cleanup(window) do
+          @attached_toolbars.delete_if { |_toolbar, owner| owner == window_address }
+          @toolbar_window_hooks.delete(window_address)
+        end
+        @toolbar_window_hooks[window_address] = true
+      end
+
+      def toolbar_attached?(toolbar)
+        @attached_toolbars.key?(toolbar.to_i)
+      end
+
+      def global(key, callback)
+        @global[key] = callback
+      end
+
+      def release_global(key)
+        @global.delete(key)
+      end
+
+      def clear
+        @controls.clear
+        @destroy_hooks.clear
+        @other.clear
+        @other_children.clear
+        @attached_toolbars.clear
+        @toolbar_window_hooks.clear
+        @global.clear
+      end
+
+      def report(error)
+        warn "LibUI callback error: #{error.full_message}"
+      end
+    end
+  end
+
+  private_constant :CallbackRegistry
+end

data/lib/libui/draw_values.rb

@@ -0,0 +1,143 @@
+module LibUI
+  class Brush
+    GradientStop = Struct.new(:position, :red, :green, :blue, :alpha,
+                              keyword_init: true)
+
+    def initialize(type: DrawBrushTypeSolid, color: [0.0, 0.0, 0.0, 1.0],
+                   x0: 0.0, y0: 0.0, x1: 0.0, y1: 0.0, outer_radius: 0.0,
+                   stops: [])
+      @native = FFI::DrawBrush.malloc
+      @native.to_ptr.free = Fiddle::RUBY_FREE
+      @native.to_ptr[0, FFI::DrawBrush.size] = "\0" * FFI::DrawBrush.size
+      @native.Type = type
+      self.color = color
+      @native.X0 = x0
+      @native.Y0 = y0
+      @native.X1 = x1
+      @native.Y1 = y1
+      @native.OuterRadius = outer_radius
+      self.stops = stops
+    end
+
+    def to_ptr
+      @native.to_ptr
+    end
+
+    def color=(rgba)
+      unless rgba.is_a?(Array) && rgba.length == 4 && rgba.all? { |component| component.is_a?(Numeric) }
+        raise TypeError, 'color must be an RGBA array'
+      end
+      @native.R, @native.G, @native.B, @native.A = rgba
+    end
+
+    def stops=(stops)
+      raise TypeError, 'stops must be an Array' unless stops.is_a?(Array)
+
+      size = FFI::DrawBrushGradientStop.size
+      pointer = stops.empty? ? Fiddle::Pointer.new(0) : Fiddle::Pointer.malloc(size * stops.length, Fiddle::RUBY_FREE)
+      stops.each_with_index do |entry, index|
+        stop = entry.is_a?(GradientStop) ? entry.to_a : entry
+        unless stop.is_a?(Array) && stop.length == 5 && stop.all? { |value| value.is_a?(Numeric) }
+          raise TypeError, 'each stop must have position, red, green, blue, alpha'
+        end
+        native = FFI::DrawBrushGradientStop.new(pointer + index * size)
+        native.Pos, native.R, native.G, native.B, native.A = stop
+      end
+      @stops_pointer = pointer
+      @native.Stops = pointer
+      @native.NumStops = stops.length
+    end
+  end
+
+  class StrokeParams
+    def initialize(cap: DrawLineCapFlat, join: DrawLineJoinMiter,
+                   thickness: 1.0, miter_limit: DrawDefaultMiterLimit,
+                   dashes: [], dash_phase: 0.0)
+      @native = FFI::DrawStrokeParams.malloc
+      @native.to_ptr.free = Fiddle::RUBY_FREE
+      @native.to_ptr[0, FFI::DrawStrokeParams.size] = "\0" * FFI::DrawStrokeParams.size
+      @native.Cap = cap
+      @native.Join = join
+      @native.Thickness = thickness
+      @native.MiterLimit = miter_limit
+      @native.DashPhase = dash_phase
+      self.dashes = dashes
+    end
+
+    def to_ptr
+      @native.to_ptr
+    end
+
+    def dashes=(values)
+      unless values.is_a?(Array) && values.all? { |value| value.is_a?(Numeric) && value.positive? }
+        raise TypeError, 'dashes must be an array of positive numbers'
+      end
+      bytes = values.pack('d*')
+      pointer = if values.empty?
+                  Fiddle::Pointer.new(0)
+                else
+                  allocated = Fiddle::Pointer.malloc(bytes.bytesize, Fiddle::RUBY_FREE)
+                  allocated[0, bytes.bytesize] = bytes
+                  allocated
+                end
+      @dashes_pointer = pointer
+      @native.Dashes = pointer
+      @native.NumDashes = values.length
+    end
+  end
+
+  class Matrix
+    def initialize
+      @native = FFI::DrawMatrix.malloc
+      @native.to_ptr.free = Fiddle::RUBY_FREE
+      LibUI.draw_matrix_set_identity(@native)
+    end
+
+    def to_ptr
+      @native.to_ptr
+    end
+
+    def translate(x, y)
+      LibUI.draw_matrix_translate(@native, x, y)
+      self
+    end
+
+    def scale(center_x, center_y, x, y)
+      LibUI.draw_matrix_scale(@native, center_x, center_y, x, y)
+      self
+    end
+
+    def rotate(x, y, angle)
+      LibUI.draw_matrix_rotate(@native, x, y, angle)
+      self
+    end
+
+    def skew(x, y, x_amount, y_amount)
+      LibUI.draw_matrix_skew(@native, x, y, x_amount, y_amount)
+      self
+    end
+
+    def multiply(other)
+      raise TypeError, 'expected LibUI::Matrix' unless other.is_a?(Matrix)
+
+      LibUI.draw_matrix_multiply(@native, other.to_ptr)
+      self
+    end
+
+    def invertible?
+      LibUI.draw_matrix_invertible(@native) != 0
+    end
+
+    def invert
+      LibUI.draw_matrix_invert(@native) != 0
+    end
+
+    def transform_point(x, y)
+      LibUI.draw_matrix_transform_point(@native, x, y)
+    end
+
+    def transform_size(x, y)
+      LibUI.draw_matrix_transform_size(@native, x, y)
+    end
+  end
+end

data/lib/libui/ffi.rb

@@ -45,6 +45,7 @@ module LibUI
     # https://github.com/andlabs/libui/blob/master/ui.h
     # keep same order
 
+    try_extern 'const char *uiVersion(void)'
     try_extern 'const char *uiInit(uiInitOptions *options)'
     try_extern 'void uiUninit(void)'
     try_extern 'void uiFreeInitError(const char *err)'
@@ -76,6 +77,8 @@ module LibUI
     ]
 
     try_extern 'void uiControlDestroy(uiControl *c)'
+    try_extern 'void uiControlOnDestroyed(uiControl *c, void (*f)(uiControl *c, void *data), void *data)'
+    try_extern 'void uiControlSetTooltip(uiControl *c, const char *tooltip)'
     try_extern 'uintptr_t uiControlHandle(uiControl *c)'
     try_extern 'uiControl *uiControlParent(uiControl *c)'
     try_extern 'void uiControlSetParent(uiControl *c, uiControl *parent)'
@@ -86,6 +89,7 @@ module LibUI
     try_extern 'int uiControlEnabled(uiControl *c)'
     try_extern 'void uiControlEnable(uiControl *c)'
     try_extern 'void uiControlDisable(uiControl *c)'
+    try_extern 'void uiControlSetMinimumSize(uiControl *c, int width, int height)'
 
     try_extern 'uiControl *uiAllocControl(size_t n, uint32_t OSsig, uint32_t typesig, const char *typenamestr)'
     try_extern 'void uiFreeControl(uiControl *c)'
@@ -117,6 +121,8 @@ module LibUI
     try_extern 'void uiWindowSetMargined(uiWindow *w, int margined)'
     try_extern 'int uiWindowResizeable(uiWindow *w)'
     try_extern 'void uiWindowSetResizeable(uiWindow *w, int resizeable)'
+    try_extern 'void uiWindowSetToolbar(uiWindow *w, uiToolbar *t)'
+    try_extern 'uiToolbar *uiWindowToolbar(uiWindow *w)'
     try_extern 'uiWindow *uiNewWindow(const char *title, int width, int height, int hasMenubar)'
 
     # uiButton
@@ -160,6 +166,9 @@ module LibUI
 
     try_extern 'char *uiLabelText(uiLabel *l)'
     try_extern 'void uiLabelSetText(uiLabel *l, const char *text)'
+    try_extern 'double uiLabelFontSize(uiLabel *l)'
+    try_extern 'void uiLabelSetFontSize(uiLabel *l, double size)'
+    try_extern 'void uiLabelResetFontSize(uiLabel *l)'
     try_extern 'uiLabel *uiNewLabel(const char *text)'
 
     # uiTab
@@ -285,6 +294,9 @@ module LibUI
     try_extern 'void uiMultilineEntrySetText(uiMultilineEntry *e, const char *text)'
     try_extern 'void uiMultilineEntryAppend(uiMultilineEntry *e, const char *text)'
     try_extern 'void uiMultilineEntryOnChanged(uiMultilineEntry *e, void (*f)(uiMultilineEntry *sender, void *senderData), void *data)'
+    try_extern 'double uiMultilineEntryFontSize(uiMultilineEntry *e)'
+    try_extern 'void uiMultilineEntrySetFontSize(uiMultilineEntry *e, double size)'
+    try_extern 'void uiMultilineEntryResetFontSize(uiMultilineEntry *e)'
     try_extern 'int uiMultilineEntryReadOnly(uiMultilineEntry *e)'
     try_extern 'void uiMultilineEntrySetReadOnly(uiMultilineEntry *e, int readonly)'
     try_extern 'uiMultilineEntry *uiNewMultilineEntry(void)'
@@ -421,7 +433,7 @@ module LibUI
     try_extern 'void uiDrawClip(uiDrawContext *c, uiDrawPath *path)'
     try_extern 'void uiDrawSave(uiDrawContext *c)'
     try_extern 'void uiDrawRestore(uiDrawContext *c)'
-    try_extern 'void uiDrawImage(uiDrawContext *c, uiImage *img, double x, double y, double width, double height)'
+    try_extern 'void uiDrawImage(uiDrawContext *c, const uiImage *img, double x, double y, double width, double height)'
 
     # uiAttribute
     try_extern 'void uiFreeAttribute(uiAttribute *a)'
@@ -575,6 +587,7 @@ module LibUI
 
     try_extern 'void uiGridAppend(uiGrid *g, uiControl *c, int left, int top, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)'
     try_extern 'void uiGridInsertAt(uiGrid *g, uiControl *c, uiControl *existing, uiAt at, int xspan, int yspan, int hexpand, uiAlign halign, int vexpand, uiAlign valign)'
+    try_extern 'void uiGridDelete(uiGrid *g, uiControl *c)'
     try_extern 'int uiGridPadded(uiGrid *g)'
     try_extern 'void uiGridSetPadded(uiGrid *g, int padded)'
     try_extern 'uiGrid *uiNewGrid(void)'
@@ -583,7 +596,29 @@ module LibUI
 
     try_extern 'uiImage *uiNewImage(double width, double height)'
     try_extern 'void uiFreeImage(uiImage *i)'
-    try_extern 'void uiImageAppend(uiImage *i, void *pixels, int pixelWidth, int pixelHeight, int byteStride)'
+    try_extern 'void uiImageAppend(uiImage *i, const void *pixels, int pixelWidth, int pixelHeight, int byteStride)'
+
+    # uiToolbar
+    typealias 'uiToolbarDisplayMode', 'int'
+
+    try_extern 'uiToolbar *uiNewToolbar(void)'
+    try_extern 'void uiFreeToolbar(uiToolbar *t)'
+    try_extern 'uiToolbarDisplayMode uiToolbarGetDisplayMode(uiToolbar *t)'
+    try_extern 'void uiToolbarSetDisplayMode(uiToolbar *t, uiToolbarDisplayMode mode)'
+    try_extern 'uiToolbarItem *uiToolbarAppendButton(uiToolbar *t, const char *text, uiImage *icon)'
+    try_extern 'uiToolbarItem *uiToolbarAppendToggleButton(uiToolbar *t, const char *text, uiImage *icon)'
+    try_extern 'void uiToolbarAppendSeparator(uiToolbar *t)'
+    try_extern 'char *uiToolbarItemText(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemSetText(uiToolbarItem *item, const char *text)'
+    try_extern 'void uiToolbarItemSetIcon(uiToolbarItem *item, uiImage *icon)'
+    try_extern 'char *uiToolbarItemTooltip(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemSetTooltip(uiToolbarItem *item, const char *tooltip)'
+    try_extern 'int uiToolbarItemEnabled(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemEnable(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemDisable(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemOnClicked(uiToolbarItem *item, void (*f)(uiToolbarItem *sender, void *senderData), void *data)'
+    try_extern 'int uiToolbarItemChecked(uiToolbarItem *item)'
+    try_extern 'void uiToolbarItemSetChecked(uiToolbarItem *item, int checked)'
 
     # uiImageView
     try_extern 'uiImageView *uiNewImageView(void)'

data/lib/libui/font.rb

@@ -0,0 +1,13 @@
+module LibUI
+  Font = Struct.new(:family, :size, :weight, :italic, :stretch, keyword_init: true) do
+    def initialize(family:, size:, weight: 400, italic: 0, stretch: 4)
+      family = String(family)
+      raise ArgumentError, 'font family contains a NUL byte' if family.include?("\0")
+
+      super(family: family.dup.freeze, size: Float(size),
+            weight: Integer(weight), italic: Integer(italic),
+            stretch: Integer(stretch))
+      freeze
+    end
+  end
+end

data/lib/libui/libui_base.rb

@@ -5,47 +5,41 @@ module LibUI
       func = FFI.func_map[original_method_name]
 
       define_method(name) do |*args, &blk|
-        # Assume that block is the last argument.
         args << blk if blk
-
-        # The proc object is converted to a Closure::BlockCaller object.
+        retained = []
         args.map!.with_index do |arg, idx|
           next arg unless arg.is_a?(Proc)
 
-          # now arg must be Proc
-
-          # The types of the function arguments are stored in advance.
-          # See the monkey patch in ffi.rb.
           _f, ret_type, arg_types = func.callback_argument_types[idx]
-          # TODO: raise some nice error if _f is nil.
-
-          callback = Fiddle::Closure::BlockCaller.new(
-            ret_type, arg_types, &arg
-          )
-          # Protect from GC
-          # by giving the owner object a reference to the callback.
-          # See https://github.com/kojix2/LibUI/issues/8
-          receiver = args.first
-          owner = if idx == 0 || # UI.queue_main{}
-                     receiver.nil? ||
-                     (receiver.respond_to?(:frozen?) && receiver.frozen?) # UI.timer(100) {}
-                    LibUIBase # keep a reference on an internal module to avoid GC
-                  else
-                    receiver # receiver object holds the callback
-                  end
-          if owner.instance_variable_defined?(:@callbacks)
-            owner.instance_variable_get(:@callbacks) << callback
-          else
-            owner.instance_variable_set(:@callbacks, [callback])
+          raise ArgumentError, "#{name} does not accept a block at argument #{idx}" unless _f
+
+          ruby_callback = arg
+          callback = Fiddle::Closure::BlockCaller.new(ret_type, arg_types) do |*callback_args|
+            begin
+              ruby_callback.call(*callback_args)
+            rescue StandardError => e
+              CallbackRegistry.report(e)
+              0
+            end
           end
+          retained << [idx, callback]
           callback
         end
 
-        # Make it possible to omit the last nil. This may be an over-optimization.
         siz = func.argument_types.size - 1
         args[siz] = nil if args.size == siz
 
-        FFI.public_send(original_method_name, *args)
+        result = FFI.public_send(original_method_name, *args)
+        retained.each do |idx, callback|
+          if idx.zero? || args.first.nil?
+            CallbackRegistry.global(original_method_name, callback)
+          elsif original_method_name.start_with?('uiMenuItem', 'uiToolbarItem')
+            CallbackRegistry.other(args.first, original_method_name, callback)
+          else
+            CallbackRegistry.control(args.first, original_method_name, callback)
+          end
+        end
+        result
       end
     end
   end

data/lib/libui/path.rb

@@ -0,0 +1,70 @@
+module LibUI
+  class Path
+    def self.open(fill_mode = DrawFillModeWinding)
+      path = new(fill_mode)
+      begin
+        yield path
+      ensure
+        path.close
+      end
+    end
+
+    def initialize(fill_mode = DrawFillModeWinding)
+      @pointer = LibUI.draw_new_path(fill_mode)
+    end
+
+    def to_ptr
+      raise RuntimeError, 'draw path is closed' unless @pointer
+
+      @pointer
+    end
+
+    def new_figure(x, y)
+      LibUI.draw_path_new_figure(to_ptr, x, y)
+      self
+    end
+
+    def new_figure_with_arc(x, y, radius, start_angle, sweep, negative = false)
+      LibUI.draw_path_new_figure_with_arc(to_ptr, x, y, radius, start_angle, sweep, negative ? 1 : 0)
+      self
+    end
+
+    def line_to(x, y)
+      LibUI.draw_path_line_to(to_ptr, x, y)
+      self
+    end
+
+    def arc_to(x, y, radius, start_angle, sweep, negative = false)
+      LibUI.draw_path_arc_to(to_ptr, x, y, radius, start_angle, sweep, negative ? 1 : 0)
+      self
+    end
+
+    def bezier_to(c1x, c1y, c2x, c2y, end_x, end_y)
+      LibUI.draw_path_bezier_to(to_ptr, c1x, c1y, c2x, c2y, end_x, end_y)
+      self
+    end
+
+    def close_figure
+      LibUI.draw_path_close_figure(to_ptr)
+      self
+    end
+
+    def add_rectangle(x, y, width, height)
+      LibUI.draw_path_add_rectangle(to_ptr, x, y, width, height)
+      self
+    end
+
+    def end_path
+      LibUI.draw_path_end(to_ptr)
+      self
+    end
+
+    def close
+      return if @pointer.nil?
+
+      LibUI.draw_free_path(@pointer)
+      @pointer = nil
+      nil
+    end
+  end
+end

data/lib/libui/platform.rb

@@ -6,38 +6,38 @@ module LibUI
       'arm64-darwin' => {
         vendor: 'vendor/libui.arm64.dylib',
         lib_names: ['libui.arm64.dylib', 'libui.dylib'],
-        release_zip: 'macOS-arm64-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.dylib'
+        release_zip: 'libui-ng-macos-arm64-shared-release.zip',
+        release_src: 'lib/libui.dylib'
       },
       'x86_64-darwin' => {
         vendor: 'vendor/libui.x86_64.dylib',
         lib_names: ['libui.x86_64.dylib', 'libui.dylib'],
-        release_zip: 'macOS-x64-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.dylib'
+        release_zip: 'libui-ng-macos-x64-shared-release.zip',
+        release_src: 'lib/libui.dylib'
       },
       'x86_64-linux' => {
         vendor: 'vendor/libui.x86_64.so',
         lib_names: ['libui.x86_64.so', 'libui.so'],
-        release_zip: 'Ubuntu-x64-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.so'
+        release_zip: 'libui-ng-ubuntu-x64-shared-release.zip',
+        release_src: 'lib/libui.so'
       },
       'aarch64-linux' => {
         vendor: 'vendor/libui.aarch64.so',
         lib_names: ['libui.aarch64.so', 'libui.so'],
-        release_zip: 'Ubuntu-arm64-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.so'
+        release_zip: 'libui-ng-ubuntu-arm64-shared-release.zip',
+        release_src: 'lib/libui.so'
       },
       'x64-mingw32' => {
         vendor: 'vendor/libui.x64.dll',
         lib_names: ['libui.x64.dll', 'libui.dll'],
-        release_zip: 'Windows-x64-msvc-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.dll'
+        release_zip: 'libui-ng-windows-x64-msvc-shared-md-release.zip',
+        release_src: 'bin/libui.dll'
       },
       'x86-mingw32' => {
         vendor: 'vendor/libui.x86.dll',
         lib_names: ['libui.x86.dll', 'libui.dll'],
-        release_zip: 'Windows-x86-msvc-shared-release.zip',
-        release_src: 'builddir/meson-out/libui.dll'
+        release_zip: 'libui-ng-windows-x86-msvc-shared-md-release.zip',
+        release_src: 'bin/libui.dll'
       }
     }.freeze