cyberarm_engine 0.13.1 → 0.17.1

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

@@ -2,13 +2,32 @@ module CyberarmEngine
   class Element
     class CheckBox < Flow
       def initialize(text, options, block = nil)
-        super({}, block = nil)
+        super(options, block)
         options[:toggled] = options[:checked]
 
         @toggle_button = ToggleButton.new(options)
-        @label         = Label.new(text, options)
+        @label         = TextBlock.new(text, options)
 
-        define_label_singletons
+        @label.subscribe(:holding_left_mouse_button) do |sender, x, y|
+          @toggle_button.left_mouse_button(sender, x, y)
+        end
+
+        @label.subscribe(:released_left_mouse_button) do |sender, x, y|
+          @toggle_button.released_left_mouse_button(sender, x, y)
+        end
+
+        @label.subscribe(:clicked_left_mouse_button) do |sender, x, y|
+          @toggle_button.clicked_left_mouse_button(sender, x, y)
+          publish(:changed, @toggle_button.value)
+        end
+
+        @label.subscribe(:enter) do |sender|
+          @toggle_button.enter(sender)
+        end
+
+        @label.subscribe(:leave) do |sender|
+          @toggle_button.leave(sender)
+        end
 
         add(@toggle_button)
         add(@label)
@@ -24,36 +43,9 @@ module CyberarmEngine
       end
 
       def value=(bool)
-        @toggle_button.vlaue = bool
-      end
-
-      def define_label_singletons
-        @label.define_singleton_method(:_toggle_button) do |button|
-          @_toggle_button = button
-        end
-
-        @label._toggle_button(@toggle_button)
-
-        @label.define_singleton_method(:holding_left_mouse_button) do |sender, x, y|
-          @_toggle_button.left_mouse_button(sender, x, y)
-        end
-
-        @label.define_singleton_method(:released_left_mouse_button) do |sender, x, y|
-          @_toggle_button.released_left_mouse_button(sender, x, y)
-        end
-
-        @label.define_singleton_method(:clicked_left_mouse_button) do |sender, x, y|
-          @_toggle_button.clicked_left_mouse_button(sender, x, y)
-        end
-
-        @label.define_singleton_method(:enter) do |sender|
-          @_toggle_button.enter(sender)
-        end
-
-        @label.define_singleton_method(:leave) do |sender|
-          @_toggle_button.leave(sender)
-        end
+        @toggle_button.value = bool
+        publish(:changed, @toggle_button.value)
       end
     end
   end
-end
+end

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

@@ -4,31 +4,32 @@ module CyberarmEngine
       include Common
 
       attr_accessor :stroke_color, :fill_color
-      attr_reader :children, :gui_state
-      attr_reader :scroll_x, :scroll_y
+      attr_reader :children, :gui_state, :scroll_position
 
       def initialize(options = {}, block = nil)
         @gui_state = options.delete(:gui_state)
         super
 
-        @scroll_x, @scroll_y = 0, 0
-        @scroll_speed = 10
+        @scroll_position = Vector.new(0, 0)
+        @scroll_speed = 40
 
         @text_color = options[:color]
 
         @children = []
+
+        event(:window_size_changed)
       end
 
       def build
         @block.call(self) if @block
 
-        recalculate
+        root.gui_state.request_recalculate
       end
 
       def add(element)
         @children << element
 
-        recalculate
+        root.gui_state.request_recalculate
       end
 
       def clear(&block)
@@ -41,7 +42,17 @@ module CyberarmEngine
 
         $__current_container__ = old_container
 
-        recalculate
+        root.gui_state.request_recalculate
+      end
+
+      def apend(&block)
+        old_container = $__current_container__
+
+        $__current_container__ = self
+        block.call(self) if block
+
+        $__current_container__ = old_container
+
         root.gui_state.request_recalculate
       end
 
@@ -49,6 +60,31 @@ module CyberarmEngine
         Gosu.clip_to(@x, @y, width, height) do
           @children.each(&:draw)
         end
+
+        if false # DEBUG
+          Gosu.flush
+
+          Gosu.draw_line(
+            x, y, Gosu::Color::RED,
+            x + outer_width, y, Gosu::Color::RED,
+            Float::INFINITY
+          )
+          Gosu.draw_line(
+            x + outer_width, y, Gosu::Color::RED,
+            x + outer_width, y + outer_height, Gosu::Color::RED,
+            Float::INFINITY
+          )
+          Gosu.draw_line(
+            x + outer_width, y + outer_height, Gosu::Color::RED,
+            x, y + outer_height, Gosu::Color::RED,
+            Float::INFINITY
+          )
+          Gosu.draw_line(
+            x, outer_height, Gosu::Color::RED,
+            x, y, Gosu::Color::RED,
+            Float::INFINITY
+          )
+        end
       end
 
       def update
@@ -57,6 +93,8 @@ module CyberarmEngine
 
       def hit_element?(x, y)
         @children.reverse_each do |child|
+          next unless child.visible?
+
           case child
           when Container
             if element = child.hit_element?(x, y)
