shoes-core 4.0.0.pre3

data/lib/shoes/core.rb

@@ -0,0 +1 @@
+require 'shoes/dsl'

data/lib/shoes/core/version.rb

@@ -0,0 +1,5 @@
+class Shoes
+  module Core
+    VERSION = "4.0.0.pre3"
+  end
+end

data/lib/shoes/dialog.rb

@@ -0,0 +1,56 @@
+class Shoes
+  class Dialog
+    def initialize
+      @gui = Shoes.backend::Dialog.new
+    end
+
+    def alert(msg = '')
+      @gui.alert msg
+    end
+
+    def confirm(msg = '')
+      @gui.confirm msg
+    end
+
+    def dialog_chooser(title, folder = false)
+      @gui.dialog_chooser title, folder
+    end
+
+    def ask(msg, args)
+      ask_me = Shoes.app(title: args[:title] || "Shoes asks:",
+                         width: 300, height: 125,
+                         modal: true) do
+        stack do
+          para msg, margin: 10
+
+          @e = edit_line margin_left: 10,
+                         width:       width - 20,
+                         secret:      args[:secret]
+
+          flow margin_top: 10 do
+            button "OK", margin_left: 150 do
+              @result = @e.text
+              quit
+            end
+
+            button "Cancel" do
+              @result = nil
+              quit
+            end
+          end
+        end
+
+        def result
+          @result
+        end
+      end
+
+      ask_me.wait_until_closed
+      ask_me.result
+    end
+
+    def ask_color(title)
+      @gui.ask_color title
+    end
+  end
+end

data/lib/shoes/dimension.rb

