fidgit 0.2.4 → 0.2.5

data/lib/fidgit/elements/text_line.rb

@@ -1,92 +1,92 @@
-module Fidgit
-  # Used internally by the label.
-  class TextLine < Element
-    VALID_JUSTIFICATION = [:left, :right, :center]
-
-    attr_reader :color, :justify
-
-    def color=(color)
-      raise ArgumentError.new("Text must be a Gosu::Color") unless color.is_a? Gosu::Color
-
-      @color = color.dup
-
-      color
-    end
-
-    def text; @text.dup; end
-
-    def text=(text)
-      raise ArgumentError.new("Text must be a String") unless text.respond_to? :to_s
-
-      @text = text.to_s.dup
-
-      recalc
-      text
-    end
-
-    def justify=(justify)
-      raise ArgumentError.new("Justify must be one of #{VALID_JUSTIFICATION.inspect}") unless VALID_JUSTIFICATION.include? justify
-      @justify = justify
-    end
-
-    # @param (see Element#initialize)
-    # @param [String] text The string to display in the line of text.
-    #
-    # @option (see Element#initialize)
-    # @option options [:left, :right, :center] :justify (:left) Text justification.
-    def initialize(text, options = {})
-      options = {
-          color: default(:color),
-          justify: default(:justify),
-      }.merge! options
-
-      super(options)
-
-      self.justify = options[:justify]
-      self.color = options[:color]
-      self.text = text
-    end
-
-    def draw_foreground
-      case @justify
-        when :left
-          rel_x = 0.0
-          draw_x = x + padding_left
-
-        when :right
-          rel_x = 1.0
-          draw_x = x + rect.width - padding_right
-
-        when :center
-          rel_x = 0.5
-          draw_x = (x + padding_left) + (rect.width - padding_right - padding_left) / 2.0
-      end
-
-      font.draw_rel(@text, draw_x, y + padding_top, z, rel_x, 0, 1, 1, color)
-    end
-
-    def min_width
-      if @text.empty?
-        [padding_left + padding_right, super].max
-      else
-        [padding_left + font.text_width(@text) + padding_right, super].max
-      end
-    end
-
-    protected
-    def layout
-      rect.width = [min_width, max_width].min
-
-      if @text.empty?
-        rect.height = [[padding_top + padding_bottom, min_height].max, max_height].min
-      else
-        rect.height = [[padding_top + font.height + padding_bottom, min_height].max, max_height].min
-      end
-    end
-
-    public
-    def to_s
-      "#{super} '#{@text}'"
-    end
-  end
+module Fidgit
+  # Used internally by the label.
+  class TextLine < Element
+    VALID_JUSTIFICATION = [:left, :right, :center]
+
+    attr_reader :color, :justify
+
+    def color=(color)
+      raise ArgumentError.new("Text must be a Gosu::Color") unless color.is_a? Gosu::Color
+
+      @color = color.dup
+
+      color
+    end
+
+    def text; @text.dup; end
+
+    def text=(text)
+      raise ArgumentError.new("Text must be a String") unless text.respond_to? :to_s
+
+      @text = text.to_s.dup
+
+      recalc
+      text
+    end
+
+    def justify=(justify)
+      raise ArgumentError.new("Justify must be one of #{VALID_JUSTIFICATION.inspect}") unless VALID_JUSTIFICATION.include? justify
+      @justify = justify
+    end
+
+    # @param (see Element#initialize)
+    # @param [String] text The string to display in the line of text.
+    #
+    # @option (see Element#initialize)
+    # @option options [:left, :right, :center] :justify (:left) Text justification.
+    def initialize(text, options = {})
+      options = {
+          color: default(:color),
+          justify: default(:justify),
+      }.merge! options
+
+      super(options)
+
+      self.justify = options[:justify]
+      self.color = options[:color]
+      self.text = text
+    end
+
+    def draw_foreground
+      case @justify
+        when :left
+          rel_x = 0.0
+          draw_x = x + padding_left
+
+        when :right
+          rel_x = 1.0
+          draw_x = x + rect.width - padding_right
+
+        when :center
+          rel_x = 0.5
+          draw_x = (x + padding_left) + (rect.width - padding_right - padding_left) / 2.0
+      end
+
+      font.draw_rel(@text, draw_x, y + padding_top, z, rel_x, 0, 1, 1, color)
+    end
+
+    def min_width
+      if @text.empty?
+        [padding_left + padding_right, super].max
+      else
+        [padding_left + font.text_width(@text) + padding_right, super].max
+      end
+    end
+
+    protected
+    def layout
+      rect.width = [min_width, max_width].min
+
+      if @text.empty?
+        rect.height = [[padding_top + padding_bottom, min_height].max, max_height].min
+      else
+        rect.height = [[padding_top + font.height + padding_bottom, min_height].max, max_height].min
+      end
+    end
+
+    public
+    def to_s
+      "#{super} '#{@text}'"
+    end
+  end
 end

