private static void NormalizeCoordinates(ref int x, ref int y)
        {
            int vScreenWidth  = MySendKeys.GetSystemMetrics(MySendKeys.SMCxvirtualscreen);
            int vScreenHeight = MySendKeys.GetSystemMetrics(MySendKeys.SMCyvirtualscreen);
            int vScreenLeft   = MySendKeys.GetSystemMetrics(MySendKeys.SMXvirtualscreen);
            int vScreenTop    = MySendKeys.GetSystemMetrics(MySendKeys.SMYvirtualscreen);

            // Absolute input requires that input is in 'normalized' coords - with the entire
            // desktop being (0,0)...(65536,65536). Need to convert input x,y coords to this
            // first.
            //
            // In this normalized world, any pixel on the screen corresponds to a block of values
            // of normalized coords - eg. on a 1024x768 screen,
            // y pixel 0 corresponds to range 0 to 85.333,
            // y pixel 1 corresponds to range 85.333 to 170.666,
            // y pixel 2 correpsonds to range 170.666 to 256 - and so on.
            // Doing basic scaling math - (x-top)*65536/Width - gets us the start of the range.
            // However, because int math is used, this can end up being rounded into the wrong
            // pixel. For example, if we wanted pixel 1, we'd get 85.333, but that comes out as
            // 85 as an int, which falls into pixel 0's range - and that's where the pointer goes.
            // To avoid this, we add on half-a-"screen pixel"'s worth of normalized coords - to
            // push us into the middle of any given pixel's range - that's the 65536/(Width*2)
            // part of the formula. So now pixel 1 maps to 85+42 = 127 - which is comfortably
            // in the middle of that pixel's block.
            // The key ting here is that unlike points in coordinate geometry, pixels take up
            // space, so are often better treated like rectangles - and if you want to target
            // a particular pixel, target its rectangle's midpoint, not its edge.
            x = ((x - vScreenLeft) * 65536) / vScreenWidth + 65536 / (vScreenWidth * 2);
            y = ((y - vScreenTop) * 65536) / vScreenHeight + 65536 / (vScreenHeight * 2);
        }
        private static void SendMouseInput(int x, int y, int data, MySendKeys.SendMouseInputFlags flags)
        {
            PermissionSet permissions = new PermissionSet(PermissionState.Unrestricted);

            permissions.Demand();

            int intflags = (int)flags;

            if ((intflags & (int)MySendKeys.SendMouseInputFlags.Absolute) != 0)
            {
                // Absolute position requires normalized coordinates.
                NormalizeCoordinates(ref x, ref y);
                intflags |= MySendKeys.MouseeventfVirtualdesk;
            }

            MySendKeys.INPUT mi = new MySendKeys.INPUT();
            mi.type = MySendKeys.InputMouse;
            mi.union.mouseInput.dx          = x;
            mi.union.mouseInput.dy          = y;
            mi.union.mouseInput.mouseData   = data;
            mi.union.mouseInput.dwFlags     = intflags;
            mi.union.mouseInput.time        = 0;
            mi.union.mouseInput.dwExtraInfo = new IntPtr(0);

            if (MySendKeys.SendInput(1, ref mi, Marshal.SizeOf(mi)) == 0)
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
        }
        public static bool GetCapsLockStatus()
        {
            //if ((MySendKeys.GetKeyState(0x20) & 0x8000)!=0) return true;
            bool CapsLock = (((ushort)MySendKeys.GetKeyState(0x14)) & 0xffff) != 0;


            return(CapsLock);
        }
        private static void SendKeyboardInput(Key key, bool press)
        {
            PermissionSet permissions = new PermissionSet(PermissionState.Unrestricted);

            permissions.Demand();

            MySendKeys.INPUT ki = new MySendKeys.INPUT();
            ki.type = MySendKeys.InputKeyboard;
            ki.union.keyboardInput.wVk   = (short)KeyInterop.VirtualKeyFromKey(key);
            ki.union.keyboardInput.wScan = (short)MySendKeys.MapVirtualKey(ki.union.keyboardInput.wVk, 0);

            int dwFlags = 0;

            if (ki.union.keyboardInput.wScan > 0)
            {
                dwFlags |= MySendKeys.KeyeventfScancode;
            }

            if (!press)
            {
                dwFlags |= MySendKeys.KeyeventfKeyup;
            }

            ki.union.keyboardInput.dwFlags = dwFlags;

            if (ExtendedKeys.Contains(key))
            {
                ki.union.keyboardInput.dwFlags |= MySendKeys.KeyeventfExtendedkey;
            }

            ki.union.keyboardInput.time        = 0;
            ki.union.keyboardInput.dwExtraInfo = new IntPtr(0);

            if (MySendKeys.SendInput(1, ref ki, Marshal.SizeOf(ki)) == 0)
            {
                throw new Win32Exception(Marshal.GetLastWin32Error());
            }
        }
        /// <summary>
        /// Types the specified text.
        /// </summary>
        /// <param name="text">The text to type.</param>
        public static void Type(string text)
        {
            foreach (char c in text)
            {
                // We get the vKey value for the character via a Win32 API. We then use bit masks to pull the
                // upper and lower bytes to get the shift state and key information. We then use WPF KeyInterop
                // to go from the vKey key info into a System.Windows.Input.Key data structure. This work is
                // necessary because Key doesn't distinguish between upper and lower case, so we have to wrap
                // the key type inside a shift press/release if necessary.
                int  vKeyValue    = MySendKeys.VkKeyScan(c);
                bool keyIsShifted = (vKeyValue & MySendKeys.VKeyShiftMask) == MySendKeys.VKeyShiftMask;
                Key  key          = KeyInterop.KeyFromVirtualKey(vKeyValue & MySendKeys.VKeyCharMask);

                if (keyIsShifted)
                {
                    Type(key, new Key[] { Key.LeftShift });
                }
                else
                {
                    Type(key);
                }
            }
        }
 public static void Type2(Key key)
 {
     MySendKeys.keybd_event((byte)KeyInterop.VirtualKeyFromKey(key), 0, 0, 0);
     MySendKeys.keybd_event((byte)KeyInterop.VirtualKeyFromKey(key), 0, 2, 0);
 }