shoes-core 4.0.0.pre3

data/lib/shoes/slot_contents.rb

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

data/lib/shoes/sound.rb

@@ -0,0 +1,18 @@
+class Shoes
+  class Sound
+    include Common::Inspect
+
+    def initialize(parent, filepath, _opts = {}, &_blk)
+      @parent = parent
+      @filepath = filepath
+
+      @gui = Shoes.configuration.backend_for(self)
+    end
+
+    attr_reader :gui, :filepath, :parent
+
+    def play
+      @gui.play
+    end
+  end
+end

data/lib/shoes/span.rb

@@ -0,0 +1,16 @@
+class Shoes
+  class Span < Text
+    def initialize(texts, styles = {})
+      @style = styles
+      super texts, styles.delete(:color)
+    end
+
+    def style
+      if @parent && @parent.respond_to?(:style)
+        @parent.style.merge(@style)
+      else
+        @style
+      end
+    end
+  end
+end

data/lib/shoes/star.rb

@@ -0,0 +1,50 @@
+class Shoes
+  class Star
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+
+    attr_reader :app, :parent, :dimensions, :gui
+    style_with :angle, :art_styles, :common_styles, :dimensions, :inner, :outer, :points
+    STYLES = { angle: 0 }
+
+    def initialize(app, parent, left, top, points, outer, inner, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+
+      # Don't use param defaults as DSL explicit passes nil for missing params
+      points ||= 10
+      outer  ||= 100.0
+      inner  ||= 50.0
+
+      # Careful not to turn Fixnum to Float, lest Dimensions make you relative!
+      width = outer * 2
+
+      # Ignore calculated height on Dimensions--will force to match width
+      @dimensions = AbsoluteDimensions.new left, top, width, 0
+      @dimensions.height = @dimensions.width
+
+      # Calculate the inner dimensions, which might be relative too
+      inner_dimensions = AbsoluteDimensions.new 0, 0, inner * 2, 0
+
+      # Get actual outer/inner from the dimension to handle relative values
+      outer = @dimensions.width / 2
+      inner = inner_dimensions.width / 2
+
+      # Now set style using adjust outer and inner
+      style_init(styles, inner: inner, outer: outer, points: points)
+
+      @parent.add_child self
+      @gui = Shoes.backend_for self
+
+      register_click blk
+    end
+
+    def in_bounds?(x, y)
+      dx = width / 2.0
+      dy = height / 2.0
+      element_left - dx <= x && x <= element_right - dx &&
+        element_top - dy <= y && y <= element_bottom - dy
+    end
+  end
+end

data/lib/shoes/text.rb

@@ -0,0 +1,24 @@
+class Shoes
+  class Text
+    include Common::Inspect
+
+    attr_reader :to_s, :texts, :color
+    attr_accessor :parent, :text_block
+
+    def initialize(texts, color = nil)
+      @texts      = texts
+      @color      = color
+      @to_s       = @texts.map(&:to_s).join
+      @parent     = nil
+      @text_block = nil
+    end
+
+    def app
+      @parent.app
+    end
+
+    def inspect
+      super.insert(-2, %( "#{self}"))
+    end
+  end
+end

data/lib/shoes/text_block.rb

@@ -0,0 +1,142 @@
+class Shoes
+  CENTER = "center".freeze
+  DEFAULT_TEXTBLOCK_FONT = "Arial"
+
+  class TextBlock
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+    include TextBlockDimensionsDelegations
+
+    attr_reader :gui, :parent, :text, :contents, :app, :text_styles, :dimensions
+    attr_accessor :cursor, :textcursor
+    style_with :common_styles, :dimensions, :text_block_styles
+    STYLES = { font: "Arial" } # used in TextBlock specs only
+
+    def initialize(app, parent, text, styles = {})
+      @parent = parent
+      @app = app
+      style_init styles
+      @dimensions = TextBlockDimensions.new parent, @style
+      handle_styles @style
+      @gui = Shoes.backend_for self
+      @parent.add_child self
+
+      # Important to use accessor and do this after the backend exists!
+      self.text = Array(text)
+
+      register_click
+    end
+
+    def in_bounds?(*args)
+      @gui.in_bounds?(*args)
+    end
+
+    def text=(*texts)
+      replace(*texts[0])
+    end
+
+    def replace(*texts)
+      # Order here matters as well--backend#replace shouldn't rely on DSL state
+      # but the texts that it's passed if it needs information at this point.
+      @gui.replace(*texts)
+
+      @text        = texts.map(&:to_s).join
+      @contents    = texts
+      @text_styles = gather_text_styles(self, texts)
+    end
+
+    def to_s
+      text
+    end
+
+    def contents_alignment(current_position = nil)
+      @gui.contents_alignment(current_position)
+    end
+
+    def adjust_current_position(current_position)
+      @gui.adjust_current_position(current_position)
+    end
+
+    def textcursor(line_height = 0)
+      @textcursor ||= app.textcursor(line_height)
+    end
+
+    def has_textcursor?
+      @textcursor
+    end
+
+    def centered?
+      style[:align] == CENTER
+    end
+
+    def links
+      return [] unless @contents
+
+      @contents.select do |element|
+        element.is_a?(Shoes::Link)
+      end
+    end
+
+    private
+
+    def gather_text_styles(parent_text, texts, styles = {}, start_point = 0)
+      texts.each do |text|
+        if text.is_a? Shoes::Text
+          text.text_block  = self
+          text.parent      = parent_text
+          end_point        = start_point + text.to_s.length - 1
+
+          # If our endpoint is before our start, it's an empty string. We treat
+          # those specially with the (0...0) range that has an empty count.
+          if end_point < start_point
+            range = (0...0)
+          else
+            range = start_point..end_point
+          end
+
+          styles[range]    ||= []
+          styles[range] << text
+          gather_text_styles(text, text.texts, styles, start_point)
+        end
+        start_point += text.to_s.length
+      end
+      styles
+    end
+
+    def handle_styles(style)
+      parse_font_style style[:font] if style[:font] # if is needed for the specs
+    end
+
+    def parse_font_style(type)
+      size_regex = /(\d+)(\s*px)?/
+      style_regex = /none|bold|normal|oblique|italic/i # TODO: add more
+
+      font_family = type.gsub(style_regex, '').gsub(size_regex, '')
+                    .split(',').map { |x| x.strip.gsub(/["]/, '') }
+
+      @style[:font] = font_family.first unless (font_family.size == 1 &&
+        font_family[0] == "") || font_family.size == 0
+
+      fsize = size_regex.match(type)
+      @style[:size] = fsize[1].to_i unless fsize.nil?
+
+      # TODO: Style options
+    end
+  end
+
+  {
+    "Banner"      => { size: 48 },
+    "Title"       => { size: 34 },
+    "Subtitle"    => { size: 26 },
+    "Tagline"     => { size: 18 },
+    "Caption"     => { size: 14 },
+    "Para"        => { size: 12 },
+    "Inscription" => { size: 10 }
+  }.each do |name, styles|
+    clazz = Class.new(TextBlock) do
+      const_set("STYLES", { font: "Arial", fill: nil }.merge(styles))
+    end
+    Shoes.const_set(name, clazz)
+  end
+end

data/lib/shoes/text_block_dimensions.rb

@@ -0,0 +1,51 @@
+class Shoes
+  # We take over a bunch of the absolute_* measurements since the jagged
+  # shape of a flowed TextBlock doesn't follow the usual rules for dimensions
+  # when we get to positioning (which is the main use of these values).
+  class TextBlockDimensions < Dimensions
+    attr_writer :absolute_right, :absolute_bottom,
+                :calculated_width, :calculated_height
+
+    def absolute_right
+      @absolute_right || super
+    end
+
+    def absolute_bottom
+      @absolute_bottom || super
+    end
+
+    # It might seem weird these reverse from above, but if explicit sizes get
+    # reported verbatim, while boundaries are set by text fitting.
+    def width
+      super || @calculated_width
+    end
+
+    def height
+      super || @calculated_height
+    end
+
+    # Since we flow, try to fit in almost any space
+    def fitting_width
+      10
+    end
+
+    # This is the width the text block initially wants to try and fit into.
+    def desired_width(containing = containing_width)
+      parent.absolute_left + containing - absolute_left
+    end
+
+    # If an explicit width's set, use that when asking how much space we need.
+    # If not, we look to the parent.
+    def containing_width
+      element_width || parent.element_width
+    end
+  end
+
+  module TextBlockDimensionsDelegations
+    extend Forwardable
+
+    DELEGATED_METHODS = TextBlockDimensions.public_instance_methods(false)
+
+    def_delegators :dimensions, *DELEGATED_METHODS
+  end
+end

data/lib/shoes/timer.rb

@@ -0,0 +1,14 @@
+class Shoes
+  class Timer
+    include Common::Inspect
+
+    def initialize(app, n = 1000, &blk)
+      @app = app
+      @n   = n
+      @blk = @app.current_slot.create_bound_block(blk)
+      @gui = Shoes.configuration.backend_for(self, @app.gui, @blk)
+    end
+
+    attr_reader :n, :gui
+  end
+end

data/lib/shoes/ui/cli.rb

@@ -0,0 +1,67 @@
+require 'optparse'
+require 'shoes'
+
+class Shoes
+  class CLI
+    attr_reader :packager
+
+    def initialize
+      @packager = Shoes::Packager.new
+    end
+
+    def parse!(args)
+      options = OptionParser.new do |opts|
+        opts.program_name = 'shoes'
+        opts.banner = <<-EOS
+Usage: #{opts.program_name} [-h] [-p package] file
+        EOS
+        opts.separator ''
+        opts.separator 'Options:'
+
+        opts.on('-p', '--package PACKAGE_TYPE', 'Package as BACKEND:PACKAGE') do |package|
+          @packager.create_package(opts.program_name, package)
+        end
+
+        opts.on('-v', '--version', 'Shoes version') do
+          puts "Shoes #{Shoes::Core::VERSION}"
+          exit
+        end
+
+        opts.on('-m', '--manual', 'Run the Shoes manual') do
+          require 'shoes/manual'
+          Shoes::Manual.run "English"
+          exit
+        end
+
+        opts.separator @packager.help(opts.program_name)
+      end
+
+      options.parse!(args)
+      options
+    end
+
+    # Execute a shoes app.
+    #
+    # @param [String] app the location of the app to run
+    def execute_app(app)
+      $LOAD_PATH.unshift(Dir.pwd)
+      require 'shoes/swt'
+      load app
+    end
+
+    def run(args)
+      opts = parse!(args)
+      if args.empty?
+        puts opts.banner
+        puts "Try '#{opts.program_name} --help' for more information"
+        exit(0)
+      end
+
+      if @packager.should_package?
+        @packager.run(args.shift)
+      else
+        execute_app(args.first)
+      end
+    end
+  end
+end

data/lib/shoes/ui/picker.rb

@@ -0,0 +1,47 @@
+class Shoes
+  module UI
+    # This class is used for interactively (if necessary) picking the Shoes
+    # backend that the user will run their Shoes app with.
+    class Picker
+      def run
+        bundle
+        generator_file = select_generator
+        write_backend(generator_file)
+      end
+
+      # Only bundle if we find a local Gemfile.  This allows us to work properly
+      # running from source without finding gem-nstalled backends.
+      def bundle
+        if File.exist?("Gemfile")
+          require 'bundler/setup'
+          Bundler.require
+        end
+      end
+
+      def select_generator
+        puts "Selecting Shoes backend to use. This is a one-time operation."
+        candidates = Gem.find_files("shoes/**/generate-backend.rb")
+        if candidates.one?
+          generator_file = candidates.first
+        else
+          fail NotImplementedError("Currently can't interactively select a backend. See #929")
+        end
+
+        generator_file
+      end
+
+      def write_backend(generator_file)
+        require generator_file
+
+        # On Windows getting odd paths with trailing double-quote
+        bin_dir = ARGV[0].gsub('"', '')
+
+        File.open(File.expand_path(File.join(bin_dir, "shoes-backend")), "w") do |file|
+          # Contract with backends is to define generate_backend method that we
+          # can call. Bit ugly, open to better options for that interchange.
+          file.write(generate_backend(ENV["SHOES_PICKER_BIN_DIR"] || bin_dir))
+        end
+      end
+    end
+  end
+end