data/lib/fidgit/elements/toggle_button.rb

@@ -1,67 +1,67 @@
-# encoding: utf-8
-
-module Fidgit
-  # A button that toggles its value from false<->true when clicked.
-  class ToggleButton < Button
-    event :changed
-
-    attr_reader :value
-    def value=(value); @value = value; update_status; end
-
-    # @param (see Button#initialize)
-    #
-    # @option (see Button#initialize)
-    def initialize(text, options = {}, &block)
-      options = {
-        value: false
-      }.merge! options
-
-      @value = options[:value]
-
-      super(text, options)
-
-      @text_on = (options[:text_on] || text).dup
-      @icon_on = options[:icon_on] || icon
-      @tip_on = (options[:tip_on] || tip).dup
-      @border_color_on = (options[:border_color_on] || options[:border_color] || default(:toggled, :border_color)).dup
-
-      @text_off = (options[:text_off] || text).dup
-      @icon_off = options[:icon_off] || icon
-      @tip_off = (options[:tip_off] || tip).dup
-      @border_color_off = (options[:border_color_off] || options[:border_color] || default(:border_color)).dup
-
-      update_status
-
-      subscribe :clicked_left_mouse_button do |sender, x, y|
-        @value = (not @value)
-        update_status
-        publish :changed, @value
-      end
-    end
-
-    protected
-    # The block for a toggle-button is connected to :changed event.
-    def post_init_block(&block)
-      subscribe :changed, &block
-    end
-
-    protected
-    def update_status
-      if @value
-        self.text = @text_on.dup
-        @icon = @icon_on ? @icon_on.dup : nil
-        @tip = @tip_on.dup
-        @border_color = @border_color_on.dup
-      else
-        self.text = @text_off.dup
-        @icon = @icon_off ? @icon_off.dup : nil
-        @tip = @tip_off.dup
-        @border_color = @border_color_off.dup
-      end
-
-      recalc
-
-      nil
-    end
-  end
+# encoding: utf-8
+
+module Fidgit
+  # A button that toggles its value from false<->true when clicked.
+  class ToggleButton < Button
+    event :changed
+
+    attr_reader :value
+    def value=(value); @value = value; update_status; end
+
+    # @param (see Button#initialize)
+    #
+    # @option (see Button#initialize)
+    def initialize(text, options = {}, &block)
+      options = {
+        value: false
+      }.merge! options
+
+      @value = options[:value]
+
+      super(text, options)
+
+      @text_on = (options[:text_on] || text).dup
+      @icon_on = options[:icon_on] || icon
+      @tip_on = (options[:tip_on] || tip).dup
+      @border_color_on = (options[:border_color_on] || options[:border_color] || default(:toggled, :border_color)).dup
+
+      @text_off = (options[:text_off] || text).dup
+      @icon_off = options[:icon_off] || icon
+      @tip_off = (options[:tip_off] || tip).dup
+      @border_color_off = (options[:border_color_off] || options[:border_color] || default(:border_color)).dup
+
+      update_status
+
+      subscribe :clicked_left_mouse_button do |sender, x, y|
+        @value = (not @value)
+        update_status
+        publish :changed, @value
+      end
+    end
+
+    protected
+    # The block for a toggle-button is connected to :changed event.
+    def post_init_block(&block)
+      subscribe :changed, &block
+    end
+
+    protected
+    def update_status
+      if @value
+        self.text = @text_on.dup
+        @icon = @icon_on ? @icon_on.dup : nil
+        @tip = @tip_on.dup
+        @border_color = @border_color_on.dup
+      else
+        self.text = @text_off.dup
+        @icon = @icon_off ? @icon_off.dup : nil
+        @tip = @tip_off.dup
+        @border_color = @border_color_off.dup
+      end
+
+      recalc
+
+      nil
+    end
+  end
 end

