redcar-dev 0.12.17dev

data/plugins/application/lib/application/commands/treebook_commands.rb

@@ -0,0 +1,117 @@
+module Redcar
+  class Application
+    
+    class CloseTreeCommand < TreeCommand
+      def execute
+        win = Redcar.app.focussed_window
+        if win and treebook = win.treebook
+          if tree = treebook.focussed_tree
+            treebook.remove_tree(tree)
+          end
+        end
+      end
+    end
+
+    class ToggleTreesCommand < TreeCommand
+      def execute
+        win = Redcar.app.focussed_window
+        if win and treebook = win.treebook
+          if win.trees_visible?
+            win.set_trees_visible(false)
+          else
+            win.set_trees_visible(true)
+          end
+        end
+      end
+    end
+
+    class SwitchTreeDownCommand < TreeCommand
+
+      def execute
+        win = Redcar.app.focussed_window
+        win.treebook.switch_down
+      end
+    end
+
+    class SwitchTreeUpCommand < TreeCommand
+
+      def execute
+        win = Redcar.app.focussed_window
+        win.treebook.switch_up
+      end
+    end
+    
+    class TreebookWidthCommand < Command
+      sensitize :open_trees
+
+      def increment
+        raise "Please implement me!"
+      end
+
+      def execute
+        if win = Redcar.app.focussed_window
+          if increment > 0
+            win.adjust_treebook_width(true)
+          else
+            win.adjust_treebook_width(false)
+          end
+        end
+      end
+    end
+    
+    class IncreaseTreebookWidthCommand < TreebookWidthCommand
+      def increment
+        1
+      end
+    end
+    
+    class DecreaseTreebookWidthCommand < TreebookWidthCommand
+      def decrement
+        -1
+      end
+    end
+
+    class OpenTreeFinderCommand < TreeCommand
+      def execute
+        if win = Redcar.app.focussed_window
+          if trees = win.treebook.trees and trees.any?
+            titles = []
+            trees.each {|t| titles << t.tree_mirror.title}
+            dialog = TreeFuzzyFilter.new(win,titles)
+            dialog.open
+          end
+        end
+      end
+
+      class TreeFuzzyFilter < FilterListDialog
+
+        def initialize(win,titles)
+          super()
+          @win = win
+          @titles = titles
+        end
+
+        def selected(text,ix)
+          if tree = @win.treebook.trees.detect do |tree|
+              tree.tree_mirror.title == text
+            end
+            if @win.treebook.focussed_tree == tree
+              @win.set_trees_visible(true) if not @win.trees_visible?
+            else
+              @win.treebook.focus_tree(tree)
+            end
+            tree.focus
+            close
+          end
+        end
+
+        def update_list(filter)
+          @titles.select do |t|
+            t.downcase.include?(filter.downcase)
+          end
+        end
+      end
+    end
+
+  end
+end

data/plugins/application/lib/application/commands/window_commands.rb

@@ -0,0 +1,68 @@
+module Redcar
+  class Application
+    class OpenNewWindowCommand < Command
+
+      def initialize(title=nil)
+        @title = title
+      end
+
+      def execute
+        window = Redcar.app.new_window
+        window.title = @title if @title
+      end
+    end
+
+    class FocusWindowCommand < Command
+      def initialize(window=nil)
+        @window = window
+      end
+
+      def execute
+        win.focus
+        @window = nil
+      end
+
+      def win
+        @window || super
+      end
+    end
+
+    class CloseWindowCommand < Command
+      def initialize(window=nil)
+        @window = window
+      end
+
+      def execute
+        Redcar.app.call_on_plugins(:close_window_guard, win) do |guard|
+          return unless guard
+        end
+        win.close
+        quit_if_no_windows if [:linux, :windows].include?(Redcar.platform)
+        @window = nil
+      end
+
+      private
+
+      def quit_if_no_windows
+        if Redcar.app.windows.length == 0
+          if Application.storage['stay_resident_after_last_window_closed'] && !(ARGV.include?("--multiple-instance"))
+            puts 'continuing to run to wait for incoming drb connections later'
+          else
+            QuitCommand.new.run
+          end
+        end
+      end
+
+      def win
+        @window || super
+      end
+    end
+
+    class ToggleFullscreen < Command
+      def execute
+        Redcar.app.focussed_window.fullscreen = !Redcar.app.focussed_window.fullscreen
+      end
+    end
+
+  end
+end

data/plugins/application/lib/application/dialog.rb

