colstrom-fidgit 0.2.7

data/lib/fidgit/elements/text_line.rb

@@ -0,0 +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
+end

data/lib/fidgit/elements/toggle_button.rb

@@ -0,0 +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
+end

data/lib/fidgit/elements/tool_tip.rb

@@ -0,0 +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
+end

data/lib/fidgit/elements/vertical.rb

@@ -0,0 +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
+end

data/lib/fidgit/event.rb

@@ -0,0 +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
+end

data/lib/fidgit/gosu_ext/color.rb

@@ -0,0 +1,136 @@
+# 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
+
+    # Convert to a 6-digit hexadecimal value, appropriate for passing to the Gosu +<c>+ tag. The alpha channel is ignored.
+    #
+    # @return [String] RGB hexadecimal string, such as "AABB00"
+    def to_hex
+      "%02x%02x%02x" % [red, green, blue]
+    end
+
+    # Colorize text for in-line rendering by Gosu.
+    # e.g. "frog" => "<c=00ff9a>frog</c>"
+    def colorize(text)
+      "<c=#{to_hex}>#{text}</c>"
+    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