shoes 4.0.0.pre1 → 4.0.0.pre2

data/lib/shoes/mock/timer.rb

@@ -1,8 +0,0 @@
-class Shoes
-  module Mock
-    class Timer
-      def initialize(*args)
-      end
-    end
-  end
-end

data/lib/shoes/oval.rb

@@ -1,28 +0,0 @@
-class Shoes
-  class Oval
-    include CommonMethods
-    include Common::Fill
-    include Common::Stroke
-    include Common::Style
-    include Common::Clickable
-    include DimensionsDelegations
-
-    attr_reader :app, :dimensions, :angle, :gui, :parent
-
-    def initialize(app, parent, left, top, width, height, opts = {}, &blk)
-      @app                 = app
-      @dimensions          = AbsoluteDimensions.new left, top, width, height, opts
-      @style               = Shoes::Common::Fill::DEFAULTS.merge(
-                            Shoes::Common::Stroke::DEFAULTS).merge(opts)
-      @style[:strokewidth] ||= 1
-      @angle               = opts[:angle]
-      @parent              = parent
-
-      @parent.add_child self
-
-      @gui = Shoes.backend_for(self, &blk)
-
-      clickable_options(opts)
-    end
-  end
-end

data/lib/shoes/point.rb

@@ -1,43 +0,0 @@
-class Shoes
-  class Point
-    def initialize(x, y)
-      @x, @y = x, y
-    end
-
-    attr_reader :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)
-      [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)
-      [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)
-      return other.respond_to?(:x) && @x == other.x && other.respond_to?(:y) && @y == other.y
-    end
-  end
-end

data/lib/shoes/progress.rb

@@ -1,26 +0,0 @@
-class Shoes
-  class Progress
-    include CommonMethods
-    include DimensionsDelegations
-
-    attr_reader :app, :parent, :blk, :gui, :opts, :dimensions, :fraction
-
-    def initialize(app, parent, opts = {}, blk = nil)
-      @app        = app
-      @parent     = parent
-      @opts       = opts
-      @blk        = blk
-      @dimensions = Dimensions.new parent, opts
-      @gui        = Shoes.configuration.backend_for(self, @parent.gui)
-
-      @parent.add_child self
-
-      @fraction = 0.0
-    end
-
-    def fraction=(value)
-      @fraction = value
-      @gui.fraction = @fraction
-    end
-  end
-end

data/lib/shoes/radio.rb

@@ -1,15 +0,0 @@
-class Shoes
-  class Radio < CheckButton  
-    attr_accessor :group
-
-    def initialize(app, parent, group, opts = {}, blk = nil)
-      @group = group
-      super(app, parent, opts, blk)
-    end
-
-    def group=(value)
-      self.gui.group = value
-      @group = value
-    end
-  end
-end

data/lib/shoes/rect.rb

@@ -1,28 +0,0 @@
-class Shoes
-  class Rect
-    include CommonMethods
-    include Common::Style
-    include Common::Fill
-    include Common::Stroke
-    include Common::Clickable
-    include DimensionsDelegations
-
-    attr_reader :app, :gui, :corners, :dimensions, :angle, :parent
-
-    def initialize(app, parent, left, top, width, height, opts = {}, &blk)
-      @app                 = app
-      @dimensions          = AbsoluteDimensions.new left, top, width, height, opts
-      @corners             = opts[:curve] || 0
-      @angle               = opts[:angle] || app.rotate
-      @style               = Common::Fill::DEFAULTS.merge(
-                             Common::Stroke::DEFAULTS).merge(opts)
-      @style[:strokewidth] ||= 1
-      @parent              = parent
-
-      @parent.add_child self
-
-      @gui = Shoes.backend_for(self, opts, &blk)
-      clickable_options(opts)
-    end
-  end
-end

data/lib/shoes/renamed_delegate.rb

@@ -1,15 +0,0 @@
-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

