protected override bool ProcessDialogKey(Keys keyData) {
            if (keyData == Keys.Escape) {
                SelectedIndex = originalSelectedIndex;
            }

            return base.ProcessDialogKey(keyData);
        }

        public ModuleProperty(MacroList p, MacroModule mod, Keys shortcut)
        {
            _parent = p;
            _prevShortCut = shortcut;
            _module = mod==null? new MacroModule(0) : (MacroModule)mod.Clone();
            //
            // Windows �t�H�[�� �f�U�C�i �T�|�[�g�ɕK�v�ł��B
            //
            InitializeComponent();

            this._titleLabel.Text = GApp.Strings.GetString("Form.ModuleProperty._titleLabel");
            this._pathLabel.Text = GApp.Strings.GetString("Form.ModuleProperty._pathLabel");
            this._additionalAssemblyLabel.Text = GApp.Strings.GetString("Form.ModuleProperty._additionalAssemblyLabel");
            this._shortcutLabel.Text = GApp.Strings.GetString("Form.ModuleProperty._shortcutLabel");
            this._debugOption.Text = GApp.Strings.GetString("Form.ModuleProperty._debugOption");
            this._okButton.Text = GApp.Strings.GetString("Common.OK");
            this._cancelButton.Text = GApp.Strings.GetString("Common.Cancel");
            this.Text = GApp.Strings.GetString("Form.ModuleProperty.Text");

            if(mod!=null) {
                _title.Text = _module.Title;
                _path.Text = _module.Path;
                _additionalAssembly.Text = Concat(_module.AdditionalAssemblies);
                _debugOption.Checked = _module.DebugMode;
                _shortcut.Key = shortcut;
            }
        }

    public void Update(GameTime gameTime, Keys k, Keys p)
    {
        if (Playertype == 0)
        {
            KeyboardState currentKeyboardState = Keyboard.GetState();
            if (currentKeyboardState.IsKeyDown(k)) // getal geeft bewegingssnelheid aan. k is voor omlaag bewegen. 
            {
                Position.Y += 6;
            }

            else if (currentKeyboardState.IsKeyDown(p)) // getal geeft bewegingssnelheid aan. p is voor omhoog bewegen. 
            {
                Position.Y -= 6;
            }
        }
        else if (Playertype == 1)
        {
            for (int i = 0; i <= 5; i++)
            {
                if (this.MiddlePaddle > Pong.getGameState.PlayingBall.MiddleBall)
                {
                    Position.Y -= 1;
                }
                else if (this.MiddlePaddle < Pong.getGameState.PlayingBall.MiddleBall)
                {
                    Position.Y += 1;
                }
            }
        }
        BoundsPaddle.X = (int)Position.X;
        BoundsPaddle.Y = (int)Position.Y;
    }

        public string Convert(Keys[] keys)
        {
            string output = "";
            bool usesShift = (keys.Contains(Keys.LeftShift) || keys.Contains(Keys.RightShift));

            foreach (Keys key in keys)
            {
                if (key >= Keys.A && key <= Keys.Z)
                    output += key.ToString();
                else if (key >= Keys.NumPad0 && key <= Keys.NumPad9)
                    output += ((int)(key - Keys.NumPad0)).ToString();
                else if (key >= Keys.D0 && key <= Keys.D9)
                {
                    string num = ((int)(key - Keys.D0)).ToString();
                    output += num;
                }
                else if(key == Keys.Space)
                {
                    output += " ";
                }
                else if(key == Keys.OemPeriod)
                {
                    output += ".";
                }

                if (!usesShift) output = output.ToLower();
            }
            return output;
        }

 public KeyboardCombo(Keys key, bool alt, bool control, bool shift)
 {
     Key = key;
     Alt = alt;
     Control = control;
     Shift = shift;
 }

        public Arrow(Keys lastKey, object obj)
        {
            Image = new Image();
            switch (lastKey)
            {
                case Keys.W:
                    Image.Path = "Gameplay/Projectiles/arrow_up";
                    break;
                case Keys.S:
                    Image.Path = "Gameplay/Projectiles/arrow_down";
                    break;
                case Keys.A:
                    Image.Path = "Gameplay/Projectiles/arrow_left";
                    break;
                case Keys.D:
                    Image.Path = "Gameplay/Projectiles/arrow_right";
                    break;
            }

            DirectionKey = lastKey;

            if (obj.GetType() == typeof(Player))
            {
                Player p = (Player)obj;
                Image.Position = p.Image.Position;
            }
            MoveSpeed = 250f;
            Image.Scale = new Vector2(1, 2);
            Image.LoadContent();
        }

 protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 {
     if ((keyData == Keys.PageDown))
     {
         dataGridView1.ClearSelection();
         dataGridView4.ClearSelection();
         dataGridView4.Focus();
         dataGridView4.Rows[0].Selected = true;
         showDetail(dataGridView4.Rows[0].Cells[1].Value.ToString());
         return true;
     }
     else if (keyData == Keys.PageUp)
     {
         dataGridView1.ClearSelection();
         dataGridView4.ClearSelection();
         dataGridView1.Focus();
         dataGridView1.Rows[0].Selected = true;
         showDetail(dataGridView1.Rows[0].Cells[1].Value.ToString());
         return true;
     }
     else
     {
         return base.ProcessCmdKey(ref msg, keyData);
     }
 }

        /// <summary>
        /// キー情報から文字を取得する
        /// </summary>
        /// <param name="key">押下されたキー</param>
        /// <param name="shitKeyPressed">シフトキーが押されていたか?</param>
        /// <param name="character">キー入力から変換された文字</param>
        /// <returns>文字取得が成功した場合trueを返す</returns>
        public static bool KeyToString(Keys key, bool shitKeyPressed,
                                                                    out char character)
        {
            bool result = false;
            character = ' ';
            CharPair charPair;

            if ((Keys.A <= key && key <= Keys.Z) || key == Keys.Space)
            {
                // A～Z、スペースキーはそのまま文字コードとして使用する
                character = (shitKeyPressed) ? (char)key : Char.ToLower((char)key);
                result = true;
            }
            else if (keyMap.TryGetValue(key, out charPair))
            {
                // それ以外の場合はKeyMapの情報を元に変換する
                if (!shitKeyPressed)
                {
                    character = charPair.NormalChar;
                    result = true;
                }
                else if (charPair.ShiftChar.HasValue)
                {
                    character = charPair.ShiftChar.Value;
                    result = true;
                }
            }

            return result;
        }

 public static bool IsKeyDown(Keys key)
 {
     if (kbState.IsKeyDown(key))
         return true;
     else
         return false;
 }

        public virtual Action<KeyboardState, GameTime> Unregister(Keys key)
        {
            Action<KeyboardState, GameTime> action = _keyboardInput[key];
            _keyboardInput.Remove(key);

            return action;
        }

        public static void ProcessKeyPreview(ref Message m, Keys ModifierKeys)
        {
            const int WM_KEYDOWN = 0x100;
            //const int WM_KEYUP = 0x101;
            const int WM_CHAR = 0x102;
            const int WM_SYSCHAR = 0x106;
            const int WM_SYSKEYDOWN = 0x104;
            //const int WM_SYSKEYUP = 0x105;
            const int WM_IME_CHAR = 0x286;

            KeyEventArgs e = null;

            if ((m.Msg != WM_CHAR) && (m.Msg != WM_SYSCHAR) && (m.Msg != WM_IME_CHAR))
            {
                e = new KeyEventArgs(((Keys)((int)((long)m.WParam))) | ModifierKeys);
                if ((m.Msg == WM_KEYDOWN) || (m.Msg == WM_SYSKEYDOWN))
                    control.TrappedKeyDown(e);

                // Remove any WM_CHAR type messages if supresskeypress is true.
                if (e.SuppressKeyPress)
                {
                    RemovePendingMessages(WM_CHAR, WM_CHAR);
                    RemovePendingMessages(WM_SYSCHAR, WM_SYSCHAR);
                    RemovePendingMessages(WM_IME_CHAR, WM_IME_CHAR);
                }
            }
        }

        public void Update(GameTime time)
        {
            oldState = currentState;
            currentState = Microsoft.Xna.Framework.Input.Keyboard.GetState();
            shiftDown = currentState.IsKeyDown(Keys.LeftShift) || currentState.IsKeyDown(Keys.RightShift);

            currentlyPressed = currentState.GetPressedKeys();
            previouslyPressed = oldState.GetPressedKeys();

            if (currentlyPressed.Length != previouslyPressed.Length)
            {
                keyHoldTimer = 0.0f;
                keyHeld = false;
                lastKeyHeld = FindLastKeyPressed();
            }

            if (!keyHeld && currentlyPressed.Length > 0)
            {
                keyHoldTimer += (float)time.ElapsedGameTime.TotalMilliseconds;
                if (keyHoldTimer > keyHoldWait)
                {
                    keyHeld = true;
                }
            }
        }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if (keyData.HasFlag(Keys.Control))
            {
                if (keyData.HasFlag(Keys.O))
                {
                    OpenMenuItem.PerformClick();
                    return true;
                }
                if (keyData.HasFlag(Keys.Alt) && keyData.HasFlag(Keys.Shift) && keyData.HasFlag(Keys.S))
                {
                    SaveDecryptedMenuItem.PerformClick();
                    return true;
                }
                if (keyData.HasFlag(Keys.Shift) && keyData.HasFlag(Keys.S))
                {
                    SaveEncryptedMenuItem.PerformClick();
                    return true;
                }
                if (keyData.HasFlag(Keys.S))
                {
                    SaveMenuItem.PerformClick();
                    return true;
                }
            }

            return m_tabPages.Any(tabPage => tabPage.OnHotkey(keyData)) || base.ProcessCmdKey(ref msg, keyData);
        }

            /// <summary>
            /// Wait until the key gets pressed.
            /// </summary>
            /// <param name="k"></param>
            public void Wait(Keys k)
            {
                if (k == Keys.None)
                    throw new ArgumentException("Must submit valid Key definition!");
                _endKey = k;

                if (this.TimeOutVal.HasValue)
                {
                    _timeoutTimer = new System.Threading.Timer(new System.Threading.TimerCallback(OnTimoutTick));
                    _timeoutTimer.Change(this.TimeOutVal.Value, Timeout.Infinite);
                }
                _keyboardHook.IAKeyEvent += OnKeyEvent;

                while (true)
                {
                    lock (abortLock)
                    {
                        if (abort)
                            break;
                    }
                    Application.DoEvents(); // This is necessary if the Wait Method gets called on the Main GUI Thread
                    Thread.Sleep(2);
                }
                _keyboardHook.IAKeyEvent -= OnKeyEvent;
            }

 public void LoadFromJson(JObject jsonData)
 {
     string tempTriggerKey = (string)jsonData["trigger key"];         // Load String from json
     VirtualKeyCode vkCode = KeyTranslater.GetKeyCode(tempTriggerKey); // Convert the string to a keycode using the Keytranslator
     triggerKey = (Keys)vkCode;                                        // Cast the Vkeycode to a key and save to the class
     commandWord = (string)jsonData["command word"];
 }

        public static KeyboardShortcut FromKeys(Keys keys)
        {
            KeyboardShortcut ks = new KeyboardShortcut();

            // check for modifers and remove from val
            if (IsSet(keys, Keys.Control))
            {
                ks.Modifiers |= Keys.Control;
                keys ^= Keys.Control;
            }
            if (IsSet(keys, Keys.Alt))
            {
                ks.Modifiers |= Keys.Alt;
                keys ^= Keys.Alt;
            }
            if (IsSet(keys, Keys.Shift))
            {
                ks.Modifiers |= Keys.Shift;
                keys ^= Keys.Shift;
            }

            // remaining should be the key
            ks.Key = keys;

            return ks;
        }

 protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 {
     if (keyData == Keys.Enter)
     {
         if (!(this.current_focused_control is Button))
         {
             if (this.current_focused_control.Name == this.mskNewSernum.Name)
             {
                 if (ValidateSN.Check(this.mskNewSernum.Text))
                 {
                     SendKeys.Send("{TAB}");
                     return true;
                 }
             }
             else
             {
                 SendKeys.Send("{TAB}");
                 return true;
             }
         }
     }
     if (keyData == Keys.Escape)
     {
         this.DialogResult = DialogResult.Cancel;
         this.Close();
         return true;
     }
     return base.ProcessCmdKey(ref msg, keyData);
 }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            if ((keyData & Keys.F5) == Keys.F5)
                this.TriggerCompileButtonClicked();

            return base.ProcessCmdKey(ref msg, keyData);
        }

        /// <summary>
        /// Gets the human readable representation of the given keys.
        /// </summary>
        /// <param name="keys">Pressed keys</param>
        /// <returns>Keys separated by plus sign</returns>
        public static string GetShortcutString(Keys keys)
        {
            if (keys == Keys.None)
            {
                return string.Empty;
            }

            List<string> singleKeys = new List<string>();

            if ((keys & Keys.Control) == Keys.Control)
            {
                singleKeys.Add("Control");
                keys = keys ^ Keys.Control;
            }
            if ((keys & Keys.Alt) == Keys.Alt)
            {
                singleKeys.Add("Alt");
                keys = keys ^ Keys.Alt;
            }
            if ((keys & Keys.Shift) == Keys.Shift)
            {
                singleKeys.Add("Shift");
                keys = keys ^ Keys.Shift;
            }

            foreach (Keys key in EndKeys)
            {
                if (keys == key)
                {
                    singleKeys.Add(new KeysConverter().ConvertTo(key, typeof(string)) as string);
                }
            }

            return String.Join("+", singleKeys.ToArray());
        }

        /// <summary>
        /// Sets the char value for the specified key and key modifier combination
        /// </summary>
        /// <param name="key">The key for which to set the corresponding char value</param>
        /// <param name="mod">The key modifier for which to set the corresponding char value</param>
        /// <param name="ch">The char value to set for the specified key and key modifier</param>
        public static void SetCharacter(Keys key, KeyModifier mod, char ch)
        {
            if (!mMap.ContainsKey(key))
                mMap.Add(key, new Dictionary<KeyModifier, char>());

            mMap[key][mod] = ch;
        }