@@ -0,0 +1,170 @@
+module Redcar
+  class Application
+    class Dialog
+      # Is the application currently showing a modal dialog?
+      def self.in_dialog?
+        @in_dialog
+      end
+
+      # Do not call
+      def self.in_dialog
+        @in_dialog = true
+        r = yield
+        @in_dialog = false
+        r
+      end
+
+      # Prompt the user with an open file dialog. Returns a path.
+      def self.open_file(options)
+        in_dialog { Redcar.gui.dialog_adapter.open_file(options) }
+      end
+
+      # Prompt the user with an open directory dialog. Returns a path.
+      def self.open_directory(options)
+        in_dialog { Redcar.gui.dialog_adapter.open_directory(options) }
+      end
+
+      # Prompt the user with an save file dialog. Returns a path.
+      def self.save_file(options)
+        in_dialog { Redcar.gui.dialog_adapter.save_file(options) }
+      end
+
+      # Show a message to the user. Requires a message and
+      # options can be:
+      #
+      #  :type should be one of available_message_box_types
+      #  :buttons should be one of available_message_box_button_combos
+      #
+      # It will return a symbol representing the button the user clicked on:
+      #
+      # For example:
+      #
+      # >> Application::Dialog.message_box("YO!", :type => :info,
+      # >>                                        :buttons => :yes_no_cancel)
+      # => :yes
+      def self.message_box(text, options={})
+        if buttons = options[:buttons] and !available_message_box_button_combos.include?(buttons)
+          raise "option :buttons must be in #{available_message_box_button_combos.inspect}"
+        end
+        if type = options[:type] and !available_message_box_types.include?(type)
+          raise "option :type must be in #{available_message_box_button_types.inspect}"
+        end
+        in_dialog { Redcar.gui.dialog_adapter.message_box(text, options) }
+      end
+
+      # Returns the list of valid button combos that can be passed
+      # as an option to message_box.
+      def self.available_message_box_button_combos
+        in_dialog { Redcar.gui.dialog_adapter.available_message_box_button_combos }
+      end
+
+      # Returns the list of valid message box types that can be passed
+      # as an option to message_box
+      def self.available_message_box_types
+        in_dialog { Redcar.gui.dialog_adapter.available_message_box_types }
+      end
+
+      # Show a dialog containing a text entry box to the user, and blocks
+      # until they dismiss it.
+      #
+      # If a block is given, the block is considered an input validator. A return
+      # value of nil from the block means the value is valid, a return value
+      # of a String from the block means the value is invalid, and the returned
+      # String will be displayed as an error message.
+      #
+      # Example:
+      #
+      # Application::Dialog.input("Number", "Please enter a big number", "101") do |text|
+      #	  if text.to_i > 100
+      #	    nil
+      #	  else
+      #	    "must be bigger than 100"
+      #	  end
+      #	end
+      #
+      # The return value is a hash containing :button and :value.
+      def self.input(title, message, initial_value="", &validator)
+        in_dialog { Redcar.gui.dialog_adapter.input(title, message, initial_value, &validator) }
+      end
+
+      # Show a dialog containing a password entry box to the user, and blocks
+      # until they dismiss it.
+      #
+      # The return value is a hash containing :button and :value.
+      def self.password_input(title, message)
+        in_dialog { Redcar.gui.dialog_adapter.password_input(title, message) }
+      end
+
+      # Shows a tool tip to the user, at the cursor location.
+      #
+      # Allowed locations:
+      #  * :cursor - the location of the text cursor in the focussed text widget
+      #  * :below_cursor - on the line directly below :cursor
+      #  * :pointer - the location of the mouse pointer
+      #  * character offset - a position in the text
+      #
+      # If :cursor is specified with no open tab, it will default to :pointer.
+      #
+      # @param [String] message
+      # @param [Symbol] location
+      def self.tool_tip(message, location)
+        Redcar.gui.dialog_adapter.tool_tip(message, location)
+      end
+
+      # Shows a popup menu to the user.
+      #
+      # Allowed locations:
+      #  * :cursor - the location of the text cursor in the focussed text widget
+      #  * :below_cursor - on the line directly below :cursor
+      #  * :pointer - the location of the mouse pointer
+      #  * character offset - a position in the text
+      #
+      # If :cursor is specified with no open tab, it will default to :pointer.
+      #
+      # @param [Redcar::Menu] menu
+      # @param [Symbol] location
+      def self.popup_menu(menu, location)
+        Redcar.gui.dialog_adapter.popup_menu(menu, location)
+      end
+
+      # Shows a non-modal popup text box to the user which closes
+      # on keyboard input or lost focus
+      #
+      # Allowed locations:
+      #  * :cursor - the location of the text cursor in the focussed text widget
+      #  * :below_cursor - on the line directly below :cursor
+      #  * :pointer - the location of the mouse pointer
+      #  * character offset - a position in the text
+      #
+      # If :cursor is specified with no open tab, it will default to :pointer.
+      #
+      # @param [String] title
+      # @param [String] message
+      # @param [Symbol] location
+      # @param [Array<Integer>] dimensions - The width and height of the text box
+      # the width is measured in pixels and the height in rows
+      def self.popup_text(title, message, location,dimensions=nil)
+        Redcar.gui.dialog_adapter.popup_text(title,message,location,dimensions)
+      end
+
+      # Shows a non-modal popup html text box to the user which closes
+      # on keyboard input
+      #
+      # Allowed locations:
+      #  * :cursor - the location of the text cursor in the focussed text widget
+      #  * :below_cursor - on the line directly below :cursor
+      #  * :pointer - the location of the mouse pointer
+      #  * character offset - a position in the text
+      #
+      # If :cursor is specified with no open tab, it will default to :pointer.
+      #
+      # @param [String] text
+      # @param [Symbol] location
+      # @param [Array<Integer>] dimensions - The width and height of the text box
+      # in pixels
+      def self.popup_html(text, location, dimensions=nil)
+        Redcar.gui.dialog_adapter.popup_html(text,location,dimensions)
+      end
+    end
+  end
+end

