Esempio n. 1
0
        private static void FixEventSeq(List <SiEvent> l)
        {
            // Convert chars to keys
            // Keys kMod = Keys.None;
            for (int i = 0; i < l.Count; ++i)
            {
                SiEvent     si = l[i];
                SiEventType t  = si.Type;

                // if(t == SiEventType.KeyModifier)
                // {
                //	if(!si.Down.HasValue) { Debug.Assert(false); continue; }
                //	if(si.Down.Value)
                //	{
                //		Debug.Assert((kMod & si.KeyModifier) == Keys.None);
                //		kMod |= si.KeyModifier;
                //	}
                //	else
                //	{
                //		Debug.Assert((kMod & si.KeyModifier) == si.KeyModifier);
                //		kMod &= ~si.KeyModifier;
                //	}
                // }
                if (t == SiEventType.Char)
                {
                    // bool bLightConv = (kMod == Keys.None);
                    int iVKey = SiCodes.CharToVKey(si.Char, true);
                    if (iVKey > 0)
                    {
                        si.Type = SiEventType.Key;
                        si.VKey = iVKey;
                    }
                }
            }
        }
Esempio n. 2
0
        private static void Beep(SiEvent si)
        {
            try
            {
                string str = si.Text;
                if (string.IsNullOrEmpty(str))
                {
                    SystemSounds.Beep.Play();
                    return;
                }

                string[] v = str.Split(new char[] { ' ', '\t' },
                                       StringSplitOptions.RemoveEmptyEntries);

                int f = 800, d = 200; // Defaults of Console.Beep()
                if (v.Length >= 1)
                {
                    int.TryParse(v[0], out f);
                }
                if (v.Length >= 2)
                {
                    int.TryParse(v[1], out d);
                }

                f = Math.Min(Math.Max(f, 37), 32767);
                if (d <= 0)
                {
                    return;
                }

                Console.Beep(f, d); // Throws on a server
            }
            catch (Exception) { Debug.Assert(false); }
        }
Esempio n. 3
0
 private static bool IsClipboardOp(SiEvent si)
 {
     if (si == null)
     {
         Debug.Assert(false); return(false);
     }
     return(si.Type == SiEventType.ClipboardCopy);
 }
Esempio n. 4
0
        private static void AppActivate(SiEvent si)
        {
            try
            {
                if (string.IsNullOrEmpty(si.Text))
                {
                    return;
                }

                IntPtr h = NativeMethods.FindWindow(si.Text);
                if (h != IntPtr.Zero)
                {
                    NativeMethods.EnsureForegroundWindow(h);
                }
            }
            catch (Exception) { Debug.Assert(false); }
        }
Esempio n. 5
0
        private static void EnsureKeyModifiers(Keys kReqMods, ref Keys kCurKbMods,
                                               List <SiEvent> l)
        {
            if (kReqMods == kCurKbMods)
            {
                return;
            }

            if ((kReqMods & Keys.Shift) != (kCurKbMods & Keys.Shift))
            {
                SiEvent si = new SiEvent();
                si.Type        = SiEventType.KeyModifier;
                si.KeyModifier = Keys.Shift;
                si.Down        = ((kReqMods & Keys.Shift) != Keys.None);

                l.Add(si);
            }

            if ((kReqMods & Keys.Control) != (kCurKbMods & Keys.Control))
            {
                SiEvent si = new SiEvent();
                si.Type        = SiEventType.KeyModifier;
                si.KeyModifier = Keys.Control;
                si.Down        = ((kReqMods & Keys.Control) != Keys.None);

                l.Add(si);
            }

            if ((kReqMods & Keys.Alt) != (kCurKbMods & Keys.Alt))
            {
                SiEvent si = new SiEvent();
                si.Type        = SiEventType.KeyModifier;
                si.KeyModifier = Keys.Alt;
                si.Down        = ((kReqMods & Keys.Alt) != Keys.None);

                l.Add(si);
            }

            kCurKbMods = kReqMods;
        }
