Exemplo n.º 1
0
 public static IList <string> ListAliasesConfig()
 {
     return(Collection.Map(CRegistery.ListAliases(), delegate(CAliasCommand alias)
     {
         return ToString(alias);
     }));
 }
Exemplo n.º 2
0
        bool Execute(string prefix = null)
        {
            IList <CAliasCommand> cmds = CRegistery.ListAliases(prefix);

            if (cmds.Count > 0)
            {
                if (shortList)
                {
                    string[] names = Collection.Map(cmds, delegate(CAliasCommand cmd)
                    {
                        return(cmd.Name);
                    });
                    Print(names);
                }
                else
                {
                    foreach (CAliasCommand cmd in cmds)
                    {
                        PrintIndent("{0} {1}", cmd.Name, cmd.Alias);
                    }
                }
            }

            return(true);
        }
Exemplo n.º 3
0
        private bool TryExecuteSingleCommand(string commandLine, bool manualMode = false)
        {
            IList <string> tokensList = CommandTokenizer.Tokenize(commandLine);

            if (tokensList.Count > 0)
            {
                string commandName = tokensList[0];

                CCommand command = CRegistery.FindCommand(commandName);
                if (command != null)
                {
                    command.Delegate      = m_delegate;
                    command.IsManualMode  = manualMode;
                    command.CommandString = commandLine;
                    bool succeed = command.ExecuteTokens(tokensList, commandLine);
                    command.Clear();

                    return(succeed);
                }

                if (manualMode)
                {
                    m_delegate.LogTerminal(StringUtils.C(commandName + ": command not found", ColorCode.ErrorUnknownCommand));
                }
            }

            return(false);
        }
Exemplo n.º 4
0
        public static void ListAliasesConfig(IList <string> lines)
        {
            IList <CAliasCommand> aliases = CRegistery.ListAliases();

            for (int i = 0; i < aliases.Count; ++i)
            {
                lines.Add(ToString(aliases[i]));
            }
        }
Exemplo n.º 5
0
        void Execute(string name, string commands)
        {
            CRegistery.AddAlias(name, StringUtils.UnArg(commands));

            PostNotification(
                CCommandNotifications.CAliasesChanged,
                CCommandNotifications.KeyName, name,
                CCommandNotifications.KeyManualMode, this.IsManualMode
                );
        }
Exemplo n.º 6
0
 void Execute(string name)
 {
     if (CRegistery.RemoveAlias(name))
     {
         PostNotification(
             CCommandNotifications.CAliasesChanged,
             CCommandNotifications.KeyName, name,
             CCommandNotifications.KeyManualMode, this.IsManualMode
             );
     }
 }
Exemplo n.º 7
0
        private string[] ListCommandNames(string prefix, CommandListOptions options)
        {
            IList <CCommand> commands = CRegistery.ListCommands(delegate(CCommand cmd)
            {
                return(!(cmd is CVarCommand) && CRegistery.ShouldListCommand(cmd, prefix, options));
            });

            return(Collection.Map(commands, delegate(CCommand cmd)
            {
                return C(cmd.Name, cmd.ColorCode);
            }));
        }
Exemplo n.º 8
0
        internal static IList <string> AutoCompleteArgs(string token)
        {
            IList <CAliasCommand> aliases = CRegistery.ListAliases();

            if (aliases != null && aliases.Count > 0)
            {
                return(Collection.Map(aliases, delegate(CAliasCommand alias)
                {
                    return alias.Name;
                }));
            }

            return(null);
        }
Exemplo n.º 9
0
        internal static IList <string> AutoCompleteArgs(string prefix)
        {
            IList <CVar> vars = CRegistery.ListVars(prefix, CCommand.DefaultListOptions);

            if (vars.Count == 0)
            {
                return(null);
            }

            return(Collection.Map(vars, delegate(CVar cvar)
            {
                return StringUtils.C(cvar.Name, ColorCode.TableVar);
            }));
        }
Exemplo n.º 10
0
        void Execute(string prefix = null)
        {
            IList <CCommand> cmds = CRegistery.ListCommands(prefix);

            foreach (CCommand cmd in cmds)
            {
                CVarCommand cvarCmd = cmd as CVarCommand;
                if (cvarCmd != null)
                {
                    cvarCmd.ParentCommand = this;
                    cvarCmd.SetDefault();
                    cvarCmd.ParentCommand = null;
                }
            }
        }
