libui 0.0.6 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0214c682062d1e669d2ec2df579d91466b2d0330205231d00734e3d9b21fc57
-  data.tar.gz: 2bce2e4f6edf26bd2442e7205ef10ad59529f1e16f2a88aa0a282cb61d623ced
+  metadata.gz: f5856ad97384408635e170c1ea252dc3dbdfa1ba3955bfc8b8c1ac2c29585ac1
+  data.tar.gz: 67a9b78e39b61805afca932fc80365b59e068493f2da937c57b03e1500a2adf5
 SHA512:
-  metadata.gz: f700b08bb46f282b7298f7530bbbade2a59fcde144e54af97bb01a1766a98b3a133b10e064cd62a69621e2d61ff9d587bff17d850f96bb23b4e5c2ee101f97a7
-  data.tar.gz: 8571472b2ceb6fa2cd5d6627fce64c896e2ae651012fd8d949f9a94a6cf70dc48df6af7f379652c956b3b1e5e6725fb14465d616abdae776e9ec635c0c4150f9
+  metadata.gz: 5204e35c1c0f4b0c5f8acd69a4a1d76b6482a1fb298376c99ce29632a202c1340a39e017b68c563b4539a74e721b1611cd3a732b4a9983ef2a0fb3eef7a80b3c
+  data.tar.gz: 8fb83fe3d145646bacb598dc88413364d534493f275c2e0ef637e9718908fe895796a1cb95cdb56f6c6d24b216f23ed68a7812a0c0978a5c700a014ecd0d1573

data/README.md

