shoes-core 4.0.0.pre3

data/lib/shoes/point.rb

@@ -0,0 +1,54 @@
+class Shoes
+  class Point
+    include Common::Inspect
+
+    def initialize(x, y)
+      @x, @y = x, y
+    end
+
+    attr_accessor :x, :y
+
+    # @param [Shoes::Point] other the other point
+    # @return [Integer] if this is further left, this.x; otherwise other.x
+    def left(other = self)
+      [x, other.x].min
+    end
+
+    # @param [Shoes::Point] other the other point
+    # @return [Integer] if this is higher, this.y; otherwise other.y
+    def top(other = self)
+      [y, other.y].min
+    end
+
+    # Creates a new point at an offset of (x,y) from this point. Positive
+    # offsets move right and down; negative offsets move left and up.
+    #
+    # @param [Integer] x the x-component of the offset
+    # @param [Integer] y the y-component of the offset
+    # @return [Shoes::Point] a new point at offset (x,y) from this point
+    def to(x, y)
+      Shoes::Point.new(@x + x, @y + y)
+    end
+
+    def width(other = self)
+      (@x - other.x).abs
+    end
+
+    def height(other = self)
+      (@y - other.y).abs
+    end
+
+    def ==(other)
+      other.respond_to?(:x) && @x == other.x && other.respond_to?(:y) && @y == other.y
+    end
+
+    def to_s
+      nothing = '_'
+      "(#{@x || nothing},#{@y || nothing})"
+    end
+
+    def inspect
+      super.insert(-2, " #{self}")
+    end
+  end
+end

data/lib/shoes/progress.rb

@@ -0,0 +1,25 @@
+class Shoes
+  class Progress
+    include Common::UIElement
+    include Common::Style
+
+    attr_reader :app, :parent, :dimensions, :gui
+    style_with :common_styles, :dimensions, :fraction
+    STYLES = { fraction: 0.0 }
+
+    def initialize(app, parent, styles = {}, _blk = nil)
+      @app = app
+      @parent = parent
+      style_init styles
+      @dimensions = Dimensions.new parent, @style
+      @parent.add_child self
+      @gui = Shoes.configuration.backend_for self, @parent.gui
+      @gui.fraction = @style[:fraction]
+    end
+
+    def fraction=(value)
+      style(fraction: value)
+      @gui.fraction = value
+    end
+  end
+end

data/lib/shoes/radio.rb

@@ -0,0 +1,15 @@
+class Shoes
+  class Radio < CheckButton
+    style_with :checked, :click, :common_styles, :dimensions, :group, :state
+
+    def initialize(app, parent, group, styles = {}, blk = nil)
+      styles[:group] = group
+      super(app, parent, styles, blk)
+    end
+
+    def group=(value)
+      style(group: value)
+      gui.group = value
+    end
+  end
+end

data/lib/shoes/rect.rb