data/lib/fidgit/elements/tool_tip.rb

@@ -1,35 +1,35 @@
-# encoding: utf-8
-
-module Fidgit
-  class ToolTip < TextLine
-    def x=(value); super(value); recalc; value; end
-    def y=(value); super(value); recalc; value; end
-    def hit?(x, y); false; end
-
-
-    # @param (see Label#initialize)
-    #
-    # @option (see Label#initialize)
-    def initialize(options = {}, &block)
-      options = {
-        z: Float::INFINITY,
-        background_color: default(:background_color),
-        border_color: default(:border_color),
-        text: '',
-      }.merge! options
-
-      super(options[:text], options)
-    end
-
-    protected
-    def layout
-      super
-
-      # Ensure the tip can't go over the edge of the screen. If it can't be avoided, align with left edge of screen.
-      rect.x = [[x, $window.width - width - padding_right].min, 0].max
-      rect.y = [[y, $window.height - height - padding_bottom].min, 0].max
-
-      nil
-    end
-  end
+# encoding: utf-8
+
+module Fidgit
+  class ToolTip < TextLine
+    def x=(value); super(value); recalc; value; end
+    def y=(value); super(value); recalc; value; end
+    def hit?(x, y); false; end
+
+
+    # @param (see Label#initialize)
+    #
+    # @option (see Label#initialize)
+    def initialize(options = {}, &block)
+      options = {
+        z: Float::INFINITY,
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        text: '',
+      }.merge! options
+
+      super(options[:text], options)
+    end
+
+    protected
+    def layout
+      super
+
+      # Ensure the tip can't go over the edge of the screen. If it can't be avoided, align with left edge of screen.
+      rect.x = [[x, $window.width - width - padding_right].min, 0].max
+      rect.y = [[y, $window.height - height - padding_bottom].min, 0].max
+
+      nil
+    end
+  end
 end

data/lib/fidgit/elements/vertical.rb

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

data/lib/fidgit/event.rb

