fidgit 0.0.2alpha

data/lib/fidgit/elements/container.rb

@@ -0,0 +1,187 @@
+# encoding: utf-8
+
+module Fidgit
+  # A container that contains Elements.
+  # @abstract
+  class Container < Element
+    def size; @children.size; end
+    def each(&block); @children.each &block; end
+    def find(&block); @children.find &block; end
+    def index(value); @children.index value; end
+    def [](index); @children[index]; end
+
+    def x=(value)
+      each {|c| c.x += value - x }
+      super(value)
+    end
+
+    def y=(value)
+      each {|c| c.y += value - y }
+      super(value)
+    end
+
+    # @param (see Element#initialize)
+    #
+    # @option (see Element#initialize)
+    def initialize(options = {})
+      options[:border_color] = default(:debug, :border_color) if Fidgit.debug_mode?
+
+      @children = []
+
+      super(options)
+    end
+
+    def add(element)
+      element.send :parent=, self
+      @children.push element
+
+      recalc
+      nil
+    end
+
+    def remove(element)
+      @children.delete element
+      element.send :parent=, nil
+
+      recalc
+      nil
+    end
+
+    def insert(position, element)
+      @children.insert position, element
+      element.send :parent=, self
+
+      recalc
+      nil
+    end
+
+    # Create a button within the container.
+    def button(text, options = {}, &block)
+      Button.new(text, {parent: self}.merge!(options), &block)
+    end
+
+    # Create a color picker within the container.
+    def color_picker(options = {}, &block)
+      ColorPicker.new({parent: self}.merge!(options), &block)
+    end
+
+    # Create a color well within the container.
+    def color_well(options = {}, &block)
+      ColorWell.new({parent: self}.merge!(options), &block)
+    end
+
+    def combo_box(options = {}, &block)
+      ComboBox.new({parent: self}.merge!(options), &block)
+    end
+
+    def file_browser(type, options = {}, &block)
+      FileBrowser.new(type, {parent: self}.merge!(options), &block)
+    end
+
+    def group(options = {}, &block)
+      Group.new({parent: self}.merge!(options), &block)
+    end
+
+    # Create a label within the container.
+    def label(text, options = {})
+      Label.new(text, {parent: self}.merge!(options))
+    end
+
+    def list(options = {}, &block)
+      List.new({parent: self}.merge!(options), &block)
+    end
+
+    def pack(arrangement, options = {}, &block)
+      klass = case arrangement
+        when :horizontal
+          HorizontalPacker
+        when :vertical
+          VerticalPacker
+        when :grid
+          GridPacker
+        else
+          raise ArgumentError, "packing arrangement must be one of :horizontal, :vertical or :grid"
+      end
+
+      klass.new({parent: self}.merge!(options), &block)
+    end
+
+    def radio_button(text, value, options = {}, &block)
+      RadioButton.new(text, value, {parent: self}.merge!(options), &block)
+    end
+
+    def scroll_area(options = {}, &block)
+      ScrollArea.new({parent: self}.merge!(options), &block)
+    end
+
+    def scroll_window(options = {}, &block)
+      ScrollWindow.new({parent: self}.merge!(options), &block)
+    end
+
+    def slider(options = {}, &block)
+      Slider.new({parent: self}.merge!(options), &block)
+    end
+
+    def text_area(options = {}, &block)
+      TextArea.new({parent: self}.merge!(options), &block)
+    end
+
+    def toggle_button(text, options = {}, &block)
+      ToggleButton.new(text, {parent: self}.merge!(options), &block)
+    end
+
+    def clear
+      @children.each {|child| child.send :parent=, nil }
+      @children.clear
+
+      recalc
+
+      nil
+    end
+
+    def update
+      each { |c| c.update }
+
+      nil
+    end
+
+    # Returns the element within this container that was hit,
+    # @return [Element, nil] The element hit, otherwise nil.
+    def hit_element(x, y)
+      @children.reverse_each do |child|
+        case child
+        when Container, Composite
+          if element = child.hit_element(x, y)
+            return element
+          end
+        else
+          return child if child.hit?(x, y)
+        end
+      end
+
+      self if hit?(x, y)
+    end
+
+    protected
+    def draw_foreground
+      each { |c| c.draw }
+
+      font.draw self.class.name, x, y, z if Fidgit.debug_mode?
+
+      nil
+    end
+
+    protected
+    # Any container passed a block will allow you access to its methods.
+    def post_init_block(&block)
+      case block.arity
+        when 1
+          yield self
+        when 0
+          instance_methods_eval &block
+        else
+          raise "block arity must be 0 or 1"
+      end
+    end
+  end
+end

