fidgit 0.0.2alpha

data/lib/fidgit/elements/vertical_packer.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+module Fidgit
+  # A vertically aligned element packing container.
+  class VerticalPacker < GridPacker
+    def initialize(options = {})
+      options[:num_columns] = 1
+
+      super options
+    end
+  end
+end

data/lib/fidgit/event.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+
+module Fidgit
+  # Adds simple event handling methods to an object (subscribe/publish pattern).
+  #
+  # @example
+  #   class JumpingBean
+  #     include Event
+  #     event :jump
+  #   end
+  #
+  #   bean = JumpingBean.new
+  #   bean.subscribe :jump do
+  #     puts "Whee!"
+  #   end
+  #
+  #   bean.subscribe :jump do |object, direction, distance|
+  #     puts "#{object.class.name} jumped #{distance} metres #{direction}"
+  #   end
+  #
+  #   bean.publish :jump, :up, 4
+  #   # Whee!
+  #   # JumpingBean jumped 4 metres up
+  #
+  module Event
+    # @overload subscribe(event, method)
+    #   Add an event handler for an event, using a method.
+    #   @return [nil]
+    #
+    # @overload subscribe(event, &block)
+    #   Add an event handler for an event, using a block.
+    #   @return [nil]
+    def subscribe(event, method = nil, &block)
+      raise ArgumentError, "Expected method or block for event handler" unless !block.nil? ^ !method.nil?
+      raise ArgumentError, "#{self.class} does not handle #{event.inspect}" unless events.include? event
+
+      @_event_handlers = Hash.new() { |hash, key| hash[key] = [] } unless @_event_handlers
+      @_event_handlers[event].push(method ? method : block)
+
+      nil
+    end
+
+    # Publish an event to all previously added handlers in the order they were added.
+    # It will automatically call the publishing object with the method named after the event if it is defined
+    # (this will be done before the manually added handlers are called).
+    #
+    # If any handler returns :handled, then no further handlers will be called.
+    #
+    # @param [Symbol] event Name of the event to publish.
+    # @param [Array] args Arguments to pass to the event handlers.
+    # @return [Symbol, nil] :handled if any handler handled the event or nil if none did.
+    def publish(event, *args)
+      raise ArgumentError, "#{self.class} does not handle #{event.inspect}" unless events.include? event
+
+      # Do nothing if the object is disabled.
+      return if respond_to?(:enabled?) and not enabled?
+
+      if respond_to? event
+        return :handled if send(event, self, *args) == :handled
+      end
+
+      if @_event_handlers
+        @_event_handlers[event].reverse_each do |handler|
+          return :handled if handler.call(self, *args) == :handled
+        end
+      end
+
+      nil
+    end
+
+    # The list of events that this object can publish/subscribe.
+    def events
+      self.class.events
+    end
+
+    # Add singleton methods to the class that includes Event.
+    def self.included(base)
+      class << base
+        def events
+          unless @events
+            # Copy the events already set up for your parent.
+            @events = if superclass.respond_to? :events
+              superclass.events.dup
+            else
+              []
+            end
+          end
+
+          @events
+        end
+
+        def event(event)
+          events.push event.to_sym unless events.include? event
+          event
+        end
+      end
+    end
+  end
+end

