fidgit 0.0.2alpha

data/lib/fidgit/elements/grid_packer.rb

@@ -0,0 +1,219 @@
+# encoding: utf-8
+
+module Fidgit
+  # A vertically aligned element packing container.
+
+  class GridPacker < Packer
+    # @return [Integer]
+    attr_reader :num_rows
+    # @return [Integer]
+    attr_reader :num_columns
+
+    # @note Currently only supports +num_columns+ mode (not +num_rows+).
+    #
+    # @param (see Packer#initialize)
+    #
+    # @option (see Packer#initialize)
+    # @option options [Integer] :num_columns Maximum number of columns to use (incompatible with :num_rows)
+    # @option options [Integer] :num_rows Maximum number of rows to use (incompatible with :num_columns)
+    def initialize(options = {})
+      options = {
+        cell_border_color: default(:cell_border_color),
+        cell_background_color: default(:cell_background_color),
+        cell_border_thickness: default(:cell_border_thickness),
+      }.merge! options
+
+      @num_columns = options[:num_columns]
+      @num_rows = options[:num_rows]
+      raise ArgumentError, "options :num_rows and :num_columns are not compatible" if @num_rows and @num_columns
+
+      @cell_border_color = options[:cell_border_color].dup
+      @cell_border_thickness = options[:cell_border_thickness]
+      @cell_background_color = options[:cell_background_color].dup
+
+      @type = @num_rows ? :fixed_rows : :fixed_columns
+
+      super options
+    end
+
+    protected
+    def layout
+      rearrange
+      repack
+    end
+
+    protected
+    # Rearrange the cells based on changes to the number of rows/columns or adding/removing elements.
+    def rearrange
+      # Calculate the number of the dynamic dimension.
+      case @type
+      when :fixed_rows
+        @num_columns = (size / @num_rows.to_f).ceil
+      when :fixed_columns
+        @num_rows = (size / @num_columns.to_f).ceil
+      end
+
+      # Create an array containing all the rows.
+      @rows = case @type
+      when :fixed_rows
+        # Rearrange the list, arranged by columns, into rows.
+        rows = Array.new(@num_rows) { [] }
+        @children.each_with_index do |child, i|
+          rows[i % @num_rows].push child
+        end
+        rows
+      when :fixed_columns
+        @children.each_slice(@num_columns).to_a
+      end
+
+      nil
+    end
+
+    protected
+    # Repack all the elements into their positions.
+    def repack
+      @widths = Array.new(@num_columns, 0)
+      @heights = Array.new(@num_rows, 0)
+
+      filled_columns = []
+      filled_rows = []
+
+      # Calculate the maximum widths of each column and the maximum height of each row.
+      @rows.each_with_index do |row, row_num|
+        row.each_with_index do |element, column_num|
+          fills = (element.align_h == :fill)
+          @widths[column_num] = [fills ? 0 : element.outer_width, @widths[column_num] || 0].max
+          filled_columns.push fills
+
+          fills = (element.align_v == :fill)
+          @heights[row_num] = [fills ? 0 : element.outer_height, @heights[row_num] || 0].max
+          filled_rows.push fills
+        end
+      end
+
+      # Expand the size of each filled column to make the minimum size required.
+      num_filled_columns = filled_columns.select {|value| value }.count
+      if num_filled_columns > 0
+        total_width = @widths.inject(0, :+) + (padding_left + padding_right) + ((@num_columns - 1) * spacing_h)
+        if total_width < min_width
+          extra_width = total_width / num_filled_columns
+          filled_columns.each_with_index do |filled, i|
+            @widths[i] += extra_width if filled
+          end
+        end
+      end
+
+      # Expand the size of each filled row to make the minimum size required.
+      num_filled_rows = filled_rows.select {|value| value }.count
+      if num_filled_rows > 0
+        total_height = @heights.inject(0, :+) + (padding_left + padding_right) + ((@num_rows - 1) * spacing_v)
+        if total_height < min_height
+          extra_height = total_height / num_filled_rows
+          filled_rows.each_with_index do |filled, i|
+            @heights[i] += extra_height if filled
+          end
+        end
+      end
+
+      # Actually place all the elements into the grid positions, modified by valign and align.
+      current_y = y + padding_top
+      @rows.each_with_index do |row, row_num|
+        current_x = x + padding_left
+
+        row.each_with_index do |element, column_num|
+          element.x = current_x + element.border_thickness
+
+          case element.align_h # Take horizontal alignment into consideration.
+            when :fill
+              if element.width < @widths[column_num]
+                element.width = @widths[column_num]
+                element.send :repack if element.is_a? GridPacker
+              end
+            when :center
+              element.x += (@widths[column_num] - element.width) / 2
+            when :right
+              element.x += @widths[column_num] - element.width
+          end
+
+          current_x += @widths[column_num]
+          current_x += spacing_h unless column_num == @num_columns - 1
+
+          element.y = current_y + element.border_thickness
+
+          case element.align_v # Take horizontal alignment into consideration.
+            when :fill
+              if element.height < @heights[row_num]
+                element.height = @heights[row_num]
+                element.send :repack if element.is_a? GridPacker
+              end
+            when :center
+              element.y += (@heights[row_num] - element.height) / 2
+            when :bottom
+              element.y += @heights[row_num] - element.height
+            else
+          end
+        end
+
+        self.width = current_x - x + padding_left if row_num == 0
+
+        current_y += @heights[row_num] unless row.empty?
+        current_y += spacing_h unless row_num == num_rows - 1
+      end
+
+      self.height = current_y - y + padding_top
+
+      nil
+    end
+
+    protected
+    # @yield The rectangle of each cell within the grid.
+    # @yieldparam [Number] x
+    # @yieldparam [Number] y
+    # @yieldparam [Number] width
+    # @yieldparam [Number] height
+    def each_cell_rect
+      x = self.x + padding_left
+
+      @widths.each_with_index do |width, column_num|
+        y = self.y + padding_top
+
+        @heights.each_with_index do |height, row_num|
+          yield x, y, width, height if @rows[row_num][column_num]
+          y += height + spacing_v
+        end
+
+        x += width + spacing_h
+      end
+
+      nil
+    end
+
+    protected
+    def draw_background
+      super
+
+      # Draw the cell backgrounds.
+      unless @cell_background_color.transparent?
+        each_cell_rect do |x, y, width, height|
+          draw_rect x, y, width, height, z, @cell_background_color
+        end
+      end
+
+      nil
+    end
+
+    protected
+    def draw_border
+      super
+
+      # Draw the cell borders.
+      if @cell_border_thickness > 0 and not @cell_border_color.transparent?
+        each_cell_rect do |x, y, width, height|
+          draw_frame x, y, width, height, @cell_border_thickness, z, @cell_border_color
+        end
+      end
+
+      nil
+    end
+  end
+end

