redcar-dev 0.12.17dev

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

@@ -0,0 +1,85 @@
+
+module Redcar
+  # A type of dialog for displaying a list inside a tab. Example uses include
+  # selection dialogs for code completion or dynamically opening files based on
+  # tab content.
+  # Modeless List dialogs can also add sub-lists, by implementing the 'previous_list'
+  # and/or 'next_list' methods, which are called when a ARROW_LEFT or ARROW_RIGHT
+  # key event is generated.
+  #
+  # Subclasses should implement the 'selected' method,
+  # and optionally 'previous_list' and 'next_list' if applicable.
+  class ModelessListDialog
+    include Redcar::Model
+    include Redcar::Observable
+
+    def initialize(close_on_lost_focus=true)
+      @close_on_lost_focus = close_on_lost_focus
+      self.controller = Redcar.gui.controller_for(self).new(self)
+    end
+
+    # Set the size of the list dialog. The width is measured in pixels
+    # and the height in rows of text
+    def set_size(width,height)
+      notify_listeners(:set_size, width,height)
+    end
+    # Set the location of the list dialog relative to an offset in a tab
+    def set_location(offset)
+      notify_listeners(:set_location,offset)
+    end
+
+    def open
+      notify_listeners(:open)
+    end
+
+    def close
+      notify_listeners(:close)
+    end
+
+    # Whether to close the list dialog when focus is lost
+    def close_on_lost_focus
+      @close_on_lost_focus
+    end
+
+    # Get a 'previous' list, where applicable, based on the
+    # currently selected item in the list
+    #
+    # @return [Array<String>] list items
+    def previous_list
+    end
+
+    # Get a 'next' list, where applicable, based on the
+    # currently selected item in the list
+    #
+    # @return [Array<String>] list items
+    def next_list
+    end
+
+    # Update the items in the dialog list
+    #
+    # @param [Array<String>] items
+    def update_list(items)
+      notify_listeners :update_list, items
+    end
+
+    # Do an action, based on the index of the selected item
+    def selected(index)
+      p "'#{select(index)}' (at index #{index}) was selected!"
+      close
+    end
+
+    # Get the text of an item at an index
+    #
+    # @return [String]
+    def select(index)
+      self.controller.select index
+    end
+
+    # The index of the currently selected text
+    #
+    # @return [Integer]
+    def selection_index
+      self.controller.selection_index
+    end
+  end
+end

data/plugins/application/lib/application/event_spewer.rb

@@ -0,0 +1,32 @@
+
+module Redcar
+  class Application
+    class EventSpewer
+      attr_accessor :within
+      
+      def initialize
+        @within = {}
+      end
+      
+      def ignore?(name, *args)
+        !!@within[[name, args]]
+      end
+      
+      def ignore(name, *args)
+        @within[[name, args]] = true
+        begin
+          yield
+        ensure
+          @within.delete([name, args])
+        end
+      end
+      
+      def create(name, *args)
+        Redcar.plugin_manager.objects_implementing(:application_event_handler).each do |object|
+          handler = object.application_event_handler
+          handler.send(name, *args) if handler.respond_to?(name)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/keymap.rb

@@ -0,0 +1,41 @@
+
+module Redcar
+  class Keymap
+    def self.build(name, platform, &block)
+      Builder.new(name, platform, &block).keymap
+    end
+
+    attr_reader :name, :platforms
+    attr_accessor :map
+
+    def initialize(name, platforms)
+      @name, @platforms = name, [*platforms]
+      @map = {}
+    end
+
+    def link(key_string, command)
+      @map[key_string] = command
+    end
+
+    def command(key_string)
+      @map[key_string]
+    end
+
+    def command_to_key(command)
+      @map.invert[command]
+    end
+
+    def length
+      @map.length
+    end
+
+    def merge(other)
+      keymap = Keymap.new(@name, @platforms)
+      (@map.keys & other.map.keys).each do |key|
+        puts "conflicting keybinding #{key}: #{@map[key].inspect} is being overwritten by #{other.map[key].inspect}"
+      end
+      keymap.map = @map.merge(other.map)
+      keymap
+    end
+  end
+end

data/plugins/application/lib/application/keymap/builder.rb

@@ -0,0 +1,23 @@
+
+module Redcar
+  class Keymap
+    class Builder
+      attr_reader :keymap
+
+      def initialize(name, platforms, &block)
+        @keymap = Keymap.new(name, platforms)
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+      
+      private
+      
+      def link(key, command)
+        @keymap.link(key, command)
+      end
+    end
+  end
+end

