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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 682da64eadd53b20ab91bae03759bd797f1f4fff9ee21534681b36cfddd58a23
-  data.tar.gz: d122607c7540b753b7b3bd9a1db38fd0538280322824581299204156f14778e4
+  metadata.gz: cb3de132da0b423f122c492dd6735a75773863a3a79b98269ef0284e91bc795a
+  data.tar.gz: 965a16503f8df259c0832bd878815028ad8346627c1eaaedc0dd82bdf5efe2be
 SHA512:
-  metadata.gz: f5e534068cfc5838326bfda1b9fc440ded3d33da76a18545d6e7d467bab59950a28aaaf9a2ac8f3dafc5986a68db9aa38d41f450e447986aa2c12efe76ee330a
-  data.tar.gz: 2dacdd4ab3fc240378f57c9e77994bfc692b238aef5c58081ba876f992a87c1cb69cf9cc8364470d6d7be3a12581b1062af51595fbe95f37f30b22f7f0b3f335
+  metadata.gz: 12dce58c3e8510568762e776d90e86b8ce4e9692462512406e687571063588e3201ce2f214f9a1a8440098e9a54910850bac321ddf962f424de2b33e32556262
+  data.tar.gz: 8f4b5b6cab26c42ae2ee1e9fce3848b633374eb986e2fa8516a178da8aae9d2e04e937f87cc8795357837abd1d8379e26d45b86c7513f5ae1c96f52aca8130e4

data/README.md

@@ -1,287 +1,183 @@
 # LibUI
 
