nuklear 0.1.0

data/lib/nuklear/ui/checkbox.rb

@@ -0,0 +1,39 @@
+module Nuklear
+  module UI
+    class Checkbox < Nuklear::UI::Base
+      attr_accessor :text
+
+      def initialize(text, checked: false, enabled: true, &block)
+        super enabled: enabled
+        @text = text
+        @checked = checked
+        on(true) { @checked = true }
+        on(false) { @checked = false }
+        if block_given?
+          on true,  &block
+          on false, &block
+        end
+      end
+
+      def checked?
+        @checked
+      end
+
+      def checked=(checked)
+        @checked = checked
+        @last_event = checked
+      end
+
+      alias selected? checked?
+      alias selected= checked=
+
+      def to_command
+        [ :ui_checkbox, text, checked? ]
+      end
+
+      def result(event, context)
+        trigger event
+      end
+    end
+  end
+end

data/lib/nuklear/ui/col.rb

@@ -0,0 +1,21 @@
+module Nuklear
+  module UI
+    class Col < Base
+      include Nuklear::UI::Container
+      attr_accessor :width
+
+      def initialize(width:, **options)
+        super(**options)
+        self.width = width
+      end
+
+      def to_command
+        [:ui_layout_row_push, width]
+      end
+
+      def result(_, context)
+        run_commands(context)
+      end
+    end
+  end
+end

data/lib/nuklear/ui/color_picker.rb

@@ -0,0 +1,31 @@
+module Nuklear
+  module UI
+    class ColorPicker < Base
+      attr_accessor :color
+      attr_reader :type
+
+      def initialize(color, type: :rgba, **options)
+        super(**options)
+        self.color = color
+        self.type = type
+      end
+
+      def type=(t)
+        case t
+        when :rgb, :rgba then @type = t
+        else raise ArgumentError, "invalid color picker type, must be :rgb or :rgba"
+        end
+      end
+
+      def to_command
+        [:ui_color_picker, color, type]
+      end
+
+      def result(color, context)
+        @color = color
+        trigger :color_changed
+        @last_event = nil
+      end
+    end
+  end
+end

data/lib/nuklear/ui/combo_box.rb

@@ -0,0 +1,42 @@
+module Nuklear
+  module UI
+    class ComboBox < Nuklear::UI::Base
+      include Nuklear::UI::Container
+
+      attr_accessor :text, :image, :color, :symbol, :width, :height
+
+      def initialize(text: nil, image: nil, color: nil, symbol: nil, width:, height:, **options)
+        super(**options)
+        self.text  = text
+        self.image = image
+        self.color = color
+        self.symbol = symbol
+        self.width = width
+        self.height = height
+      end
+
+      def red; color.red; end
+      def red=(a); color.red = a; end
+      def green; color.green; end
+      def green=(a); color.green = a; end
+      def blue; color.blue; end
+      def blue=(a); color.blue = a; end
+      def alpha; color.alpha; end
+      def alpha=(a); color.alpha = a; end
+      def hue; color.hue; end
+      def hue=(a); color.hue = a; end
+      def saturation; color.saturation; end
+      def saturation=(a); color.saturation = a; end
+      def value; color.value; end
+      def value=(a); color.value = a; end
+
+      def to_command
+        [ :ui_combobox, text, color, symbol, image, width, height ]
+      end
+
+      def result(expanded, context)
+        run_commands(context) if expanded
+      end
+    end
+  end
+end

data/lib/nuklear/ui/container.rb

@@ -0,0 +1,80 @@
+module Nuklear
+  module UI
+    module Container
+      def commands
+        @commands ||= []
+      end
+
+      def run_command(context, command)
+        if command.respond_to?(:to_command)
+          if !command.respond_to?(:enabled?) || command.enabled?
+            cmd = command.to_command
+            result = send(cmd[0], context, *cmd[1..-1]) do |ret|
+              command.result(ret, context) if command.respond_to?(:result)
+            end
+            command.result(result, context) if !result.nil? && command.respond_to?(:result)
+          end
+        elsif command.respond_to?(:[])
+          send(command[0], context, *command[1..-1])
+        else
+          raise "Unexpected command #{command.inspect}"
+        end
+      end
+
+      def run_commands(context)
+        commands.each do |command|
+          if command.respond_to?(:to_commands)
+            command.to_commands.each { |cmd| run_command(context, cmd) }
+          else
+            run_command(context, command)
+          end
+        end
+      end
+
+      def <<(other)
+        commands << other
+      end
+
+      # Iterates over every item in this container, and yields each item
+      # (starting with the container itself) to the block.
+      def traverse(&block)
+        yield self
+        commands.each do |item|
+          if item.respond_to?(:traverse)
+            item.traverse(&block)
+          else
+            yield item
+          end
+        end
+      end
+
+      # Traverses this container and any of its sub-containers, yielding each
+      # item to the block. Returns each item for which the block returned true.
+      def find(&block)
+        matches = []
+        traverse do |item|
+          matches << item if yield(item)
+        end
+        return matches
+      end
+
+      LayoutRowDynamic = Struct.new(:height, :ncols) do
+        def to_command
+          [ :ui_layout_row_dynamic, height, ncols ]
+        end
+      end
+
+      def layout_row_dynamic(height, ncols)
+        LayoutRowDynamic.new(height, ncols).tap { |row| commands << row }
+      end
+
+      def method_missing(name, *args)
+        if respond_to?(:"ui_#{name}")
+          commands << [:"ui_#{name}", *args]
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/nuklear/ui/edit_string.rb

