colstrom-fidgit 0.2.7

data/lib/fidgit/elements/color_well.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+
+module Fidgit
+  class ColorWell < RadioButton
+    alias_method :color, :value
+
+    # @param (see RadioButton#initialize)
+    # @option (see RadioButton#initialize)
+    def initialize(options = {}, &block)
+      options = {
+        width: default(:width),
+        height: default(:height),
+        color: default(:color),
+        outline_color: default(:outline_color),
+        checked_border_color: default(:checked, :border_color),
+      }.merge! options
+
+      @outline_color = options[:outline_color].dup
+
+      super('', (options[:color] || options[:value]).dup, options)
+    end
+
+    protected
+    def draw_background
+      super
+
+      draw_frame x + 2, y + 2, width - 4, height - 4, 1, z, @outline_color
+
+      nil
+    end
+
+    protected
+    def draw_foreground
+      draw_rect x + 3, y + 3, width - 6, height - 6, z, value
+
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/combo_box.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+require 'forwardable'
+
+module Fidgit
+class ComboBox < Button
+  extend Forwardable
+
+  ARROW_IMAGE = "combo_arrow.png"
+
+  def_delegators :@menu, :each
+
+  event :changed
+
+  def index; @menu.index(@value) end
+  def value; @value; end
+  
+  def value=(value)
+    if @value != value
+      @value = value
+      item = @menu.find(@value)
+      self.text = item.text
+      self.icon = item.icon
+      publish :changed, @value
+    end
+
+    value
+  end
+
+  def index=(index)
+    if index.between?(0, @menu.size - 1)
+      self.value = @menu[index].value
+    end
+
+    index
+  end
+
+  # @param (see Button#initialize)
+  # @option (see Button#initialize)
+  # @option options [] :value
+  def initialize(options = {}, &block)
+    options = {
+      background_color: default(:background_color),
+      border_color: default(:border_color),
+    }.merge! options
+
+    @value = options[:value]
+    
+    @hover_index = 0
+
+    @menu = MenuPane.new(show: false) do
+      subscribe :selected do |widget, value|
+        self.value = value
+      end
+    end
+
+    @@arrow ||= Gosu::Image[ARROW_IMAGE]
+
+    super('', options)
+
+    rect.height = [height, font.height + padding_top + padding_bottom].max
+    rect.width = [width, font.height * 4 + padding_left + padding_right].max
+  end
+
+  def item(text, value, options = {}, &block)
+    item = @menu.item(text, value, options, &block)
+
+    # Force text to be updated if the item added has the same value.
+    if item.value == @value
+      self.text = item.text
+      self.icon = item.icon
+    end
+
+    recalc
+
+    item
+  end
+
+  def draw
+    super
+    size = height / @@arrow.width.to_f
+    @@arrow.draw x + width - height, y, z, size, size
+  end
+
+  def clicked_left_mouse_button(sender, x, y)
+    @menu.x = self.x
+    @menu.y = self.y + height + border_thickness
+    $window.game_state_manager.current_game_state.show_menu @menu
+
+    nil
+  end
+
+  def clear
+    self.text = ""
+    self.icon = nil
+    @menu.clear
+  end
+
+  protected
+  def layout
+    super
+
+    # Max width of all items + allow size for the arrow.
+    rect.width = [@menu.width + height, min_width].max
+
+    nil
+  end
+
+
+  protected
+  # Any combo-box passed a block will allow you access to its methods.
+  def post_init_block(&block)
+    with(&block)
+  end
+end
+end

data/lib/fidgit/elements/composite.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+module Fidgit
+  # A composite element, made up of other elements (but manages them internally).
+  class Composite < Packer
+    DEBUG_BORDER_COLOR = Gosu::Color.rgba(0, 255, 0, 100) # Color to draw an outline in when debugging layout.
+
+    # @param (see Element#initialize)
+    #
+    # @option (see Element#initialize)
+    def initialize(options = {})
+      options[:border_color] = DEBUG_BORDER_COLOR if Fidgit.debug_mode?
+
+      super(options)
+    end
+  end
+end