@@ -72,7 +110,12 @@ module CyberarmEngine
 
       def recalculate
         @current_position = Vector.new(@style.margin_left + @style.padding_left, @style.margin_top + @style.padding_top)
+        @current_position += @scroll_position
+
         return unless visible?
+
+        Stats.increment(:gui_recalculations_last_frame, 1)
+
         stylize
 
         layout
@@ -81,24 +124,26 @@ module CyberarmEngine
           @width  = @style.width  = window.width
           @height = @style.height = window.height
         else
-          @width, @height = 0, 0
+          @width = 0
+          @height = 0
 
           _width = dimensional_size(@style.width, :width)
-          _height= dimensional_size(@style.height,:height)
+          _height = dimensional_size(@style.height, :height)
 
-          @width  = _width  ? _width  : (@children.map {|c| c.x + c.outer_width }.max || 0).round
-          @height = _height ? _height : (@children.map {|c| c.y + c.outer_height}.max || 0).round
+          @width  = _width  || (@children.map { |c| c.x + c.outer_width }.max || 0).round
+          @height = _height || (@children.map { |c| c.y + c.outer_height }.max || 0).round
         end
 
-
         # Move child to parent after positioning
         @children.each do |child|
-          child.x += @x
-          child.y += @y
+          child.x += (@x + @style.border_thickness_left) - style.margin_left
+          child.y += (@y + @style.border_thickness_top) - style.margin_top
 
           child.stylize
           child.recalculate
           child.reposition # TODO: Implement top,bottom,left,center, and right positioning
+
+          Stats.increment(:gui_recalculations_last_frame, 1)
         end
 
         update_background
@@ -109,32 +154,36 @@ module CyberarmEngine
       end
 
       def max_width
-        @max_width ? @max_width : window.width - (@parent ? @parent.style.margin_right + @style.margin_right : @style.margin_right)
+        _width = dimensional_size(@style.width, :width)
+        if _width
+          outer_width
+        else
+          window.width - (@parent ? @parent.style.margin_right + @style.margin_right : @style.margin_right)
+        end
       end
 
       def fits_on_line?(element) # Flow
+        p [@options[:id], @width] if @options[:id]
         @current_position.x + element.outer_width <= max_width &&
-        @current_position.x + element.outer_width <= window.width
+          @current_position.x + element.outer_width <= window.width
       end
 
       def position_on_current_line(element) # Flow
         element.x = element.style.margin_left + @current_position.x
         element.y = element.style.margin_top  + @current_position.y
 
-        element.recalculate
-
         @current_position.x += element.outer_width
         @current_position.x = @style.margin_left if @current_position.x >= max_width
       end
 
-      def tallest_neighbor(querier, y_position) # Flow
+      def tallest_neighbor(querier, _y_position) # Flow
         response = querier
         @children.each do |child|
           response = child if child.outer_height > response.outer_height
           break if child == querier
         end
 
-        return response
+        response
       end
 
       def position_on_next_line(child) # Flow
@@ -144,8 +193,6 @@ module CyberarmEngine
         child.x = child.style.margin_left + @current_position.x
         child.y = child.style.margin_top  + @current_position.y
 
-        child.recalculate
-
         @current_position.x += child.outer_width
       end
 
@@ -153,23 +200,56 @@ module CyberarmEngine
         element.x = element.style.margin_left + @current_position.x
         element.y = element.style.margin_top  + @current_position.y
 
-        element.recalculate
-
         @current_position.y += element.outer_height
       end
 
-      # def mouse_wheel_up(sender, x, y)
-      #   @children.each {|c| c.y -= @scroll_speed}
-      #   @children.each {|c| c.recalculate}
-      # end
+      def mouse_wheel_up(sender, x, y)
+        return unless @style.scroll
+        return if height < max_scroll_height
 
-      # def mouse_wheel_down(sender, x, y)
-      #   @children.each {|c| c.y += @scroll_speed}
-      #   @children.each {|c| c.recalculate}
-      # end
+        if @scroll_position.y < 0
+          @scroll_position.y += @scroll_speed
+          @scroll_position.y = 0 if @scroll_position.y > 0
+          recalculate
+
+          return :handled
+        end
+      end
+
+      def mouse_wheel_down(sender, x, y)
+        return unless @style.scroll
+        return if height < max_scroll_height
+
+        if @scroll_position.y.abs < max_scroll_height
+          @scroll_position.y -= @scroll_speed
+          @scroll_position.y = -max_scroll_height if @scroll_position.y.abs > max_scroll_height
+          recalculate
+
+          return :handled
+        end
+      end
 
       def value
-        @children.map {|c| c.class}.join(", ")
+        @children.map { |c| c.class }.join(", ")
+      end
+
+      def to_s
+        "#{self.class} x=#{x} y=#{y} width=#{width} height=#{height} children=#{@children.size}"
+      end
+
+      def write_tree(indent = "", _index = 0)
+        puts self
+
+        indent += "  "
+        @children.each_with_index do |child, i|
+          print "#{indent}#{i}: "
+
+          if child.is_a?(Container)
+            child.write_tree(indent)
+          else
+            puts child
+          end
+        end
       end
     end
   end

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

