Exemplo n.º 1
0
 static void SpecialRestoreCursor(KeyState state)
 {
     WinAPI.SetCursorPos(state.Point.X, state.Point.Y);
 }
Exemplo n.º 2
0
        static void HandleSpecial(KeyState state, string special, ref uint modifiers, ref int nextPos)
        {
            int    count = 1;
            string other = "";

            Regex re = new Regex("^([^ ]+) *<([0-9]+)>$");
            Match m  = re.Match(special);

            if (m.Success)
            {
                special = m.Groups[1].ToString();
                count   = int.Parse(m.Groups[2].ToString());
            }

            re = new Regex("^([^ ]+) (.+)$");
            m  = re.Match(special);
            if (m.Success)
            {
                special = m.Groups[1].ToString();
                other   = m.Groups[2].ToString();
            }

            for (int i = 0; i < count; i++)
            {
                switch (special.ToLower())
                {
                case SpecialCommands.Begin:
                    s_State.StartLoop(nextPos);
                    break;

                case SpecialCommands.Loop:
                {
                    int targetPos = 0;
                    if (s_State.IterateLoop(ReadNum(other), ref targetPos))
                    {
                        nextPos = targetPos;
                    }
                }
                break;

                case SpecialCommands.AddVar:
                    s_State.Variable += ReadNum(other);
                    break;

                case SpecialCommands.SetVar:
                    s_State.Variable = ReadNum(other);
                    break;

                case SpecialCommands.TypeVar:
                    PressString(s_State.Variable.ToString());
                    break;

                case SpecialCommands.ActiveApp:
                    ActiveApp.HandleCode(other);
                    break;

                case SpecialCommands.RotateDisplay:
                    SpecialRotateDisplay(other);
                    break;

                case SpecialCommands.PasteScrub:
                    ClearModifiers(ref modifiers);
                    SpecialPasteScrub();
                    break;

                case SpecialCommands.Hibernate:
                    Hibernate(false);
                    break;

                case SpecialCommands.Suspend:
                    Hibernate(true);
                    break;

                case SpecialCommands.Launch:
                    SpecialLaunch(other);
                    i = count;
                    break;

                case SpecialCommands.Clip:
                    ClearModifiers(ref modifiers);
                    SpecialClip();
                    i = count;
                    break;

                case SpecialCommands.SysCommand:
                    SpecialSysCommand(other);
                    i = count;
                    break;

                case SpecialCommands.Sleep:
                    Thread.Sleep(ReadNum(other));
                    break;

                case SpecialCommands.StoreCursor:
                    SpecialStoreCursor(state);
                    break;

                case SpecialCommands.RestoreCursor:
                    SpecialRestoreCursor(state);
                    break;

                case SpecialCommands.MoveCursor:
                    SpecialMoveCursor(other);
                    break;

                case SpecialCommands.OffsetCursor:
                    SpecialOffsetCursor(other);
                    i = count;
                    break;

                //case SpecialCommands.VLC:
                //    SpecialVLC(other);
                //    i = count;
                //    break;
                case SpecialCommands.CD:
                    SpecialCD(other);
                    break;

                case SpecialCommands.AltDown:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Alt, true, false, false);
                    break;

                case SpecialCommands.AltUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Alt, false, true, false);
                    break;

                case SpecialCommands.CtrlDown:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Control, true, false, false);
                    break;

                case SpecialCommands.CtrlUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Control, false, true, false);
                    break;

                case SpecialCommands.ShiftDown:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Shift, true, false, false);
                    break;

                case SpecialCommands.ShiftUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Shift, false, true, false);
                    break;

                case SpecialCommands.SwitchTo:
                    SwitchToWindow.Switch(other);
                    i = count;
                    break;

                case SpecialCommands.BackSpace:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Backspace);
                    break;

                case SpecialCommands.BkSp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Backspace);
                    break;

                case SpecialCommands.BS:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Backspace);
                    break;

                case SpecialCommands.CapsLock:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Capital);
                    break;

                case SpecialCommands.Del:
                case SpecialCommands.Delete:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Delete);
                    break;

                case SpecialCommands.Down:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Down);
                    break;

                case SpecialCommands.End:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.End);
                    break;

                case SpecialCommands.Enter:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Return);
                    break;

                case SpecialCommands.Esc:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Escape);
                    break;

                case SpecialCommands.F1:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F1);
                    break;

                case SpecialCommands.F2:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F2);
                    break;

                case SpecialCommands.F3:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F3);
                    break;

                case SpecialCommands.F4:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F4);
                    break;

                case SpecialCommands.F5:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F5);
                    break;

                case SpecialCommands.F6:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F6);
                    break;

                case SpecialCommands.F7:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F7);
                    break;

                case SpecialCommands.F8:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F8);
                    break;

                case SpecialCommands.F9:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F9);
                    break;

                case SpecialCommands.F10:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F10);
                    break;

                case SpecialCommands.F11:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F11);
                    break;

                case SpecialCommands.F12:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.F12);
                    break;

                case SpecialCommands.Home:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Home);
                    break;

                case SpecialCommands.Ins:
                case SpecialCommands.Insert:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Insert);
                    break;

                case SpecialCommands.Click:
                case SpecialCommands.LClick:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseLClick);
                    break;

                case SpecialCommands.LDown:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseLDown);
                    break;

                case SpecialCommands.Left:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Left);
                    break;

                case SpecialCommands.LUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseLUp);
                    break;

                case SpecialCommands.NumLock:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.NumLock);
                    break;

                case SpecialCommands.PgDn:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.PageDown);
                    break;

                case SpecialCommands.PgUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.PageUp);
                    break;

                case SpecialCommands.RClick:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseRClick);
                    break;

                case SpecialCommands.RDown:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseRDown);
                    break;

                case SpecialCommands.Right:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Right);
                    break;

                case SpecialCommands.RUp:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.MouseRUp);
                    break;

                case SpecialCommands.ScrollLock:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Scroll);
                    break;

                case SpecialCommands.Tab:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Tab);
                    break;

                case SpecialCommands.Up:
                    ClearModifiers(ref modifiers);
                    PressKeyVK(WinAPI.KeyCode.Up);
                    break;

                default:
                    ClearModifiers(ref modifiers);
                    PressString(special);
                    break;
                }
            }
        }