@@ -0,0 +1,48 @@
+module Nuklear
+  module UI
+    class EditString < Nuklear::UI::Base
+      attr_accessor :flags, :max_length, :filter, :text
+
+      def initialize(text: "", flags: 0, max_length: 255, filter: nil, enabled: true)
+        super enabled: enabled
+        @text         = text
+        @flags        = Nuklear.parse_flags :edit, flags
+        @max_length   = max_length
+        @filter       = filter
+        @demand_focus = false
+      end
+
+      def demand_focus?
+        @demand_focus
+      end
+
+      def focus
+        @demand_focus = true
+      end
+
+      def to_commands
+        if demand_focus?
+          @demand_focus = false
+          [
+            [:ui_edit_focus, flags],
+            self,
+          ]
+        else
+          [self]
+        end
+      end
+
+      def to_command
+        [:ui_edit_string, flags, text, max_length, filter]
+      end
+
+      def result(result, context)
+        trigger(:activated)   if (result & Nuklear::NK_EDIT_ACTIVATED)   > 0
+        trigger(:deactivated) if (result & Nuklear::NK_EDIT_DEACTIVATED) > 0
+        trigger(:committed)   if (result & Nuklear::NK_EDIT_COMMITED)    > 0
+        trigger(:active)      if (result & Nuklear::NK_EDIT_ACTIVE)      > 0
+        trigger(:inactive)    if (result & Nuklear::NK_EDIT_INACTIVE)    > 0
+      end
+    end
+  end
+end

data/lib/nuklear/ui/enableable.rb

@@ -0,0 +1,29 @@
+module Nuklear
+  module UI
+    module Enableable
+      def enabled=(a)
+        @enabled = a
+      end
+
+      def disabled=(a)
+        self.enabled = !a
+      end
+
+      def enable
+        self.enabled = true
+      end
+
+      def disable
+        self.enabled = false
+      end
+
+      def enabled?
+        @enabled.nil? ? true : @enabled
+      end
+
+      def disabled?
+        !enabled?
+      end
+    end
+  end
+end

data/lib/nuklear/ui/events.rb

@@ -0,0 +1,23 @@
+module Nuklear
+  module UI
+    module Events
+      def on(*events, &block)
+        events.each do |event|
+          event_listeners_for(event) << block
+        end
+      end
+
+      def event_listeners_for(event)
+        @event_listeners ||= {}
+        @event_listeners[event] ||= []
+      end
+
+      def trigger(event)
+        if event != @last_event # prevent triggering every frame
+          event_listeners_for(event).each { |listener| listener.call event }
+          @last_event = event
+        end
+      end
+    end
+  end
+end

data/lib/nuklear/ui/group.rb

@@ -0,0 +1,31 @@
+module Nuklear
+  module UI
+    class Group < Nuklear::UI::Base
+      include Nuklear::UI::Container
+
+      attr_accessor :title, :scroll_x, :scroll_y
+
+      def initialize(title = object_id.to_s, **options)
+        super(**options)
+        @scroll_x = @scroll_y = 0
+        self.title = title
+      end
+
+      def to_command
+        [ :ui_group, title, flags, scroll_x, scroll_y ]
+      end
+
+      def flags
+        0
+      end
+
+      def result(new_state, context)
+        if new_state.kind_of?(Array)
+          @scroll_x, @scroll_y = new_state
+        else
+          run_commands(context)
+        end
+      end
+    end
+  end
+end

data/lib/nuklear/ui/label.rb

