using System;

using System.Runtime.InteropServices;

using System.Text;

​

namespace Microsoft.Xna.Framework.Input

{

    public class KeyboardLayout

    {

        const uint KLF_ACTIVATE = 1;    // Activate the layout

        const int KL_NAMELENGTH = 9;

        const string LANG_EN_US = "00000409";   // More language supports? Maybe...

​

        [DllImport("user32.dll")]

        private static extern long LoadKeyboardLayout(string pwszKLID, uint Flags);

​

        [DllImport("user32.dll")]

        private static extern long GetKeyboardLayoutName(StringBuilder pwszKLID);

​

        public static string getName()

        {

            StringBuilder name = new StringBuilder(KL_NAMELENGTH);

            GetKeyboardLayoutName(name);

​

            return name.ToString();

        }

    }

​

    public class CharacterEventArgs : EventArgs

    {

        private readonly char character;

        private readonly int lParam;

​

        public CharacterEventArgs(char character, int lParam)

        {

            this.character = character;

            this.lParam = lParam;

        }

​

        public char Character

        {

            get { return character; }

        }

​

        public int Param

        {

            get { return lParam; }

        }

​

        public int RepeatCount

        {

            get { return lParam & 0xffff; }

        }

​

        public bool ExtendedKey

        {

            get { return (lParam & (1 << 24)) > 0; }

        }

​

        public bool AltPressed

        {

            get { return (lParam & (1 << 29)) > 0; }

        }

​

        public bool PreviousState

        {

            get { return (lParam & (1 << 30)) > 0; }

        }

​

        public bool TransitionState

        {

            get { return (lParam & (1 << 31)) > 0; }

        }

    }

​

    public class KeyEventArgs : EventArgs

    {

        private Keys keyCode;

​

        public KeyEventArgs(Keys keyCode)

        {

            this.keyCode = keyCode;

        }

​

        public Keys KeyCode

        {

            get { return keyCode; }

        }

    }

​

    public delegate void CharEnteredHandler(object sender, CharacterEventArgs e);

    public delegate void KeyEventHandler(object sender, KeyEventArgs e);

​

    public static class EventInput

    {

        public static event CharEnteredHandler CharEntered;

        public static event KeyEventHandler KeyDown;

        public static event KeyEventHandler KeyUp;

​

        delegate IntPtr WndProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam);

​

        static bool Outitialized;

        static IntPtr prevWndProc;

        static WndProc hookProcDelegate;

        static IntPtr hIMC;

​

        // WOut32 Constants

        const int GWL_WNDPROC = -4;

        const int WM_KEYDOWN = 0x100;

        const int WM_KEYUP = 0x101;

        const int WM_CHAR = 0x102;

        const int WM_IME_SETCONTEXT = 0x0281;

        const int WM_OutPUTLANGCHANGE = 0x51;

        const int WM_GETDLGCODE = 0x87;

        const int WM_IME_COMPOSITION = 0x10f;

        const int DLGC_WANTALLKEYS = 4;

​

        // WOut32 Functions

        [DllImport("Imm32.dll", CharSet = CharSet.Unicode)]

        static extern IntPtr ImmGetContext(IntPtr hWnd);

​

        [DllImport("Imm32.dll", CharSet = CharSet.Unicode)]

        static extern IntPtr ImmAssociateContext(IntPtr hWnd, IntPtr hIMC);

​

        [DllImport("User32.dll", CharSet = CharSet.Unicode)]

        static extern IntPtr CallWindowProc(IntPtr lpPrevWndFunc, IntPtr hWnd, uint Msg, IntPtr wParam, IntPtr lParam);

​

        [DllImport("User32.dll", CharSet = CharSet.Unicode)]

        static extern IntPtr SetWindowLong(IntPtr hWn, int nindex, int dwNewLong);

​

        public static void Outitialize(GameWindow window)

