colstrom-fidgit 0.2.7

data/lib/fidgit/elements/image_frame.rb

@@ -0,0 +1,65 @@
+module Fidgit
+  # A wrapper around a Gosu::Image to show it in the GUI.
+  class ImageFrame < Element
+    ENABLED_COLOR = Gosu::Color::WHITE
+    DISABLED_COLOR = Gosu::Color.rgb(150, 150, 150)
+
+    attr_reader :image, :factor_x, :factor_y
+
+    def thumbnail?; @thumbnail; end
+
+    # @param (see Element#initialize)
+    # @param [Gosu::Image] image Gosu image to display.
+    #
+    # @option (see Element#initialize)
+    # @option options [Boolean] :thumbnail (false) Is the image expanded to be square?
+    def initialize(image, options = {})
+      options = {
+          thumbnail: false,
+          factor: 1,
+      }.merge! options
+
+      @thumbnail = options[:thumbnail]
+      @factor_x = options[:factor_x] || options[:factor]
+      @factor_y = options[:factor_y] || options[:factor]
+
+      super(options)
+
+      self.image = image
+    end
+
+    def image=(image)
+      @image = image
+
+      recalc
+
+      image
+    end
+
+
+    def draw_foreground
+      @image.draw(x + padding_left, y + padding_top, z, factor_x, factor_y, enabled? ? ENABLED_COLOR : DISABLED_COLOR) if @image
+    end
+
+    protected
+    def layout
+      if @image
+        if @thumbnail
+          size = [@image.width, @image.height].max
+          rect.width = size * @factor_x
+          rect.height = size * @factor_y
+        else
+          rect.width = @image.width * @factor_x
+          rect.height = @image.height * @factor_y
+        end
+      else
+        rect.width = rect.height = 0
+      end
+
+      rect.width += padding_left + padding_right
+      rect.height += padding_top + padding_bottom
+
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/label.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Fidgit
+  class Label < Composite
+    ICON_POSITIONS = [:top, :bottom, :left, :right]
+
+    attr_reader :icon_position
+
+    attr_accessor :background_color, :border_color
+
+    def_delegators :@text, :text, :color, :font, :color=, :text=
+
+    def icon; @icon ? @icon.image : nil; end
+
+    def hit_element(x, y)
+      # The sub-elements should never get events.
+      hit?(x, y) ? self : nil
+    end
+
+    def icon=(icon)
+      raise ArgumentError.new("Icon must be a Gosu::Image") unless icon.is_a? Gosu::Image or icon.nil?
+
+      @contents.remove(@icon) if @icon.image
+      @icon.image = icon
+      position = [:left, :top].include?(icon_position) ? 0 : 1
+      @contents.insert(position, @icon) if @icon.image
+
+      icon
+    end
+
+    # Set the position of the icon, respective to the text.
+    def icon_position=(position)
+      raise ArgumentError.new("icon_position must be one of #{ICON_POSITIONS}") unless ICON_POSITIONS.include? position
+
+      @icon_position = position
+
+      case @icon_position
+        when :top, :bottom
+          @contents.instance_variable_set :@type, :fixed_columns
+          @contents.instance_variable_set :@num_columns, 1
+        when :left, :right
+          @contents.instance_variable_set :@type, :fixed_rows
+          @contents.instance_variable_set :@num_rows, 1
+      end
+
+      self.icon = @icon.image if @icon.image # Force the icon into the correct position.
+
+      position
+    end
+
+    # @param (see Element#initialize)
+    # @param [String] text The string to display in the label.
+    #
+    # @option (see Element#initialize)
+    # @option options [Gosu::Image, nil] :icon (nil)
+    # @option options [:left, :right, :center] :justify (:left) Text justification.
+    def initialize(text, options = {})
+      options = {
+        color: default(:color),
+        justify: default(:justify),
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+        icon_options: {},
+        font_name: default(:font_name),
+        font_height: default(:font_height),
+        icon_position: default(:icon_position),
+      }.merge! options
+
+      super(options)
+
+      # Bit of a fudge since font info is managed circularly here!
+      # By using a grid, we'll be able to turn it around easily (in theory).
+      @contents = grid num_rows: 1, padding: 0, spacing_h: spacing_h, spacing_v: spacing_v, width: options[:width], height: options[:height], z: z do |contents|
+        @text = TextLine.new(text, parent: contents, justify: options[:justify], color: options[:color], padding: 0, z: z,
+                               font_name: options[:font_name], font_height: options[:font_height], align_h: :fill, align_v: :center)
+      end
+
+      # Create an image frame, but don't show it unless there is an image in it.
+      @icon = ImageFrame.new(nil, options[:icon_options].merge(z: z, align: :center))
+      @icon.image = options[:icon]
+
+      self.icon_position = options[:icon_position]
+    end
+  end
+end

