cyberarm_engine 0.12.1 → 0.16.0

data/lib/cyberarm_engine/ui/elements/list_box.rb

@@ -0,0 +1,82 @@
+module CyberarmEngine
+  class Element
+    class ListBox < Button
+      attr_accessor :items
+      attr_reader :choose
+
+      def initialize(options = {}, block = nil)
+        @items = options[:items] || []
+        @choose = options[:choose] || @items.first
+
+        super(@choose, options, block)
+
+        @style.background_canvas.background = default(:background)
+
+        # TODO: "Clean Up" into own class?
+        @menu = Stack.new(parent: parent, width: @options[:width], theme: @options[:theme])
+        @menu.define_singleton_method(:recalculate_menu) do
+          @x = @__list_box.x
+          @y = @__list_box.y + @__list_box.height
+        end
+        @menu.instance_variable_set(:"@__list_box", self)
+
+        def @menu.recalculate
+          super
+
+          recalculate_menu
+        end
+
+        self.choose = @choose
+      end
+
+      def choose=(item)
+        valid = @items.detect { |i| i == item }
+        raise "Invalid value '#{item}' for choose, valid options were: #{@items.map { |i| "#{i.inspect}" }.join(", ")}" unless valid
+
+        @choose = item
+
+        self.value = item.to_s
+
+        recalculate
+      end
+
+      def released_left_mouse_button(_sender, _x, _y)
+        show_menu
+
+        :handled
+      end
+
+      def show_menu
+        @menu.clear
+
+        @items.each do |item|
+          btn = Button.new(
+            item,
+            {
+              parent: @menu,
+              width: 1.0,
+              theme: @options[:theme],
+              margin: 0,
+              border_color: 0x00ffffff
+            },
+            proc do
+              self.choose = item
+              @block&.call(item)
+            end
+          )
+
+          @menu.add(btn)
+        end
+        recalculate
+
+        root.gui_state.show_menu(@menu)
+      end
+
+      def recalculate
+        super
+
+        @menu.recalculate
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/ui/elements/progress.rb

@@ -5,7 +5,7 @@ module CyberarmEngine
         super(options, block)
 
         @fraction_background = Background.new(background: @style.fraction_background)
-        self.value = options[:fraction] ? options[:fraction] : 0.0
+        self.value = options[:fraction] || 0.0
       end
 
       def render
@@ -14,9 +14,9 @@ module CyberarmEngine
 
       def recalculate
         _width = dimensional_size(@style.width, :width)
-        _height= dimensional_size(@style.height,:height)
+        _height = dimensional_size(@style.height, :height)
         @width = _width
-        @height= _height
+        @height = _height
 
         update_background
       end
@@ -43,8 +43,9 @@ module CyberarmEngine
         @fraction = decimal.clamp(0.0, 1.0)
         update_background
 
-        return @fraction
+        publish(:changed, @fraction)
+        @fraction
       end
     end
   end
-end
+end

data/lib/cyberarm_engine/ui/elements/radio.rb

@@ -0,0 +1,6 @@
+module CyberarmEngine
+  class Element
+    class Radio < Element
+    end
+  end
+end

data/lib/cyberarm_engine/ui/elements/slider.rb