@@ -1,159 +1,159 @@
-# 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
-    # Created and returned by {Event#subscribe} and can be used to unsubscribe from the event.
-    class Subscription
-      attr_reader :publisher, :event, :handler
-
-      def initialize(publisher, event, handler)
-        raise TypeError unless publisher.is_a? Event
-        raise TypeError unless event.is_a? Symbol
-        raise TypeError unless handler.is_a? Proc or handler.is_a? Method
-
-        @publisher, @event, @handler = publisher, event, handler
-      end
-
-      def unsubscribe
-        @publisher.unsubscribe self
-      end
-    end
-
-    class << self
-      def new_event_handlers
-        # Don't use Set, since it is not guaranteed to be ordered.
-        Hash.new {|h, k| h[k] = [] }
-      end
-    end
-
-    # @return [Subscription] Definition of this the handler created by this subscription, to be used with {#unsubscribe}
-    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 ||= Event.new_event_handlers
-      handler = method || block
-      @_event_handlers[event] << handler
-
-      Subscription.new self, event, handler
-    end
-
-    # @overload unsubscribe(subscription)
-    #   Unsubscribe from a #{Subscription}, as returned from {#subscribe}
-    #   @param subscription [Subscription]
-    #   @return [Boolean] true if the handler was able to be deleted.
-    #
-    # @overload unsubscribe(handler)
-    #   Unsubscribe from first event this handler has been used to subscribe to..
-    #   @param handler [Block, Method] Event handler used.
-    #   @return [Boolean] true if the handler was able to be deleted.
-    #
-    # @overload unsubscribe(event, handler)
-    #   Unsubscribe from specific handler on particular event.
-    #   @param event [Symbol] Name of event originally subscribed to.
-    #   @param handler [Block, Method] Event handler used.
-    #   @return [Boolean] true if the handler was able to be deleted.
-    #
-    def unsubscribe(*args)
-      @_event_handlers ||= Event.new_event_handlers
-
-      case args.size
-        when 1
-          case args.first
-            when Subscription
-              # Delete specific event handler.
-              subscription = args.first
-              raise ArgumentError, "Incorrect publisher for #{Subscription}: #{subscription.publisher}" unless subscription.publisher == self
-              unsubscribe subscription.event, subscription.handler
-            when Proc, Method
-              # Delete first events that use the handler.
-              handler = args.first
-              !!@_event_handlers.find {|_, handlers| handlers.delete handler }
-            else
-              raise TypeError, "handler must be a #{Subscription}, Block or Method: #{args.first}"
-          end
-        when 2
-          event, handler = args
-          raise TypeError, "event name must be a Symbol: #{event}" unless event.is_a? Symbol
-          raise TypeError, "handler name must be a Proc/Method: #{handler}" unless handler.is_a? Proc or handler.is_a? Method
-          !!@_event_handlers[event].delete(handler)
-        else
-          raise ArgumentError, "Requires 1..2 arguments, but received #{args.size} arguments"
-      end
-    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 defined? @_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
-          # Copy the events already set up for your parent.
-          @events ||= if superclass.respond_to? :events
-                        superclass.events.dup
-                      else
-                        []
-                      end
-        end
-
-        def event(event)
-          events.push event.to_sym unless events.include? event
-          event
-        end
-      end
-    end
-  end
+# 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
+    # Created and returned by {Event#subscribe} and can be used to unsubscribe from the event.
+    class Subscription
+      attr_reader :publisher, :event, :handler
+
+      def initialize(publisher, event, handler)
+        raise TypeError unless publisher.is_a? Event
+        raise TypeError unless event.is_a? Symbol
+        raise TypeError unless handler.is_a? Proc or handler.is_a? Method
+
+        @publisher, @event, @handler = publisher, event, handler
+      end
+
+      def unsubscribe
+        @publisher.unsubscribe self
+      end
+    end
+
+    class << self
+      def new_event_handlers
+        # Don't use Set, since it is not guaranteed to be ordered.
+        Hash.new {|h, k| h[k] = [] }
+      end
+    end
+
+    # @return [Subscription] Definition of this the handler created by this subscription, to be used with {#unsubscribe}
+    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 ||= Event.new_event_handlers
+      handler = method || block
+      @_event_handlers[event] << handler
+
+      Subscription.new self, event, handler
+    end
+
+    # @overload unsubscribe(subscription)
+    #   Unsubscribe from a #{Subscription}, as returned from {#subscribe}
+    #   @param subscription [Subscription]
+    #   @return [Boolean] true if the handler was able to be deleted.
+    #
+    # @overload unsubscribe(handler)
+    #   Unsubscribe from first event this handler has been used to subscribe to..
+    #   @param handler [Block, Method] Event handler used.
+    #   @return [Boolean] true if the handler was able to be deleted.
+    #
+    # @overload unsubscribe(event, handler)
+    #   Unsubscribe from specific handler on particular event.
+    #   @param event [Symbol] Name of event originally subscribed to.
+    #   @param handler [Block, Method] Event handler used.
+    #   @return [Boolean] true if the handler was able to be deleted.
+    #
+    def unsubscribe(*args)
+      @_event_handlers ||= Event.new_event_handlers
+
+      case args.size
+        when 1
+          case args.first
+            when Subscription
+              # Delete specific event handler.
+              subscription = args.first
+              raise ArgumentError, "Incorrect publisher for #{Subscription}: #{subscription.publisher}" unless subscription.publisher == self
+              unsubscribe subscription.event, subscription.handler
+            when Proc, Method
+              # Delete first events that use the handler.
+              handler = args.first
+              !!@_event_handlers.find {|_, handlers| handlers.delete handler }
+            else
+              raise TypeError, "handler must be a #{Subscription}, Block or Method: #{args.first}"
+          end
+        when 2
+          event, handler = args
+          raise TypeError, "event name must be a Symbol: #{event}" unless event.is_a? Symbol
+          raise TypeError, "handler name must be a Proc/Method: #{handler}" unless handler.is_a? Proc or handler.is_a? Method
+          !!@_event_handlers[event].delete(handler)
+        else
+          raise ArgumentError, "Requires 1..2 arguments, but received #{args.size} arguments"
+      end
+    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 defined? @_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
+          # Copy the events already set up for your parent.
+          @events ||= if superclass.respond_to? :events
+                        superclass.events.dup
+                      else
+                        []
+                      end
+        end
+
+        def event(event)
+          events.push event.to_sym unless events.include? event
+          event
+        end
+      end
+    end
+  end
 end