Exemplo n.º 3
0
 static void SpecialStoreCursor(KeyState state)
 {
     WinAPI.GetCursorPos(out state.Point);
 }
Exemplo n.º 4
0
        static public void PressSendKeys(string keys, uint modifiers)
        {
            s_State.Reset();

            List <WinAPI.KeyCode> modify = new List <WinAPI.KeyCode>();
            KeyState state = new KeyState();

            for (int pos = 0; pos < keys.Length; pos++)
            {
                Regex re;
                Match m;
                bool  handled = false;

                if (!handled)
                {
                    re = new Regex("^([\\^\\%\\+]+)\\(([^\\)]+)\\)");
                    m  = re.Match(keys.Substring(pos));
                    if (m.Success)
                    {
                        ClearModifiers(ref modifiers);
                        handled = true;

                        foreach (char cur in m.Groups[1].ToString())
                        {
                            switch (cur)
                            {
                            case '+':
                                PressKeyVK(WinAPI.KeyCode.Shift, true, false, false);
                                modify.Add(WinAPI.KeyCode.Shift);
                                break;

                            case '%':
                                PressKeyVK(WinAPI.KeyCode.Alt, true, false, false);
                                modify.Add(WinAPI.KeyCode.Alt);
                                break;

                            case '^':
                                PressKeyVK(WinAPI.KeyCode.Control, true, false, false);
                                modify.Add(WinAPI.KeyCode.Control);
                                break;
                            }
                        }
                        PressSendKeys(m.Groups[2].ToString(), modifiers);
                        foreach (WinAPI.KeyCode vk in modify)
                        {
                            PressKeyVK(vk, false, true, false);
                        }
                        modify.Clear();

                        pos += m.Groups[1].ToString().Length + m.Groups[2].ToString().Length + 1;
                    }
                }

                if (!handled)
                {
                    re = new Regex("^([\\^\\%\\+]+)\\{([^\\}]+)\\}");
                    m  = re.Match(keys.Substring(pos));
                    if (m.Success)
                    {
                        ClearModifiers(ref modifiers);
                        handled = true;

                        foreach (char cur in m.Groups[1].ToString())
                        {
                            switch (cur)
                            {
                            case '+':
                                PressKeyVK(WinAPI.KeyCode.Shift, true, false, false);
                                modify.Add(WinAPI.KeyCode.Shift);
                                break;

                            case '%':
                                PressKeyVK(WinAPI.KeyCode.Alt, true, false, false);
                                modify.Add(WinAPI.KeyCode.Alt);
                                break;

                            case '^':
                                PressKeyVK(WinAPI.KeyCode.Control, true, false, false);
                                modify.Add(WinAPI.KeyCode.Control);
                                break;
                            }
                        }
                        PressSendKeys("{" + m.Groups[2].ToString() + "}", 0);
                        foreach (WinAPI.KeyCode vk in modify)
                        {
                            PressKeyVK(vk, false, true, false);
                        }
                        modify.Clear();

                        pos += m.Groups[1].ToString().Length + m.Groups[2].ToString().Length + 1;
                    }
                }

                if (!handled)
                {
                    re = new Regex("^([\\^\\%\\+]+)(.)");
                    m  = re.Match(keys.Substring(pos));
                    if (m.Success)
                    {
                        ClearModifiers(ref modifiers);
                        handled = true;

                        foreach (char cur in m.Groups[1].ToString())
                        {
                            switch (cur)
                            {
                            case '+':
                                PressKeyVK(WinAPI.KeyCode.Shift, true, false, false);
                                modify.Add(WinAPI.KeyCode.Shift);
                                break;

                            case '%':
                                PressKeyVK(WinAPI.KeyCode.Alt, true, false, false);
                                modify.Add(WinAPI.KeyCode.Alt);
                                break;

                            case '^':
                                PressKeyVK(WinAPI.KeyCode.Control, true, false, false);
                                modify.Add(WinAPI.KeyCode.Control);
                                break;
                            }
                        }
                        PressSendKeys(m.Groups[2].ToString(), 0);
                        foreach (WinAPI.KeyCode vk in modify)
                        {
                            PressKeyVK(vk, false, true, false);
                        }
                        modify.Clear();

                        pos += m.Groups[1].ToString().Length;
                    }
                }

                if (!handled)
                {
                    if (keys[pos] == '~')
                    {
                        ClearModifiers(ref modifiers);
                        handled = true;

                        PressKeyVK(WinAPI.KeyCode.Return);
                    }
                }

                if (!handled)
                {
                    if (keys.Length - pos >= 3)
                    {
                        if (keys.Substring(pos, 3) == "{}}")
                        {
                            ClearModifiers(ref modifiers);
                            handled = true;

                            PressString("}");

                            pos += 2;
                        }
                    }
                }

                if (!handled)
                {
                    if (keys.Length - pos >= 3)
                    {
                        if (keys.Substring(pos, 3) == "{{}")
                        {
                            ClearModifiers(ref modifiers);
                            handled = true;

                            PressString("{");

                            pos += 2;
                        }
                    }
                }

                if (!handled)
                {
                    re = new Regex("^\\{([^\\{]+)\\}");
                    m  = re.Match(keys.Substring(pos));
                    if (m.Success)
                    {
                        handled = true;

                        int nextPos = pos;

                        HandleSpecial(state, m.Groups[1].ToString(), ref modifiers, ref nextPos);

                        if (nextPos != pos)
                        {
                            pos = nextPos - 1;
                        }
                        else
                        {
                            pos += m.Groups[1].ToString().Length + 1;
                        }
                    }
                }

                if (!handled)
                {
                    ClearModifiers(ref modifiers);
                    PressString(keys[pos].ToString());
                }
            }
        }