data/lib/fidgit/elements/group.rb

@@ -0,0 +1,66 @@
+ # encoding: utf-8
+
+ module Fidgit
+   class Group < Packer
+    attr_reader :selected
+
+    event :changed
+
+    def value; @selected ? @selected.value : nil; end
+
+    # @example
+    #   group do
+    #     pack :horizontal do
+    #       radio_button 1, text: '1', checked: true
+    #       radio_button 2, text: '2'
+    #       subscribe :changed do |sender, value|
+    #         puts value
+    #       end
+    #     end
+    #   end
+    #
+    # @param (see Packer#initialize)
+    #
+    # @option (see Packer#initialize)
+    def initialize(options = {}, &block)
+      super(options)
+
+      @selected = nil
+      @buttons = []
+    end
+
+    def add_button(button)
+      @buttons.push button
+      self.value = button.value if button.checked?
+      nil
+    end
+
+    def remove_button(button)
+      self.value = nil if button == @selected
+      @buttons.delete button
+      nil
+    end
+
+    # @example
+    #   @my_group = group do
+    #     pack :horizontal do
+    #       radio_button(1, text: '1', checked: true)
+    #       radio_button(2, text: '2')
+    #     end
+    #    end
+    #
+    #   # later
+    #   @my_group.value = 2
+    def value=(value)
+      if value != self.value
+        button = @buttons.find { |b| b.value == value }
+        @selected.uncheck if @selected and @selected.checked?
+        @selected = button
+        @selected.check if @selected and not @selected.checked?
+        publish :changed, self.value
+      end
+
+      value
+    end
+  end
+end