@@ -0,0 +1,104 @@
+module CyberarmEngine
+  class Element
+    class Slider < Container
+      class Handle < Button
+        def initialize(*args)
+          super(*args)
+
+          event(:begin_drag)
+          event(:drag_update)
+          event(:end_drag)
+
+          subscribe :begin_drag do |_sender, x, y, _button|
+            @drag_start_pos = Vector.new(x, y)
+
+            :handled
+          end
+
+          subscribe :drag_update do |_sender, x, y, _button|
+            @parent.handle_dragged_to(x, y)
+
+            :handled
+          end
+
+          subscribe :end_drag do
+            @drag_start_pos = nil
+
+            :handled
+          end
+        end
+
+        def draggable?(button)
+          button == :left
+        end
+      end
+
+      attr_reader :range, :step_size, :value
+
+      def initialize(options = {}, block = nil)
+        super(options, block)
+
+        @range     = @options[:range] || (0.0..1.0)
+        @step_size = @options[:step] || 0.1
+        @value     = @options[:value] || (@range.first + @range.last) / 2
+
+        @handle = Handle.new("", parent: self, width: 8, height: 1.0) { close }
+        add(@handle)
+      end
+
+      def recalculate
+        _width = dimensional_size(@style.width, :width)
+        _height = dimensional_size(@style.height, :height)
+
+        @width  = _width
+        @height = _height
+
+        position_handle
+        @handle.recalculate
+        @handle.update_background
+
+        update_background
+      end
+
+      def position_handle
+        @handle.x = @x + @style.padding_left + @style.border_thickness_left +
+                    ((content_width - @handle.outer_width) * (@value - @range.min) / (@range.max - @range.min).to_f)
+
+        @handle.y = @y + @style.border_thickness_top + @style.padding_top
+      end
+
+      def draw
+        super
+
+        @handle.draw
+      end
+
+      def update
+        super
+
+        @tip = value.to_s
+        @handle.tip = @tip
+      end
+
+      def holding_left_mouse_button(_sender, x, y)
+        handle_dragged_to(x, y)
+
+        :handled
+      end
+
+      def handle_dragged_to(x, _y)
+        @ratio = ((x - @handle.width / 2) - @x) / (content_width - @handle.outer_width)
+
+        self.value = @ratio.clamp(0.0, 1.0) * (@range.max - @range.min) + @range.min
+      end
+
+      def value=(n)
+        @value = n
+        position_handle
+        @handle.recalculate
+
+        publish(:changed, @value)
+      end
+    end
+  end
+end

data/lib/cyberarm_engine/ui/elements/stack.rb

@@ -1,8 +1,6 @@
 module CyberarmEngine
   class Element
     class Stack < Container
-      include Common
-
       def layout
         @children.each do |child|
           move_to_next_line(child)
@@ -10,4 +8,4 @@ module CyberarmEngine
       end
     end
   end
-end
+end

data/lib/cyberarm_engine/ui/elements/text_block.rb

@@ -0,0 +1,156 @@
+module CyberarmEngine
+  class Element
+    class TextBlock < Element
+      def initialize(text, options = {}, block = nil)
+        super(options, block)
+
+        @text = Text.new(
+          text, font: @options[:font], z: @z, color: @options[:color],
+                size: @options[:text_size], shadow: @options[:text_shadow],
+                shadow_size: @options[:text_shadow_size],
+                shadow_color: @options[:text_shadow_color]
+        )
+
+        @raw_text = text
+      end
+
+      def render
+        @text.draw
+      end
+
+      def clicked_left_mouse_button(_sender, _x, _y)
+        @block&.call(self) if @enabled
+
+        # return :handled
+      end
+
+      def recalculate
+        @width  = 0
+        @height = 0
+
+        _width  = dimensional_size(@style.width,  :width)
+        _height = dimensional_size(@style.height, :height)
+
+        handle_text_wrapping(_width)
+
+        @width  = _width  || @text.width.round
+        @height = _height || @text.height.round
+
+        @text.y = @style.border_thickness_top + @style.padding_top + @y
+        @text.z = @z + 3
+
+        if (text_alignment = @options[:text_align])
+          case text_alignment
+          when :left
+            @text.x = @style.border_thickness_left + @style.padding_left + @x
+          when :center
+            @text.x = if @text.width <= outer_width
+                        @x + outer_width / 2 - @text.width / 2
+                      else # Act as left aligned
+                        @style.border_thickness_left + @style.padding_left + @x
+                      end
+          when :right
+            @text.x = @x + outer_width - (@text.width + @style.border_thickness_right + @style.padding_right)
+          end
+        end
+
+        update_background
+      end
+
+      def handle_text_wrapping(max_width)
+        max_width ||= @parent&.width
+        max_width ||= @x - (window.width + noncontent_width)
+        wrap_behavior = style.text_wrap
+        copy = @raw_text.to_s.dup
+
+        if line_width(copy[0]) <= max_width && line_width(copy) > max_width && wrap_behavior != :none
+          breaks = []
+          line_start = 0
+          line_end   = copy.length
+
+          while line_start != copy.length
+            if line_width(copy[line_start...line_end]) > max_width
+              line_end = ((line_end - line_start) / 2.0)
+              line_end = 1.0 if line_end <= 1
+            elsif line_end < copy.length && line_width(copy[line_start...line_end + 1]) < max_width
+              # To small, grow!
+              # TODO: find a more efficient way
+              line_end += 1
+
+            else # FOUND IT!
+              entering_line_end = line_end.floor
+              max_reach = line_end.floor - line_start < 63 ? line_end.floor - line_start : 63
+              reach = 0
+
+              if wrap_behavior == :word_wrap
+                max_reach.times do |i|
+                  reach = i
+                  break if copy[line_end.floor - i].to_s.match(/[[:punct:]]| /)
+                end
+
+                # puts "Max width: #{max_width}/#{line_width(@raw_text)} Reach: {#{reach}/#{max_reach}} Line Start: #{line_start}/#{line_end.floor} (#{copy.length}|#{@raw_text.length}) [#{entering_line_end}] '#{copy}' {#{copy[line_start...line_end]}}"
+                line_end = line_end.floor - reach + 1 if reach != max_reach # Add +1 to walk in front of punctuation
+              end
+
+              breaks << line_end.floor
+              line_start = line_end.floor
+              line_end = copy.length
+
+              break if entering_line_end == copy.length || reach == max_reach
+            end
+          end
+
+          breaks.each_with_index do |pos, index|
+            copy.insert(pos + index, "\n") if pos + index >= 0 && pos + index < copy.length
+          end
+        end
+
+        @text.text = copy
+      end
+
+      def line_width(text)
+        (@text.textobject.markup_width(text) + noncontent_width)
+      end
+
+      def value
+        @raw_text
+      end
+
+      def value=(value)
+        @raw_text = value.to_s.chomp
+
+        old_width = width
+        old_height = height
+        recalculate
+
+        root.gui_state.request_recalculate if old_width != width || old_height != height
+
+        publish(:changed, self.value)
+      end
+    end
+
+    class Banner < TextBlock
+    end
+
+    class Title < TextBlock
+    end
+
+    class Subtitle < TextBlock
+    end
+
+    class Tagline < TextBlock
+    end
+
+    class Caption < TextBlock
+    end
+
+    class Para < TextBlock
+    end
+
+    class Inscription < TextBlock
+    end
+
+    class ToolTip < TextBlock
+    end
+  end
+end