data/lib/fidgit/elements/element.rb

@@ -0,0 +1,252 @@
+# encoding: utf-8
+
+# The Fidgit GUI framework for Gosu.
+module Fidgit
+  class << self
+    attr_accessor :debug_mode
+  end
+
+  self.debug_mode = false
+
+  def self.debug_mode?; debug_mode; end
+
+  # An element within the GUI environment.
+  # @abstract
+  class Element
+    include Event
+
+    event :left_mouse_button
+    event :holding_left_mouse_button
+    event :released_left_mouse_button
+    event :clicked_left_mouse_button
+    
+    event :right_mouse_button
+    event :holding_right_mouse_button
+    event :released_right_mouse_button
+    event :clicked_right_mouse_button
+    
+    event :mouse_wheel_up
+    event :mouse_wheel_down
+
+    event :enter
+    event :hover
+    event :leave
+
+    DEFAULT_SCHEMA_FILE = File.expand_path(File.join(__FILE__, '..', '..', '..', '..', 'config', 'default_schema.yml'))
+
+    VALID_ALIGN_H = [:left, :center, :right, :fill]
+    VALID_ALIGN_V = [:top, :center, :bottom, :fill]
+
+    attr_reader :z, :tip, :font_size, :padding_top, :padding_right, :padding_bottom, :padding_left, :align_h, :align_v, :parent, :border_thickness
+
+    attr_accessor :background_color
+
+    def x; rect.x; end
+    def x=(value); rect.x = value; end
+
+    def y; rect.y; end
+    def y=(value); rect.y = value; end
+
+    # Width not including border.
+    def width; rect.width; end
+    def width=(value); rect.width = [[value, @width_range.max].min, @width_range.min].max; end
+    def min_width; @width_range.min; end
+    def max_width; @width_range.max; end
+    # Width including border thickness.
+    def outer_width; rect.width + @border_thickness * 2; end
+
+    # Height not including border.
+    def height; rect.height; end
+    def height=(value); rect.height = [[value, @height_range.max].min, @height_range.min].max; end
+    def min_height; @height_range.min; end
+    def max_height; @height_range.max; end
+    # Height including border thickness.
+    def outer_height; rect.height + @border_thickness * 2; end
+
+    # Can the object be dragged?
+    def drag?(button); false; end
+
+    def enabled?; @enabled; end
+    def enabled=(value); @enabled = value; end
+
+    def font; @font ||= Gosu::Font[@font_name, @font_size]; end
+
+    def rect; @rect; end; protected :rect
+
+    def self.schema; @@schema ||= Schema.new(YAML.load(File.read(DEFAULT_SCHEMA_FILE)));; end
+
+    class << self
+      alias_method :original_new, :new
+
+      def new(*args, &block)
+        obj = original_new(*args) # Block should be ignored.
+        obj.send :post_init
+        obj.send :post_init_block, &block if block_given?
+        obj
+      end
+    end
+
+    # Get the default value from the schema.
+    #
+    # @param [Symbol, Array<Symbol>] names
+    def default(*names)
+      self.class.schema.default(self.class, names)
+    end
+
+    # @param [Element, nil] parent
+    #
+    # @option options [Number] :x (0)
+    # @option options [Number] :y (0)
+    # @option options [Number] :z (0)
+    #
+    # @option options [Number] :width (auto)
+    # @option options [Number] :min_width (value of :width option)
+    # @option options [Number] :max_width (value of :width option)
+    #
+    # @option options [Number] :height (auto)
+    # @option options [Number] :min_height (value of :height option)
+    # @option options [Number] :max_height (value of :height option)
+    #
+    # @option options [String] :tip ('') Tool-tip text
+    # @option options [String] :font_name ('')
+    # @option options [String] :font_size (30)
+    #
+    # @option options [Gosu::Color] :background_color (transparent)
+    # @option options [Gosu::Color] :border_color (transparent)
+    #
+    # @option options [Boolean] :enabled (true)
+    #
+    # @option options [Number] :padding (4)
+    # @option options [Number] :padding_h (:padding option)
+    # @option options [Number] :padding_v (:padding option)
+    # @option options [Number] :padding_top (:padding_v option)
+    # @option options [Number] :padding_right (:padding_h option)
+    # @option options [Number] :padding_bottom (:padding_v option)
+    # @option options [Number] :padding_left (:padding_h option)
+    #
+    # @option options [Symbol] :align Align both horizontally and vertically. One of :center, :fill or [<align_v>, <align_h>] such as [:top, :right].
+    # @option options [Symbol] :align_h (value or :align else :left) One of :left, :center, :right :fill
+    # @option options [Symbol] :align_v (value of :align else :top) One of :top, :center, :bottom, :fill
+
+    # @yield instance_methods_eval with respect to self.
+    def initialize(options = {}, &block)
+      options = {
+        x: 0,
+        y: 0,
+        z: 0,
+        tip: '',
+        font_name: default(:font_name),
+        font_size: default(:font_size),
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        border_thickness: default(:border_thickness),
+        enabled: true,
+      }.merge! options
+
+      @enabled = options[:enabled]
+
+      # Alignment and min/max dimensions.
+      @align_h = options[:align_h] || Array(options[:align]).last || default(:align_h)
+      raise ArgumentError, "Invalid align_h: #{@align_h}" unless VALID_ALIGN_H.include? @align_h
+
+      min_width = (options[:min_width] || options[:width] || 0)
+      max_width = (options[:max_width] || options[:width] || Float::INFINITY)
+      @width_range = min_width..max_width                                         
+
+      @align_v = options[:align_v] || Array(options[:align]).first ||  default(:align_v)
+      raise ArgumentError, "Invalid align_v: #{@align_v}" unless VALID_ALIGN_V.include? @align_v
+
+      min_height = (options[:min_height] || options[:height] || 0)
+      max_height = (options[:max_height] || options[:height] || Float::INFINITY)
+      @height_range = min_height..max_height
+
+      @background_color = options[:background_color].dup
+      @border_color = options[:border_color].dup
+      @border_thickness = options[:border_thickness]
+
+      @padding_top = options[:padding_top]       || options[:padding_v] || options[:padding] ||  default(:padding_top)
+      @padding_right = options[:padding_right]   || options[:padding_h] || options[:padding] ||  default(:padding_right)
+      @padding_bottom = options[:padding_bottom] || options[:padding_v] || options[:padding] ||  default(:padding_bottom)
+      @padding_left = options[:padding_left]     || options[:padding_h] || options[:padding] ||  default(:padding_left)
+      self.parent = options[:parent]
+
+      @z = options[:z]
+      @tip = options[:tip].dup
+      @font_name = options[:font_name].dup
+      @font_size = options[:font_size]
+
+      @rect = Chingu::Rect.new(options[:x], options[:y], options[:width] || 0, options[:height] || 0)
+    end
+
+    def recalc
+      old_width, old_height = width, height
+      layout
+      parent.recalc if parent and (width != old_width or height != old_height)
+
+      nil
+    end
+
+    # Check if a point (screen coordinates) is over the element.
+    def hit?(x, y)
+      @rect.collide_point?(x, y)
+    end
+
+    # Redraw the element.
+    def draw
+      draw_background
+      draw_border
+      draw_foreground
+      nil
+    end
+
+    # Update the element.
+    def update
+      nil
+    end
+
+    def draw_rect(*args)
+      $window.current_game_state.draw_rect(*args)
+    end
+
+    def draw_frame(*args)
+      $window.current_game_state.draw_frame(*args)
+    end
+
+    protected
+    def parent=(parent); @parent = parent; end
+
+    protected
+    def draw_background
+      draw_rect(x, y, width, height, z, @background_color) unless @background_color.transparent?
+    end
+
+    protected
+    def draw_border
+      draw_frame(x, y, width, height, @border_thickness, z, @border_color) if @border_thickness > 0 and not @border_color.transparent?
+    end
+
+    protected
+    def draw_foreground
+      nil
+    end
+
+    protected
+    # Should be overridden in children to recalculate the width and height of the element and, if a container
+    # manage the positions of its children.
+    def layout
+      nil
+    end
+
+    protected
+    def post_init
+      recalc
+      @parent.send :add, self if @parent
+    end
+
+    protected
+    # By default, elements do not accept block arguments.
+    def post_init_block(&block)
+      raise ArgumentError, "does not accept a block"
+    end
+  end
+end

