shoes-dsl 4.0.0.pre2

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,158 @@
+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,271 @@
+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
+      old_current_slot = @app.current_slot
+      @app.current_slot = self
+      blk.call if blk
+      @app.current_slot = old_current_slot
+    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
+
+    def scroll_top
+      @scroll_top
+    end
+
+    def scroll_top=(position)
+      @scroll_top = position
+    end
+
+    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)
+      return current_position unless element.needs_to_be_positioned?
+      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)
+      raise '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(self.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.absolute_left + element.left
+      elsif element.absolute_right_position?
+        self.absolute_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.absolute_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.absolute_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.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?
+      not @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

data/lib/shoes/slot_contents.rb

@@ -0,0 +1,50 @@
+class Shoes
+  class SlotContents < SimpleDelegator
+    include Common::Inspect
+
+    def initialize
+      @contents         = []
+      @prepending       = false
+      @prepending_index = 0
+      super(@contents)
+    end
+
+    def add_element(element)
+      if @prepending
+        prepend_element element
+      else
+        append_element element
+      end
+    end
+
+    def prepend(&blk)
+      @prepending_index = 0
+      @prepending = true
+      blk.call
+      @prepending = false
+    end
+
+    def clear
+      # reverse_each is important as otherwise we always miss to delete one
+      # element
+      @contents.reverse_each do |element|
+        element.is_a?(Shoes::Slot) ? element.clear : element.remove
+      end
+      @contents.clear
+    end
+
+    def inspect
+      super.insert(-2, " @size=#{size} @prepending=#{@prepending} @prepending_index=#{@prepending_index}")
+    end
+
+    private
+    def append_element(element)
+      @contents << element
+    end
+
+    def prepend_element(element)
+      @contents.insert @prepending_index, element
+      @prepending_index += 1
+    end
+  end
+end