@@ -1,9 +1,9 @@
-# libui
+# LibUI
 
 ![build](https://github.com/kojix2/libui/workflows/build/badge.svg)
 [![Gem Version](https://badge.fury.io/rb/libui.svg)](https://badge.fury.io/rb/libui)
 
-:radio_button: [libui](https://github.com/andlabs/libui) - a portable GUI library -for Ruby
+:radio_button: [libui](https://github.com/andlabs/libui) - a portable GUI library - for Ruby
 
 ## Installation
 
@@ -11,27 +11,38 @@
 gem install libui
 ```
 
-The libui gem uses the standard Ruby library [Fiddle](https://github.com/ruby/fiddle) to call C functions. And this gem contains the official release of the libui shared library version 4.1 for Windows, Mac, and Linux. That means there is no need to install anything other than this gem.
+* The gem package contains the [official release](https://github.com/andlabs/libui/releases/tag/alpha4.1) of the libui shared library versions 4.1 for Windows, Mac, and Linux. 
+  * Namely `libui.dll`, `libui.dylib`, and `libui.so` (only 1.4MB in total).
+* No dependency
+  * The libui gem uses the standard Ruby library [Fiddle](https://github.com/ruby/fiddle) to call C functions. 
+
+| Windows | Mac | Linux |
+|---------|-----|-------|
+|<img src="https://user-images.githubusercontent.com/5798442/103118046-900ea780-46b0-11eb-81fc-32626762e4df.png">|<img src="https://user-images.githubusercontent.com/5798442/103118059-99980f80-46b0-11eb-9d12-324ec4d297c9.png">|<img src="https://user-images.githubusercontent.com/5798442/103118068-a0bf1d80-46b0-11eb-8c5c-3bdcc3dcfb26.png">|
+
+Note: If you are using the 32-bit (x86) version of Ruby, you need to download the 32-bit (x86) native dll. See [Development](#development).
 
 ## Usage
 
 ```ruby
 require 'libui'
+
 UI = LibUI
 
 UI.init
 
-main_window = UI.new_window('hello world', 300, 200, 1)
-UI.window_on_closing(main_window) do
-  puts 'Bye Bye'
-  UI.control_destroy(main_window)
-  UI.quit
-  0
-end
+main_window = UI.new_window('hello world', 200, 100, 1)
 
 button = UI.new_button('Button')
+
 UI.button_on_clicked(button) do
   UI.msg_box(main_window, 'Information', 'You clicked the button')
+end
+
+UI.window_on_closing(main_window) do
+  puts 'Bye Bye'
+  UI.control_destroy(main_window)
+  UI.quit
   0
 end
 
@@ -46,10 +57,11 @@ See [examples](https://github.com/kojix2/libui/tree/main/examples) directory.
 
 ### General Rules
 
+Compared to original libui written in C,
+
 * The method names are snake_case.
 * If the last argument is nil, it can be omitted.
 * You can pass a block as a callback. 
-  * Please return 0 explicitly in the block.
   * The block will be converted to a Proc object and added to the last argument.
   * Even in that case, it is possible to omit the last argument nil.
   
@@ -57,6 +69,7 @@ See [examples](https://github.com/kojix2/libui/tree/main/examples) directory.
 
 * At the moment, it is not object-oriented.
   * Instead of providing a half-baked object-oriented approach, leave it as is.
+* [A list of DSLs for LibUI.](https://github.com/kojix2/LibUI/wiki/DSL-for-LibUI)
 
 ### How to use fiddle pointers?
 
@@ -92,35 +105,79 @@ UI.font_button_on_changed(font_button) do
 end
 ```
 
+* Callbacks
+  * In Ruby/Fiddle, C callback function is written as an object of
+    `Fiddle::Closure::BlockCaller` or `Fiddle::Closure`. 
+    In this case, you need to be careful about Ruby's garbage collection. 
+    If the function object is collected, memory will be freed 
+    and a segmentation violation will occur when the callback is invoked.
+
+```ruby
+# to a local variable to prevent it from being collected by GC.
+handler.MouseEvent   = (c1 = Fiddle::Closure::BlockCaller.new(0, [0]) {})
+handler.MouseCrossed = (c2 = Fiddle::Closure::BlockCaller.new(0, [0]) {})
+handler.DragBroken   = (c3 = Fiddle::Closure::BlockCaller.new(0, [0]) {})
+```
+
 ### How to create an executable (.exe) on Windows 
 
 OCRA (One-Click Ruby Application) builds Windows executables from Ruby source code. 
 * https://github.com/larsch/ocra/
 
+In order to build a exe with Ocra, include 3 DLLs from ruby_builtin_dlls folder:
+
+```sh
+ocra examples/control_gallery.rb        ^
+  --dll ruby_builtin_dlls/libssp-0.dll  ^
+  --dll ruby_builtin_dlls/libgmp-10.dll ^
+  --dll ruby_builtin_dlls/libffi-7.dll  ^
+  --gem-all=fiddle                      ^
+```
+
+Add additional options below if necessary.
+
+```sh
+  --window                              ^
+  --add-all-core                        ^
+  --chdir-first                         ^
+  --icon assets\app.ico                 ^
+  --verbose                             ^
+  --output out\gallery.exe
+```
+
 ## Development
 
 ```sh
 git clone https://github.com/kojix2/libui
 cd libui
 bundle install
-bundle exec rake vendor:all
+bundle exec rake vendor:all_x64 # download shared libraries for all platforms
 bundle exec rake test
 ```
 
-Use the following rake tasks to download the libui binary files and save them in the vendor directory.
+You can use the following rake tasks to download the shared library required for your platform.
 
 `rake -T`
 
 ```
-rake vendor:all       # Download libui.so, libui.dylib, and libui.dll to ve...
-rake vendor:linux     # Download libui.so for Linux to vendor directory
-rake vendor:mac       # Download libui.dylib for Mac to vendor directory
-rake vendor:windows   # Download libui.dll for Windows to vendor directory
+rake vendor:all_x64      # Download libui.so, libui.dylib, and libui.dll to...
+rake vendor:linux_x64    # Download libui.so for Linux to vendor directory
+rake vendor:linux_x86    # Download libui.so for Linux to vendor directory
+rake vendor:mac_x64      # Download libui.dylib for Mac to vendor directory
+rake vendor:windows_x64  # Download libui.dll for Windows to vendor directory
+rake vendor:windows_x86  # Download libui.dll for Windows to vendor directory
 ```
 
+For example, If you are using a 32-bit (x86) version of Ruby on Windows, type `rake vendor:windows_x86`.
+
+Or Set environment variable `LIBUIDIR` to specify the path to the shared library.
+
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/kojix2/libui.
+Would you like to add your commits to libui?
+* Please feel free to send us your [pull requests](https://github.com/kojix2/libui/pulls).
+  * Small corrections, such as typofixes, are appreciated.
+* Did you find any bugs?　Write it in the [issues](https://github.com/kojix2/LibUI/issue) section!
 
 ## Acknowledgement
 

data/lib/libui/ffi.rb

@@ -1,85 +1,12 @@
 # frozen_string_literal: true
 
 require 'fiddle/import'
-
-module Fiddle
-  # Change the Function to hold a little more information.
-  # FIXME: Give inner_function a better name.
-  class Function
-    attr_accessor :inner_functions, :argtype
-  end
-
-  module Importer
-    def parse_signature(signature, tymap = nil)
-      tymap ||= {}
-      ret, func, args = split_signature(signature)
-      symname = func
-      ctype   = parse_ctype(ret, tymap)
-      inner_funcs = []                                                    # Added
-      argtype = split_arguments(args).collect.with_index do |arg, idx|    # Added with_index
-        # Check if it is a function pointer or not
-        if arg =~ /\(\*.*\)\(.*\)/ # Added
-          # From the arguments, create a notation that looks like a function declaration
-          # int(*f)(int *, void *) -> int f(int *, void *)
-          func_arg = arg.sub('(*', ' ').sub(')', '') # Added
-          # Use Fiddle's parse_signature method again.
-          inner_funcs[idx] = parse_signature(func_arg)                    # Added
-        end                                                               # Added
-        parse_ctype(arg, tymap)
-      end
-      # Added inner_funcs. Original method return only 3 values.
-      [symname, ctype, argtype, inner_funcs]
-    end
-
-    # refactored
-    def split_signature(signature)
-      case compact(signature)
-      when /^(?:[\w*\s]+)\(\*(\w+)\((.*?)\)\)(?:\[\w*\]|\(.*?\));?$/
-        ret  = TYPE_VOIDP
-        func = Regexp.last_match(1)
-        args = Regexp.last_match(2)
-      when /^([\w*\s]+[*\s])(\w+)\((.*?)\);?$/
-        ret  = Regexp.last_match(1).strip
-        func = Regexp.last_match(2)
-        args = Regexp.last_match(3)
-      else
-        raise("can't parse the function prototype: #{signature}")
-      end
-      [ret, func, args]
-    end
-
-    def extern(signature, *opts)
-      symname, ctype, argtype, inner_funcs = parse_signature(signature, type_alias)
-      opt = parse_bind_options(opts)
-      f = import_function(symname, ctype, argtype, opt[:call_type])
-
-      f.inner_functions = inner_funcs # Added
-      f.argtype         = argtype     # Added
-
-      name = symname.gsub(/@.+/, '')
-      @func_map[name] = f
-      # define_method(name){|*args,&block| f.call(*args,&block)}
-      begin
-        /^(.+?):(\d+)/ =~ caller.first
-        file = Regexp.last_match(1)
-        line = Regexp.last_match(2).to_i
-      rescue StandardError
-        file, line = __FILE__, __LINE__ + 3
-      end
-      module_eval(<<-EOS, file, line)
-        def #{name}(*args, &block)
-          @func_map['#{name}'].call(*args,&block)
-        end
-      EOS
-      module_function(name)
-      f
-    end
-  end
-end
+require_relative 'fiddle_patch'
 
 module LibUI
   module FFI
     extend Fiddle::Importer
+    extend FiddlePatch
 
     begin
       dlload LibUI.ffi_lib
@@ -284,7 +211,20 @@ module LibUI
     try_extern 'void uiRadioButtonsOnSelected(uiRadioButtons *r, void (*f)(uiRadioButtons *, void *), void *data)'
     try_extern 'uiRadioButtons *uiNewRadioButtons(void)'
 
-    # uiDateTimePicker # Fixme: struct tm
+    # uiDateTimePicker
+
+    # time.h
+    TM = struct [
+      'int tm_sec',
+      'int tm_min',
+      'int tm_hour',
+      'int tm_mday',
+      'int tm_mon',
+      'int tm_year',
+      'int tm_wday',
+      'int tm_yday',
+      'int tm_isdst'
+    ]
 
     try_extern 'void uiDateTimePickerTime(uiDateTimePicker *d, struct tm *time)'
     try_extern 'void uiDateTimePickerSetTime(uiDateTimePicker *d, const struct tm *time)'

data/lib/libui/fiddle_patch.rb

@@ -0,0 +1,79 @@
+module LibUI
+  module FiddlePatch
+    def parse_signature(signature, tymap = nil)
+      tymap ||= {}
+      ctype, func, args = case compact(signature)
+                          when /^(?:[\w\*\s]+)\(\*(\w+)\((.*?)\)\)(?:\[\w*\]|\(.*?\));?$/
+                            [TYPE_VOIDP, Regexp.last_match(1), Regexp.last_match(2)]
+                          when /^([\w\*\s]+[*\s])(\w+)\((.*?)\);?$/
+                            [parse_ctype(Regexp.last_match(1).strip, tymap), Regexp.last_match(2), Regexp.last_match(3)]
+                          else
+                            raise("can't parserake the function prototype: #{signature}")
+                          end
+      symname = func
+      callback_argument_types = {}                                              # Added
+      argtype = split_arguments(args).collect.with_index do |arg, idx|          # Added with_index
+        # Check if it is a function pointer or not
+        if arg =~ /\(\*.*\)\(.*\)/                                              # Added
+          # From the arguments, create a notation that looks like a function declaration
+          # int(*f)(int *, void *) -> int f(int *, void *)
+          func_arg = arg.sub('(*', ' ').sub(')', '')                            # Added
+          # Use Fiddle's parse_signature method again.
+          callback_argument_types[idx] = parse_signature(func_arg)              # Added
+        end
+        parse_ctype(arg, tymap)
+      end
+      # Added callback_argument_types. Original method return only 3 values.
+      [symname, ctype, argtype, callback_argument_types]
+    end
+
+    def extern(signature, *opts)
+      symname, ctype, argtype, callback_argument_types = parse_signature(signature, type_alias)
+      opt = parse_bind_options(opts)
+      func = import_function(symname, ctype, argtype, opt[:call_type])
+
+      # callback_argument_types
+      func.instance_variable_set(:@callback_argument_types, 
+                                   callback_argument_types) # Added
+      # attr_reader
+      def func.callback_argument_types
+        @callback_argument_types
+      end
+
+      # argument_types
+      # Ruby 2.7 Fiddle::Function dose not have @argument_types
+      # Ruby 3.0 Fiddle::Function has @argument_types
+      if func.instance_variable_defined?(:@argument_types)
+        # check if @argument_types are the same
+        if func.instance_variable_get(:@argument_types) != argtype
+          warn "#{symname} func.argument_types:#{func.argument_types} != argtype #{argtype}"
+        end
+      else
+        func.instance_variable_set(:@argument_types, argtype)
+      end
+      # attr_reader
+      def func.argument_types
+        @argument_types
+      end
+
+      name = symname.gsub(/@.+/, '')
+      @func_map[name] = func
+      # define_method(name){|*args,&block| f.call(*args,&block)}
+      begin
+        /^(.+?):(\d+)/ =~ caller.first
+        file = Regexp.last_match(1)
+        line = Regexp.last_match(2).to_i
+      rescue StandardError
+        file, line = __FILE__, __LINE__ + 3
+      end
+      module_eval(<<-EOS, file, line)
+        def #{name}(*args, &block)
+          @func_map['#{name}'].call(*args,&block)
+        end
+      EOS
+      module_function(name)
+      func
+    end
+  end
+  private_constant :FiddlePatch
+end

data/lib/libui/libui_base.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module LibUI
+  module LibUIBase
+    FFI.func_map.each_key do |original_method_name|
+      name = Utils.convert_to_ruby_method(original_method_name)
+      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.
+        args.map!.with_index do |arg, idx|
+          if arg.is_a?(Proc)
+            # The types of the function arguments are recorded beforehand.
+            # See the monkey patch in ffi.rb.
+            callback = Fiddle::Closure::BlockCaller.new(
+              *func.callback_argument_types[idx][1..2], &arg
+            )
+            # Protect from GC
+            # See https://github.com/kojix2/LibUI/issues/8
+            receiver = args[0]
+            if receiver.instance_variable_defined?(:@callbacks)
+              receiver.instance_variable_get(:@callbacks) << callback
+            else
+              receiver.instance_variable_set(:@callbacks, [callback])
+            end
+            callback
+          else
+            arg
+          end
+        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)
+      end
+    end
+  end
+
+  private_constant :LibUIBase
+end

data/lib/libui/utils.rb

@@ -8,7 +8,7 @@ module LibUI
       # Converting camel case to underscore case in ruby
       # https://stackoverflow.com/questions/1509915/converting-camel-case-to-underscore-case-in-ruby#1509939
       def underscore(str)
-        str.gsub(/::/, '/')
+        str.gsub(/::/, '/') # Maybe we don't need it.
            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
            .tr('-', '_')

data/lib/libui/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LibUI
-  VERSION = '0.0.6'
+  VERSION = '0.0.10'
 end

data/lib/libui.rb

@@ -10,14 +10,7 @@ module LibUI
     attr_accessor :ffi_lib
   end
 
-  lib_name = case RbConfig::CONFIG['host_os']
-             when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-               'libui.dll'
-             when /darwin|mac os/
-               'libui.dylib'
-             else
-               'libui.so'
-             end
+  lib_name = "libui.#{RbConfig::CONFIG['SOEXT']}"
 
   self.ffi_lib = if ENV['LIBUIDIR'] && !ENV['LIBUIDIR'].empty?
                    File.expand_path(lib_name, ENV['LIBUIDIR'])
@@ -26,45 +19,17 @@ module LibUI
                  end
 
   require_relative 'libui/ffi'
+  require_relative 'libui/libui_base'
 
-  class << self
-    FFI.func_map.each_key do |original_method_name|
-      name = Utils.convert_to_ruby_method(original_method_name)
-      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.
-        args.map!.with_index do |arg, idx|
-          if arg.is_a?(Proc)
-            # The types of the function arguments are recorded beforehand.
-            # See the monkey patch in ffi.rb.
-            Fiddle::Closure::BlockCaller.new(*func.inner_functions[idx][1..2], &arg)
-          else
-            arg
-          end
-        end
-
-        # Make it possible to omit the last nil. This may be an over-optimization.
-        siz = func.argtype.size - 1
-        args[siz] = nil if args.size == siz
+  extend LibUIBase
 
-        FFI.public_send(original_method_name, *args)
-      end
-    end
+  class << self
+    def init(opt = FFI::InitOptions.malloc)
+      i = super(opt)
+      return if i.size.zero?
 
-    module CustomMethods
-      def init(opt = FFI::InitOptions.malloc)
-        i = super(opt)
-        unless i.size.zero?
-          warn 'error'
-          warn UI.free_init_error(init)
-        end
-      end
+      warn 'error'
+      warn UI.free_init_error(init)
     end
-
-    prepend CustomMethods
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libui
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.10
 platform: ruby
 authors:
 - kojix2
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-22 00:00:00.000000000 Z
+date: 2021-09-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -91,6 +91,8 @@ files:
 - README.md
 - lib/libui.rb
 - lib/libui/ffi.rb
+- lib/libui/fiddle_patch.rb
+- lib/libui/libui_base.rb
 - lib/libui/utils.rb
 - lib/libui/version.rb
 - vendor/LICENSE
@@ -117,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: Ruby bindings to libui