data/plugins/application/lib/application/menu.rb

@@ -0,0 +1,117 @@
+
+module Redcar
+  class Menu
+    include Enumerable
+    include Redcar::Model
+
+    # Default priority for all menu's and items if they aren't explicitly provided
+    DEFAULT_PRIORITY = 50
+
+    # Default mnemonic values for primary menus
+    MNEMONICS = {
+      "File"    => "&File",
+      "Edit"    => "&Edit",
+      "Project" => "&Project",
+      "Debug"   => "&Debug",
+      "View"    => "&View",
+      "Plugins" => "P&lugins",
+      "Bundles" => "&Bundles",
+      "Help"    => "&Help"
+    }
+
+    attr_reader :text, :entries, :priority
+
+    # A Menu will initially have nothing in it.
+    def initialize(text=nil, options={})
+      @text, @entries, @priority = Menu.parse(text), [], options[:priority]
+    end
+
+    # Iterate over each entry, sorted by priority
+    def each
+      sorted = {:first => [], :last => []}
+      entries.each {|e| (sorted[e.priority || Menu::DEFAULT_PRIORITY] ||= []) << e}
+
+      # Get the nasty Symbols out of the hash so we can sort it
+      first = sorted.delete(:first)
+      last = sorted.delete(:last)
+
+      # Yield up the results
+      first.each {|val| yield val }
+      sorted.keys.sort.each {|i| sorted[i].each {|val| yield val }}
+      last.each {|val| yield val }
+    end
+
+    # Add a Redcar::MenuItem or a Redcar::Menu
+    def <<(entry)
+      entries << entry
+      self
+    end
+
+    # Number of entries in the menu
+    def length
+      entries.length
+    end
+
+    # Fetch the sub_menu with the given name
+    #
+    # @param [String]
+    # @return [Menu]
+    def sub_menu(text)
+      detect {|e| e.text == text and e.is_a?(Menu) }
+    end
+
+    def entry(text)
+      detect {|e| e.text == text }
+    end
+
+    # Append items and sub_menus using the same syntax as Menu::Builder
+    def build(&block)
+      Menu::Builder.new(self, &block)
+    end
+
+    def ==(other)
+      return false unless length == other.length
+      return false unless text == other.text
+      entries.zip(other.entries) do |here, there|
+        return false unless here.class == there.class and here == there
+      end
+      true
+    end
+
+    def is_unique?
+      false
+    end
+
+    def lazy_text?
+      false
+    end
+
+    # Merge two Menu trees together. Modifies this Menu.
+    #
+    # @param [Menu] another Menu
+    def merge(other)
+      @priority = @priority || other.priority
+      other.entries.each do |other_entry|
+        if here = entry(other_entry.text) and not other_entry.is_unique?
+          if here.class == other_entry.class
+            here.merge(other_entry)
+          else
+            entries[entries.index(here)] = other_entry
+          end
+        else
+          self << other_entry
+        end
+      end
+    end
+
+    # Get menu text from a string, adding mnemonics where applicable
+    def self.parse(menu_text)
+      menu_text = "" unless menu_text
+      if Redcar.platform != :osx and mnemonic = MNEMONICS[menu_text]
+        mnemonic
+      else
+        menu_text
+      end
+    end
+  end
+end

data/plugins/application/lib/application/menu/builder.rb