@@ -0,0 +1,21 @@
+class Shoes
+  class Rect
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+
+    attr_reader :app, :parent, :dimensions, :gui
+    style_with :angle, :art_styles, :curve, :common_styles, :dimensions
+    STYLES = { angle: 0 }
+
+    def initialize(app, parent, left, top, width, height, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+      style_init styles
+      @dimensions = AbsoluteDimensions.new left, top, width, height, @style
+      @parent.add_child self
+      @gui = Shoes.backend_for self
+      register_click blk
+    end
+  end
+end

data/lib/shoes/renamed_delegate.rb

@@ -0,0 +1,15 @@
+module RenamedDelegate
+  include Forwardable
+
+  def renamed_delegate_to(getter, methods, renamings)
+    methods.each do |method|
+      method_name = method.to_s
+      renamed_method_name = renamings.inject(method_name) do |name, (word, sub)|
+        name.gsub word, sub
+      end
+      if renamed_method_name != method_name
+        def_delegator getter, method_name, renamed_method_name
+      end
+    end
+  end
+end

data/lib/shoes/shape.rb

@@ -0,0 +1,159 @@
+class Shoes
+  class Shape
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+
+    attr_reader :app, :parent, :dimensions, :gui, :blk, :x, :y
+    attr_reader :left_bound, :top_bound, :right_bound, :bottom_bound
+    style_with :art_styles, :center, :common_styles, :dimensions
+
+    # Creates a new Shoes::Shape
+    #
+    def initialize(app, parent, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+      style_init styles
+      @dimensions = AbsoluteDimensions.new @style
+      @parent.add_child self
+      @gui = Shoes.backend_for self
+      register_click
+
+      @blk = blk
+      # True until we've asked the pen to draw
+      @before_drawing = true
+      @app.eval_with_additional_context self, &blk
+    end
+
+    def width
+      @app.width
+    end
+
+    def height
+      @app.height
+    end
+
+    # Moves the shape
+    #
+    # @param [Integer] left The new left value
+    # @param [Integer] top The new top value
+    # @return [Shoes::Shape] This shape
+    def move(left, top)
+      self.left = left
+      self.top = top
+      @gui.update_position
+      self
+    end
+
+    # Draws a line from the current position to the given point
+    #
+    # @param [Integer] x The new point's x-value
+    # @param [Integer] y The new point's y-value
+    # @return [Shoes::Shape] This shape
+    def line_to(x, y)
+      update_bounds_rect(@x, @y, x, y)
+      @x, @y = x, y
+      @gui.line_to(x, y)
+      self
+    end
+
+    # Moves the drawing "pen" to the given point
+    #
+    # @param [Integer] x The new point's x-value
+    # @param [Integer] y The new point's y-value
+    # @return [Shoes::Shape] self This shape
+    def move_to(x, y)
+      @x, @y = x, y
+      @gui.move_to(x, y)
+      self
+    end
+
+    # Draws a curve
+    #
+    # @param [Integer] cx1 The first control point's x-value
+    # @param [Integer] cy1 The first control point's y-value
+    # @param [Integer] cx2 The second control point's x-value
+    # @param [Integer] cy2 The second control point's y-value
+    # @param [Integer] x The end point's x-value
+    # @param [Integer] y The end point's y-value
+    # @return [Shoes::Shape] This shape
+    def curve_to(cx1, cy1, cx2, cy2, x, y)
+      update_bounds([@x, cx1, cx2, x], [@y, cy1, cy2, y])
+      @x, @y = x, y
+      @gui.curve_to(cx1, cy1, cx2, cy2, x, y)
+      self
+    end
+
+    # Draws an arc
+    #
+    # @param [Integer] x The left position
+    # @param [Integer] y The top position
+    # @param [Integer] width The width of the arc
+    # @param [Integer] height The height of the arc
+    # @param [Integer] start_angle The start angle
+    # @param [Integer] arc_angle The angular extent of the arc, relative to the start angle
+    # @return [Shoes::Shape] This shape
+    def arc(x, y, width, height, start_angle, arc_angle)
+      update_bounds_rect(x - width / 2, y - height / 2, x + width / 2, y + height / 2)
+      @x, @y = x, y
+      @gui.arc(x, y, width, height, start_angle, arc_angle)
+      self
+    end
+
+    private
+
+    # Updates the bounds of this shape to include the rectangle described by
+    # (x1, y1) and (x2, y2)
+    #
+    # @param [Integer] x1 The x-value of the first coordinate
+    # @param [Integer] y1 The y-value of the first coordinate
+    # @param [Integer] x2 The x-value of the second coordinate
+    # @param [Integer] y2 The y-value of the second coordinate
+    # @return nil
+    def update_bounds_rect(x1, y1, x2, y2)
+      update_bounds([x1, x2], [y1, y2])
+    end
+
+    # Updates the bounds of this shape to the rectangle covering all
+    # the given coordinates.
+    #
+    # @param [Array<Integer>] xs Array of X coordinates
+    # @param [Array<Integer>] ys Array of Y coordinates
+    # @return nil
+    def update_bounds(xs, ys)
+      all_xs = all_x_values(xs)
+      all_ys = all_y_values(ys)
+      @left_bound = calculate_primary_dimension_value @left_bound, all_xs
+      @top_bound = calculate_primary_dimension_value @top_bound, all_ys
+      @right_bound = calculate_secondary_dimension_value @right_bound, all_xs
+      @bottom_bound = calculate_secondary_dimension_value @bottom_bound, all_ys
+      @before_drawing = false
+      nil
+    end
+
+    def all_x_values(xs)
+      all_values xs, @x, @left_bound, @right_bound
+    end
+
+    def all_y_values(ys)
+      all_values ys, @y, @top_bound, @bottom_bound
+    end
+
+    def all_values(values, current, min, max)
+      additional = @before_drawing ? [current] : [current, min, max]
+      (values + additional).map(&:to_i)
+    end
+
+    def calculate_primary_dimension_value(current, new)
+      new_min = Array(new).min
+      return new_min if @before_drawing || new_min < current
+      current
+    end
+
+    def calculate_secondary_dimension_value(current, new)
+      new_max = Array(new).max
+      return new_max if @before_drawing || new_max > current
+      current
+    end
+  end
+end

data/lib/shoes/slot.rb

@@ -0,0 +1,276 @@
+class Shoes
+  class Slot
+    include Common::UIElement
+    include Common::Clickable
+    include Common::Style
+
+    # We need that offset because otherwise element overlap e.g. occupy
+    # the same pixel - this way they start right next to each other
+    # See #update_current_position
+    NEXT_ELEMENT_OFFSET = 1
+
+    attr_reader :parent, :dimensions, :gui, :contents, :blk, :hover_proc, :leave_proc
+    style_with :art_styles, :attach, :common_styles, :dimensions, :scroll
+    STYLES = { scroll: false }
+
+    def initialize(app, parent, styles = {}, blk = nil)
+      init_attributes(app, parent, styles, blk)
+      @parent.add_child self
+      @gui = Shoes.configuration.backend_for self, @parent.gui
+      eval_block blk
+      contents_alignment
+    end
+
+    def init_attributes(app, parent, styles, blk)
+      @app            = app
+      @parent         = parent
+      @contents       = SlotContents.new
+      @blk            = blk
+      style_init styles
+      @dimensions     = Dimensions.new parent, @style
+      @fixed_height   = height || false
+      @scroll_top     = 0
+      set_default_dimension_values
+      @pass_coordinates = true
+    end
+
+    def set_default_dimension_values
+      self.width          ||= 1.0
+      self.height         ||= 0
+      self.absolute_left  ||= 0
+      self.absolute_top   ||= 0
+    end
+
+    def clear(&blk)
+      contents.clear
+      eval_block blk
+    end
+
+    def eval_block(blk, *args)
+      old_current_slot = @app.current_slot
+      @app.current_slot = self
+      blk.call(*args) if blk
+      @app.current_slot = old_current_slot
+    end
+
+    def create_bound_block(blk)
+      Proc.new do |*args|
+        eval_block(blk, *args)
+      end
+    end
+
+    def add_child(element)
+      contents.add_element element
+    end
+
+    def remove_child(element)
+      contents.delete element
+    end
+
+    def append(&blk)
+      eval_block blk
+    end
+
+    def prepend(&blk)
+      contents.prepend do
+        eval_block blk
+      end
+    end
+
+    def contents_alignment(_ = nil)
+      position_contents
+      determine_slot_height
+    end
+
+    def hovered?
+      @hovered
+    end
+
+    def hover(blk)
+      @hover_proc = blk
+      @app.add_mouse_hover_control self
+    end
+
+    def leave(blk)
+      @leave_proc = blk
+      @app.add_mouse_hover_control self
+    end
+
+    def mouse_hovered
+      @hovered = true
+      @hover_proc.call(self) if @hover_proc
+    end
+
+    def mouse_left
+      @hovered = false
+      @leave_proc.call(self) if @leave_proc
+    end
+
+    def scroll_height
+      position_contents.y
+    end
+
+    def scroll_max
+      scroll_height - height
+    end
+
+    attr_reader :scroll_top
+
+    attr_writer :scroll_top
+
+    def app
+      @app.app # return the Shoes::App not the internal app
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{hash.to_s(16)} @contents=#{@contents.inspect} and so much stuff literally breaks the memory limit. Look at it selectively.>"
+    end
+
+    protected
+
+    CurrentPosition = Struct.new(:x, :y, :next_line_start)
+
+    def position_contents
+      current_position = CurrentPosition.new element_left,
+                                             element_top,
+                                             element_top
+
+      contents.each do |element|
+        next if element.hidden?
+        current_position = positioning(element, current_position)
+      end
+      current_position
+    end
+
+    def positioning(element, current_position)
+      position_element element, current_position
+      element.contents_alignment(current_position) if element.respond_to? :contents_alignment
+      if element.takes_up_space?
+        update_current_position(current_position, element)
+      else
+        current_position
+      end
+    end
+
+    def position_element(_element, _current_position)
+      fail 'position_element is a subclass responsibility'
+    end
+
+    def position_in_current_line(element, current_position)
+      position_element_at element,
+                          position_x(current_position.x, element),
+                          position_y(current_position.y, element)
+    end
+
+    def move_to_next_line(element, current_position)
+      position_element_at element,
+                          position_x(element_left, element),
+                          position_y(current_position.next_line_start, element)
+    end
+
+    def position_element_at(element, x, y)
+      return if element_did_not_move?(element, x, y)
+      element._position x, y
+    end
+
+    def element_did_not_move?(element, x, y)
+      element.absolute_left == x && element.absolute_top == y
+    end
+
+    def update_current_position(current_position, element)
+      return current_position if element.absolutely_positioned?
+      current_position.x = element.absolute_right + NEXT_ELEMENT_OFFSET
+      current_position.y = element.absolute_top
+      next_element_line_start = next_line_start_from element
+      if current_position.next_line_start < next_element_line_start
+        current_position.next_line_start = next_element_line_start
+      end
+      element.adjust_current_position current_position
+      current_position
+    end
+
+    def next_line_start_from(element)
+      element.absolute_bottom + NEXT_ELEMENT_OFFSET
+    end
+
+    def position_x(relative_x, element)
+      if element.absolute_x_position?
+        absolute_x_position(element)
+      else
+        relative_x
+      end
+    end
+
+    def absolute_x_position(element)
+      if element.absolute_left_position?
+        self.element_left + element.left
+      elsif element.absolute_right_position?
+        self.element_right - (element.right + element.width)
+      end
+    end
+
+    def position_y(relative_y, element)
+      if element.absolute_y_position?
+        absolute_y_position(element)
+      else
+        relative_y
+      end
+    end
+
+    def absolute_y_position(element)
+      if element.absolute_top_position?
+        self.element_top + element.top
+      elsif element.absolute_bottom_position?
+        # TODO: slots grow... to really position it relative to the bottom
+        # we probably need to position it after everything has been positioned
+        self.element_bottom - (element.bottom + element.height)
+      end
+    end
+
+    def fits_on_the_same_line?(element, current_x)
+      fitting_width = element.width
+      fitting_width = element.fitting_width if element.respond_to?(:fitting_width)
+      current_x + fitting_width - 1 <= element_right
+    end
+
+    def determine_slot_height
+      content_height = compute_content_height
+      self.height = content_height if has_variable_height?
+      content_height
+    end
+
+    def compute_content_height
+      max_bottom = contents.
+                    select(&:takes_up_space?).
+                    reject(&:hidden?).
+                    map(&:absolute_bottom).
+                    max
+
+      if max_bottom
+        max_bottom - self.absolute_top + NEXT_ELEMENT_OFFSET
+      else
+        0
+      end
+    end
+
+    def has_variable_height?
+      !@fixed_height
+    end
+  end
+
+  class Flow < Slot
+    def position_element(element, current_position)
+      if fits_on_the_same_line?(element, current_position.x)
+        position_in_current_line(element, current_position)
+      else
+        move_to_next_line(element, current_position)
+      end
+    end
+  end
+
+  class Stack < Slot
+    def position_element(element, current_position)
+      move_to_next_line(element, current_position)
+    end
+  end
+end