data/lib/cyberarm_engine/ui/elements/toggle_button.rb

@@ -1,56 +1,65 @@
 module CyberarmEngine
   class Element
     class ToggleButton < Button
-      attr_reader :toggled
+      attr_reader :toggled, :value
 
       def initialize(options, block = nil)
-        super(options[:checkmark], options, block)
-        @toggled = options[:toggled] || false
-        if @toggled
-          @text.text = @options[:checkmark]
+        if options.dig(:theme, :ToggleButton, :checkmark_image)
+          options[:theme][:ToggleButton][:image_width] ||= options[:theme][:Label][:text_size]
+          super(get_image(options.dig(:theme, :ToggleButton, :checkmark_image)), options, block)
+
+          @_image = @image
         else
-          @text.text = ""
+          super(options[:checkmark], options, block)
         end
 
-        return self
-      end
+        @value = options[:checked] || false
 
-      def toggled=(boolean)
-        @toggled = !boolean
-        toggle
+        if @value
+          @image = @_image if @_image
+          @raw_text = @options[:checkmark]
+        else
+          @image = nil
+          @raw_text = ""
+        end
       end
 
-      def clicked_left_mouse_button(sender, x, y)
-        toggle
+      def clicked_left_mouse_button(_sender, _x, _y)
+        self.value = !@value
 
         @block.call(self) if @block
 
-        return :handled
-      end
-
-      def toggle
-        if @toggled
-          @toggled = false
-          @text.text = ""
-        else
-          @toggled = true
-          @text.text = @options[:checkmark]
-        end
+        :handled
       end
 
       def recalculate
         super
+        return if @image
+
+        _width  = dimensional_size(@style.width,  :width)
+        _height = dimensional_size(@style.height, :height)
+
+        @width  = _width  || @text.textobject.text_width(@options[:checkmark])
+        @height = _height || @text.height
 
-        _width = dimensional_size(@style.width, :width)
-        _height= dimensional_size(@style.height,:height)
-        @width  = _width  ? _width  : @text.textobject.text_width(@options[:checkmark])
-        @height = _height ? _height : @text.height
         update_background
       end
 
-      def value
-        @toggled
+      def value=(boolean)
+        @value = boolean
+
+        if boolean
+          @image = @_image if @_image
+          @raw_text = @options[:checkmark]
+        else
+          @image = nil
+          @raw_text = ""
+        end
+
+        recalculate
+
+        publish(:changed, @value)
       end
     end
   end
-end
+end