Exemplo n.º 11
0
        bool Execute(string command)
        {
            CCommand cmd = CRegistery.FindCommand(command);

            if (cmd == null)
            {
                PrintError("{0}: command not found \"{1}\"", this.Name, command);
                return(false);
            }

            cmd.Delegate = this.Delegate;
            cmd.PrintUsage(true);
            cmd.Delegate = null;

            return(true);
        }
Exemplo n.º 12
0
        protected override IList <string> AutoCompleteArgs(string commandLine, string prefix)
        {
            IList <CVar> vars = CRegistery.ListVars(delegate(CVarCommand cmd)
            {
                return(cmd.IsBool && CRegistery.ShouldListCommand(cmd, prefix, CCommand.DefaultListOptions));
            });

            if (vars.Count == 0)
            {
                return(null);
            }

            return(Collection.Map(vars, delegate(CVar cvar) {
                return StringUtils.C(cvar.Name, ColorCode.TableVar);
            }));
        }
Exemplo n.º 13
0
        bool Execute(string name)
        {
            CVarCommand cmd = CRegistery.FindCvarCommand(name);

            if (cmd == null)
            {
                PrintError("Can't find cvar: '{0}'", name);
                return(false);
            }

            cmd.ParentCommand = this;
            cmd.SetDefault();
            cmd.ParentCommand = null;

            return(true);
        }
Exemplo n.º 14
0
        bool Execute(string prefix = null)
        {
            CommandListOptions options = CCommand.DefaultListOptions;

            if (includeSystem)
            {
                options |= CommandListOptions.System;
            }

            // TODO: refactoring
            IList <CVar> vars = CRegistery.ListVars(prefix, options);

            if (vars.Count > 0)
            {
                if (shortList)
                {
                    string[] names = Collection.Map(vars, delegate(CVar cvar) {
                        return(StringUtils.C(cvar.Name, ColorCode.TableVar));
                    });
                    Print(names);
                }
                else
                {
                    StringBuilder result = new StringBuilder();
                    for (int i = 0; i < vars.Count; ++i)
                    {
                        CVar cvar = vars[i];
                        result.AppendFormat("  {0} {1}", StringUtils.C(cvar.Name, ColorCode.TableVar), StringUtils.Arg(cvar.Value));

                        // TODO: better color highlight
                        if (!cvar.IsDefault)
                        {
                            result.AppendFormat(" {0} {1}", StringUtils.C("default", ColorCode.TableVar), cvar.DefaultValue);
                        }

                        if (i < vars.Count - 1)
                        {
                            result.Append('\n');
                        }
                    }

                    Print(result.ToString());
                }
            }

            return(true);
        }
Exemplo n.º 15
0
        void Execute(string prefix = null)
        {
            IList <CAliasCommand> aliases = CRegistery.ListAliases(prefix);

            if (aliases.Count > 0)
            {
                foreach (CAliasCommand alias in aliases)
                {
                    CRegistery.RemoveAlias(alias.Name);
                }

                PostNotification(
                    CCommandNotifications.CAliasesChanged,
                    CCommandNotifications.KeyManualMode, this.IsManualMode
                    );
            }
        }
        private CVar ResolveCvar(string identifier)
        {
            CVar cvar = CRegistery.FindCvar(identifier);

            if (cvar == null)
            {
                PrintError("Can't find boolean variable: '{0}'", identifier);
                return(null);
            }

            if (!cvar.IsBool)
            {
                PrintError("Boolean variable expected: '{0}'", identifier);
                return(null);
            }

            return(cvar);
        }
Exemplo n.º 17
0
        protected override IList <string> AutoCompleteArgs(string commandLine, string token)
        {
            IList <CCommand> commands = CRegistery.ListCommands(delegate(CCommand command)
            {
                return(!(command is CVarCommand) &&
                       !(command is CDelegateCommand) &&
                       !(command is CAliasCommand) &&
                       CRegistery.ShouldListCommand(command, token, CCommand.DefaultListOptions));
            });

            if (commands.Count == 0)
            {
                return(null);
            }

            return(Collection.Map(commands, delegate(CCommand cmd)
            {
                return StringUtils.C(cmd.Name, cmd.ColorCode);
            }));
        }
