shoes-core 4.0.0.pre3

data/lib/shoes/file_not_found_error.rb

@@ -0,0 +1,4 @@
+class Shoes
+  class FileNotFoundError < StandardError
+  end
+end

data/lib/shoes/font.rb

@@ -0,0 +1,50 @@
+class Shoes
+  FONT_DIR = DIR + "/fonts/"
+
+  module Font
+    FONT_TYPES = "{ttf,ttc,otf,fnt,fon,bdf,pcf,snf,mmm,pfb,pfm}"
+    @loaded_fonts = {}
+
+    class << self
+      attr_reader :loaded_fonts
+
+      def font_paths_from_dir(path)
+        font_paths = []
+        Dir.glob(path + "**/*." + FONT_TYPES).each do |font_path|
+          font_paths << font_path
+        end
+        font_paths
+      end
+
+      def add_font(path)
+        Shoes.backend::Font.add_font(path)
+      end
+
+      def add_font_to_fonts(path)
+        name = font_name(path)
+        Shoes::FONTS << name
+        name
+      end
+
+      def initial_fonts
+        Shoes.backend::Font.initial_fonts
+      end
+
+      private
+
+      def font_name(path)
+        remove_file_ext(parse_filename_from_path(path))
+      end
+
+      def parse_filename_from_path(file_path)
+        Pathname.new(file_path).basename.to_s
+      end
+
+      def remove_file_ext(file_name)
+        file_name.chomp(File.extname(file_name))
+      end
+    end
+  end
+
+  FONTS = []
+end

data/lib/shoes/gradient.rb

@@ -0,0 +1,31 @@
+class Shoes
+  class Gradient
+    include Common::Inspect
+    include Comparable
+
+    def initialize(color1, color2, alpha = Shoes::Color::OPAQUE)
+      @color1, @color2 = color1, color2
+      @alpha = alpha
+    end
+
+    attr_reader :alpha, :color1, :color2
+
+    def inspect
+      super.insert(-2, " #{color1}->#{color2}")
+    end
+
+    def <=>(other) # arbitrarily compare 1st non-equal color
+      raise_class_mismatch_error(other) unless other.is_a?(self.class)
+      if @color1 == other.color1
+        @color2 <=> other.color2
+      else
+        @color1 <=> other.color1
+      end
+    end
+
+    def raise_class_mismatch_error(other)
+      fail ArgumentError,
+           "can't compare #{self.class.name} with #{other.class.name}"
+    end
+  end
+end

data/lib/shoes/image.rb

