Remove windows from commands

Change-Id: I5b6e7e2ca81d114028fef6cac0d88498def62ea0
Depends-On: I895be099fa526e4e4b566e7178120b5d1ad0912c
Reviewed-on: http://gerrit.dmdirc.com/2011
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Chris Smith <chris@dmdirc.com>

src/com/dmdirc/actions/ActionModel.java

 import com.dmdirc.actions.interfaces.ActionType;
 import com.dmdirc.commandparser.parsers.CommandParser;
 import com.dmdirc.commandparser.parsers.GlobalCommandParser;
-import com.dmdirc.ui.interfaces.Window;
 
 import java.util.ArrayList;
 import java.util.Arrays;
             return false;
         }
 
-        Window window = null;
         WritableFrameContainer container = null;
         CommandParser cp = null;
 
             container = ServerManager.getServerManager().getServers().get(0);
         }
 
-        if (arguments.length > 0 && arguments[0] instanceof Window) {
-            window = (Window) arguments[0];
-        }
-
         if (container == null) {
             cp = GlobalCommandParser.getGlobalCommandParser();
         } else {
         }
 
         for (String command : response) {
-            cp.parseCommand(container, window, sub.doSubstitution(command, arguments));
+            cp.parseCommand(container, sub.doSubstitution(command, arguments));
         }
 
         if (newFormat != null && format != null) {

src/com/dmdirc/commandparser/CommandManager.java

 
         // Channel commands
         registerCommand(new Ban(), Ban.INFO);
-        registerCommand(new ChannelSettings(), ChannelSettings.INFO);
         registerCommand(new Cycle(), Cycle.INFO);
         registerCommand(new Invite(), Invite.INFO);
         registerCommand(new KickReason(), KickReason.INFO);
         registerCommand(new OpenQuery(), OpenQuery.INFO);
         registerCommand(new Raw(), Raw.INFO);
         registerCommand(new Reconnect(), Reconnect.INFO);
-        registerCommand(new ServerSettings(), ServerSettings.INFO);
         registerCommand(new Umode(), Umode.INFO);
 
         registerCommand(new RawServerCommand("lusers"));

src/com/dmdirc/commandparser/commands/IntelligentCommand.java

 
 package com.dmdirc.commandparser.commands;
 
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.ui.input.AdditionalTabTargets;
-import com.dmdirc.ui.interfaces.InputWindow;
 
 import java.util.List;
 
     class IntelligentCommandContext {
 
         /** The window the command is being entered in. */
-        private final InputWindow window;
+        private final WritableFrameContainer window;
 
         /** The previously supplied arguments, if any. */
         private final List<String> previousArgs;
          * @param previousArgs The previously supplied arguments, if any
          * @param partial The partially-typed word being completed
          */
-        public IntelligentCommandContext(final InputWindow window,
+        public IntelligentCommandContext(final WritableFrameContainer window,
                 final List<String> previousArgs, final String partial) {
             this.window = window;
             this.previousArgs = previousArgs;
          *
          * @return The command's input window
          */
-        public InputWindow getWindow() {
+        public WritableFrameContainer getWindow() {
             return window;
         }
 

src/com/dmdirc/commandparser/commands/ValidatingCommand.java

  */
 package com.dmdirc.commandparser.commands;
 
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.ui.interfaces.InputWindow;
 import com.dmdirc.util.validators.ValidationResponse;
 
 /**
      * @return A validation response indicating the validity of the arguments
      * @since 0.6.3m1
      */
-    ValidationResponse validateArguments(InputWindow origin, CommandArguments arguments);
+    ValidationResponse validateArguments(WritableFrameContainer origin,
+            CommandArguments arguments);
 
 }

src/com/dmdirc/commandparser/commands/WrappableCommand.java

 
 package com.dmdirc.commandparser.commands;
 
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.ui.interfaces.InputWindow;
 
 /**
  * Wrapping commands are commands whose arguments may be wrapped into multiple
      * @return The number of lines that the arguments will result in
      * @since 0.6.3m1
      */
-    int getLineCount(InputWindow origin, CommandArguments arguments);
+    int getLineCount(WritableFrameContainer origin, CommandArguments arguments);
 
 }

src/com/dmdirc/commandparser/commands/channel/ChannelSettings.java

-/*
- * Copyright (c) 2006-2011 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.commands.channel;
-
-import com.dmdirc.FrameContainer;
-import com.dmdirc.commandparser.BaseCommandInfo;
-import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.commandparser.CommandType;
-import com.dmdirc.commandparser.commands.Command;
-import com.dmdirc.commandparser.commands.CommandOptions;
-import com.dmdirc.commandparser.commands.IntelligentCommand;
-import com.dmdirc.commandparser.commands.context.ChannelCommandContext;
-import com.dmdirc.commandparser.commands.context.CommandContext;
-import com.dmdirc.ui.input.AdditionalTabTargets;
-
-/**
- * Opens the channel settings window for the channel.
- */
-@CommandOptions(allowOffline = false)
-public class ChannelSettings extends Command implements
-        IntelligentCommand {
-
-    /** A command info object for this command. */
-    public static final CommandInfo INFO = new BaseCommandInfo("channelsettings",
-            "channelsettings - opens the channel settings window",
-            CommandType.TYPE_CHANNEL);
-
-    /** {@inheritDoc} */
-    @Override
-    public void execute(final FrameContainer origin,
-            final CommandArguments args, final CommandContext context) {
-        context.getSource().getController().showChannelSettingsDialog(
-                ((ChannelCommandContext) context).getChannel());
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public AdditionalTabTargets getSuggestions(final int arg,
-            final IntelligentCommandContext context) {
-        return new AdditionalTabTargets().excludeAll();
-    }
-}

src/com/dmdirc/commandparser/commands/chat/Me.java

 import com.dmdirc.FrameContainer;
 import com.dmdirc.MessageTarget;
 import com.dmdirc.commandparser.BaseCommandInfo;
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.ValidatingCommand;
 import com.dmdirc.commandparser.commands.context.ChatCommandContext;
 import com.dmdirc.commandparser.commands.context.CommandContext;
-import com.dmdirc.ui.interfaces.InputWindow;
 import com.dmdirc.util.validators.ValidationResponse;
 
 /**
 
     /** {@inheritDoc} */
     @Override
-    public ValidationResponse validateArguments(final InputWindow origin,
+    public ValidationResponse validateArguments(
+            final WritableFrameContainer origin,
             final CommandArguments arguments) {
-        if (origin.getContainer().getServer() == null
-                || origin.getContainer().getServer().getParser() == null) {
+        if (origin.getServer() == null
+                || origin.getServer().getParser() == null) {
             return new ValidationResponse();
         }
 
         final int length = 2 + arguments.getArgumentsAsString().length();
 
-        if (origin.getContainer().getServer().getParser().getMaxLength("PRIVMSG",
-                origin.getContainer().getName()) <= length) {
+        if (origin.getServer().getParser().getMaxLength("PRIVMSG",
+                origin.getName()) <= length) {
             return new ValidationResponse("Too long");
         } else {
             return new ValidationResponse();

src/com/dmdirc/commandparser/commands/context/ChannelCommandContext.java

 package com.dmdirc.commandparser.commands.context;
 
 import com.dmdirc.Channel;
+import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A specialised {@link CommandContext} for commands executed in channels.
      * with the input
      * @param channel The channel associated with the command
      */
-    public ChannelCommandContext(final Window source,
+    public ChannelCommandContext(final FrameContainer source,
             final CommandInfo commandInfo, final Channel channel) {
         super(source, commandInfo, channel);
         this.channel = channel;

src/com/dmdirc/commandparser/commands/context/ChatCommandContext.java

 
 package com.dmdirc.commandparser.commands.context;
 
+import com.dmdirc.FrameContainer;
 import com.dmdirc.MessageTarget;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command context specific to chat windows.
      * @param commandInfo The command info object which associated the command with the input
      * @param chat The chat container associated with the command
      */
-    public ChatCommandContext(final Window source, final CommandInfo commandInfo,
-            final MessageTarget chat) {
+    public ChatCommandContext(final FrameContainer source,
+            final CommandInfo commandInfo, final MessageTarget chat) {
         super(source, commandInfo, chat.getServer());
         this.chat = chat;
     }

src/com/dmdirc/commandparser/commands/context/CommandContext.java

 
 package com.dmdirc.commandparser.commands.context;
 
+import com.dmdirc.FrameContainer;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * Provides information relating to the context that a command was executed in.
     protected final CommandInfo commandInfo;
 
     /** The source of this command. */
-    protected final Window source;
+    protected final FrameContainer source;
 
     /**
      * Creates a new command context.
      * @param source The source of the command
      * @param commandInfo The command info object which associated the command with the input
      */
-    public CommandContext(final Window source, final CommandInfo commandInfo) {
+    public CommandContext(final FrameContainer source, final CommandInfo commandInfo) {
         this.source = source;
         this.commandInfo = commandInfo;
     }
      *
      * @return The window the command came from, or null
      */
-    public Window getSource() {
+    public FrameContainer getSource() {
         return source;
     }
 

src/com/dmdirc/commandparser/commands/context/QueryCommandContext.java

 
 package com.dmdirc.commandparser.commands.context;
 
+import com.dmdirc.FrameContainer;
 import com.dmdirc.Query;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A query-specific command context.
      * Creates a new query command context.
      *
      * @param source The source of the command
-     * @param commandInfo The command info object which associated the command with the input
+     * @param commandInfo The command info object which associated the command
+     * with the input
      * @param query The query associated with the command
      */
-    public QueryCommandContext(final Window source, final CommandInfo commandInfo, final Query query) {
+    public QueryCommandContext(final FrameContainer source,
+            final CommandInfo commandInfo, final Query query) {
         super(source, commandInfo, query);
         this.query = query;
     }

src/com/dmdirc/commandparser/commands/context/ServerCommandContext.java

 
 package com.dmdirc.commandparser.commands.context;
 
+import com.dmdirc.FrameContainer;
 import com.dmdirc.Server;
 import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command context for server commands.
      * @param commandInfo The command info object which associated the command with the input
      * @param server The server associated with the command
      */
-    public ServerCommandContext(final Window source, final CommandInfo commandInfo,
+    public ServerCommandContext(final FrameContainer source, final CommandInfo commandInfo,
             final Server server) {
         super(source, commandInfo);
         this.server = server;

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

         final String command = args.getArgumentsAsString();
 
         for (Server target : ServerManager.getServerManager().getServers()) {
-            target.getCommandParser().parseCommand(target, context.getSource(), command);
+            target.getCommandParser().parseCommand(target, command);
         }
     }
 

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

                 && context.getPreviousArgs().get(0).equals("--ts"))) {
 
             final List<FrameContainer> windowList = new ArrayList<FrameContainer>();
-            final Server currentServer = context.getWindow().getContainer()
-                    .getServer();
+            final Server currentServer = context.getWindow().getServer();
 
             //Active window's Children
-            windowList.addAll(context.getWindow().getContainer().getChildren());
+            windowList.addAll(context.getWindow().getChildren());
 
             //Children of Current Window's server
             if (currentServer != null) {

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

         if (result != negative) {
             if (origin == null) {
                 GlobalCommandParser.getGlobalCommandParser().parseCommand(null,
-                        context.getSource(), args.getArgumentsAsString(1));
+                        args.getArgumentsAsString(1));
             } else {
                 ((WritableFrameContainer) origin).getCommandParser()
-                        .parseCommand(origin, context.getSource(), args.getArgumentsAsString(1));
+                        .parseCommand(origin, args.getArgumentsAsString(1));
             }
         }
     }

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

         final AdditionalTabTargets res = new AdditionalTabTargets();
 
         if (arg == 0) {
-            res.addAll(context.getWindow().getContainer().getConfigManager()
+            res.addAll(context.getWindow().getConfigManager()
                     .getDomains());
             res.add("--unset");
             res.add("--append");
                     || previousArgs.get(0).equalsIgnoreCase("--append")
                     || previousArgs.get(0).equalsIgnoreCase("--server")
                     || previousArgs.get(0).equalsIgnoreCase("--channel")) {
-                res.addAll(context.getWindow().getContainer().getConfigManager()
+                res.addAll(context.getWindow().getConfigManager()
                         .getDomains());
             } else {
-                res.addAll(context.getWindow().getContainer().getConfigManager()
+                res.addAll(context.getWindow().getConfigManager()
                         .getOptions(previousArgs.get(0)).keySet());
             }
             res.excludeAll();
                 || previousArgs.get(0).equalsIgnoreCase("--append")
                 || previousArgs.get(0).equalsIgnoreCase("--server")
                 || previousArgs.get(0).equalsIgnoreCase("--channel"))) {
-            res.addAll(context.getWindow().getContainer().getConfigManager()
+            res.addAll(context.getWindow().getConfigManager()
                     .getOptions(previousArgs.get(1)).keySet());
             res.excludeAll();
         }

src/com/dmdirc/commandparser/commands/server/AllChannels.java

 
         for (String channel : server.getChannels()) {
             server.getChannel(channel).getCommandParser()
-                    .parseCommand(server.getChannel(channel), context.getSource(), command);
+                    .parseCommand(server.getChannel(channel), command);
         }
     }
 

src/com/dmdirc/commandparser/commands/server/JoinChannelCommand.java

     @Override
     public AdditionalTabTargets getSuggestions(final int arg,
             final IntelligentCommandContext context) {
-        final FrameContainer source = context.getWindow().getContainer();
+        final FrameContainer source = context.getWindow();
         final Server server = source.getServer();
         final List<String> results = checkSource(source, true, true);
 

src/com/dmdirc/commandparser/commands/server/Message.java

 import com.dmdirc.FrameContainer;
 import com.dmdirc.Server;
 import com.dmdirc.commandparser.BaseCommandInfo;
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.parser.interfaces.Parser;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.ui.input.TabCompletionType;
-import com.dmdirc.ui.interfaces.InputWindow;
 
 /**
  * Allows the user to send privmsgs.
 
     /** {@inheritDoc} */
     @Override
-    public int getLineCount(final InputWindow origin, final CommandArguments arguments) {
+    public int getLineCount(final WritableFrameContainer origin,
+            final CommandArguments arguments) {
         if (arguments.getArguments().length >= 2) {
             final String target = arguments.getArguments()[0];
-            return origin.getContainer().getServer().getNumLines("PRIVMSG "
+            return origin.getServer().getNumLines("PRIVMSG "
                     + target + " :" + arguments.getArgumentsAsString(1));
         } else {
             return 1;

src/com/dmdirc/commandparser/commands/server/OpenQuery.java

 import com.dmdirc.Query;
 import com.dmdirc.Server;
 import com.dmdirc.commandparser.BaseCommandInfo;
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.commands.context.ServerCommandContext;
 import com.dmdirc.ui.input.AdditionalTabTargets;
 import com.dmdirc.ui.input.TabCompletionType;
-import com.dmdirc.ui.interfaces.InputWindow;
 import com.dmdirc.ui.messages.Styliser;
 
 /**
         }
 
         if (!args.isSilent()) {
-            context.getSource().getController().requestWindowFocus(query);
+            //TODO how are we going to handle focusing an existing query?
+            //context.getSource().getController().requestWindowFocus(query);
+            return; //NOPMD
         }
     }
 
 
     /** {@inheritDoc} */
     @Override
-    public int getLineCount(final InputWindow origin, final CommandArguments arguments) {
+    public int getLineCount(final WritableFrameContainer origin,
+            final CommandArguments arguments) {
         if (arguments.getArguments().length >= 2) {
             final String target = arguments.getArguments()[0];
-            return origin.getContainer().getServer().getNumLines("PRIVMSG "
+            return origin.getServer().getNumLines("PRIVMSG "
                     + target + " :" + arguments.getArgumentsAsString(1));
         } else {
             return 1;

src/com/dmdirc/commandparser/commands/server/ServerSettings.java

-/*
- * Copyright (c) 2006-2011 Chris Smith, Shane Mc Cormack, Gregory Holmes,
- * Simon Mott
- *
- * 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.commands.server;
-
-import com.dmdirc.FrameContainer;
-import com.dmdirc.commandparser.BaseCommandInfo;
-import com.dmdirc.commandparser.CommandArguments;
-import com.dmdirc.commandparser.CommandInfo;
-import com.dmdirc.commandparser.CommandType;
-import com.dmdirc.commandparser.commands.Command;
-import com.dmdirc.commandparser.commands.CommandOptions;
-import com.dmdirc.commandparser.commands.IntelligentCommand;
-import com.dmdirc.commandparser.commands.context.CommandContext;
-import com.dmdirc.commandparser.commands.context.ServerCommandContext;
-import com.dmdirc.ui.input.AdditionalTabTargets;
-
-/**
- * Opens the server settings window for the server.
- *
- * @since 0.6.4
- */
-@CommandOptions(allowOffline=false)
-public class ServerSettings extends Command implements IntelligentCommand {
-
-    /** A command info object for this command. */
-    public static final CommandInfo INFO = new BaseCommandInfo("serversettings",
-            "serversettings - opens the server settings window",
-            CommandType.TYPE_SERVER);
-
-    /** {@inheritDoc} */
-    @Override
-    public void execute(final FrameContainer origin,
-            final CommandArguments args, final CommandContext context) {
-        context.getSource().getController().showServerSettingsDialog(
-                ((ServerCommandContext) context).getServer());
-    }
-
-    /** {@inheritDoc} */
-    @Override
-    public AdditionalTabTargets getSuggestions(final int arg,
-            final IntelligentCommandContext context) {
-        return new AdditionalTabTargets().excludeAll();
-    }
-}

src/com/dmdirc/commandparser/parsers/ChannelCommandParser.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.ChannelCommandContext;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command parser that is tailored for use in a channel environment.
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args) {
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args) {
         if (commandInfo.getType() == CommandType.TYPE_CHANNEL) {
-            command.execute(origin, args, new ChannelCommandContext(window, commandInfo, channel));
+            command.execute(origin, args, new ChannelCommandContext(origin,
+                    commandInfo, channel));
         } else {
-            super.executeCommand(origin, window, commandInfo, command, args);
+            super.executeCommand(origin, commandInfo, command, args);
         }
     }
 

src/com/dmdirc/commandparser/parsers/ChatCommandParser.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.ChatCommandContext;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command parser which implements common functionality for chat windows
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args) {
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args) {
         if (commandInfo.getType() == CommandType.TYPE_CHAT) {
-            command.execute(origin, args, new ChatCommandContext(window, commandInfo, owner));
+            command.execute(origin, args, new ChatCommandContext(origin,
+                    commandInfo, owner));
         } else {
-            super.executeCommand(origin, window, commandInfo, command, args);
+            super.executeCommand(origin, commandInfo, command, args);
         }
     }
 
     /** {@inheritDoc} */
     @Override
-    protected void handleNonCommand(final FrameContainer origin, final String line) {
+    protected void handleNonCommand(final FrameContainer origin,
+            final String line) {
         owner.sendLine(line);
     }
 

src/com/dmdirc/commandparser/parsers/CommandParser.java

 import com.dmdirc.commandparser.commands.ExternalCommand;
 import com.dmdirc.commandparser.commands.PreviousCommand;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.ui.interfaces.Window;
 import com.dmdirc.util.RollingList;
 
 import java.io.Serializable;
      * @since 0.6.4
      */
     public final void parseCommand(final FrameContainer origin,
-            final Window window, final String line, final boolean parseChannel) {
+            final String line, final boolean parseChannel) {
         final CommandArguments args = new CommandArguments(line);
 
         if (args.isCommand()) {
-            if (handleChannelCommand(origin, window, args, parseChannel)) {
+            if (handleChannelCommand(origin, args, parseChannel)) {
                 return;
             }
 
             if (commands.containsKey(args.getCommandName().toLowerCase())) {
                 final CommandInfoPair pair = commands.get(args.getCommandName().toLowerCase());
                 addHistory(args.getStrippedLine());
-                executeCommand(origin, window, pair.getCommandInfo(), pair.getCommand(), args);
+                executeCommand(origin, pair.getCommandInfo(), pair.getCommand(), args);
             } else {
                 handleInvalidCommand(origin, args);
             }
      * @return True iff the command was handled, false otherwise
      */
     protected boolean handleChannelCommand(final FrameContainer origin,
-            final Window window, final CommandArguments args, final boolean parseChannel) {
+            final CommandArguments args, final boolean parseChannel) {
         final boolean silent = args.isSilent();
         final String command = args.getCommandName();
         final String[] cargs = args.getArguments();
 
                 if (server.hasChannel(channel)) {
                     server.getChannel(channel).getCommandParser()
-                            .parseCommand(origin, window, commandManager.getCommandChar()
+                            .parseCommand(origin, commandManager.getCommandChar()
                             + args.getCommandName() + " " + args.getWordsAsString(2), false);
                 } else {
                     final Map.Entry<CommandInfo, Command> actCommand
      * @since 0.6.4
      */
     public final void parseCommand(final FrameContainer origin,
-            final Window window, final String line) {
-        parseCommand(origin, window, line, true);
+            final String line) {
+        parseCommand(origin, line, true);
     }
 
     /**
      * @since 0.6.4
      */
     protected abstract void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args);
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args);
 
     /**
      * Called when the user attempted to issue a command (i.e., used the command

src/com/dmdirc/commandparser/parsers/GlobalCommandParser.java

 import com.dmdirc.commandparser.commands.context.CommandContext;
 import com.dmdirc.logger.ErrorLevel;
 import com.dmdirc.logger.Logger;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * The command parser used for global commands.
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args) {
-        command.execute(origin, args, new CommandContext(window, commandInfo));
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args) {
+        command.execute(origin, args, new CommandContext(origin, commandInfo));
     }
 
     /**

src/com/dmdirc/commandparser/parsers/QueryCommandParser.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.QueryCommandContext;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command parser that is tailored for use in a query environment. Handles
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args) {
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args) {
         if (commandInfo.getType() == CommandType.TYPE_QUERY) {
-            command.execute(origin, args, new QueryCommandContext(window, commandInfo, query));
+            command.execute(origin, args, new QueryCommandContext(origin,
+                    commandInfo, query));
         } else {
-            super.executeCommand(origin, window, commandInfo, command, args);
+            super.executeCommand(origin, commandInfo, command, args);
         }
     }
 

src/com/dmdirc/commandparser/parsers/ServerCommandParser.java

 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
 import com.dmdirc.commandparser.commands.context.ServerCommandContext;
-import com.dmdirc.ui.interfaces.Window;
 
 /**
  * A command parser used in the context of a server.
     /** {@inheritDoc} */
     @Override
     protected void executeCommand(final FrameContainer origin,
-            final Window window, final CommandInfo commandInfo,
-            final Command command, final CommandArguments args) {
+            final CommandInfo commandInfo, final Command command,
+            final CommandArguments args) {
         if (commandInfo.getType() == CommandType.TYPE_SERVER) {
             if (hasCommandOptions(command) && !getCommandOptions(command).allowOffline()
                     && (server == null || (server.getState() != ServerState.CONNECTED
                     origin.addLine("commandError", "You must be connected to use this command");
                 }
             } else {
-                command.execute(origin, args, new ServerCommandContext(window, commandInfo, server));
+                command.execute(origin, args, new ServerCommandContext(origin, commandInfo, server));
             }
         } else {
-            super.executeCommand(origin, window, commandInfo, command, args);
+            super.executeCommand(origin, commandInfo, command, args);
         }
     }
 

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

 
 package com.dmdirc.ui.input;
 
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.actions.ActionManager;
 import com.dmdirc.actions.CoreActionType;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.ui.input.tabstyles.TabCompletionStyle;
 import com.dmdirc.ui.interfaces.InputField;
 import com.dmdirc.ui.interfaces.InputValidationListener;
-import com.dmdirc.ui.interfaces.InputWindow;
 import com.dmdirc.ui.messages.Styliser;
 import com.dmdirc.util.ListenerList;
 import com.dmdirc.util.RollingList;
     /** The CommandParser to use for our input. */
     protected final CommandParser commandParser;
     /** The frame that we belong to. */
-    protected final InputWindow parentWindow;
+    protected final WritableFrameContainer parentWindow;
     /** The tab completion style. */
     protected TabCompletionStyle style;
     /** Our listener list. */
      */
     public InputHandler(final InputField thisTarget,
             final CommandParser thisCommandParser,
-            final InputWindow thisParentWindow) {
+            final WritableFrameContainer thisParentWindow) {
 
-        buffer = new RollingList<String>(thisParentWindow.getContainer()
-                .getConfigManager().getOptionInt("ui", "inputbuffersize"), "");
+        buffer = new RollingList<String>(thisParentWindow.getConfigManager()
+                .getOptionInt("ui", "inputbuffersize"), "");
 
         this.commandParser = thisCommandParser;
         this.parentWindow = thisParentWindow;
 
         setStyle();
 
-        parentWindow.getContainer().getConfigManager().addChangeListener(
+        parentWindow.getConfigManager().addChangeListener(
                 "tabcompletion", "style", this);
 
         addUpHandler();
      */
     private void setStyle() {
         style = (TabCompletionStyle) PluginManager.getPluginManager()
-                .getServiceProvider("tabcompletion", parentWindow.getContainer()
+                .getServiceProvider("tabcompletion", parentWindow
                 .getConfigManager().getOption("tabcompletion", "style"))
-                .getExportedService("getCompletionStyle").execute(tabCompleter, parentWindow);
+                .getExportedService("getCompletionStyle").execute(tabCompleter,
+                parentWindow);
     }
 
     /**
                 fireLineWrap(count);
             }
         } else {
-            final int lines = parentWindow.getContainer().getNumLines(text);
+            final int lines = parentWindow.getNumLines(text);
                 fireLineWrap(lines);
         }
     }
 
             case KeyEvent.VK_ENTER:
                 if ((flags & HANDLE_RETURN) != 0 && !line.isEmpty()) {
-                    commandParser.parseCommandCtrl(parentWindow.getContainer(), line);
+                    commandParser.parseCommandCtrl(parentWindow, line);
                     addToBuffer(line);
                 }
                 break;
 
             ActionManager.getActionManager().triggerEvent(
                     CoreActionType.CLIENT_USER_INPUT, null,
-                    parentWindow.getContainer(), thisBuffer);
+                    parentWindow, thisBuffer);
 
             addToBuffer(thisBuffer.toString());
 
-            commandParser.parseCommand(parentWindow.getContainer(),
-                    parentWindow, thisBuffer.toString());
+            commandParser.parseCommand(parentWindow, thisBuffer.toString());
         }
         fireLineWrap(0);
         fireCommandPassed();

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

 
 package com.dmdirc.ui.input;
 
+import com.dmdirc.WritableFrameContainer;
 import com.dmdirc.commandparser.CommandArguments;
 import com.dmdirc.commandparser.CommandInfo;
 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.commands.IntelligentCommand;
 import com.dmdirc.commandparser.commands.IntelligentCommand.IntelligentCommandContext;
 import com.dmdirc.config.IdentityManager;
-import com.dmdirc.ui.interfaces.InputWindow;
 import com.dmdirc.util.MapList;
 
 import java.util.Arrays;
      * @return Additional tab targets for the text, or null if none are available
      * @since 0.6.4
      */
-    private static AdditionalTabTargets getIntelligentResults(final InputWindow window,
+    private static AdditionalTabTargets getIntelligentResults(
+            final WritableFrameContainer window,
             final CommandArguments args, final String partial) {
         if (!args.isCommand()) {
             return null;
      * @return Additional tab targets for the text, or null if none are available
      * @since 0.6.4
      */
-    public static AdditionalTabTargets getIntelligentResults(final InputWindow window,
-            final String text, final String partial) {
+    public static AdditionalTabTargets getIntelligentResults(
+            final WritableFrameContainer window, final String text,
+            final String partial) {
         return getIntelligentResults(window, new CommandArguments(text), partial);
     }
 }

test/com/dmdirc/commandparser/parsers/CommandParserTest.java

     @Test
     public void testBasicCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/echo this is a test");
+        tcp.parseCommand(null, "/echo this is a test");
 
         assertNull(tcp.nonCommandLine);
         assertNull(tcp.invalidCommand);
     @Test
     public void testBasicNoArgs() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/echo");
+        tcp.parseCommand(null, "/echo");
 
         assertNull(tcp.nonCommandLine);
         assertNull(tcp.invalidCommand);
     @Test
     public void testSilentNoArgs() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/.echo");
+        tcp.parseCommand(null, "/.echo");
 
         assertNull(tcp.nonCommandLine);
         assertNull(tcp.invalidCommand);
     @Test
     public void testSilentCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/.echo this is a test");
+        tcp.parseCommand(null, "/.echo this is a test");
 
         assertNull(tcp.nonCommandLine);
         assertNull(tcp.invalidCommand);
     @Test
     public void testNonExistantCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/foobar moo bar");
+        tcp.parseCommand(null, "/foobar moo bar");
 
         assertNull(tcp.nonCommandLine);
         assertEquals("foobar", tcp.invalidCommand);
     @Test
     public void testEmptyCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/ moo bar");
+        tcp.parseCommand(null, "/ moo bar");
 
         assertNull(tcp.nonCommandLine);
         assertEquals("", tcp.invalidCommand);
         assertNull(tcp.executedCommand);
         assertFalse(tcp.wasSilent);
     }
-    
+
     @Test
     public void testEmptySilentCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/. moo bar");
+        tcp.parseCommand(null, "/. moo bar");
 
         assertNull(tcp.nonCommandLine);
         assertEquals("", tcp.invalidCommand);
         assertNull(tcp.executedCommand);
         assertFalse(tcp.wasSilent);
     }
-    
+
     @Test
     public void testNonCommand() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "Foobar baz");
+        tcp.parseCommand(null, "Foobar baz");
 
         assertNotNull(tcp.nonCommandLine);
         assertEquals("Foobar baz", tcp.nonCommandLine);
         assertNull(tcp.executedCommand);
         assertFalse(tcp.wasSilent);
     }
-    
+
     @Test
     public void testCommandHistory() {
         final TestCommandParser tcp = new TestCommandParser();
-        tcp.parseCommand(null, null, "/echo this is a test");
+        tcp.parseCommand(null, "/echo this is a test");
 
         final long time1 = tcp.getCommandTime("echo this is a test");
         assertTrue(time1 > 0);
-        
-        tcp.parseCommand(null, null, "/echo this is a test");
+
+        tcp.parseCommand( null, "/echo this is a test");
         final long time2 = tcp.getCommandTime("echo this is a test");
         assertTrue(time2 > 0);
         assertTrue(time2 >= time1);
-        
+
         assertEquals(0L, tcp.getCommandTime("echo"));
-    }    
+    }
 
 }

test/com/dmdirc/harness/TestCommandParser.java

 import com.dmdirc.commandparser.CommandManager;
 import com.dmdirc.commandparser.CommandType;
 import com.dmdirc.commandparser.commands.Command;
-import com.dmdirc.ui.interfaces.Window;
 
 public class TestCommandParser extends CommandParser {
     private static final long serialVersionUID = 7073002401375438532L;
     }
 
     @Override
-    protected void executeCommand(FrameContainer origin, Window window,
+    protected void executeCommand(FrameContainer origin,
             CommandInfo commandInfo, Command command, CommandArguments args) {
         executedCommand = command;
         wasSilent = args.isSilent();