@@ -1,175 +0,0 @@
-class Shoes
-  class Shape
-    include Shoes::CommonMethods
-    include Shoes::Common::Fill
-    include Shoes::Common::Stroke
-    include Shoes::Common::Style
-    include Shoes::Common::Clickable
-
-    # Creates a new Shoes::Shape
-    #
-    def initialize(app, opts = {}, blk = nil)
-      @app = app
-      @style = Shoes::Common::Fill::DEFAULTS.merge(Shoes::Common::Stroke::DEFAULTS).merge(opts)
-      @style[:strokewidth] ||= @app.style[:strokewidth] || 1
-      @blk = blk
-
-      @displace_left = 0
-      @displace_top  = 0
-
-      # GUI
-      @gui = Shoes.backend_for(self, @style)
-
-      instance_eval &@blk unless @blk.nil?
-
-      clickable_options(opts)
-    end
-
-    attr_reader :app, :blk, :gui, :hidden
-    attr_reader :x, :y
-    attr_accessor :displace_left, :displace_top
-
-    def left
-      @left || 0
-    end
-
-    def top
-      @top || 0
-    end
-
-    alias_method :absolute_left, :left
-    alias_method :absolute_top, :top
-    alias_method :element_left, :left
-    alias_method :element_top, :top
-
-
-    def right
-      @right || left
-    end
-
-    def bottom
-      @bottom || top
-    end
-
-    def width
-      @app.width
-    end
-
-    def height
-      @app.height
-    end
-
-    alias_method :element_width, :width
-    alias_method :element_height, :height
-
-    def needs_to_be_positioned?
-      true
-    end
-
-    def takes_up_space?
-      true
-    end
-
-    def positioned?
-      absolute_left && absolute_top
-    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)
-      @right += offset(@left, left) if @right
-      @bottom += offset(@top, top) if @bottom
-      @left = left
-      @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
-
-    def quad_to *args
-      @gui.quad_to *args
-    end
-
-    def curve_to(cx1, cy1, cx2, cy2, x, y)
-      update_bounds([@x, cx1, cx2, x], [@y, cy1, cy2, y])
-      @gui.curve_to(cx1, cy1, cx2, cy2, x, y)
-      self
-    end
-
-    def arc(x, y, width, height, start_angle, arc_angle)
-      @x, @y = x, y
-      update_bounds_rect(x-width/2, y-height/2, x+width/2, y+height/2)
-      @gui.arc(x, y, width, height, start_angle, arc_angle)
-    end
-
-    private
-    # Gives the relative offset of the new position from original position.
-    # This calculation is for a single coordinate value, e.g. an x or a y.
-    #
-    # @param [Integer] original The original position
-    # @param [Integer] new The new position
-    # @return [Integer] A value that should be added to the current position in order to
-    #   move to the new position.
-    def offset(original, new)
-      return 0 unless original && new
-      relative = (new - original).abs
-      relative = -relative if new < original
-      relative
-    end
-
-    # 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)
-      x_min = xs.min
-      x_max = xs.max
-      y_min = ys.min
-      y_max = ys.max
-      @left = x_min unless @left && x_min > @left
-      @top = y_min unless @top && y_min > @top
-      @right = x_max unless @right && x_max < @right
-      @bottom = y_max unless @bottom && y_max < @bottom
-      nil
-    end
-  end
-end

data/lib/shoes/slot.rb

@@ -1,232 +0,0 @@
-class Shoes
-  class Slot
-    include Common::Clickable
-    include CommonMethods
-    include DimensionsDelegations
-
-    NEXT_ELEMENT_ON_SAME_LINE_OFFSET = Point.new(1, 0)
-    NEXT_ELEMENT_ON_NEXT_LINE_OFFSET = Point.new(0, 1)
-
-    attr_reader :parent, :gui, :contents, :blk, :dimensions, :hover_proc,
-                :leave_proc
-
-    def initialize(app, parent, opts={}, &blk)
-      init_attributes(app, parent, opts, blk)
-      @parent.add_child self
-
-      @gui = Shoes.configuration.backend_for(self, @parent.gui)
-      eval_block blk
-      contents_alignment
-    end
-
-    def init_attributes(app, parent, opts, blk)
-      @app            = app
-      @parent         = parent
-      @contents       = SlotContents.new
-      @blk            = blk
-      @dimensions     = Dimensions.new parent, opts
-      @fixed_height   = height || false
-      set_default_dimension_values
-    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
-      @app.current_slot = self
-      blk.call if blk
-      @app.current_slot = parent
-    end
-
-    def add_child(element)
-      contents.add_element element
-    end
-
-    def append(&blk)
-      eval_block blk
-    end
-
-    def prepend(&blk)
-      contents.prepend do
-        eval_block blk
-      end
-    end
-
-    def contents_alignment(_=nil)
-      last_position = position_contents
-      determine_slot_height(last_position)
-    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
-    end
-
-    def mouse_left
-      @hovered = false
-    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_modifier = 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, position_modifier)
-      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)
-      NEXT_ELEMENT_ON_SAME_LINE_OFFSET
-    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)
-      NEXT_ELEMENT_ON_NEXT_LINE_OFFSET
-    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, position_modifier)
-      return current_position if element.absolutely_positioned?
-      current_position.x = element.absolute_right + position_modifier.x
-      current_position.y = element.absolute_top + position_modifier.y
-      if current_position.next_line_start < element.absolute_bottom + 1
-        current_position.next_line_start = element.absolute_bottom + 1
-      end
-      current_position
-    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(last_position)
-      content_height = compute_content_height(last_position)
-      self.height = content_height if has_variable_height?
-      content_height
-    end
-
-    def compute_content_height(last_position)
-      last_position.next_line_start - self.absolute_top
-    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