data/lib/fidgit/elements/container.rb

@@ -0,0 +1,210 @@
+# encoding: utf-8
+require 'forwardable'
+
+module Fidgit
+  # A container that contains Elements.
+  # @abstract
+  class Container < Element
+    extend Forwardable
+
+    def_delegators :@children, :size, :each, :find, :index, :[], :empty?, :map, :select, :inject
+
+    def x=(value)
+      @children.each {|c| c.x += value - x }
+      super(value)
+    end
+
+    def y=(value)
+      @children.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 an icon.
+    def image_frame(image, options = {}, &block)
+      ImageFrame.new(image, {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
+
+    public
+    # Pack elements within the block horizontally.
+    def horizontal(options = {}, &block)
+      Horizontal.new({ parent: self }.merge!(options), &block)
+    end
+
+    public
+    # Pack elements within the blockvertically.
+    def vertical(options = {}, &block)
+      Vertical.new({ parent: self }.merge!(options), &block)
+    end
+
+    public
+    # Pack elements within the block in a grid (matrix) formation.
+    def grid(options = {}, &block)
+      Grid.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
+      @children.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
+      @children.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)
+      with(&block)
+    end
+
+    public
+    def to_s
+      "#{super} [#{@children.size} #{@children.size == 1 ? 'child' : 'children'}]"
+    end
+
+    public
+    def write_tree(indent = "", index = 0)
+      puts self
+
+      indent = indent + "  "
+
+      @children.each.with_index do |element, i|
+          print "#{indent}#{i}: "
+
+          case element
+            when Container
+              element.write_tree(indent)
+            else
+              puts element
+          end
+      end
+    end
+  end
+end

data/lib/fidgit/elements/element.rb

@@ -0,0 +1,298 @@
+# 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 :middle_mouse_button
+    event :holding_middle_mouse_button
+    event :released_middle_mouse_button
+    event :clicked_middle_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, :padding_top, :padding_right, :padding_bottom, :padding_left,
+                :align_h, :align_v, :parent, :border_thickness, :font
+
+    attr_accessor :background_color
+    attr_writer :tip
+
+    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)
+      if @mouse_over and enabled? and not value
+        $window.current_game_state.unset_mouse_over
+      end
+
+      @enabled = value
+    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, :default] :font_name (:default, which resolves as the default Gosu font)
+    # @option options [String] :font_height (30)
+    # @option options [Gosu::Font] :font Use this instead of :font_name and :font_height
+    #
+    # @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_height: default(:font_height),
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        border_thickness: default(:border_thickness),
+        enabled: true,
+      }.merge! options
+
+      @enabled = options[:enabled]
+
+      @mouse_over = false
+
+      # 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 = if options[:font_name].nil? or options[:font_name] == :default
+                     Gosu::default_font_name
+                   else
+                     options[:font_name].dup
+                   end
+
+      @font = options[:font] || Gosu::Font[font_name, options[:font_height]]
+
+      @rect = Chingu::Rect.new(options[:x], options[:y], options[:width] || 0, options[:height] || 0)
+    end
+
+    def font=(font)
+      raise TypeError unless font.is_a? Gosu::Font
+      @font = font
+      recalc
+      font
+    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
+
+    public
+    # Evaluate a block, just like it was a constructor block.
+    def with(&block)
+      raise ArgumentError.new("Must pass a block") unless block_given?
+      case block.arity
+        when 1
+          yield self
+        when 0
+          instance_methods_eval(&block)
+        else
+          raise "block arity must be 0 or 1"
+      end
+    end
+
+    protected
+    # By default, elements do not accept block arguments.
+    def post_init_block(&block)
+      raise ArgumentError, "does not accept a block"
+    end
+
+    public
+    def to_s
+      "#{self.class} (#{x}, #{y}) #{width}x#{height}"
+    end
+  end
+end