@@ -0,0 +1,269 @@
+class Shoes
+  class Dimension
+    attr_reader :parent
+    attr_accessor :absolute_start
+    protected :parent # we shall not mess with parent,see #495
+
+    # in case you wonder about the -1... it is used to adjust the right and
+    # bottom values. Because right is not left + width but rather left + width -1
+    # Let me give you an example:
+    # Say left is 20 and we have a width of 100 then the right must be 119,
+    # because you have to take pixel number 20 into account so 20..119 is 100
+    # while 20..120 is 101. E.g.:
+    # (20..119).size => 100
+    PIXEL_COUNTING_ADJUSTMENT = -1
+
+    def initialize(parent = nil, start_as_center = false)
+      @parent          = parent
+      @start_as_center = start_as_center
+    end
+
+    def start
+      value = basic_start_value
+      value = adjust_start_for_center(value) if start_as_center?
+      value
+    end
+
+    def end
+      @end || report_relative_to_parent_end
+    end
+
+    def extent
+      result = @extent
+      if @parent
+        result = calculate_relative(result) if is_relative?(result)
+        result = calculate_negative(result) if is_negative?(result)
+      end
+      result
+    end
+
+    def extent=(value)
+      @extent = value
+      @extent = parse_from_string @extent if is_string? @extent
+      @extent
+    end
+
+    def absolute_end
+      return absolute_start if extent.nil? || absolute_start.nil?
+      absolute_start + extent + PIXEL_COUNTING_ADJUSTMENT
+    end
+
+    def element_extent
+      my_extent = extent
+      if my_extent.nil?
+        nil
+      else
+        extent - (margin_start + margin_end)
+      end
+    end
+
+    def element_extent=(value)
+      self.extent = if value.nil?
+                      nil
+                    else
+                      margin_start + value + margin_end
+                    end
+    end
+
+    def element_start
+      return nil if absolute_start.nil?
+      absolute_start + margin_start + displace_start
+    end
+
+    def element_end
+      return nil if element_start.nil? || element_extent.nil?
+      element_start + element_extent + PIXEL_COUNTING_ADJUSTMENT
+    end
+
+    def absolute_start_position?
+      !@start.nil?
+    end
+
+    def absolute_end_position?
+      !@end.nil?
+    end
+
+    def absolute_position?
+      absolute_start_position? || absolute_end_position?
+    end
+
+    def positioned?
+      absolute_start
+    end
+
+    def in_bounds?(value)
+      (absolute_start <= value) && (value <= absolute_end)
+    end
+
+    # For... reasons it is important to have the value of the instance variable
+    # set to nil if it's not modified and then return a default value on the
+    # getter... reason being that for ParentDimensions we need to be able to
+    # figure out if a value has been modified or if we should consult the
+    # parent value - see ParentDimension implementation
+    [:margin_start, :margin_end, :displace_start].each do |method|
+      define_method method do
+        instance_variable_name = '@' + method.to_s
+        value = instance_variable_get(instance_variable_name) || 0
+        value = calculate_relative value if is_relative? value
+        value
+      end
+    end
+
+    def self.define_int_parsing_writer(name)
+      define_method "#{name}=" do |value|
+        instance_variable_set("@#{name}", parse_int_value(value))
+      end
+    end
+
+    %w(start end margin_start margin_end displace_start).each do |method|
+      define_int_parsing_writer method
+    end
+
+    private
+
+    def basic_start_value
+      value = @start
+      value = calculate_relative value if is_relative?(value)
+      value = report_relative_to_parent_start if value.nil?
+      value
+    end
+
+    def is_relative?(result)
+      # as the value is relative to the parent values bigger than one don't
+      # make much sense and are problematic. E.g. through calculations users
+      # might end up with values like 5.14 meaning 5 pixel which would get
+      # interpreted as 514% of the parent
+      # Also check for existance of parent because otherwise relative
+      # calculation makes no sense
+      result.is_a?(Float) && result <= 1 && @parent
+    end
+
+    def calculate_relative(result)
+      (result * @parent.element_extent).to_i
+    end
+
+    def is_string?(result)
+      result.is_a?(String)
+    end
+
+    def is_negative?(result)
+      result && result < 0
+    end
+
+    def calculate_negative(result)
+      @parent.element_extent + result
+    end
+
+    PERCENT_REGEX = /(-?\d+(\.\d+)*)%/
+
+    def parse_from_string(result)
+      match = result.gsub(/\s+/, "").match(PERCENT_REGEX)
+      if match
+        match[1].to_f / 100.0
+      elsif valid_integer_string?(result)
+        int_from_string(result)
+      else
+        nil
+      end
+    end
+
+    def parse_int_value(input)
+      if input.is_a?(Integer) || input.is_a?(Float)
+        input
+      elsif valid_integer_string?(input)
+        int_from_string(input)
+      else
+        nil
+      end
+    end
+
+    def int_from_string(result)
+      (result.gsub(' ', '')).to_i
+    end
+
+    NUMBER_REGEX = /^-?\s*\d+/
+
+    def valid_integer_string?(input)
+      input.is_a?(String) && input.match(NUMBER_REGEX)
+    end
+
+    def report_relative_to_parent_start
+      if element_start && parent && parent.element_start
+        element_start - parent.element_start
+      else
+        nil
+      end
+    end
+
+    def report_relative_to_parent_end
+      if element_end && parent && parent.element_end
+        parent.element_end - element_end
+      else
+        nil
+      end
+    end
+
+    def start_as_center?
+      @start_as_center
+    end
+
+    def adjust_start_for_center(value)
+      my_extent = extent
+      if my_extent && my_extent > 0
+        value - my_extent / 2
+      else
+        nil
+      end
+    end
+  end
+
+  class ParentDimension < Dimension
+    SIMPLE_DELEGATE_METHODS = [:absolute_start, :start]
+
+    SIMPLE_DELEGATE_METHODS.each do |method|
+      define_method method do
+        if value_modified? method
+          super
+        else
+          parent.public_send(method)
+        end
+      end
+    end
+
+    def extent
+      [extent_in_parent, raw_extent(super)].min
+    end
+
+    private
+
+    # Represents the extent, bounded by the parent container's sizing
+    def extent_in_parent
+      if parent.element_end
+        # Why subtracting an absolute from an element dimension value? A
+        # diagram helped me reason out what we wanted.
+        #
+        # parent.      parent.      self.       self.    parent.      parent.
+        # abs_start    elem_start   abs_start   abs_end  elem_end     abs_end
+        # |   margin   |            |           |        |   margin   |
+        #
+        # To get our extent respecting the parent's margins, it's our absolute
+        # start, minus parent's element end (so we don't blow past the margin)
+        extent_in_parent = parent.element_end - self.absolute_start - PIXEL_COUNTING_ADJUSTMENT
+      else
+        # If we hit this, then the extent in parent isn't available and will be
+        # ignored by the min call below
+        extent_in_parent = Float::INFINITY
+      end
+    end
+
+    # Represents the raw value set for extent, either on element or on parent
+    def raw_extent(original_value)
+      original_value || parent.extent
+    end
+
+    def value_modified?(method)
+      instance_variable = ('@' + method.to_s).to_sym
+      instance_variable_get(instance_variable)
+    end
+  end
+end