@@ -0,0 +1,21 @@
+module Nuklear
+  module UI
+    class Label < Nuklear::UI::Base
+      include Nuklear::UI::TextAlign
+      
+      attr_accessor :text, :color, :wrap, :align
+
+      def initialize(text, color: nil, wrap: false, align: :left, **options)
+        super(**options)
+        self.text  = text
+        self.color = color
+        self.wrap  = wrap
+        self.align = align
+      end
+
+      def to_command
+        [:ui_label, text, color, wrap, align_as_flags(align)]
+      end
+    end
+  end
+end

data/lib/nuklear/ui/menu.rb

@@ -0,0 +1,43 @@
+module Nuklear
+  module UI
+    class Menu < Nuklear::UI::Base
+      include Nuklear::UI::Container
+      include Nuklear::UI::TextAlign
+
+      attr_accessor :title, :image, :symbol, :align, :width, :height
+
+      def initialize(enabled: true, title: nil, image: nil, symbol: nil,
+                     align: :left, width:, height:)
+        super enabled: enabled
+        @title = title
+        @image = image
+        @symbol = symbol
+        @align = align
+        @width = width
+        @height = height
+      end
+
+      def to_command
+        [:ui_menu, {
+            id: object_id,
+            title: title,
+            image: image,
+            symbol: symbol,
+            align: align_as_flags(align),
+            width: width,
+            height: height
+          }
+        ]
+      end
+
+      def visible?
+        @visible
+      end
+
+      def result(visible, context)
+        @visible = visible
+        run_commands(context) if visible
+      end
+    end
+  end
+end

data/lib/nuklear/ui/menu_bar.rb

@@ -0,0 +1,19 @@
+module Nuklear
+  module UI
+    class MenuBar < Nuklear::UI::Base
+      include Nuklear::UI::Container
+
+      def initialize(enabled: true)
+        super enabled: enabled
+      end
+
+      def to_command
+        [:ui_menubar]
+      end
+
+      def result(visible, context)
+        run_commands(context) if visible
+      end
+    end
+  end
+end

data/lib/nuklear/ui/menu_item.rb

@@ -0,0 +1,34 @@
+module Nuklear
+  module UI
+    class MenuItem < Nuklear::UI::Base
+      include Nuklear::UI::Container
+      include Nuklear::UI::TextAlign
+
+      attr_accessor :title, :image, :symbol, :align
+
+      def initialize(enabled: true, title: nil, image: nil, symbol: nil, align: :left, &block)
+        super enabled: enabled
+        @title = title
+        @image = image
+        @symbol = symbol
+        @align = align
+        on(:clicked, &block) if block_given?
+      end
+
+      def to_command
+        [:ui_menu_item, {
+            title: title,
+            image: image,
+            symbol: symbol,
+            align: align_as_flags(align)
+          }
+        ]
+      end
+
+      def result(clicked, context)
+        trigger(:clicked)
+        @last_event = nil # trigger event each time
+      end
+    end
+  end
+end

data/lib/nuklear/ui/option.rb

@@ -0,0 +1,17 @@
+module Nuklear
+  module UI
+    class Option < Nuklear::UI::Checkbox
+      def to_command
+        [ :ui_option, text, checked? ]
+      end
+
+      # Override #result to prevent user deselecting this option by clicking
+      # on it. Checkbox can be deselected, option cannot. Only choosing a
+      # competing option can cause it to be deselected, and doing that does
+      # not call #result. See Nuklear::UI::OptionGroup.
+      def result(event, context)
+        trigger event if event
+      end
+    end
+  end
+end

data/lib/nuklear/ui/option_group.rb

@@ -0,0 +1,22 @@
+module Nuklear
+  module UI
+    class OptionGroup < Base
+      include Nuklear::UI::Container
+
+      def initialize(**options)
+        super(**options)
+        @options = []
+      end
+
+      def selection=(selected)
+        @options.each { |option| option.selected = (option == selected) }
+      end
+
+      def <<(other)
+        super other
+        @options << other
+        other.on(true) { self.selection = other }
+      end
+    end
+  end
+end

data/lib/nuklear/ui/popup.rb