data/lib/fidgit/gosu_ext/color.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+module Gosu
+  class Color
+    # Is the color completely transparent?
+    def transparent?; alpha == 0; end
+    # Is the color completely opaque?
+    def opaque?; alpha == 255; end
+
+    # RGB in 0..255 format (Alpha assumed 255)
+    #
+    # @param [Integer] red
+    # @param [Integer] green
+    # @param [Integer] blue
+    # @return [Color]
+    def self.rgb(red, green, blue)
+      new(255, red, green, blue)
+    end
+
+    # RGBA in 0..255 format
+    #
+    # @param [Integer] red
+    # @param [Integer] green
+    # @param [Integer] blue
+    # @param [Integer] alpha
+    # @return [Color]
+    def self.rgba(red, green, blue, alpha)
+      new(alpha, red, green, blue)
+    end
+
+    # ARGB in 0..255 format (equivalent to Color.new, but explicit)
+    #
+    # @param [Integer] alpha
+    # @param (see Color.rgb)
+    # @return [Color]
+    def self.argb(alpha, red, green, blue)
+      new(alpha, red, green, blue)
+    end
+
+    # HSV format (alpha assumed to be 255)
+    #
+    # @param [Float] hue 0.0..360.0
+    # @param [Float] saturation 0.0..1.0
+    # @param [Float] value 0.0..1.0
+    # @return [Color]
+    def self.hsv(hue, saturation, value)
+      from_hsv(hue, saturation, value)
+    end
+
+    # HSVA format
+    #
+    # @param [Float] hue 0.0..360.0
+    # @param [Float] saturation 0.0..1.0
+    # @param [Float] value 0.0..1.0
+    # @param [Integer] alpha 1..255
+    # @return [Color]
+    def self.hsva(hue, saturation, value, alpha)
+      from_ahsv(alpha, hue, saturation, value)
+    end
+
+    class << self
+      alias_method :ahsv, :from_ahsv
+    end
+
+    # Convert from an RGBA array, as used by TexPlay.
+    #
+    # @param [Array<Float>] color TexPlay color [r, g, b, a] in range 0.0..1.0
+    # @return [Color]
+    def self.from_tex_play(color)
+      rgba(*color.map {|c| (c * 255).to_i })
+    end
+
+    # Convert to an RGBA array, as used by TexPlay.
+    #
+    # @return [Array<Float>] TexPlay color array [r, g, b, a] in range 0.0..1.0
+    def to_tex_play
+      [red / 255.0, green / 255.0, blue / 255.0,  alpha / 255.0]
+    end
+
+    # Show the Color as <RGBA [0, 0, 0, 0]> or, if opaque, <RGB [0, 0, 0]> (Gosu default is '(ARGB:0/0/0/0)')
+    def to_s
+      if opaque?
+        "<RGB [#{red}, #{green}, #{blue}]>"
+      else
+        "<RGBA [#{red}, #{green}, #{blue}, #{alpha}]>"
+      end
+    end
+
+    def +(other)
+      raise ArgumentError, "Can only add another #{self.class}" unless other.is_a? Color
+
+      copy = Color.new(0)
+
+      copy.red = [red + other.red, 255].min
+      copy.green = [green + other.green, 255].min
+      copy.blue = [blue + other.blue, 255].min
+      copy.alpha = [alpha + other.alpha, 255].min
+
+      copy
+    end
+
+    def -(other)
+      raise ArgumentError, "Can only take away another #{self.class}" unless other.is_a? Color
+
+      copy = Color.new(0)
+
+      copy.red = [red - other.red, 0].max
+      copy.green = [green - other.green, 0].max
+      copy.blue = [blue - other.blue, 0].max
+      copy.alpha = [alpha - other.alpha, 0].max
+
+      copy
+    end
+
+    def ==(other)
+      if other.is_a? Color
+        red == other.red and green == other.green and blue == other.blue and alpha == other.alpha
+      else
+        false
+      end
+    end
+  end
+end