data/lib/fidgit/elements/list.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module Fidgit
+  class List < Composite
+    class Item < RadioButton
+    end
+
+    event :changed
+
+    def size; @items.size; end
+    def clear; @items.clear; end
+
+    def initialize(options = {})
+      options = {
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+      }.merge! options
+
+      super options
+
+      group do
+        subscribe :changed do |sender, value|
+          publish :changed, value
+        end
+
+        @items = vertical spacing: 0
+      end
+    end
+
+    # @param [String] text
+    # @option options [Gosu::Image] :icon
+    def item(text, value, options = {}, &block)
+      Item.new(text, value, { parent: @items }.merge!(options), &block)
+    end
+
+    protected
+    def layout
+      super
+      if @items
+        max_width = @items.each.to_a.map {|c| c.width }.max || 0
+        @items.each {|c| c.rect.width = max_width }
+      end
+
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/main_packer.rb

@@ -0,0 +1,25 @@
+require_relative "vertical"
+
+module Fidgit
+  # Main container that can contains a single "proper" packing element.
+  class MainPacker < Vertical
+    def initialize(options = {})
+      options = {
+          width: $window.width,
+          height: $window.height,
+      }.merge! options
+
+      super options
+    end
+
+    def width; $window.width; end
+    def height; $window.height; end
+    def width=(value); ; end
+    def height=(value); ; end
+
+    def add(element)
+      raise "MainPacker can only contain packing elements" unless element.is_a? Packer
+      super(element)
+    end
+  end
+end

data/lib/fidgit/elements/menu_pane.rb

@@ -0,0 +1,163 @@
+require 'forwardable'
+
+module Fidgit
+  class MenuPane < Composite
+    # An item within the menu.
+    class Item < Button
+      attr_reader :value, :shortcut_text
+
+      # @param (see Button#initialize)
+      #
+      # @option (see Button#initialize)
+      # @param [any] value Value if the user picks this item
+      # @option options [String] :shortcut_text ('')
+      def initialize(text, value, options = {})
+        options = {
+          enabled: true,
+          border_color: default(:border_color),
+          shortcut_text: '',
+        }.merge! options
+
+        @value = value
+        @shortcut_text = options[:shortcut_text]
+
+        super(text, options)
+      end
+
+      def draw_foreground
+        super
+
+        unless @shortcut_text.empty?
+          font.draw_rel("#{@shortcut_text}", rect.right - padding_right, y + ((height - font.height) / 2).floor, z, 1, 0, 1, 1, color)
+        end
+
+        nil
+      end
+
+      protected
+      def layout
+        super
+
+        # Ignore layout request when asked before TextLine has been created.
+        rect.width += font.text_width("  #{@shortcut_text}") unless @shortcut_text.empty? or @text.nil?
+
+        nil
+      end
+    end
+
+    class Separator < Label
+      # @param (see Item#initialize)
+      #
+      # @option (see Item#initialize)
+      def initialize(options = {})
+        options = {
+          height: default(:line_height),
+          background_color: default(:background_color),
+          padding: 0,
+        }.merge! options
+
+        super '', options
+      end
+    end
+
+    extend Forwardable
+
+    def_delegators :@items, :each, :clear, :size, :[]
+
+    event :selected
+
+    def index(value); @items.index find(value); end
+    def x=(value); super(value); recalc; end
+    def y=(value); super(value); recalc; end
+
+    # @option (see Composite#initialize)
+    # @option options [Float] :x (cursor x, if in a GuiState)
+    # @option options [Float] :y (cursor y, if in a GuiState)
+    # @option options [Boolean] :show (true) Whether to show immediately (show later with #show).
+    def initialize(options = {}, &block)
+      options = {
+        background_color: default(:color),
+        z: Float::INFINITY,
+        show: true,
+      }.merge! options
+
+      state = $window.current_game_state
+      if state.is_a? GuiState
+        cursor = $window.current_game_state.cursor
+        options = {
+          x: cursor.x,
+          y: cursor.y,
+        }.merge! options
+      end
+
+      @items = nil
+
+      super(options)
+
+      @items = vertical spacing: 0, padding: 0
+
+      if options[:show] and state.is_a? GuiState
+        show
+      end
+    end
+
+    def find(value)
+      @items.find {|c| c.value == value }
+    end
+
+    def separator(options = {})
+      options[:z] = z
+
+      Separator.new({ parent: @items }.merge!(options))
+    end
+
+    def item(text, value, options = {}, &block)
+      options = options.merge({
+         parent: @items,
+         z: z,
+      })
+      item = Item.new(text, value, options, &block)
+
+      item.subscribe :left_mouse_button, method(:item_selected)
+      item.subscribe :right_mouse_button, method(:item_selected)
+
+      item
+    end
+
+    def item_selected(sender, x, y)
+      publish(:selected, sender.value)
+
+      $window.game_state_manager.current_game_state.hide_menu
+
+      nil
+    end
+
+    def show
+      $window.game_state_manager.current_game_state.show_menu self
+      nil
+    end
+
+    protected
+    def layout
+      super
+
+      if @items
+        # Ensure the menu can't go over the edge of the screen. If it can't be avoided, align with top-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
+
+        # Move the actual list if the menu has moved to keep on the screen.
+        @items.x = x + padding_left
+        @items.y = y + padding_top
+
+        # Ensure that all items are of the same width.
+        max_width = @items.map(&:width).max || 0
+        @items.each {|c| c.rect.width = max_width }
+
+        @items.recalc # Move all the items inside the packer to correct ones.
+      end
+
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/packer.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module Fidgit
+  # Container that auto-packs elements.
+  #
+  # @abstract
+  class Packer < Container
+    attr_reader :spacing_h, :spacing_v
+
+    # @param (see Container#initialize)
+    #
+    # @option (see Container#initialize)
+    def initialize(options = {})
+      options = {
+      }.merge! options
+
+      @spacing_h = options[:spacing_h] || options[:spacing] || default(:spacing_h)
+      @spacing_v = options[:spacing_v] || options[:spacing] || default(:spacing_v)
+
+      super(options)
+    end
+
+    protected
+    # Recalculate the size of the container.
+    # Should be overridden by any descendant that manages the positions of its children.
+    def layout
+      # This assumes that the container overlaps all the children.
+
+      # Move all children if we have moved.
+      @children.each.with_index do |child, index|
+        child.x = padding_left + x
+        child.y = padding_top + y
+      end
+
+      # Make us as wrap around the largest child.
+      rect.width = (@children.map {|c| c.width }.max || 0) + padding_left + padding_right
+      rect.height = (@children.map {|c| c.height }.max || 0) + padding_top + padding_bottom
+
+      super
+    end
+  end
+end