data/lib/fidgit/elements/horizontal_packer.rb

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

data/lib/fidgit/elements/label.rb

@@ -0,0 +1,77 @@
+# encoding: utf-8
+
+module Fidgit
+  class Label < Element
+    attr_accessor :color, :background_color, :border_color
+    attr_reader :text, :icon
+
+    def text=(value)
+      @text = value
+      recalc
+      nil
+    end
+
+    def icon=(value)
+      @icon = value
+      recalc
+      nil
+    end
+
+    # @param (see Element#initialize)
+    # @param [String] text The string to display in the label.
+    #
+    # @option (see Element#initialize)
+    # @option options [Fidgit::Thumbnail, Gosu::Image, nil] :icon (nil)
+    def initialize(text, options = {})
+      options = {
+        color: default(:color),
+        background_color: default(:background_color),
+        border_color: default(:border_color),
+      }.merge! options
+
+      @text = text.dup
+      @icon = options[:icon]
+      @color = options[:color].dup
+
+      super(options)
+    end
+
+    def draw_foreground
+      current_x = x + padding_left
+      if @icon
+        @icon.draw(current_x, y + padding_top, z)
+        current_x += @icon.width + padding_left
+      end
+
+      unless @text.empty?
+        font.draw(@text, current_x, y + padding_top, z, 1, 1, @color)
+      end
+
+      nil
+    end
+
+    protected
+    def layout
+      if @icon
+        if @text.empty?
+          rect.width = [padding_left + @icon.width + padding_right, width].max
+          rect.height = [padding_top + @icon.height + padding_bottom, height].max
+        else
+          # Todo: Use padding_h inside here? Probably by making this a Composite.
+          rect.width = [padding_left + @icon.width + [padding_left + padding_right].max + font.text_width(@text) + padding_right, width].max
+          rect.height = [padding_top + [@icon.height, font_size].max + padding_bottom, height].max
+        end
+      else
+        if @text.empty?
+          rect.width = [padding_left + padding_right, width].max
+          rect.height = [padding_top + padding_bottom, height].max
+        else
+          rect.width = [padding_left + font.text_width(@text) + padding_right, width].max
+          rect.height = [padding_top + font_size + padding_bottom, height].max
+        end
+      end
+
+      nil
+    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 = pack :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/menu_pane.rb

@@ -0,0 +1,149 @@
+# encoding: utf-8
+
+module Fidgit
+  class MenuPane < Composite
+    # An item within the menu.
+    class Item < Button
+      attr_reader :value, :shortcut
+
+      # @param (see Button#initialize)
+      #
+      # @option (see Button#initialize)
+      # @param [any] value Value if the user picks this item
+      # @option options [Boolean] :enabled (true)
+      # @option options [String] :shortcut ('')
+      def initialize(text, value, options = {})
+        options = {
+          enabled: true,
+          border_color: default(:border_color),
+        }.merge! options
+
+        @value = value
+        @enabled = [true, false].include?(options[:enabled]) ? options[:enabled] : true
+        @shortcut = options[:shortcut] || ''
+
+        super(text, options)
+      end
+
+      def draw_foreground
+        super
+        unless @shortcut.empty?
+          font.draw_rel("#{@shortcut}", rect.right - padding_right, y + ((height - font_size) / 2).floor, z, 1, 0, 1, 1, color)
+        end
+
+        nil
+      end
+
+      protected
+      def layout
+        super
+        rect.width += font.text_width("  #{@shortcut}") unless @shortcut.empty?
+        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
+
+    event :selected
+
+    def index(value); @items.index find(value); end
+    def size; @items.size; end
+    def [](index); @items[index]; 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
+
+      super(options)
+
+      @items = pack :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[:z] = z
+      item = Item.new(text, value, { parent: @items }.merge!(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 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.each.to_a.map {|c| c.width }.max || 0
+        @items.each {|c| c.rect.width = max_width }
+      end
+
+      nil
+    end
+  end
+end