data/lib/fidgit/history.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Fidgit
+  # Manages a history of actions, along with doing, undoing and redoing those actions.
+  class History
+    # Maximum number of actions in the History before Actions are deleted.
+    DEFAULT_MAX_SIZE = 250
+
+    # An action in the History. Inherit actions from this in order to add them to a History.
+    class Action
+      # Perform the action.
+      def do; raise NotImplementedError, "#{self.class} does not have a do method defined"; end
+
+      # Reverse the action.
+      def undo; raise NotImplementedError, "#{self.class} does not have an undo method defined"; end
+    end
+
+    # Is there an action that can be undone?
+    def can_undo?; @last_done >= 0; end
+
+    # Is there an action that has been undone that can now be redone?
+    def can_redo?; @last_done < (@actions.size - 1); end
+
+    def initialize(max_size = DEFAULT_MAX_SIZE)
+      @max_size = max_size
+      @actions = []
+      @last_done = -1 # Last command that was performed.
+    end
+
+    # Perform a History::Action, adding it to the history.
+    # If there are currently any actions that have been undone, they will be permanently lost and cannot be redone.
+    #
+    # @param [History::Action] action Action to be performed
+    def do(action)
+      raise ArgumentError, "Parameter, 'action', expected to be a #{Action}, but received: #{action}" unless action.is_a? Action
+
+      # Remove all undone actions when a new one is performed.
+      @actions = @actions[0..@last_done] if can_redo?
+
+      # If history is too big, remove the oldest action.
+      if @actions.size >= @max_size
+        @actions.shift
+      end
+
+      @last_done = @actions.size
+      @actions << action
+      action.do
+
+      nil
+    end
+
+    # Perform a History::Action, replacing the last action that was performed.
+    #
+    # @param [History::Action] action Action to be performed
+    def replace_last(action)
+      raise ArgumentError, "Parameter, 'action', expected to be a #{Action}, but received: #{action}" unless action.is_a? Action
+
+      @actions[@last_done].undo
+      @actions[@last_done] = action
+      action.do
+
+      nil
+    end
+
+    # Undo the last action that was performed.
+    def undo
+      raise "Can't undo unless there are commands in past" unless can_undo?
+
+      @actions[@last_done].undo
+      @last_done -= 1
+
+      nil
+    end
+
+    # Redo the last action that was undone.
+    def redo
+      raise "Can't redo if there are no commands in the future" unless can_redo?
+
+      @last_done += 1
+      @actions[@last_done].do
+
+      nil
+    end
+  end
+end

data/lib/fidgit/redirector.rb

@@ -0,0 +1,83 @@
+module Fidgit
+  # Redirects methods to an object, but does not mask methods and ivars from the calling context.
+  module RedirectorMethods
+    # Evaluate a block accessing methods and ivars from the calling context, but calling public methods
+    # (not ivars or non-public methods) on this object in preference.
+    def instance_methods_eval(&block)
+      raise ArgumentError, "block required" unless block_given?
+
+      context = eval('self', block.binding)
+
+      context.send :push_redirection_target, self
+
+      begin
+        yield context
+      ensure
+        context.send :pop_redirection_target
+      end
+
+      self
+    end
+
+    protected
+    def push_redirection_target(target)
+      meta_class = class << self; self; end
+      base_methods = Object.public_instance_methods
+
+      # Redirect just the public methods of the target, less those that are on Object.
+      methods_to_redirect = target.public_methods - base_methods
+
+      # Only hide those public/private/protected methods that are being redirected.
+      methods_overridden = []
+      [:public, :protected, :private].each do |access|
+        methods_to_hide = meta_class.send("#{access}_instance_methods", false) & methods_to_redirect
+        methods_to_hide.each do |meth|
+          # Take a reference to the method we are about to override.
+          methods_overridden.push [meth, method(meth), access]
+          meta_class.send :remove_method, meth
+        end
+      end
+
+      # Add a method, to redirect calls to the target.
+      methods_to_redirect.each do |meth|
+        meta_class.send :define_method, meth do |*args, &block|
+          target.send meth, *args, &block
+        end
+      end
+
+      redirection_stack.push [target, methods_overridden, methods_to_redirect]
+
+      target
+    end
+
+    protected
+    def pop_redirection_target
+      meta_class = class << self; self; end
+
+      target, methods_to_recreate, methods_to_remove = redirection_stack.pop
+
+      # Remove the redirection methods
+      methods_to_remove.reverse_each do |meth|
+        meta_class.send :remove_method, meth
+      end
+
+      # Replace with the previous versions of the methods.
+      methods_to_recreate.reverse_each do |meth, reference, access|
+        meta_class.send :define_method, meth, reference
+        meta_class.send access, meth unless access == :public
+      end
+
+      target
+    end
+
+    # Direct access to the redirection stack.
+    private
+    def redirection_stack
+      @_redirection_stack ||= []
+    end
+  end
+end
+
+class Object
+  include Fidgit::RedirectorMethods
+end

data/lib/fidgit/schema.rb

