Implemented intelligent tab completion

git-svn-id: http://svn.dmdirc.com/trunk@1503 00569f92-eb28-0410-84fd-f71c24880f

src/com/dmdirc/commandparser/CommandManager.java

@@ -367,6 +367,25 @@ public final class CommandManager {
         queryParsers.add(parser);
     }
     
+    /**
+     * Retrieves the command identified by the specified signature, regardless
+     * of type.
+     * 
+     * @param signature The signature to look for
+     * @return A command with a matching signature, or null if none were found
+     */
+    public static Command getCommand(final String signature) {
+        if (getGlobalCommand(signature) != null) {
+            return (Command) getGlobalCommand(signature);
+        } else if (getServerCommand(signature) != null) {
+            return (Command) getServerCommand(signature);
+        } else if (getChannelCommand(signature) != null) {
+            return (Command) getChannelCommand(signature);
+        } else {
+            return (Command) getChannelCommand(signature);
+        }
+    }
+    
     /**
      * Retrieves the server command identified by the specified signature.
      * @param signature The signature to look for

src/com/dmdirc/commandparser/IntelligentCommand.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2006-2007 Chris Smith, Shane Mc Cormack, Gregory Holmes
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+package com.dmdirc.commandparser;
+
+import java.util.List;
+
+/**
+ * Intelligent commands implement a method that provides a list of possible
+ * options for them, for use (for example) by table completers.
+ * @author chris
+ */
+public interface IntelligentCommand {
+
+    /**
+     * Returns a list of suggestions for the specified argument, given the list
+     * of previous arguments.
+     * @param arg The argument that is being completed
+     * @param previousArgs The contents of the previous arguments, if any
+     * @return A list of suggestions for the argument
+     */
+    List<String> getSuggestions(int arg, List<String> previousArgs);
+    
+}

src/com/dmdirc/commandparser/commands/global/Set.java

@@ -26,12 +26,15 @@ import com.dmdirc.Config;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandWindow;
 import com.dmdirc.commandparser.GlobalCommand;
+import com.dmdirc.commandparser.IntelligentCommand;
+import java.util.ArrayList;
+import java.util.List;
 
 /**
  * The set command allows the user to inspect and change global config settings.
  * @author chris
  */