@@ -0,0 +1,179 @@
+module CyberarmEngine
+  class Element
+    class EditBox < EditLine
+      def initialize(*args)
+        super(*args)
+
+        @active_line = 0
+
+        @repeatable_keys = [
+          {
+            key: Gosu::KB_UP,
+            down: false,
+            repeat_delay: 50,
+            last_repeat: 0,
+            action: proc { move(:up) }
+          },
+          {
+            key: Gosu::KB_DOWN,
+            down: false,
+            repeat_delay: 50,
+            last_repeat: 0,
+            action: proc { move(:down) }
+          }
+        ]
+      end
+
+      def update
+        super
+
+        caret_stay_left_of_last_newline
+        calculate_active_line
+
+        @repeatable_keys.each do |key|
+          if key[:down] && (Gosu.milliseconds > key[:last_repeat] + key[:repeat_delay])
+            key[:action].call
+            key[:last_repeat] = Gosu.milliseconds
+          end
+        end
+      end
+
+      def draw_caret
+        Gosu.draw_rect(caret_position, @text.y + @active_line * @text.textobject.height, @caret_width, @caret_height,
+                       @caret_color, @z)
+      end
+
+      def draw_selection
+        selection_width = caret_position - selection_start_position
+
+        Gosu.draw_rect(selection_start_position, @text.y, selection_width, @text.textobject.height,
+                       default(:selection_color), @z)
+      end
+
+      def text_input_position_for(_method)
+        line = @text_input.text[0...@text_input.caret_pos].lines.last
+        _x = @text.x + @offset_x
+
+        if @type == :password
+          _x + @text.width(default(:password_character) * line.length)
+        else
+          _x + @text.width(line)
+        end
+      end
+
+      def set_position(int)
+        int = 0 if int < 0
+        @text_input.selection_start = @text_input.caret_pos = int
+      end
+
+      def calculate_active_line
+        sub_text = @text_input.text[0...@text_input.caret_pos]
+        @active_line = sub_text.lines.size - 1
+      end
+
+      def caret_stay_left_of_last_newline
+        @text_input.text += "\n" unless @text_input.text.end_with?("\n")
+
+        eof = @text_input.text.chomp.length
+        set_position(eof) if @text_input.caret_pos > eof
+      end
+
+      def caret_position_under_mouse(mouse_x, mouse_y)
+        active_line = row_at(mouse_y)
+        right_offset = column_at(mouse_x, mouse_y)
+
+        buffer = @text_input.text.lines[0..active_line].join if active_line != 0
+        buffer = @text_input.text.lines.first if active_line == 0
+        line = buffer.lines.last
+
+        if buffer.chars.last == "\n"
+          (buffer.length - line.length) + right_offset - 1
+        else
+          (buffer.length - line.length) + right_offset
+        end
+      end
+
+      def move_caret_to_mouse(mouse_x, mouse_y)
+        set_position(caret_position_under_mouse(mouse_x, mouse_y))
+      end
+
+      def row_at(y)
+        ((y - @text.y) / @text.textobject.height).round
+      end
+
+      def column_at(x, y)
+        row = row_at(y)
+
+        buffer = @text_input.text.lines[0..row].join if row != 0
+        buffer = @text_input.text.lines.first if row == 0
+
+        line = @text_input.text.lines[row]
+        line ||= ""
+        column = 0
+
+        line.length.times do |_i|
+          break if @text.textobject.text_width(line[0...column]) >= (x - @text.x).clamp(0.0, Float::INFINITY)
+
+          column += 1
+        end
+
+        column
+      end
+
+      def button_down(id)
+        super
+
+        @repeatable_keys.detect do |key|
+          next unless key[:key] == id
+
+          key[:down] = true
+          key[:last_repeat] = Gosu.milliseconds + key[:repeat_delay]
+          return true
+        end
+
+        case id
+        when Gosu::KB_ENTER, Gosu::KB_RETURN
+          caret_pos = @text_input.caret_pos
+          @text_input.text = @text_input.text.insert(@text_input.caret_pos, "\n")
+          @text_input.caret_pos = @text_input.selection_start = caret_pos + 1
+        end
+      end
+
+      def button_up(id)
+        super
+
+        @repeatable_keys.detect do |key|
+          if key[:key] == id
+            key[:down] = false
+            return true
+          end
+        end
+      end
+
+      def move(direction)
+        pos = @text_input.caret_pos
+        line = nil
+
+        case direction
+        when :up
+          return if @active_line == 0
+        when :down
+          return if @active_line == @text_input.text.chomp.lines
+
+          text = @text_input.text.chomp.lines[0..@active_line].join("\n")
+          pos = text.length
+        end
+
+        set_position(pos)
+      end
+
+      def drag_update(_sender, x, y, _button)
+        int = caret_position_under_mouse(x, y)
+        int = 0 if int < 0
+        @text_input.caret_pos = int
+
+        :handled
+      end
+    end
+  end
+end