@@ -0,0 +1,123 @@
+# encoding: utf-8
+
+module Fidgit
+  # An object that manages Schema values. Usually loaded from a YAML file.
+  #
+  # @example
+  #   schema = Schema.new(YAML.load(file.read('default_schema.yml')))
+  #   default_color = schema.default(Element, :disabled, :color)
+  #   schema.merge_schema!(YAML.load(file.read('override_schema.yml'))
+  #   overridden_color = schema.default(Element, :disabled, :color)
+  class Schema
+    CONSTANT_PREFIX = '?'
+
+    # @param [Hash<Symbol => Hash>] schema data containing
+    def initialize(schema)
+      @constants = {}
+      @elements = {}
+
+      merge_schema! schema
+    end
+
+    # Merge in a hash containing constant values.
+    #
+    # @param [Hash<Symbol => Hash>] constants_hash Containing :colors, :constants and :elements hashes.
+    def merge_schema!(schema)
+      merge_constants!(schema[:constants]) if schema[:constants]
+      merge_elements!(schema[:elements]) if schema[:elements]
+
+      self
+    end
+
+    # Merge in a hash containing constant values. Arrays will be resolved as colors in RGBA or RGB format.
+    #
+    # @param [Hash<Symbol => Object>] constants_hash
+    def merge_constants!(constants_hash)
+      constants_hash.each_pair do |name, value|
+        @constants[name] = case value
+        when Array
+          case value.size
+          when 3 then Gosu::Color.rgb(*value)
+          when 4 then Gosu::Color.rgba(*value)
+          else
+            raise "Colors must be in 0..255, RGB or RGBA array format"
+          end
+        else
+          value
+        end
+      end
+
+      self
+    end
+
+    # Merge in a hash containing default values for each element.
+    #
+    # @param [Hash<Symbol => Hash>] elements_hash
+    def merge_elements!(elements_hash)
+      elements_hash.each_pair do |klass_names, data|
+        klass = Fidgit
+        klass_names.to_s.split('::').each do |klass_name|
+          klass = klass.const_get klass_name
+        end
+
+        raise "elements must be names of classes derived from #{Element}" unless klass.ancestors.include? Fidgit::Element
+        @elements[klass] ||= {}
+        @elements[klass].deep_merge! data
+      end
+
+      self
+    end
+
+    # Get the constant value associated with +name+.
+    #
+    # @param [Symbol] name
+    # @return [Object]
+    def constant(name)
+      @constants[name]
+    end
+
+    # @param [Class] klass Class to look for defaults for.
+    # @param [Symbol, Array<Symbol>] names Hash names to search for in that class's schema.
+    def default(klass, names)
+      raise ArgumentError, "#{klass} is not a descendent of the #{Element} class" unless klass.ancestors.include? Element
+      value = default_internal(klass, Array(names), true)
+      raise("Failed to find named value #{names.inspect} for class #{klass}") unless value
+      value
+    end
+
+    protected
+    # @param [Class] klass Class to look for defaults for.
+    # @param [Array<Symbol>] names Hash names to search for in that class's schema.
+    # @param [Boolean] default_to_outer Whether to default to an outer value (used internally)
+    def default_internal(klass, names, default_to_outer)
+      # Find the value by moving through the nested hash via the names.
+      value = @elements[klass]
+
+      names.each do |name|
+        break unless value.is_a? Hash
+        value = value.has_key?(name) ? value[name] : nil
+      end
+
+      # Convert the value to a color/constant if they are symbols.
+      value = if value.is_a? String and value[0] == CONSTANT_PREFIX
+          str = value[1..-1]
+          constant(str.to_sym) || value # If the value isn't a constant, return the string.
+        else
+          value
+      end
+
+      # If we didn't find the value for this class, default to parent class value.
+      if value.nil? and klass != Element and klass.ancestors.include? Element
+        # Check if any ancestors define the fully named value.
+        value = default_internal(klass.superclass, names, false)
+      end
+
+      if value.nil? and default_to_outer and names.size > 1
+        # Check the outer values (e.g. if [:hover, :color] is not defined, try [:color]).
+        value = default_internal(klass, names[1..-1], true)
+      end
+
+      value
+    end
+  end
+end