data/plugins/application/lib/application/dialogs/filter_list_dialog.rb

@@ -0,0 +1,123 @@
+module Redcar
+  # A type of dialog containing a textbox and a list, where the list can be updated
+  # based on the contents of the textbox. For example, the Find File dialog box in
+  # the Project plugin.
+  #
+  # Subclasses should implement the 'update_list' method and the 'selected' method.
+  class FilterListDialog
+    include Redcar::Model
+    include Redcar::Observable
+  
+    def initialize
+      self.controller = Redcar.gui.controller_for(self).new(self)
+    end
+    
+    def open
+      notify_listeners(:open)
+    end
+    
+    def close
+      notify_listeners(:close)
+    end
+    
+    # Called by the controller when the user changes the filter.
+    #
+    # @param [String] the filter entered by the user
+    # @return [Array<String>] the new list to display
+    def update_list(filter)
+      if filter == ""
+        %w(foo bar baz qux quux corge)
+      else
+        a = []
+        5.times {|i| a << filter + " " + i.to_s }
+        a
+      end
+    end
+    
+    # Called by the controller when the user selects a row in the list.
+    #
+    # @param [String] the list row text selected by the user
+    # @param [Integer] the index of the row in the list selected by the user
+    def selected(text, ix)
+      puts "Hooray! You selected #{text} at index #{ix}"
+    end
+    
+    # Called by the controller when the user moves through the list.
+    #
+    # @param [String] the list row text that is now highlighted
+    # @param [Integer] the index of the row that is now highlighted
+    def moved_to(text, ix)
+      # Override with the code you wish you had
+    end
+
+    # Helper method for fuzzily filtering a list
+    #
+    # @param [Array<A>]     list        the list to filter
+    # @param [String]       query       the fuzzy string to match on
+    # @param [Integer]      max_length  the length of the resulting list (default 20)
+    # @block A -> String    optionally turns an element from the list into a string to match on
+    def filter_and_rank_by(list, query, max_length=20)
+      re = make_regex(query)
+      ranked_list = []
+      cutoff = 100000000
+      results = list.each do |element|
+        begin
+          match_data = (block_given? ? yield(element) : element).match(re)
+          if match_data
+            captures = []
+            match_data.captures.each_with_index do |_, i|
+              i += 1 # Match group 0 is actually the complete regex, we are interested in the subgroups
+              previous_capture = captures.last
+              if previous_capture and match_data.begin(i) - previous_capture[:end] <= 1
+                # If the the current match starts where the previous match ended, or they even overlap, merge the matches
+                captures.last[:end] = match_data.end(i)
+              else
+                # Record the match
+                captures << {:begin => match_data.begin(i), :end => match_data.end(i)}
+              end
+            end
+            if captures.first[:begin] < cutoff
+              # The penalty is calculated as such: The values of the beginnings of matches are penalty, the lengths are bonuses
+              # This way, matching early and continiously is rewarded. Matching late in a word or only at intervals is punished.
+              penalty = captures.inject(0) {|p,c| p + c[:begin] - (c[:end] - c[:begin]) }
+              ranked_list << {:penalty => penalty, :first_match => captures.first[:begin], :element => element}
+              ranked_list = ranked_list.sort_by {|a| a[:penalty] }
+
+              # Performance optimization: Once we reach the maximum length, remove elements (saves later sorting)
+              # Set the new cutoff to the beginning of the previously last element, to avoid later elements getting
+              # into the list which would have an even worse rank.
+              if ranked_list.length > max_length
+                cutoff = ranked_list.last[:first_match]
+                ranked_list.pop
+              end
+            end
+          end
+        rescue Errno::ENOENT
+          # File.directory? can throw no such file or directory even if File.exist?
+          # has returned true. For example this happens on some awful textmate filenames
+          # unicode in them.
+        end
+      end
+      ranked_list.map {|a| a[:element] }
+    end
+    
+    # The time interval in seconds in which moved_to events are ignored
+    # Override to select different interval
+    def step_time
+      1
+    end
+
+    def step?
+      @last_step ||= Time.now - step_time
+      @last_step + step_time <= Time.now
+    end
+
+    private
+    
+    def make_regex(text)
+      re_src = "(" + text.split(//).map{|l| Regexp.escape(l) }.join(").*?(") + ")"
+      Regexp.new(re_src, :options => Regexp::IGNORECASE)
+    end
+  end
+end
+