Exemplo n.º 18
0
        bool Execute(string cvarName)
        {
            CVarCommand cmd = CRegistery.FindCvarCommand(cvarName);

            if (cmd == null)
            {
                PrintError("Can't find cvar '" + cvarName + "'");
                return(false);
            }

            if (!cmd.IsInt)
            {
                PrintError("Can't toggle non-int value");
                return(false);
            }

            cmd.ParentCommand = this;
            cmd.SetValue(cmd.BoolValue ? 0 : 1);
            cmd.ParentCommand = null;

            return(true);
        }
Exemplo n.º 19
0
        private static IList <string> ListCvars()
        {
            IList <CVar> cvars = CRegistery.ListVars(delegate(CVarCommand cmd)
            {
                return(!cmd.IsDefault && !cmd.HasFlag(CFlags.NoArchive));
            });

            IList <string> entries = new List <string>(cvars.Count);

            foreach (CVar cvar in cvars)
            {
                if (cvar.Value != null)
                {
                    entries.Add(string.Format("{0} {1}", cvar.Name, StringUtils.Arg(cvar.Value)));
                }
                else
                {
                    entries.Add("null " + cvar.Name);
                }
            }

            return(entries);
        }
Exemplo n.º 20
0
 public CCommand FindCommand(string name)
 {
     return(CRegistery.FindCommand(name));
 }
Exemplo n.º 21
0
 public CVar FindCvar(string name)
 {
     return(CRegistery.FindCvar(name));
 }
Exemplo n.º 22
0
        //////////////////////////////////////////////////////////////////////////////

        #region Inheritance

        protected virtual void ResolveCommands()
        {
            CRegistery.ResolveElements();
        }
Exemplo n.º 23
0
        bool Execute(string stroke, string command = null) // TODO: refactor me!
        {
            string name = stroke.ToLower();

            if (!string.IsNullOrEmpty(command))
            {
                CShortCut shortCut;
                if (!CShortCut.TryParse(stroke, out shortCut))
                {
                    PrintError("Invalid shortcut: {0}", name);
                    return(false);
                }

                string keyUpCommand = null;

                char keyDownOp = command[0];
                if (keyDownOp == '+' || keyDownOp == '-')
                {
                    if (command.Length == 1)
                    {
                        PrintError("Identifier expected!");
                        return(false);
                    }

                    string identifier = command.Substring(1);

                    // register operation command
                    CCommand keyDownCmd = CRegistery.FindCommand(command);
                    if (keyDownCmd == null)
                    {
                        keyDownCmd = new COperationCommand(keyDownOp, identifier);
                        CRegistery.Register(keyDownCmd);
                        keyDownCmd.SetFlag(CCommandFlags.System, true);
                    }

                    // register opposite operation command
                    char keyUpOp = OppositeOperation(keyDownOp);
                    keyUpCommand = keyUpOp + identifier;
                    CCommand keyUpCmd = CRegistery.FindCommand(keyUpCommand);
                    if (keyUpCmd == null)
                    {
                        keyUpCmd = new COperationCommand(keyUpOp, identifier);
                        CRegistery.Register(keyUpCmd);
                        keyUpCmd.SetFlag(CCommandFlags.System, true);
                    }
                }

                CBindings.Bind(shortCut, StringUtils.UnArg(command), keyUpCommand != null ? StringUtils.UnArg(keyUpCommand) : null);

                PostNotification(
                    CCommandNotifications.CBindingsChanged,
                    CCommandNotifications.KeyManualMode, this.IsManualMode
                    );

                return(true);
            }

            IList <CBinding> bindings = CBindings.List(name);

            if (bindings.Count > 0)
            {
                foreach (CBinding b in bindings)
                {
                    PrintIndent(ToString(b));
                }
            }
            else
            {
                PrintIndent("No bindings");
            }

            return(true);
        }
Exemplo n.º 24
0
 protected override IList <string> AutoCompleteArgs(string commandLine, string token)
 {
     return(CRegistery.ListVarNames(token, CCommand.DefaultListOptions));
 }