Esempio n. 6
0
        private static List <SiEvent> ParseSpecial(CharStream cs)
        {
            // Skip leading white space
            while (true)
            {
                char ch = cs.PeekChar();
                if (ch == char.MinValue)
                {
                    Debug.Assert(false); return(null);
                }

                if (!char.IsWhiteSpace(ch))
                {
                    break;
                }
                cs.ReadChar();
            }

            // First char is *always* part of the name (support for "{{}", etc.)
            char chFirst = cs.ReadChar();

            if (chFirst == char.MinValue)
            {
                Debug.Assert(false); return(null);
            }

            int           iPart = 0;
            StringBuilder sbName = new StringBuilder(), sbParams =
                new StringBuilder();

            sbName.Append(chFirst);

            while (true)
            {
                char ch = cs.ReadChar();
                if (ch == char.MinValue)
                {
                    Debug.Assert(false); return(null);
                }
                if (ch == '}')
                {
                    break;
                }

                if (iPart == 0)
                {
                    if (char.IsWhiteSpace(ch))
                    {
                        ++iPart;
                    }
                    else
                    {
                        sbName.Append(ch);
                    }
                }
                else
                {
                    sbParams.Append(ch);
                }
            }

            string strName   = sbName.ToString();
            string strParams = sbParams.ToString().Trim();

            uint?ouParam = null;

            if (strParams.Length > 0)
            {
                uint uParamTry;
                if (uint.TryParse(strParams, out uParamTry))
                {
                    ouParam = uParamTry;
                }
            }

            List <SiEvent> l = new List <SiEvent>();

            if (strName.Equals("DELAY", StrUtil.CaseIgnoreCmp))
            {
                if (!ouParam.HasValue)
                {
                    Debug.Assert(false); return(null);
                }

                SiEvent si = new SiEvent();
                si.Type  = SiEventType.Delay;
                si.Delay = ouParam.Value;

                l.Add(si);
                return(l);
            }
            if (strName.StartsWith("DELAY=", StrUtil.CaseIgnoreCmp))
            {
                SiEvent si = new SiEvent();
                si.Type = SiEventType.SetDefaultDelay;

                string strDelay = strName.Substring(6).Trim();
                uint   uDelay;
                if (uint.TryParse(strDelay, out uDelay))
                {
                    si.Delay = uDelay;
                }
                else
                {
                    Debug.Assert(false); return(null);
                }

                l.Add(si);
                return(l);
            }
            if (strName.Equals("VKEY", StrUtil.CaseIgnoreCmp) ||
                strName.Equals("VKEY-NX", StrUtil.CaseIgnoreCmp) ||
                strName.Equals("VKEY-EX", StrUtil.CaseIgnoreCmp))
            {
                if (!ouParam.HasValue)
                {
                    Debug.Assert(false); return(null);
                }

                SiEvent si = new SiEvent();
                si.Type = SiEventType.Key;
                si.VKey = (int)ouParam.Value;

                if (strName.EndsWith("-NX", StrUtil.CaseIgnoreCmp))
                {
                    si.ExtendedKey = false;
                }
                else if (strName.EndsWith("-EX", StrUtil.CaseIgnoreCmp))
                {
                    si.ExtendedKey = true;
                }

                l.Add(si);
                return(l);
            }
            if (strName.Equals("APPACTIVATE", StrUtil.CaseIgnoreCmp))
            {
                SiEvent si = new SiEvent();
                si.Type = SiEventType.AppActivate;
                si.Text = strParams;

                l.Add(si);
                return(l);
            }
            if (strName.Equals("BEEP", StrUtil.CaseIgnoreCmp))
            {
                SiEvent si = new SiEvent();
                si.Type = SiEventType.Beep;
                si.Text = strParams;

                l.Add(si);
                return(l);
            }

            SiCode siCode = SiCodes.Get(strName);

            SiEvent siTmpl = new SiEvent();

            if (siCode != null)
            {
                siTmpl.Type        = SiEventType.Key;
                siTmpl.VKey        = siCode.VKey;
                siTmpl.ExtendedKey = siCode.ExtKey;
            }
            else if (strName.Length == 1)
            {
                siTmpl.Type = SiEventType.Char;
                siTmpl.Char = strName[0];
            }
            else
            {
                // TODO: UI messages shall be handled during globalization/localization process
                throw new FormatException("Auto type unknown placeholder\n" + @"{" + strName + @"}");
            }

            uint uRepeat = 1;

            if (ouParam.HasValue)
            {
                uRepeat = ouParam.Value;
            }

            for (uint u = 0; u < uRepeat; ++u)
            {
                SiEvent si = new SiEvent();
                si.Type        = siTmpl.Type;
                si.VKey        = siTmpl.VKey;
                si.ExtendedKey = siTmpl.ExtendedKey;
                si.Char        = siTmpl.Char;

                l.Add(si);
            }

            return(l);
        }
Esempio n. 7
0
        private static List <SiEvent> Parse(string strSequence)
        {
            CharStream     cs = new CharStream(strSequence);
            List <SiEvent> l  = new List <SiEvent>();
            // TODO: UI messages shall be handled during globalization/localization process
            string strError = "Invalid Auto fill sequence";

            Keys kCurKbMods = Keys.None;

            List <Keys> lMods = new List <Keys>();

            lMods.Add(Keys.None);

            while (true)
            {
                char ch = cs.ReadChar();
                if (ch == char.MinValue)
                {
                    break;
                }

                if ((ch == '+') || (ch == '^') || (ch == '%'))
                {
                    if (lMods.Count == 0)
                    {
                        Debug.Assert(false); break;
                    }
                    else if (ch == '+')
                    {
                        lMods[lMods.Count - 1] |= Keys.Shift;
                    }
                    else if (ch == '^')
                    {
                        lMods[lMods.Count - 1] |= Keys.Control;
                    }
                    else if (ch == '%')
                    {
                        lMods[lMods.Count - 1] |= Keys.Alt;
                    }
                    else
                    {
                        Debug.Assert(false);
                    }

                    continue;
                }
                else if (ch == '(')
                {
                    lMods.Add(Keys.None);
                    continue;
                }
                else if (ch == ')')
                {
                    if (lMods.Count >= 2)
                    {
                        lMods.RemoveAt(lMods.Count - 1);
                        lMods[lMods.Count - 1] = Keys.None;
                    }
                    else
                    {
                        throw new FormatException(strError);
                    }

                    continue;
                }

                Keys kEffMods = Keys.None;
                foreach (Keys k in lMods)
                {
                    kEffMods |= k;
                }

                EnsureKeyModifiers(kEffMods, ref kCurKbMods, l);

                if (ch == '{')
                {
                    List <SiEvent> lSub = ParseSpecial(cs);
                    if (lSub == null)
                    {
                        throw new FormatException(strError);
                    }

                    l.AddRange(lSub);
                }
                else if (ch == '}')
                {
                    throw new FormatException(strError);
                }
                else if (ch == '~')
                {
                    SiEvent si = new SiEvent();
                    si.Type = SiEventType.Key;
                    si.VKey = (int)Keys.Enter;

                    l.Add(si);
                }
                else
                {
                    SiEvent si = new SiEvent();
                    si.Type = SiEventType.Char;
                    si.Char = ch;

                    l.Add(si);
                }

                lMods[lMods.Count - 1] = Keys.None;
            }

            EnsureKeyModifiers(Keys.None, ref kCurKbMods, l);

            return(l);
        }