data/lib/fidgit/elements/radio_button.rb

@@ -0,0 +1,86 @@
+# encoding: utf-8
+
+module Fidgit
+  class RadioButton < Button
+    attr_reader :group, :value
+
+    event :changed
+
+    def checked?; @checked; end
+
+    # @param (see Button#initialize)
+    # @param [Object] value
+    #
+    # @option (see Button#initialize)
+    # @option options [Boolean] :checked
+    def initialize(text, value, options = {}, &block)
+      options = {
+        checked: false,
+        checked_border_color: default(:checked, :border_color),
+      }.merge! options
+
+      @checked = options[:checked]
+      @value = value
+
+      super(text, options)
+
+      @checked_border_color = options[:checked_border_color].dup
+      @unchecked_border_color = border_color
+      add_to_group
+
+      @border_color = (checked? ? @checked_border_color : @unchecked_border_color).dup
+    end
+
+    def clicked_left_mouse_button(sender, x, y)
+      super
+      check
+      nil
+    end
+
+    # Check the button and update its group. This may uncheck another button in the group if one is selected.
+    def check
+      return if checked?
+
+      @checked = true
+      @group.value = value
+      @border_color = @checked_border_color.dup
+      publish :changed, @checked
+
+      nil
+    end
+
+    # Uncheck the button and update its group.
+    def uncheck
+      return unless checked?
+
+      @checked = false
+      @group.value = value
+      @border_color = @unchecked_border_color.dup
+      publish :changed, @checked
+
+      nil
+    end
+
+    protected
+    def parent=(parent)
+      @group.remove_button self if @parent
+      super(parent)
+      add_to_group if parent
+      parent
+    end
+
+    protected
+    def add_to_group
+      container = parent
+      while container and not container.is_a? Group
+        container = container.parent
+      end
+
+      raise "#{self.class.name} must be placed inside a group element" unless container
+
+      @group = container
+      @group.add_button self
+      nil
+    end
+  end
+end