Пример #1
0
 public Event(EventType type, string value,
              NativeMethods.KeyboardUpDown kud)
 {
     Kud   = kud;
     Type  = type;
     Value = value;
 }
Пример #2
0
        public void ProcAction(ActionItem action,
                               NativeMethods.KeyboardUpDown kud)
        {
            var result = _stateMachine.ExecCore(action, kud);

            ProcessExecResult(result);
        }
Пример #3
0
 public ExecResult(bool shouldCancel,
                   ExecStatus status, string nextBank,
                   ActionType actionType, string actionValue,
                   NativeMethods.KeyboardUpDown kud)
 {
     ShouldCancel = shouldCancel;
     Status       = status;
     NextBank     = nextBank;
     ActionType   = actionType;
     ActionValue  = actionValue;
     UpDown       = kud;
 }
Пример #4
0
        public void SendKey(string str,
                            NativeMethods.KeyboardUpDown keyboardUpDown)
        {
            var p = Conv(str);

            switch (keyboardUpDown)
            {
            case NativeMethods.KeyboardUpDown.Down:
                NativeMethods.keybd_event(p, 0, KEYEVENTF_KEYDOWN,
                                          (UIntPtr)0);
                break;

            case NativeMethods.KeyboardUpDown.Up:
                NativeMethods.keybd_event(p, 0, KEYEVENTF_KEYUP,
                                          (UIntPtr)0);
                break;
            }
        }
Пример #5
0
        public ExecResult ExecCore(ActionItem item,
                                   NativeMethods.KeyboardUpDown kud)
        {
            if (item == null)
            {
                return(new ExecResult(true));
            }

            switch (item.ActionType)
            {
            case ActionType.Key:
                switch (kud)
                {
                case NativeMethods.KeyboardUpDown.Up:
                    return(new ExecResult(true, ExecStatus.None, "",
                                          ActionType.Key, item.ActionValue, kud));

                case NativeMethods.KeyboardUpDown.Down:
                    return(new ExecResult(true, ExecStatus.LoadBank,
                                          item.NextBank, ActionType.Key,
                                          item.ActionValue, kud));

                default:
                    return(new ExecResult(true));
                }

            default:
                switch (kud)
                {
                case NativeMethods.KeyboardUpDown.Down:
                    return(new ExecResult(true, ExecStatus.LoadBank,
                                          item.NextBank,
                                          item.ActionType, item.ActionValue, kud));

                default:
                    return(new ExecResult(true));
                }
            }
        }
Пример #6
0
        public ExecResult Exec(List <Entry> entries, Keys keyCode,
                               NativeMethods.KeyboardUpDown upDown, bool isMenuVisible = false)
        {
            if (entries == null)
            {
                return(new ExecResult(false));
            }

            var modifilers = new[]
            {
                Keys.LControlKey, Keys.LShiftKey, Keys.LMenu,
                Keys.RControlKey, Keys.RShiftKey, Keys.RMenu,
                Keys.Control, Keys.Shift, Keys.Alt,
                Keys.ControlKey, Keys.ShiftKey
            };

            if (!modifilers.Contains(keyCode))
            {
                if (_sendingKey == keyCode)
                {
                    _sendingKey = Keys.None;
                    return(new ExecResult(true));
                }

                var keyStr = SendKeyCode.Conv(keyCode);
                var query  = from mi in entries
                             where mi.Trigger == keyStr
                             select mi;
                var mi1 = query.FirstOrDefault();

                if (mi1?.Trigger == null)
                {
                    return(new ExecResult(false));
                }

                if (mi1.ActionItem == null)
                {
                    return(new ExecResult(false));
                }

                switch (mi1.ActionItem.ActionType)
                {
                case ActionType.Send:
                    switch (upDown)
                    {
                    case NativeMethods.KeyboardUpDown.Down:
                        if (0 != _downedModifierKeys.Count)
                        {
                            return(new ExecResult(false));
                        }

                        if (_sendingKey == Keys.None)
                        {
                            _sendingKey = keyCode;
                            return(ExecCore(mi1.ActionItem, upDown));
                        }
                        return(new ExecResult(false));

                    case NativeMethods.KeyboardUpDown.Up:
                        return(new ExecResult(false));


                    case NativeMethods.KeyboardUpDown.None:
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(
                                  nameof(upDown), upDown, null);
                    }
                    break;

                case ActionType.None:
                    return(_downedModifierKeys.Count == 0
                            ? ExecCore(mi1.ActionItem, upDown)
                            : new ExecResult(false));
                }
                return(ExecCore(mi1.ActionItem, upDown));
            }

            if (upDown != NativeMethods.KeyboardUpDown.Down)
            {
                _downedModifierKeys.Remove(keyCode);
            }
            else
            {
                _downedModifierKeys.Add(keyCode);
            }

            return(new ExecResult(false));
        }
Пример #7
0
 public void SendKey(string str,
                     NativeMethods.KeyboardUpDown keyboardUpDown)
 {
     EventLog.Add(new Event(EventType.SendKey, str, keyboardUpDown));
 }