Esempio n. 1
0
        void Execute(string prefix = null)
        {
            IList <CBinding> bindings = CBindings.List(prefix);

            foreach (CBinding b in bindings)
            {
                PrintIndent("bind {0} {1}", b.shortCut.ToString(), StringUtils.Arg(b.cmdKeyDown));
            }
        }
Esempio n. 2
0
        private static IList <string> ListBindings()
        {
            IList <CBinding> bindings = CBindings.List();

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

            foreach (CBinding binding in bindings)
            {
                entries.Add(string.Format("bind {0} {1}", binding.shortCut.ToString(), StringUtils.Arg(binding.cmdKeyDown)));
            }

            return(entries);
        }
Esempio n. 3
0
        public static IList <string> ListShortCuts(string prefix = null) // TODO: unit tests
        {
            IList <CBinding> bindings = CBindings.List(prefix);

            string[] shortcuts = new string[bindings.Count];

            int index = 0;

            foreach (CBinding b in bindings)
            {
                shortcuts[index++] = b.shortCut.ToString();
            }

            return(shortcuts);
        }
Esempio n. 4
0
        void Execute(string prefix)
        {
            if (CBindings.Count > 0)
            {
                IList <CBinding> bindings = CBindings.List(prefix);
                if (bindings.Count > 0)
                {
                    foreach (CBinding binding in bindings)
                    {
                        CBindings.Unbind(binding.shortCut);
                    }

                    PostNotification();
                }
            }
        }
Esempio n. 5
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);
        }