data/lib/shoes/dimensions.rb

@@ -0,0 +1,203 @@
+# Dimensions is a central class that most Shoes classes use to represent their
+# dimensions, e.g. where they are and how much space they are taking up there.
+# All the different position types might be confusing. So here is a little list:
+#
+# Position (left, top, right, bottom)
+# plain (left, top, right, bottom)
+#   An offset relative to the parent (parents mostly are slots e.g.
+#   flows/stacks), e.g it isn't fully positioned/doesn't flow anymore when set
+#
+# absolute (absolute_left, absolute_top, absolute_right, absolute_bottom)
+#   The absolute position of an element in the app, set by positioning code (in
+#   slot.rb). Might not be the beginning of the element as it also takes margins
+#   into account, so it could be the beginning of the margin. Is also used in
+#   the positioning code.
+#
+# element_* (element_left, element_top, element_right, element_bottom)
+# Derived from absolute_* but shows the real position of the object, e.g. it
+# adds the margins to absolute_* (mostly used by backend drawing code).
+#
+# Space taken up (width/height)
+# plain (width, height)
+#   The whole space taken up by this element with margins and everything. Used
+#   for positioning/by the user.
+#
+# element_* (element_width, element_height)
+#   Just the space taken up by the element itself without margins.
+#   Used by drawing.
+#
+# Note that this is NOT how margins work in the CSS box model. We diverge for
+# reasons mentioned in this comment/thread:
+# https://github.com/shoes/shoes4/pull/467#issuecomment-27655355
+
+class Shoes
+  class Dimensions
+    extend RenamedDelegate
+    include Common::Inspect
+
+    attr_writer :width, :height, :margin_left, :margin_right, :margin_top,
+                :margin_bottom, :top, :left, :right, :bottom
+    attr_reader :parent, :x_dimension, :y_dimension
+    attr_accessor :absolute_left, :absolute_top,
+                  :displace_left, :displace_top
+    protected :parent # we shall not mess with parent,see #495
+
+    # in case you wonder about the -1... it is used to adjust the right and
+    # bottom values. Because right is not left + width but rather left + width -1
+    # Let me give you an example:
+    # Say left is 20 and we have a width of 100 then the right must be 119,
+    # because you have to take pixel number 20 into account so 20..119 is 100
+    # while 20..120 is 101. E.g.:
+    # (20..119).size => 100
+    PIXEL_COUNTING_ADJUSTMENT = -1
+
+    def initialize(parent, left_or_hash = nil, top = nil, width = nil,
+                   height = nil, opts = {})
+      @parent = parent
+      if hash_as_argument?(left_or_hash)
+        init_with_hash(left_or_hash)
+      else
+        init_with_arguments(left_or_hash, top, width, height, opts)
+      end
+    end
+
+    def absolute_x_position?
+      x_dimension.absolute_position?
+    end
+
+    def absolute_y_position?
+      y_dimension.absolute_position?
+    end
+
+    def absolutely_positioned?
+      absolute_x_position? || absolute_y_position?
+    end
+
+    def positioned?
+      x_dimension.positioned? && y_dimension.positioned?
+    end
+
+    def in_bounds?(x, y)
+      x_dimension.in_bounds?(x) && y_dimension.in_bounds?(y)
+    end
+
+    def margin
+      [margin_left, margin_top, margin_right, margin_bottom]
+    end
+
+    def margin=(margin)
+      margin = [margin, margin, margin, margin] unless margin.is_a? Array
+      self.margin_left, self.margin_top,
+      self.margin_right, self.margin_bottom =  margin
+    end
+
+    def takes_up_space?
+      true
+    end
+
+    def inspect
+      nothing = '_'
+      super.insert(-2,
+                   " relative:#{Point.new left, top}->#{Point.new right, bottom}" \
+                   " absolute:#{Point.new absolute_left, absolute_top}->#{Point.new absolute_right, absolute_bottom}" \
+                   " #{width || nothing}x#{height || nothing}")
+    end
+
+    def self.setup_delegations
+      methods_to_rename = Dimension.public_instance_methods false
+      renamed_delegate_to :x_dimension, methods_to_rename, 'start'  => 'left',
+                                                           'end'    => 'right',
+                                                           'extent' => 'width'
+      renamed_delegate_to :y_dimension, methods_to_rename, 'start'  => 'top',
+                                                           'end'    => 'bottom',
+                                                           'extent' => 'height'
+    end
+
+    setup_delegations
+
+    private
+
+    def hash_as_argument?(left)
+      left.respond_to? :fetch
+    end
+
+    def init_with_hash(hash)
+      init_with_arguments hash.fetch(:left, nil), hash.fetch(:top, nil),
+                          hash.fetch(:width, nil), hash.fetch(:height, nil),
+                          hash
+    end
+
+    def init_with_arguments(left, top, width, height, opts)
+      @left_top_as_center = opts.fetch(:center, false)
+      init_x_and_y_dimensions
+      general_options opts # order important for redrawing
+      self.displace_left = opts.fetch(:displace_left, nil)
+      self.displace_top  = opts.fetch(:displace_top, nil)
+      self.left          = left
+      self.top           = top
+      self.width         = width
+      self.height        = height
+    end
+
+    def init_x_and_y_dimensions
+      parent_x_dimension = @parent ? @parent.x_dimension : nil
+      parent_y_dimension = @parent ? @parent.y_dimension : nil
+      @x_dimension = Dimension.new parent_x_dimension, @left_top_as_center
+      @y_dimension = Dimension.new parent_y_dimension, @left_top_as_center
+    end
+
+    def general_options(opts)
+      self.right =  opts[:right]
+      self.bottom = opts[:bottom]
+      init_margins opts
+    end
+
+    def init_margins(opts)
+      new_opts = opts.reject { |_k, v| v.nil? }
+      self.margin        = new_opts[:margin]
+      self.margin_left   = new_opts.fetch(:margin_left, margin_left)
+      self.margin_top    = new_opts.fetch(:margin_top, margin_top)
+      self.margin_right  = new_opts.fetch(:margin_right, margin_right)
+      self.margin_bottom = new_opts.fetch(:margin_bottom, margin_bottom)
+    end
+  end
+
+  # for objects that do not depend on their parent (get 1.04 as real values)
+  class AbsoluteDimensions < Dimensions
+    def initialize(*args)
+      super(nil, *args)
+    end
+  end
+
+  # for objects that are more defined by their parents, delegates method calls
+  # to crucial methods to the parent if the instance variable isn't set
+  class ParentDimensions < Dimensions
+    def init_x_and_y_dimensions
+      @x_dimension = ParentDimension.new @parent.x_dimension,
+                                         @left_top_as_center
+      @y_dimension = ParentDimension.new @parent.y_dimension,
+                                         @left_top_as_center
+    end
+  end
+
+  # depends on a #dimensions method being present that returns a Dimensions object
+  module DimensionsDelegations
+    extend Forwardable
+
+    UNDELEGATED_METHODS = [:to_s]
+    DELEGATED_METHODS = Dimensions.public_instance_methods(false) - UNDELEGATED_METHODS
+
+    def_delegators :dimensions, *DELEGATED_METHODS
+
+    def adjust_current_position(*_)
+      # no-op by default for almost all elements
+    end
+  end
+
+  # depends on a #dsl method to forward to (e.g. for backend objects)
+  module BackendDimensionsDelegations
+    extend Forwardable
+
+    def_delegators :dsl, *DimensionsDelegations::DELEGATED_METHODS
+  end
+end