-[![test](https://github.com/kojix2/LibUI/actions/workflows/test.yml/badge.svg)](https://github.com/kojix2/LibUI/actions/workflows/test.yml)
-[![Gem Version](https://img.shields.io/badge/dynamic/json?label=gem%20version&query=%24%5B0%5D.number&url=https%3A%2F%2Frubygems.org%2Fapi%2Fv1%2Fversions%2Flibui.json&color=brightgreen)](https://rubygems.org/gems/libui/versions)
-[![Lines of Code](https://img.shields.io/endpoint?url=https%3A%2F%2Ftokei.kojix2.net%2Fbadge%2Fgithub%2Fkojix2%2FLibUI%2Flines)](https://tokei.kojix2.net/github/kojix2/LibUI)
-<a href="https://github.com/AndyObtiva/glimmer-dsl-libui"><img alt="glimmer-dsl-libui" src="https://github.com/AndyObtiva/glimmer/blob/master/images/glimmer-logo-hi-res.svg" width="50" height="50" align="right"></a>
+[![Tests](https://github.com/kojix2/LibUI/actions/workflows/test.yml/badge.svg)](https://github.com/kojix2/LibUI/actions/workflows/test.yml)
+[![Gem Version](https://img.shields.io/gem/v/libui)](https://rubygems.org/gems/libui)
 
-LibUI is a Ruby wrapper for libui family.
+LibUI is a procedural Ruby binding for [libui-ng](https://github.com/libui-ng/libui-ng),
+a native GUI library for Windows, macOS, and Linux. It uses
+[Fiddle](https://github.com/ruby/fiddle) and keeps the C API's names and
+structure, with Ruby-friendly values where they help.
 
-:rocket: [libui-ng](https://github.com/kojix2/libui-ng) - A cross-platform portable GUI library
+## Release lines
 
-## Installation
+This README describes the `main` branch and the 0.3.x series, which track the
+newer libui-ng dev API. The 0.2.x series is maintained separately on
+[`0.2-stable`](https://github.com/kojix2/LibUI/tree/0.2-stable) for compatibility
+with the older libui-ng pre-build API. Existing 0.2.x applications can stay on
+that series while it receives fixes and compatible additions.
 
-```sh
-gem install libui # --pre
-```
+## Screenshots
 
-- The gem package includes the libui-ng shared library for Windows, Mac, and Linux.
-  - Namely `libui.x64.dll`/`libui.x86.dll`, `libui.x86_64.dylib`/`libui.arm64.dylib`, or `libui.x86_64.so`/`libui.aarch64.so`.
-- No dependencies required.
-  - The libui gem uses the standard Ruby library [Fiddle](https://github.com/ruby/fiddle) to call C functions.
+| Windows | macOS | Linux |
+| --- | --- | --- |
+| <img alt="LibUI window on Windows" src="https://user-images.githubusercontent.com/5798442/103118046-900ea780-46b0-11eb-81fc-32626762e4df.png"> | <img alt="LibUI window on macOS" src="https://user-images.githubusercontent.com/5798442/103118059-99980f80-46b0-11eb-9d12-324ec4d297c9.png"> | <img alt="LibUI window on Linux" src="https://user-images.githubusercontent.com/5798442/103118068-a0bf1d80-46b0-11eb-8c5c-3bdcc3dcfb26.png"> |
 
-| 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"> |
+## Install
 
-Notes:
+```sh
+gem install libui
+```
 
-- If you are using the 32-bit (x86) version of Ruby, you need to download the 32-bit (x86) native dll. See the [Development](#development) section.
-- On Windows, libui may not work due to missing DLLs. In that case, you need to install [Visual C++ Redistributable](https://docs.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist). See ([#48](https://github.com/kojix2/LibUI/issues/48))
-- Users with [Raspberry Pi](https://www.raspberrypi.com/) or other platforms will need to compile the C libui library. See the [Development](#development) section.
+To install a prerelease version, use `gem install libui --pre`. Gems for
+supported platforms include the libui-ng shared library. For a local libui-ng
+build, set `LIBUIDIR` to the directory containing its `.dll`, `.dylib`, or
+`.so` file. On Windows, the library may also need the
+[Visual C++ Redistributable](https://learn.microsoft.com/en-us/cpp/windows/latest-supported-vc-redist).
 
-## Usage
+## Quick start
 
 ```ruby
 require 'libui'
 
 UI = LibUI
-
 UI.init
 
-main_window = UI.new_window('hello world', 200, 100, 1)
-
-button = UI.new_button('Button')
-
+window = UI.new_window('Hello', 300, 100, 0)
+button = UI.new_button('Click me')
 UI.button_on_clicked(button) do
-  UI.msg_box(main_window, 'Information', 'You clicked the button')
+  UI.msg_box(window, 'Hello', 'Button clicked')
 end
-
-UI.window_on_closing(main_window) do
-  puts 'Bye Bye'
+UI.window_set_child(window, button)
+UI.window_on_closing(window) do
   UI.quit
   1
 end
 
-UI.window_set_child(main_window, button)
-UI.control_show(main_window)
-
+UI.control_show(window)
 UI.main
-UI.quit
+UI.uninit
 ```
 
-For more examples, see the [examples](https://github.com/kojix2/libui/tree/main/examples) directory.
+Run the example with `ruby hello.rb`. Explore [examples](examples) for
+individual controls and [examples2](examples2) for larger applications.
 
-### General Rules
+## API
 
-Compared to the original libui library written in C:
+Names follow libui-ng with `ui` removed and CamelCase converted to
+`snake_case`: `uiNewWindow` becomes `LibUI.new_window`. Event callbacks accept
+a block or `Proc`; LibUI retains them for the native owner's lifetime. The
+[libui-ng API reference](https://libui-ng.github.io/libui-ng/) documents the
+underlying controls and functions. `LibUI::FFI` exposes the original C bindings
+when needed.
 
-- Method names use snake_case.
-- The last argument can be omitted if it's nil.
-- A block can be passed as a callback.
-  - The block will be converted to a Proc object and added as the last argument.
-  - The last argument can still be omitted when nil.
+### Ruby values
 
-You can use [the libui-ng API documentation](https://libui-ng.github.io/libui-ng/) as a reference.
+Native controls, images, attributes, and text layouts are still represented by
+Fiddle pointers. Common getters and setters use Ruby values:
 
-### DSLs for LibUI
+- Text and file dialog results are strings; a canceled file dialog returns `nil`.
+- Size, position, color, and table selection results are arrays.
+- Date and time picker methods use Ruby `Time`, `DateTime`, or `Date` values.
+- Font getters return `LibUI::Font` values.
 
-LibUI is not object-oriented because it is a thin Ruby wrapper (binding) for the procedural C libui library, mirroring its API structure.
-
-To build actual applications, it is recommended to use a DSL for LibUI, as they enable writing object-oriented code the Ruby way (instead of procedural code the C way):
-
-- [Glimmer DSL for LibUI](https://github.com/AndyObtiva/glimmer-dsl-libui)
-
-### Working with fiddle pointers
+For example, inside a running UI session:
 
 ```ruby
-require 'libui'
-UI = LibUI
-UI.init
-```
+width, height = UI.window_content_size(window)
+rows = UI.table_get_selection(table)
+UI.table_set_selection(table, [1, 3])
+UI.table_set_selection(table, []) # Clear the selection
 
-Text getter methods such as `label_text`, `entry_text`, and `window_title`
-return `Fiddle::Pointer` objects for strings allocated by libui. Convert the
-pointer to a Ruby string, then release it with `free_text`.
-
-```ruby
-label = UI.new_label("Ruby")
-pointer = UI.label_text(label) # #<Fiddle::Pointer>
-text = pointer.to_s
-UI.free_text(pointer)
-p text # Ruby
+path = UI.open_file(window) # A String, or nil if canceled
+UI.date_time_picker_set_time(picker, Time.now)
+selected_time = UI.date_time_picker_time(picker)
 ```
 
-Use `ensure` if the code between conversion and cleanup can raise:
+Selection indices must exist in the table model; the selection mode controls
+how many rows may be selected. `LibUI.version` returns the loaded libui-ng build
+identifier as a string; `LibUI::VERSION` is the gem version.
 
-```ruby
-def ui_text(text_pointer)
-  text_pointer.to_s
-ensure
-  UI.free_text(text_pointer) if text_pointer && !text_pointer.null?
-end
-```
+### Drawing and tables
 
-If you need to use C structs, you can do the following:
+The Ruby value classes `Font`, `Brush`, `StrokeParams`, and `Matrix` hide native
+structs. `AreaHandler` and `TableModel` manage their callbacks. A drawing area
+can use Ruby objects instead of manually allocating native structs:
 
 ```ruby
-font_button = UI.new_font_button
-
-# Allocate memory
-font_descriptor = UI::FFI::FontDescriptor.malloc
-font_descriptor.to_ptr.free = Fiddle::RUBY_FREE
-# font_descriptor = UI::FFI::FontDescriptor.malloc(Fiddle::RUBY_FREE) # fiddle 1.0.1 or higher
-
-UI.font_button_on_changed(font_button) do
-  UI.font_button_font(font_button, font_descriptor)
-  begin
-    p family:  font_descriptor.Family.to_s,
-      size:    font_descriptor.Size,
-      weight:  font_descriptor.Weight,
-      italic:  font_descriptor.Italic,
-      stretch: font_descriptor.Stretch
-  ensure
-    UI.free_font_button_font(font_descriptor)
+brush = UI::Brush.new(color: [0.4, 0.4, 0.8, 1.0])
+handler = UI::AreaHandler.new(draw: ->(event) do
+  UI::Path.open do |path|
+    path.add_rectangle(0, 0, event.area_width, event.area_height).end_path
+    event.context.fill(path, brush)
   end
-end
+end)
+area = UI.new_area(handler)
 ```
 
-- Callbacks
-  - In Ruby/Fiddle, a C callback function is written as an object of
-    `Fiddle::Closure::BlockCaller` or `Fiddle::Closure`.
-    Be careful about Ruby's garbage collection - if the function object is collected, memory will be freed resulting in a segmentation violation when the callback is invoked.
+`Path.open` frees the drawing path when the block exits. For a table, provide
+Ruby rows and their libui-ng column types:
 
 ```ruby
-# Assign 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]) {})
+rows = [%w[cat meow], %w[dog woof]]
+model = UI::TableModel.new(column_types: [UI::TableValueTypeString] * 2,
+                           rows: rows)
+table = UI.new_table(model: model)
+UI.table_append_text_column(table, 'Animal', 0, -1)
+UI.table_append_text_column(table, 'Sound', 1, -1)
+# After destroying the table: model.free
 ```
 
-### Creating a Windows executable (.exe) with OCRA
-
-OCRA (One-Click Ruby Application) builds Windows executables from Ruby source code.
+See [basic_area.rb](examples/basic_area.rb),
+[basic_draw_text.rb](examples/basic_draw_text.rb), and
+[basic_table.rb](examples/basic_table.rb) for complete programs.
 
-- https://github.com/larsch/ocra/
+### Images
 
-To build an exe with Ocra, include 3 DLLs from the ruby_builtin_dlls folder:
+Apart from library configuration, **`image_append_rgba` is the only procedural
+helper without a direct C counterpart**. The C API's `uiImageAppend` requires
+premultiplied RGBA bytes; `LibUI.image_append` has the same requirement.
+`image_append_rgba(image, bytes, width, height)` accepts ordinary RGBA bytes,
+converts a copy, and calls `image_append`:
 
-```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                      ^
+```ruby
+image = UI.new_image(width, height)
+UI.image_append_rgba(image, rgba_bytes, width, height)
 ```
 
-Add additional options below if necessary:
+See [basic_table_image.rb](examples/basic_table_image.rb) for an example using
+PNG data in a table.
 
-```sh
-  --window                              ^
-  --add-all-core                        ^
-  --chdir-first                         ^
-  --icon assets\app.ico                 ^
-  --verbose                             ^
-  --output out\gallery.exe
-```
+## Ownership
+
+Native controls follow libui-ng's parent-child ownership rules. Destroy a
+top-level control with `control_destroy`; destroying a parent also destroys its
+children. Standalone resources such as images and text layouts have matching
+`free_*` methods. Free a `TableModel` after the table using it has been
+destroyed. `Path.open` handles path cleanup.
 
 ## Development
 
 ```sh
-git clone https://github.com/kojix2/libui
-cd libui
+git clone https://github.com/kojix2/LibUI.git
+cd LibUI
 bundle install
 bundle exec rake vendor:auto
 bundle exec rake test
 ```
 
-JRuby on macOS needs Java and AppKit must start on the first thread:
-
-```sh
-export JAVA_HOME=/path/to/openjdk
-export JRUBY_OPTS=-J-XstartOnFirstThread
-jruby -Ilib examples/basic_button.rb
-jruby -S rake test
-```
-
-Take note that, as the above code shows, LibUI works via jruby as well, so you have an additional
-GUI library (aside from jruby-swing by default) to test simple User Interfaces too.
-
-### Pre-built shared libraries for libui-ng
-
-Download pre-built libui-ng shared libraries (per your current platform):
-
-```sh
-bundle exec rake vendor:auto
-```
-
-Clean downloaded vendor files (keeps `vendor/{LICENSE,README}.md`):
-
-```sh
-bundle exec rake vendor:clean
-```
-
-### Using your own libui build
-
-If you build libui-ng yourself, set `LIBUIDIR` to the directory containing the compiled `.so/.dylib/.dll` so LibUI can load it. You may also replace files under `vendor/` with your build if preferred. See [#46](https://github.com/kojix2/LibUI/issues/46#issuecomment-1041575792).
-
-### Publishing gems
-
-#### Automated Publishing
-
-Push a version tag to automatically publish platform-specific gems:
-
-```sh
-git tag v0.2.0
-git push origin v0.2.0
-```
-
-Requires `RUBYGEMS_API_KEY` repository secret with scoped API key.
-
-#### Manual Publishing
-
-```sh
-ls vendor             # check the vendor directory
-rm -rf pkg            # remove previously built gems
-rake build_platform   # build gems
-
-# Check the contents of the gem
-find pkg -name *.gem -exec sh -c "echo; echo \# {}; tar -O -f {} -x data.tar.gz | tar zt" \;
-
-rake release_platform # publish gems
-```
-
-Windows Ruby (x64-mingw32 or x64-mingw-ucrt)
-
-```sh
-gem install rake rubyzip
-GEM_PLATFORM=x64-mingw32 rake vendor:clean
-GEM_PLATFORM=x64-mingw32 rake vendor:auto
-GEM_PLATFORM=x64-mingw32 gem build libui.gemspec
-gem push libui-0.2.0-x64-mingw32.gem
-```
-
-### libui or libui-ng
-
-- From version 0.1.X, LibUI supports only libui-ng.
-- Version 0.0.X only supports andlabs/libui.
-
-## Contributing
-
-Would you like to contribute to LibUI?
-
-- Please feel free to send us your [pull requests](https://github.com/kojix2/libui/pulls).
-  - Small corrections, such as typo fixes, are appreciated.
-- Did you find any bugs? Submit them in the [issues](https://github.com/kojix2/LibUI/issues) section!
-
-Do you need commit rights?
-
-- If you need commit rights to my repository or want to get admin rights and take over the project, please feel free to contact @kojix2.
-- Many OSS projects become abandoned because only the founder has commit rights to the original repository.
-
-Support libui-ng development
-
-- Contributing to the development of libui-ng is a contribution to the entire libui community, including Ruby's LibUI.
-- For example, it would be easier to release LibUI in Ruby if libui-ng could be built easily and official shared libraries could be distributed.
-
-## Acknowledgements
-
-This project is inspired by libui-ruby.
+The tests need a GUI display. On macOS with JRuby, set
+`JRUBY_OPTS=-J-XstartOnFirstThread`. `bundle exec rake vendor:clean` removes
+downloaded binaries. The [RubyGems release workflow](.github/workflows/release-rubygems.yml)
+builds and publishes gems from version tags using trusted publishing.
 
-- https://github.com/jamescook/libui-ruby
+## Related projects and contributing
 
-While libui-ruby uses [Ruby-FFI](https://github.com/ffi/ffi), this gem uses [Fiddle](https://github.com/ruby/fiddle).
+For an object-oriented DSL built on LibUI, see
+[Glimmer DSL for LibUI](https://github.com/AndyObtiva/glimmer-dsl-libui).
+LibUI was inspired by [libui-ruby](https://github.com/jamescook/libui-ruby).
+Bug reports and pull requests are welcome in the
+[GitHub repository](https://github.com/kojix2/LibUI).
 
 ## License
 
-[MIT License](https://opensource.org/licenses/MIT).
+[MIT](LICENSE.txt)

data/lib/libui/area_handler.rb

@@ -0,0 +1,155 @@
+module LibUI
+  class DrawContext
+    def initialize(pointer)
+      @pointer = Fiddle::Pointer.new(pointer.to_i)
+      @active = true
+    end
+
+    def to_ptr
+      raise RuntimeError, 'draw context is only valid during on_draw' unless @active
+
+      @pointer
+    end
+
+    def fill(path, brush)
+      LibUI.draw_fill(to_ptr, path, brush)
+    end
+
+    def stroke(path, brush, stroke_params)
+      LibUI.draw_stroke(to_ptr, path, brush, stroke_params)
+    end
+
+    def draw_text(layout, x, y)
+      LibUI.draw_text(to_ptr, layout, x, y)
+    end
+
+    def draw_image(image, x, y, width, height)
+      LibUI.draw_image(to_ptr, image, x, y, width, height)
+    end
+
+    def transform(matrix)
+      LibUI.draw_transform(to_ptr, matrix)
+    end
+
+    def clip(path)
+      LibUI.draw_clip(to_ptr, path)
+    end
+
+    def save
+      LibUI.draw_save(to_ptr)
+    end
+
+    def restore
+      LibUI.draw_restore(to_ptr)
+    end
+
+    def invalidate
+      @active = false
+    end
+  end
+
+  class AreaHandler
+    DrawEvent = Struct.new(:context, :area_width, :area_height, :clip_x, :clip_y,
+                           :clip_width, :clip_height, keyword_init: true)
+    MouseEvent = Struct.new(:x, :y, :area_width, :area_height, :down, :up,
+                            :count, :modifiers, :held_1_to_64, keyword_init: true)
+    KeyEvent = Struct.new(:key, :ext_key, :modifier, :modifiers, :up,
+                          keyword_init: true)
+
+    def initialize(draw: nil, mouse_event: nil, mouse_crossed: nil,
+                   drag_broken: nil, key_event: nil)
+      @handlers = { draw: draw, mouse_event: mouse_event,
+                    mouse_crossed: mouse_crossed, drag_broken: drag_broken,
+                    key_event: key_event }
+      @native = FFI::AreaHandler.malloc
+      @native.to_ptr.free = Fiddle::RUBY_FREE
+      @closures = {}
+      install_callbacks
+    end
+
+    def to_ptr
+      @native.to_ptr
+    end
+
+    def on_draw(&block)
+      @handlers[:draw] = block
+      self
+    end
+
+    def on_mouse_event(&block)
+      @handlers[:mouse_event] = block
+      self
+    end
+
+    def on_mouse_crossed(&block)
+      @handlers[:mouse_crossed] = block
+      self
+    end
+
+    def on_drag_broken(&block)
+      @handlers[:drag_broken] = block
+      self
+    end
+
+    def on_key_event(&block)
+      @handlers[:key_event] = block
+      self
+    end
+
+    private
+
+    def install_callbacks
+      pointer = Fiddle::TYPE_VOIDP
+      integer = Fiddle::TYPE_INT
+      @closures[:draw] = callback(Fiddle::TYPE_VOID, [pointer, pointer, pointer]) do |_handler, _area, params_ptr|
+        params = FFI::AreaDrawParams.new(params_ptr)
+        context = DrawContext.new(params.Context)
+        event = DrawEvent.new(context: context, area_width: params.AreaWidth,
+                              area_height: params.AreaHeight, clip_x: params.ClipX,
+                              clip_y: params.ClipY, clip_width: params.ClipWidth,
+                              clip_height: params.ClipHeight)
+        begin
+          @handlers[:draw]&.call(event)
+        ensure
+          context.invalidate
+        end
+      end
+      @closures[:mouse_event] = callback(Fiddle::TYPE_VOID, [pointer, pointer, pointer]) do |_handler, _area, event_ptr|
+        native = FFI::AreaMouseEvent.new(event_ptr)
+        @handlers[:mouse_event]&.call(MouseEvent.new(x: native.X, y: native.Y,
+          area_width: native.AreaWidth, area_height: native.AreaHeight,
+          down: native.Down, up: native.Up, count: native.Count,
+          modifiers: native.Modifiers, held_1_to_64: native.Held1To64))
+      end
+      @closures[:mouse_crossed] = callback(Fiddle::TYPE_VOID, [pointer, pointer, integer]) do |_handler, _area, left|
+        @handlers[:mouse_crossed]&.call(left != 0)
+      end
+      @closures[:drag_broken] = callback(Fiddle::TYPE_VOID, [pointer, pointer]) do |_handler, _area|
+        @handlers[:drag_broken]&.call
+      end
+      @closures[:key_event] = callback(integer, [pointer, pointer, pointer]) do |_handler, _area, event_ptr|
+        native = FFI::AreaKeyEvent.new(event_ptr)
+        event = KeyEvent.new(key: native.Key, ext_key: native.ExtKey,
+                             modifier: native.Modifier, modifiers: native.Modifiers,
+                             up: native.Up != 0)
+        @handlers[:key_event]&.call(event) ? 1 : 0
+      end
+      @native.Draw = @closures[:draw]
+      @native.MouseEvent = @closures[:mouse_event]
+      @native.MouseCrossed = @closures[:mouse_crossed]
+      @native.DragBroken = @closures[:drag_broken]
+      @native.KeyEvent = @closures[:key_event]
+    end
+
+    def callback(return_type, argument_types, &block)
+      Fiddle::Closure::BlockCaller.new(return_type, argument_types) do |*args|
+        begin
+          block.call(*args)
+        rescue StandardError => e
+          CallbackRegistry.report(e)
+          0
+        end
+      end
+    end
+  end
+end