colstrom-fidgit 0.2.7

data/lib/fidgit/elements/file_browser.rb

@@ -0,0 +1,152 @@
+# encoding: utf-8
+
+module Fidgit
+  class FileBrowser < Composite
+    VALID_TYPES = [:open, :save]
+
+    event :selected
+
+    attr_reader :pattern, :base_directory
+
+    def show_extension?; @show_extension; end
+    def directory
+      dir = File.join(*@directories)
+      dir = File.join(@base_directory, dir) unless @base_directory.empty?
+      dir
+    end
+    def file_name; @file_name_text.text; end
+    def file_path; File.join(directory, file_name); end
+
+    # @param [Symbol] type One of :open, :save
+    # @option options [String] :base_directory ('') Outermost directory that the browser will see.
+    # @option options [String] :directory (current working directory).
+    # @option options [String] :file_name ('') Initially selected file in the directory.
+    # @option options [String] :pattern ('*.*')
+    # @option options [Boolean] :show_extension (true)
+    def initialize(type, options = {})
+      options = {
+        base_directory: '',
+        directory: Dir.pwd,
+        file_name: '',
+        pattern: default(:pattern),
+        show_extension: default(:show_extension),
+        width: 400,
+        save_text: "Save",
+        open_text: "Open",
+        cancel_text: "Cancel",
+      }.merge! options
+
+      @type = type
+      raise ArgumentError, "type must be one of #{VALID_TYPES}, not #{@type}" unless VALID_TYPES.include? @type
+
+      @pattern = options[:pattern]
+      @show_extension = options[:show_extension]
+      @base_directory = options[:base_directory].chomp File::SEPARATOR
+
+      @directories = options[:directory].sub(/^#{@base_directory}/, '').split(File::SEPARATOR)
+      if @directories.first == ''
+        @directories[0] = File::SEPARATOR
+      end
+
+      super options
+
+      vertical do
+        @nav_buttons = horizontal padding: 0, spacing: 2
+
+        @scroll_window = scroll_window(height: 250, width: options[:width]) do
+          @files_list = list(width: options[:width]) do
+            subscribe :changed do |sender, file_path|
+              if file_path
+                file_name = File.basename file_path
+                if File.directory? file_path
+                  @directories.push file_name
+                  create_nav_buttons
+                  update_files_list
+                else
+                  @file_name_text.text = file_name
+                end
+              end
+            end
+          end
+        end
+
+        @file_name_text = text_area(text: options[:file_name], max_height: font.height * 1.5, width: options[:width], border_thickness: 1)
+
+        create_nav_buttons
+
+        horizontal align: :center, padding: 0 do
+          @action_button = button(options[:"#{type}_text"]) do
+            publish :selected, @type, file_path
+          end
+
+          button(options[:cancel_text]) do
+            publish :selected, :cancel, file_path
+          end
+        end
+
+        # Ensure that the open/save button is enabled only when the path is sensible.
+        @file_name_text.subscribe :changed do |sender, text|
+          @action_button.enabled = case @type
+          when :open
+            File.exists? file_path and not File.directory? file_path
+          when :save
+            not text.empty?
+          end
+        end
+
+        update_files_list
+      end
+    end
+
+    protected
+    def create_nav_buttons(size = @directories.size)
+      @nav_buttons.clear
+
+      @directories = @directories[0..size]
+
+      @directories.each_with_index do |dir, i|
+        if i < @directories.size - 1
+          @nav_buttons.button(dir) do
+            create_nav_buttons(i)
+          end
+        else
+          @nav_buttons.label dir, border_color: @@schema.default(Button, :border_color), border_thickness: @@schema.default(Button, :border_thickness)
+        end
+      end
+
+      update_files_list
+    end
+
+    protected
+    def update_files_list
+      @files_list.clear
+      @file_name_text.text = ''
+      @scroll_window.offset_x = @scroll_window.offset_y = 0
+
+      # Add folders.
+      Dir.glob(File.join(directory, "*")).each do |file_path|
+        if File.directory? file_path
+          @files_list.item File.basename(file_path), file_path, icon: Gosu::Image["file_directory.png"]
+        end
+      end
+
+      # Add files that match the pattern.
+      Dir.glob(File.join(directory, pattern)).each do |file_path|
+        unless File.directory? file_path
+          file_name = if @show_extension
+                        File.basename(file_path)
+                      else
+                        File.basename(file_path, File.extname(file_path))
+                      end
+
+          @files_list.item file_name, file_path, icon: Gosu::Image["file_file.png"]
+        end
+      end
+    end
+
+    protected
+    def post_init_block(&block)
+      subscribe :selected, &block
+    end
+  end
+end

data/lib/fidgit/elements/grid.rb

@@ -0,0 +1,227 @@
+# encoding: utf-8
+
+module Fidgit
+  # A vertically aligned element packing container.
+
+  class Grid < Packer
+    # @return [Symbol]
+    attr_reader :type
+
+    # @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(@rows.empty? ? 0 : @rows[0].size, 0)
+      @heights = Array.new(@rows.size, 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 ? element.min_width : element.outer_width, @widths[column_num]].max
+          filled_columns.push fills
+
+          fills = (element.align_v == :fill)
+          @heights[row_num] = [fills ? element.min_width : element.outer_height, @heights[row_num]].max
+          filled_rows.push fills
+        end
+      end
+
+      # Expand the size of each filled column to make the minimum size required.
+      unless @widths.empty?
+        num_filled_columns = filled_columns.select {|value| value }.count
+        total_width = @widths.inject(0, :+) + (padding_left + padding_right) + ((@num_columns - 1) * spacing_h)
+        extra_width = min_width - total_width
+        if extra_width > 0
+          if num_filled_columns > 0
+            @widths[filled_columns.index true] += extra_width
+          else
+            @widths[-1] += extra_width
+          end
+        end
+      end
+
+      # Expand the size of each filled row to make the minimum size required.
+      unless @heights.empty?
+        num_filled_rows = filled_rows.select {|value| value }.count
+        total_height = @heights.inject(0, :+) + (padding_left + padding_right) + ((@num_rows - 1) * spacing_v)
+        extra_height = min_height - total_height
+        if extra_height > 0
+          if num_filled_rows > 0
+            @heights[filled_rows.index true] += extra_height
+          else
+            @heights[-1] += extra_height
+          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? Grid
+              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? Grid
+              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,64 @@
+module Fidgit
+  class Group < Packer
+    attr_reader :selected
+
+    event :changed
+
+    def value; @selected ? @selected.value : nil; end
+
+    # @example
+    #   group do
+    #     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
+    #     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.rb

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