-public final class Set extends GlobalCommand {
+public final class Set extends GlobalCommand implements IntelligentCommand {
     
     /**
      * Creates a new instance of Set.
@@ -46,17 +49,17 @@ public final class Set extends GlobalCommand {
     public void execute(final CommandWindow origin, final boolean isSilent,
             final String... args) {
         switch (args.length) {
-            case 0:
-                doDomainList(origin, isSilent);
-                break;
-            case 1:
-                doOptionsList(origin, isSilent, args[0]);
-                break;
-            case 2:
-                doShowOption(origin, isSilent, args[0], args[1]);
-                break;
-            default:
-                doSetOption(origin, isSilent, args[0], args[1], implodeArgs(2, args));
+        case 0:
+            doDomainList(origin, isSilent);
+            break;
+        case 1:
+            doOptionsList(origin, isSilent, args[0]);
+            break;
+        case 2:
+            doShowOption(origin, isSilent, args[0], args[1]);
+            break;
+        default:
+            doSetOption(origin, isSilent, args[0], args[1], implodeArgs(2, args));
         }
     }
     
@@ -142,29 +145,42 @@ public final class Set extends GlobalCommand {
         sendLine(origin, isSilent, "commandOutput", domain + "." + option + " has been set to: " + newvalue);
     }
     
-    /** {@inheritDoc}. */
+    /** {@inheritDoc} */
     public String getName() {
         return "set";
     }
     
-    /** {@inheritDoc}. */
+    /** {@inheritDoc} */
     public boolean showInHelp() {
         return true;
     }
     
-    /** {@inheritDoc}. */
+    /** {@inheritDoc} */
     public boolean isPolyadic() {
         return true;
     }
     
-    /** {@inheritDoc}. */
+    /** {@inheritDoc} */
     public int getArity() {
         return 0;
     }
     
-    /** {@inheritDoc}. */
+    /** {@inheritDoc} */
     public String getHelp() {
         return "set [domain [option [newvalue]]] - inspect or change configuration settings";
     }
     
+    /** {@inheritDoc} */
+    public List<String> getSuggestions(int arg, List<String> previousArgs) {
+        final List<String> res = new ArrayList<String>();
+        
+        if (arg == 0) {
+            res.addAll(Config.getDomains());
+        } else if (arg == 1 && previousArgs.size() >= 1) {
+            res.addAll(Config.getOptions(previousArgs.get(0)));
+        }
+        
+        return res;
+    }
+    
 }

src/com/dmdirc/ui/input/InputHandler.java

@@ -23,8 +23,11 @@
 package com.dmdirc.ui.input;
 
 import com.dmdirc.Config;
+import com.dmdirc.commandparser.Command;
+import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandParser;
 import com.dmdirc.commandparser.CommandWindow;
+import com.dmdirc.commandparser.IntelligentCommand;
 import com.dmdirc.ui.components.ColourPickerDialog;
 import com.dmdirc.ui.messages.Styliser;
 
@@ -32,6 +35,8 @@ import java.awt.event.ActionEvent;
 import java.awt.event.ActionListener;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
+import java.util.ArrayList;
+import java.util.List;
 
 import javax.swing.JTextField;
 
@@ -177,46 +182,46 @@ public final class InputHandler implements KeyListener, ActionListener {
      */
     private void handleControlKey(final KeyEvent keyEvent) {
         switch (keyEvent.getKeyCode()) {
-            case KeyEvent.VK_B:
-                addControlCode(Styliser.CODE_BOLD, POSITION_END);
-                break;
-                
-            case KeyEvent.VK_U:
-                addControlCode(Styliser.CODE_UNDERLINE, POSITION_END);
-                break;
-                
-            case KeyEvent.VK_O:
-                addControlCode(Styliser.CODE_STOP, POSITION_END);
-                break;
-                
-            case KeyEvent.VK_I:
-                addControlCode(Styliser.CODE_ITALIC, POSITION_END);
-                break;
-                
-            case KeyEvent.VK_F:
-                if ((keyEvent.getModifiers() & KeyEvent.SHIFT_MASK) != 0) {
-                    addControlCode(Styliser.CODE_FIXED, POSITION_END);
-                }
-                break;
-                
-            case KeyEvent.VK_K:
-                if ((keyEvent.getModifiers() & KeyEvent.SHIFT_MASK) == 0) {
-                    addControlCode(Styliser.CODE_COLOUR, POSITION_START);
-                    showColourPicker(true, false);
-                } else {
-                    addControlCode(Styliser.CODE_HEXCOLOUR, POSITION_START);
-                    showColourPicker(false, true);
-                }
-                break;
-                
-            case KeyEvent.VK_ENTER:
-                commandParser.parseCommandCtrl(parentWindow, target.getText());
-                addToBuffer(target.getText());
-                break;
-                
-            default:
-                /* Do nothing. */
-                break;
+        case KeyEvent.VK_B:
+            addControlCode(Styliser.CODE_BOLD, POSITION_END);
+            break;
+            
+        case KeyEvent.VK_U:
+            addControlCode(Styliser.CODE_UNDERLINE, POSITION_END);
+            break;
+            
+        case KeyEvent.VK_O:
+            addControlCode(Styliser.CODE_STOP, POSITION_END);
+            break;
+            
+        case KeyEvent.VK_I:
+            addControlCode(Styliser.CODE_ITALIC, POSITION_END);
+            break;
+            
+        case KeyEvent.VK_F:
+            if ((keyEvent.getModifiers() & KeyEvent.SHIFT_MASK) != 0) {
+                addControlCode(Styliser.CODE_FIXED, POSITION_END);
+            }
+            break;
+            
+        case KeyEvent.VK_K:
+            if ((keyEvent.getModifiers() & KeyEvent.SHIFT_MASK) == 0) {
+                addControlCode(Styliser.CODE_COLOUR, POSITION_START);
+                showColourPicker(true, false);
+            } else {
+                addControlCode(Styliser.CODE_HEXCOLOUR, POSITION_START);
+                showColourPicker(false, true);
+            }
+            break;
+            
+        case KeyEvent.VK_ENTER:
+            commandParser.parseCommandCtrl(parentWindow, target.getText());
+            addToBuffer(target.getText());
+            break;
+            
+        default:
+            /* Do nothing. */
+            break;
         }
     }
     
@@ -277,17 +282,68 @@ public final class InputHandler implements KeyListener, ActionListener {
             return;
         }
         
+        if (start > 0 && text.charAt(0) == Config.getCommandChar().charAt(0)) {
+            doCommandTabCompletion(text, start, end);
+        } else {
+            doNormalTabCompletion(text, start, end, null);
+        }
+    }
+    
+    /**
+     * Handles potentially intelligent tab completion.
+     *
+     * @param text The text that is being completed
+     * @param start The start index of the word we're completing
+     * @param end The end index of the word we're completing
+     */
+    private void doCommandTabCompletion(final String text, final int start,
+            final int end) {
+        final String signature = text.substring(1, text.indexOf(' '));
+        final Command command = CommandManager.getCommand(signature);
+        
+        if (command instanceof IntelligentCommand) {
+            int args = 0;
+            int lastArg = signature.length() + 2;
+            final List<String> previousArgs = new ArrayList<String>();
+            
+            final String word = text.substring(start, end);
+            
+            for (int i = lastArg; i < start; i++) {
+                if (text.charAt(i) == ' ') {
+                    args++;
+                    previousArgs.add(text.substring(lastArg, i));
+                    lastArg = i + 1;
+                }
+            }
+            
+            final List<String> results = ((IntelligentCommand) command).getSuggestions(args, previousArgs);
+            
+            doNormalTabCompletion(text, start, end, results);
+        } else {
+            doNormalTabCompletion(text, start, end, null);
+        }
+    }
+    
+    /**
+     * Handles normal (non-intelligent-command) tab completion.
+     *
+     * @param text The text that is being completed
+     * @param start The start index of the word we're completing
+     * @param end The end index of the word we're completing
+     * @param additional A list of additional strings to use
+     */
+    private void doNormalTabCompletion(final String text, final int start,
+            final int end, final List<String> additional) {
         final String word = text.substring(start, end);
         
-        final TabCompleterResult res = tabCompleter.complete(word);
+        final TabCompleterResult res = tabCompleter.complete(word, additional);
         
         if (res.getResultCount() == 0) {
             // TODO: Beep, or something
         } else if (res.getResultCount() == 1) {
             // One result, just replace it
             final String result = res.getResults().get(0);
-            text = text.substring(0, start) + result + text.substring(end);
-            target.setText(text);
+            target.setText(text.substring(0, start) + result + text.substring(end));
             target.setCaretPosition(start + result.length());
         } else {
             // Multiple results
@@ -295,8 +351,7 @@ public final class InputHandler implements KeyListener, ActionListener {
             if (sub.equalsIgnoreCase(word)) {
                 // TODO: Beep, display possible answers, etc
             } else {
-                text = text.substring(0, start) + sub + text.substring(end);
-                target.setText(text);
+                target.setText(text.substring(0, start) + sub + text.substring(end));
                 target.setCaretPosition(start + sub.length());
             }
         }

src/com/dmdirc/ui/input/TabCompleter.java

@@ -60,13 +60,24 @@ public final class TabCompleter {
     
     /**
      * Attempts to complete the partial string.
+     * 
      * @param partial The string to tab complete
+     * @param additionals A list of additional strings to use
      * @return A TabCompleterResult containing any matches found
      */
-    public TabCompleterResult complete(final String partial) {
+    public TabCompleterResult complete(final String partial,
+            final List<String> additionals) {
 	final TabCompleterResult result = new TabCompleterResult();
+        
+        final List<String> targets = new ArrayList<String>();
+        
+        if (additionals != null) { 
+            targets.addAll(additionals);
+        }
+        
+        targets.addAll(entries);
 	
-	for (String entry : entries) {
+	for (String entry : targets) {
 	    if (Config.getOptionBool("tabcompletion", "casesensitive")) {
 		if (entry.startsWith(partial)) {
 		    result.addResult(entry);
@@ -80,7 +91,7 @@ public final class TabCompleter {
 	}
 	
 	if (parent != null) {
-	    result.merge(parent.complete(partial));
+	    result.merge(parent.complete(partial, null));
 	}
 	return result;
     }