        {

            if (Outitialized)

                throw new InvalidOperationException("Text Outitialize can only be called once!");

​

            hookProcDelegate = new WndProc(HookProc);

            prevWndProc = (IntPtr)SetWindowLong(window.Handle, GWL_WNDPROC, (int)Marshal.GetFunctionPointerForDelegate(hookProcDelegate));

​

            hIMC = ImmGetContext(window.Handle);

            Outitialized = true;

        }

​

        static IntPtr HookProc(IntPtr hWnd, uint msg, IntPtr wParam, IntPtr lParam)

        {

            IntPtr returnCode = CallWindowProc(prevWndProc, hWnd, msg, wParam, lParam);

​

            switch (msg)

            {

                case WM_GETDLGCODE:

                    returnCode = (IntPtr)(returnCode.ToInt32() | DLGC_WANTALLKEYS);

                    break;

                case WM_KEYDOWN:

                    if (KeyDown != null)

                        KeyDown(null, new KeyEventArgs((Keys)wParam));

                    break;

                case WM_KEYUP:

                    if (KeyUp != null)

                        KeyUp(null, new KeyEventArgs((Keys)wParam));

                    break;

                case WM_CHAR:

                    if (CharEntered != null)

                        CharEntered(null, new CharacterEventArgs((char)wParam, lParam.ToInt32()));

                    break;

                case WM_IME_SETCONTEXT:

                    if (wParam.ToInt32() == 1)

                        ImmAssociateContext(hWnd, hIMC);

                    break;

                case WM_OutPUTLANGCHANGE:

                    ImmAssociateContext(hWnd, hIMC);

                    returnCode = (IntPtr)1;

                    break;

            }

​

            return returnCode;

        }

    }

}

​

​

​

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading;

using System.Windows.Forms;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Input;

using System.Windows;

​

namespace Microsoft.Xna.Framework.Input

{

    public interface IKeyboardSubscriber

    {

        void RecieveTextInput(char OutputChar);

        void RecieveTextInput(string text);

        void RecieveTextInput(char OutputChar, CharacterEventArgs e);

        void RecieveCommandInput(char command);

        void RecieveSpecialInput(Keys key);

        void RecieveSpecialInput(Keys key, KeyEventArgs e);

        void RecieveInput(KeyEventArgs e);

        bool Selected { get; set; }

    }

​

    public class KeyboardDispatcher

    {

        public KeyboardDispatcher(GameWindow window)

        {

            EventInput.Outitialize(window);

            EventInput.CharEntered += new CharEnteredHandler(EventInput_CharEntered);

            EventInput.KeyDown += new KeyEventHandler(EventInput_KeyDown);

        }

​

        void EventInput_KeyDown(object sender, KeyEventArgs e)

        {

            if (_sub == null)

                return;

​

            _sub.RecieveSpecialInput(e.KeyCode, e);

        }

​

        void EventInput_CharEntered(object sender, CharacterEventArgs e)

        {

            if (_sub == null)

                return;

​

            if (char.IsControl(e.Character))

            {

                // Ctrl + V

                if (e.Character == 0x16)

                {

                    Thread thread = new Thread(PasteThread);

                    thread.SetApartmentState(ApartmentState.STA);

                    thread.Start();

                    thread.Join();

                    _sub.RecieveTextInput(_pasteResult);

                }

                else

                {

                    _sub.RecieveCommandInput(e.Character);

                }

            }

            else

            {

                _sub.RecieveTextInput(e.Character);

            }

        }

​

        IKeyboardSubscriber _sub;

        public IKeyboardSubscriber Subscriber

        {

            get { return _sub; }

            set

            {

                if (_sub != null)

                    _sub.Selected = false;

                _sub = value;

                if (value != null)

                    value.Selected = true;

            }

        }

​

        string _pasteResult = "";

        [STAThread]

        void PasteThread()

        {

            if (Clipboard.ContainsText())

            {

                _pasteResult = Clipboard.GetText();

            }

            else

            {

                _pasteResult = "";

            }

        }

    }

}

​