@@ -0,0 +1,80 @@
+
+module Redcar
+  class Menu
+    # A DSL for building menus simply. An example of usage
+    #
+    #     builder = Menu::Builder.new "Edit" do
+    #       item "Select All", SelectAllCommand
+    #       sub_menu "Indent" do
+    #         item "Increase", IncreaseIndentCommand
+    #         item("Decrease") { puts "decrease selected" }
+    #       end
+    #     end
+    #
+    # This is equivalent to:
+    # 
+    #     menu = Redcar::Menu.new("Edit")
+    #     menu << Redcar::Menu::Item.new("Select All", SelectAllCommand)
+    #     indent_menu = Redcar::Menu.new("Indent") 
+    #     indent_menu << Redcar::Menu::Item.new("Increase", IncreaseIndentCommand)
+    #     indent_menu << Redcar::Menu::Item.new("Decrease") do
+    #       puts "decrease selected"
+    #     end
+    #     menu << indent_menu
+    class Builder
+      attr_reader :menu
+      
+      def self.build(name=nil, &block)
+        new(name, &block).menu
+      end
+      
+      def initialize(menu_or_text=nil, &block)
+        case menu_or_text
+        when String, nil
+          @menu = Redcar::Menu.new(menu_or_text||"")
+        when Menu
+          @menu = menu_or_text
+        end
+        @current_menu = @menu
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+      end
+      
+      def item(text, options={}, &block)
+        @current_menu << Item.new(text, options, &block)
+      end
+      
+      def separator(options={})
+        @current_menu << Item::Separator.new(options)
+      end
+      
+      def sub_menu(text, options={}, &block)
+        new_menu = Menu.new(text, options)
+        @current_menu << new_menu
+        old_menu, @current_menu = @current_menu, new_menu
+        if block.arity == 1
+          block.call(self)
+        else
+          instance_eval(&block)
+        end
+        @current_menu = old_menu
+      end
+      
+      def lazy_sub_menu(text, options={}, &block)
+        new_menu = LazyMenu.new(block, text, options)
+        @current_menu << new_menu
+      end
+      
+      def group(options={}, &block)
+        Builder::Group.new(self, options, &block)
+      end
+      
+      def append(item)
+        @current_menu << item
+      end
+    end
+  end
+end

data/plugins/application/lib/application/menu/builder/group.rb

@@ -0,0 +1,47 @@
+
+module Redcar
+  class Menu
+    class Builder
+      # An extension to the Builder to allow groups of menu object to inherit options.
+      #
+      # This is supported for all options, even options that don't exist yet!
+      #
+      # Currently, this is only useful in a practical sense to apply a :priority to a 
+      # set of objects
+      class Group
+        
+        def initialize(builder, options={}, &block)
+          @builder = builder
+          @defaults = options
+          
+          if block.arity == 1
+            block.call(self)
+          else
+            instance_eval(&block)
+          end
+        end
+        
+        def item(text, options={}, &block)
+          options = {:command => options} if not options.respond_to?('[]')
+          @builder.item(text, @defaults.merge(options), &block)
+        end
+        
+        def separator(options={})
+          @builder.separator(@defaults.merge(options))
+        end
+        
+        def sub_menu(text, options={}, &block)
+          @builder.sub_menu(text, @defaults.merge(options), &block)
+        end
+        
+        def lazy_sub_menu(text, options={}, &block)
+          @builder.lazy_sub_menu(text, @defaults.merge(options), &block)
+        end
+
+        def append(item)
+          @builder.append(item)
+        end
+      end
+    end
+  end
+end

data/plugins/application/lib/application/menu/item.rb

@@ -0,0 +1,79 @@
+
+module Redcar
+  class Menu
+    class Item
+      class Separator < Item
+        def initialize(options={})
+          super(nil, options)
+        end
+        
+        def is_unique?
+          true
+        end
+      end
+      
+      attr_reader :command, :priority, :value, :type, :active
+  
+      # Create a new Item, with the given text to display in the menu, and
+      # either:
+      #   the Redcar::Command that is run when the item is selected.
+      #   or a block to run when the item is selected
+      def initialize(text, options={}, &block)
+        @text = text
+        
+        if options.respond_to?('[]')
+          @command = options[:command] || block
+          @priority = options[:priority]
+          @value = options[:value]
+          @type = options[:type]
+          @active = options[:active] ? true : false
+        # This branch is for compatibility with old code. Please use :command 
+        # option in new code
+        # FIXME: Should this be removed at some point?
+        else
+          @command = options || block
+        end
+        
+        @priority ||= Menu::DEFAULT_PRIORITY
+      end
+      
+      # Call this to signal that the menu item has been selected by the user.
+      def selected(with_key=false)
+        if @value
+          @command.new.run(:value => @value)
+        else  
+          @command.new.run#(:with_key => with_key)
+        end
+      end
+      
+      def type
+        @type
+      end
+      
+      def type
+        @type
+      end
+      
+      def text
+        @text.is_a?(Proc) ? @text.call : @text
+      end
+      
+      def lazy_text?
+        @text.is_a?(Proc)
+      end
+      
+      def merge(other)
+        @command = other.command
+        @priority = other.priority
+      end
+      
+      def ==(other)
+        text == other.text and command == other.command
+      end
+      
+      def is_unique?
+        false
+      end
+    end
+  end
+end