data/lib/fidgit/elements/file_browser.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+module Fidgit
+  class FileBrowser < Composite
+    VALID_TYPES = [:open, :save]
+
+    event :selected
+
+    attr_reader :pattern, :base_directory
+
+    def show_extension?; @show_extension; end
+    def directory
+      dir = File.join(*@directories)
+      dir = File.join(@base_directory, dir) unless @base_directory.empty?
+      dir
+    end
+    def file_name; @file_name_text.text; end
+    def file_path; File.join(directory, file_name); end
+
+    # @param [Symbol] type One of :open, :save
+    # @option options [String] :base_directory ('') Outermost directory that the browser will see.
+    # @option options [String] :directory (current working directory).
+    # @option options [String] :file_name ('') Initially selected file in the directory.
+    # @option options [String] :pattern ('*.*')
+    # @option options [Boolean] :show_extension (true)
+    def initialize(type, options = {})
+      options = {
+        base_directory: '',
+        directory: Dir.pwd,
+        file_name: '',
+        pattern: default(:pattern),
+        show_extension: default(:show_extension),
+        width: 400,
+        save_text: "Save",
+        open_text: "Open",
+        cancel_text: "Cancel",
+      }.merge! options
+
+      @type = type
+      raise ArgumentError, "type must be one of #{VALID_TYPES}, not #{@type}" unless VALID_TYPES.include? @type
+
+      @pattern = options[:pattern]
+      @show_extension = options[:show_extension]
+      @base_directory = options[:base_directory].chomp File::SEPARATOR
+
+      @directories = options[:directory].sub(/^#{@base_directory}/, '').split(File::SEPARATOR)
+      if @directories.first == ''
+        @directories[0] = File::SEPARATOR
+      end
+
+      super options
+
+      pack :vertical do
+        @nav_buttons = pack :horizontal, padding: 0, spacing: 2
+
+        @scroll_window = scroll_window(height: 250, width: options[:width]) do
+          @files_list = list(width: options[:width]) do
+            subscribe :changed do |sender, file_path|
+              if file_path
+                file_name = File.basename file_path
+                if File.directory? file_path
+                  @directories.push file_name
+                  create_nav_buttons
+                  update_files_list
+                else
+                  @file_name_text.text = file_name
+                end
+              end
+            end
+          end
+        end
+
+        @file_name_text = text_area(text: options[:file_name], max_height: font_size * 1.5, width: options[:width], border_thickness: 1)
+
+        create_nav_buttons
+
+        pack :horizontal, align: :center, padding: 0 do
+          @action_button = button(options[:"#{type}_text"]) do
+            publish :selected, @type, file_path
+          end
+
+          button(options[:cancel_text]) do
+            publish :selected, :cancel, file_path
+          end
+        end
+
+        # Ensure that the open/save button is enabled only when the path is sensible.
+        @file_name_text.subscribe :changed do |sender, text|
+          @action_button.enabled = case @type
+          when :open
+            File.exists? file_path and not File.directory? file_path
+          when :save
+            not text.empty?
+          end
+        end
+
+        update_files_list
+      end
+    end
+
+    protected
+    def create_nav_buttons(size = @directories.size)
+      @nav_buttons.clear
+
+      @directories = @directories[0..size]
+
+      @directories.each_with_index do |dir, i|
+        if i < @directories.size - 1
+          @nav_buttons.button(dir) do
+            create_nav_buttons(i)
+          end
+        else
+          @nav_buttons.label dir, border_color: @@schema.default(Button, :border_color), border_thickness: @@schema.default(Button, :border_thickness)
+        end
+      end
+
+      update_files_list
+    end
+
+    protected
+    def update_files_list
+      @files_list.clear
+      @file_name_text.text = ''
+      @scroll_window.offset_x = @scroll_window.offset_y = 0
+
+      # Add folders.
+      Dir.glob(File.join(directory, "*")).each do |file_path|
+        if File.directory? file_path
+          @files_list.item File.basename(file_path), file_path, icon: Gosu::Image["file_directory.png"]
+        end
+      end
+
+      # Add files that match the pattern.
+      Dir.glob(File.join(directory, pattern)).each do |file_path|
+        unless File.directory? file_path
+          file_name = if @show_extension
+                        File.basename(file_path)
+                      else
+                        File.basename(file_path, File.extname(file_path))
+                      end
+
+          @files_list.item file_name, file_path, icon: Gosu::Image["file_file.png"]
+        end
+      end
+    end
+
+    protected
+    def post_init_block(&block)
+      subscribe :selected, &block
+    end
+  end
+end