@@ -0,0 +1,37 @@
+require 'nuklear/ui/window'
+
+module Nuklear
+  module UI
+    class Popup < Nuklear::UI::Window
+      attr_accessor :type
+
+      def initialize(title, type: :static, enabled: false, **options)
+        super title, enabled: enabled, **options
+        self.type = type
+        on(:visible) { self.enabled = true }
+        on(:hidden) { self.enabled = false }
+      end
+
+      def to_command
+        [:ui_popup,
+          type == :dynamic ? NK_POPUP_DYNAMIC : NK_POPUP_STATIC,
+          title,
+          flags,
+          left,
+          top,
+          width,
+          height
+        ]
+      end
+
+      def visible?
+        @enabled
+      end
+
+      def result(visibility, context)
+        trigger(visibility)
+        run_commands(context) if visible?
+      end
+    end
+  end
+end

data/lib/nuklear/ui/progress.rb

@@ -0,0 +1,33 @@
+module Nuklear
+  module UI
+    class Progress < Base
+      attr_accessor :current, :min, :max
+      attr_writer :modifiable
+
+      def initialize(enabled: true, min: 1, max: 100, current: 1, modifiable: true)
+        super enabled: enabled
+        @min = min
+        @max = max
+        @current = current
+        @modifiable = modifiable
+        on(:changed) { yield @current } if block_given?
+      end
+
+      def to_command
+        [:ui_progress, current, max, modifiable?]
+      end
+
+      def modifiable?
+        @modifiable
+      end
+
+      def result(x, context)
+        x = min if x < min
+        return unless x != @current
+        @current = x
+        trigger :changed
+        @last_event = nil
+      end
+    end
+  end
+end

data/lib/nuklear/ui/property.rb

@@ -0,0 +1,28 @@
+module Nuklear
+  module UI
+    class Property < Base
+      attr_accessor :current, :min, :max, :step, :inc_per_pixel, :text
+
+      def initialize(enabled: true, text: '', min: 1, max: 100, current: 1, step: 1, inc_per_pixel: 1)
+        super enabled: enabled
+        @text = text
+        @min = min
+        @max = max
+        @current = current
+        @step = step
+        @inc_per_pixel = inc_per_pixel
+        on(:changed) { yield @current } if block_given?
+      end
+
+      def to_command
+        [:ui_property, text, min, current, max, step, inc_per_pixel]
+      end
+
+      def result(x, context)
+        @current = x
+        trigger :changed
+        @last_event = nil
+      end
+    end
+  end
+end

data/lib/nuklear/ui/row.rb

@@ -0,0 +1,28 @@
+module Nuklear
+  module UI
+    class Row < Base
+      include Nuklear::UI::Container
+      attr_accessor :height, :type, :width
+
+      def initialize(height:, width: nil, type: nil, **options)
+        super(**options)
+        self.type = type
+        self.height = height
+        self.width = width
+        raise ArgumentError, ":width is required if type is :static" if type == :static && width.nil?
+      end
+
+      def to_command
+        case type
+        when :dynamic then [:ui_layout_row_dynamic, height, commands.size]
+        when :static  then [:ui_layout_row_static, height, width, commands.size]
+        else [:ui_layout_row_begin, type || :static, height, commands.size]
+        end
+      end
+
+      def result(_, context)
+        run_commands(context)
+      end
+    end
+  end
+end

data/lib/nuklear/ui/select_list.rb

@@ -0,0 +1,31 @@
+module Nuklear
+  module UI
+    class SelectList < Nuklear::UI::Base
+      include Nuklear::UI::Container
+
+      attr_accessor :choices, :selection, :item_height, :width, :height
+
+      def initialize(choices, selection: choices[0], item_height:, width:, height:, **options)
+        super(**options)
+        self.choices = choices
+        self.selection = selection
+        self.item_height = item_height
+        self.width = width
+        self.height = height
+        on(:selection_changed) { yield self.selection } if block_given?
+      end
+
+      def to_command
+        [ :ui_combo, choices.index(selection) || 0, choices, item_height, width, height ]
+      end
+
+      def result(choice_index, context)
+        if @selection != choices[choice_index]
+          @selection = choices[choice_index]
+          trigger(:selection_changed)
+          @last_event = nil
+        end
+      end
+    end
+  end
+end

data/lib/nuklear/ui/selectable.rb

@@ -0,0 +1,21 @@
+module Nuklear
+  module UI
+    class Selectable < Nuklear::UI::Checkbox
+      include Nuklear::UI::TextAlign
+
+      attr_accessor :image, :text, :align
+
+      def initialize(text: nil, align: :left, image: nil, selected: false, **options, &block)
+        super(**options, &block)
+        self.selected = selected
+        @text = text
+        @image = image
+        @align = align
+      end
+
+      def to_command
+        [ :ui_selectable, image, text, selected?, align_as_flags(align) ]
+      end
+    end
+  end
+end