@@ -0,0 +1,53 @@
+class Shoes
+  class Image
+    include Common::UIElement
+    include Common::Style
+    include Common::Clickable
+
+    BINARY_ENCODING = Encoding.find('binary')
+
+    attr_reader :app, :parent, :dimensions, :gui
+    style_with :art_styles, :common_styles, :dimensions, :file_path
+
+    def initialize(app, parent, file_path_or_data, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+      style_init styles, file_path: normalized_source(file_path_or_data)
+      @dimensions = Dimensions.new parent, @style
+      @parent.add_child self
+      @gui = Shoes.configuration.backend_for self, @parent.gui
+      register_click blk
+    end
+
+    def path
+      @style[:file_path]
+    end
+
+    def path=(path_or_data)
+      style(file_path: normalized_source(path_or_data))
+      @gui.update_image
+    end
+
+    def url?(path_or_data)
+      path_or_data =~ %r{^https?://}
+    end
+
+    def raw_image_data?(name_or_data)
+      name_or_data.encoding == BINARY_ENCODING
+    end
+
+    private
+
+    def normalized_source(path_or_data)
+      return path_or_data if raw_image_data?(path_or_data)
+      return path_or_data if url?(path_or_data)
+      absolute_file_path(path_or_data)
+    end
+
+    def absolute_file_path(path)
+      path = File.join(Dir.pwd, path) unless Pathname(path).absolute?
+      fail FileNotFoundError, "#{path} not found." unless File.exist?(path)
+      path
+    end
+  end
+end

data/lib/shoes/image_pattern.rb

@@ -0,0 +1,12 @@
+class Shoes
+  class ImagePattern
+    include Common::Inspect
+
+    def initialize(path)
+      @path = path
+      @gui = Shoes.configuration.backend_for(self)
+    end
+
+    attr_reader :gui, :path
+  end
+end

data/lib/shoes/input_box.rb

@@ -0,0 +1,59 @@
+class Shoes
+  class InputBox
+    include Common::UIElement
+    include Common::Style
+    include Common::Changeable
+
+    attr_reader :app, :parent, :dimensions, :gui
+
+    def initialize(app, parent, text, styles = {}, blk = nil)
+      @app = app
+      @parent = parent
+      style_init styles, text: text.to_s
+      @dimensions = Dimensions.new parent, @style
+      @parent.add_child self
+      @gui = Shoes.configuration.backend_for self, @parent.gui
+      change(&blk) if blk
+    end
+
+    def state=(value)
+      style(state: value)
+      @gui.enabled value.nil?
+    end
+
+    def focus
+      @gui.focus
+    end
+
+    def text
+      @gui.text
+    end
+
+    def text=(value)
+      style(text: value.to_s)
+      @gui.text = value.to_s
+    end
+
+    def highlight_text(start_index, final_index)
+      @gui.highlight_text(start_index, final_index)
+    end
+
+    def caret_to(index)
+      @gui.caret_to(index)
+    end
+  end
+
+  class EditBox < InputBox
+    style_with :change, :common_styles, :dimensions, :text, :state
+    STYLES = { width: 200, height: 108, text: '' }
+  end
+
+  class EditLine < InputBox
+    style_with :change, :common_styles, :dimensions, :text, :secret, :state
+    STYLES = { width:  200, height: 28, text: '' }
+
+    def secret?
+      secret
+    end
+  end
+end

data/lib/shoes/internal_app.rb

@@ -0,0 +1,230 @@
+class Shoes
+  # This is the representation of the app that is used internally by Shoes
+  # objects. It is *NOT* the app object that a user interacts with in a
+  # Shoes.app block. The user facing App object is...the App object.
+  #
+  # The InternalApp object is responsible for maintaining the state of the App
+  # and providing the bulk of the functionality, leaving the App a relatively
+  # blank slate for users to bend to their will.
+  class InternalApp
+    include Common::Style
+    include Common::Clickable
+    include DimensionsDelegations
+
+    extend Forwardable
+
+    DEFAULT_OPTIONS = { width: 600,
+                        height: 500,
+                        title: "Shoes 4",
+                        resizable: true,
+                        background: Shoes::COLORS.fetch(:shoes_background) }.freeze
+
+    def initialize(app, opts, &blk)
+      @app = app
+      @blk = blk
+      set_attributes_from_options(opts)
+      set_initial_attributes
+    end
+
+    def setup_gui
+      @gui = Shoes.configuration.backend::App.new self
+
+      self.current_slot = create_top_slot
+      execution_blk = create_execution_block(blk)
+      eval_block execution_blk
+
+      setup_global_keypresses
+      register_console_keypress
+    end
+
+    attr_reader :gui, :top_slot, :app, :dimensions,
+                :mouse_motion, :owner, :element_styles, :resize_callbacks
+    attr_accessor :elements, :current_slot, :opts, :blk, :mouse_button,
+                  :mouse_pos, :mouse_hover_controls, :resizable, :app_title,
+                  :width, :height, :start_as_fullscreen, :location
+
+    def_delegators :@app, :eval_with_additional_context
+
+    def clear(&blk)
+      current_slot.clear(&blk)
+    end
+
+    def contents
+      top_slot.contents
+    end
+
+    def width
+      started? ? gui.width : @dimensions.width
+    end
+
+    def height
+      started? ? gui.height : @dimensions.height
+    end
+
+    def font(path = Shoes::DEFAULT_TEXTBLOCK_FONT)
+      app.font path
+    end
+
+    def started?
+      gui && gui.started?
+    end
+
+    def add_child(_child)
+      # No-op. The top_slot needs this method, but we already hold an explicit
+      # reference to the top_slot, so we don't need to add it as a child. Other
+      # elements should be added as children of the top_slot.
+    end
+
+    def default_styles
+      Common::Style::DEFAULT_STYLES.clone
+    end
+
+    def in_bounds?(_x, _y)
+      true
+    end
+
+    def fullscreen=(state)
+      gui.fullscreen = state
+    end
+
+    def fullscreen
+      gui.fullscreen
+    end
+
+    alias_method :start_as_fullscreen?, :start_as_fullscreen
+
+    # Necessary for click/mouse positioning checks
+    def hidden?
+      false
+    end
+
+    def add_mouse_hover_control(element)
+      unless mouse_hover_controls.include? element
+        mouse_hover_controls << element
+      end
+    end
+
+    def open_gui
+      gui.open
+    end
+
+    def quit
+      @gui.quit
+    end
+
+    def scroll_top
+      gui.scroll_top
+    end
+
+    def scroll_top=(n)
+      gui.scroll_top = n
+    end
+
+    def clipboard
+      gui.clipboard
+    end
+
+    def clipboard=(str)
+      gui.clipboard = str
+    end
+
+    def download(url, opts, &block)
+      app.download url, opts, &block
+    end
+
+    def textcursor(line_height)
+      app.line(0, 0, 0, line_height, hidden: true)
+    end
+
+    def execute_block(blk)
+      app.instance_eval(&blk)
+    end
+
+    def gutter
+      gui.gutter
+    end
+
+    def add_resize_callback(blk)
+      @resize_callbacks << blk
+    end
+
+    def inspect
+      super.insert(-2, " \"#{@app_title}\" #{@dimensions.inspect})")
+    end
+
+    def self.global_keypresses
+      @global_keypresses ||= {}
+    end
+
+    def self.add_global_keypress(key, &blk)
+      global_keypresses[key] = blk
+    end
+
+    def wait_until_closed
+      return unless gui
+      gui.wait_until_closed
+    end
+
+    private
+
+    def create_top_slot
+      @top_slot = Flow.new self, self, width: width, height: height
+    end
+
+    def eval_block(execution_blk)
+      @top_slot.append(&execution_blk)
+    end
+
+    def create_execution_block(blk)
+      if blk
+        execution_blk = proc do
+          execute_block blk
+        end
+      elsif Shoes::URL.urls.keys.any? { |page| page.match '/' }
+        execution_blk = proc do
+          app.visit '/'
+        end
+      else
+        execution_blk = nil
+      end
+      execution_blk
+    end
+
+    def set_initial_attributes
+      @style                = default_styles
+      @element_styles       = {}
+      @mouse_motion         = []
+      @mouse_button         = 0
+      @mouse_pos            = [0, 0]
+      @mouse_hover_controls = []
+      @resize_callbacks     = []
+      @pass_coordinates     = true
+    end
+
+    def set_attributes_from_options(opts)
+      opts = DEFAULT_OPTIONS.merge(opts)
+
+      @app_title           = opts[:title]
+      @resizable           = opts[:resizable]
+      @start_as_fullscreen = opts[:fullscreen]
+      @opts                = opts
+      @owner               = opts[:owner]
+      @dimensions          = AbsoluteDimensions.new opts
+      self.absolute_left   = 0
+      self.absolute_top    = 0
+    end
+
+    def setup_global_keypresses
+      @app.keypress do |key|
+        blk = self.class.global_keypresses[key]
+        @app.instance_eval(&blk) unless blk.nil?
+      end
+    end
+
+    def register_console_keypress
+      self.class.add_global_keypress(:"alt_/") do
+        Logger.setup
+      end
+    end
+  end
+end

data/lib/shoes/key_event.rb

@@ -0,0 +1,17 @@
+class Shoes
+  class KeyEvent
+    def initialize(app, &blk)
+      @app = app
+      @gui = Shoes.backend_for self, &blk
+    end
+
+    attr_reader :app
+
+    def remove
+      @gui.remove
+    end
+  end
+
+  class Keypress < KeyEvent; end
+  class Keyrelease < KeyEvent; end
+end