/// <summary>
 /// Обычный конструктор
 /// </summary>
 public ApplicationMessageBinding(ApplicationMessage message, Keys mainKey, WindowMessage messageType)
 {
     Message = message;
     Title = EnumFriendlyName<ApplicationMessage>.GetString(message);
     this.mainKey = mainKey;
     this.messageType = messageType;
 }

        internal IntPtr FilterMessage( IntPtr hwnd, WindowMessage msg, IntPtr wParam, IntPtr lParam, ref bool handled )
        {
            // It is possible to be re-entered during disposal.  Just return.
            if(null == _source || null == _source.Value)
            {
                return IntPtr.Zero;
            }
            
            if (msg == WindowMessage.WM_APPCOMMAND)
            {
                // WM_APPCOMMAND message notifies a window that the user generated an application command event,
                // for example, by clicking an application command button using the mouse or typing an application command
                // key on the keyboard.
                RawAppCommandInputReport report = new RawAppCommandInputReport(
                                                        _source.Value,
                                                        InputMode.Foreground,
                                                        SafeNativeMethods.GetMessageTime(),
                                                        GetAppCommand(lParam),
                                                        GetDevice(lParam),
                                                        InputType.Command);

                handled = _site.Value.ReportInput(report);
            }
            
            return handled ? new IntPtr(1) : IntPtr.Zero ;
        }

 public override void SendWindowMsg(WindowMessage msg, params object[] args)
 {
     base.SendWindowMsg(msg, args);
     switch (msg) {
         case WindowMessage.eWindow_BeAttacked:
             //受击者被攻击
             BattleRoleItem script = this.BeAttackedRoleGo.GetComponent<BattleRoleItem>();
             script.SetBeAttackTargetPos((Vector3)args[0]);
             script.BeAttackedStart();
             break;
         case WindowMessage.eWindow_BattleStart:
             SetAttackBothSide((RoleType)args[0]);
             BattleStart();
             break;
         case WindowMessage.eWindow_CurRoundOver:
             BeforeNextRound();
             if (BattleMgr.Instance.IsBattleOver()) {
                 BattleMgr.Instance.CurBattleStatus = BattleStatus.Invalid;
                 return;
             }
             BattleMgr.Instance.bStartRun = true;   //本轮攻击结束，开始跑速
             break;
         default:
             break;
     }
 }

 public void Initialize()
 {
     var window = new WindowMessage(Text);
     ManagerWindow.NewWindow("gameEventMessage",window);
     ManagerInput.ThrottleInput = true;
     Done = false;
 }

        public bool RegisterWindowMessageHandler(WindowMessage callback)
        {
            bool result = true;
            if (null == callback)
            {
                throw FxTrace.Exception.AsError(new ArgumentNullException("callback"));
            }

            //if there are no other callbacks registered - create initial multicast delegate 
            //and hookup message processing
            if (null == this.listeners)
            {
                this.listeners = (WindowMessage)Delegate.Combine(callback);
                this.HookupMessageProcessing();
            }
                //otherwise, check if callback is not in the list already
            else 
            {
                Delegate[] initial = this.listeners.GetInvocationList();
                //if it isn't - add it to callback list
                if (-1 == Array.IndexOf<Delegate>(initial, callback))
                {
                    Delegate[] combined = new Delegate[initial.Length + 1];
                    combined[initial.Length] = callback;
                    Array.Copy(initial, combined, initial.Length);

                    this.listeners = (WindowMessage)Delegate.Combine(combined);
                }
                else
                {
                    result = false;
                }
            }
            return result;
        }

        protected override bool DialogProc(IntPtr hwndDlg, WindowMessage uMsg, IntPtr wParam, IntPtr lParam)
        {
            switch (uMsg)
            {
                case WindowMessage.InitDialog:
                    {
                        Rect initialSize = new Rect
                        {
                            Left = 0,
                            Top = 0,
                            Right = 260,
                            Bottom = 260
                        };

                        Win32.MapDialogRect(hwndDlg, ref initialSize);

                        this.Size = new System.Drawing.Size(initialSize.Right, initialSize.Bottom);

                        this.Refresh();
                    }
                    break;
            }

            return base.DialogProc(hwndDlg, uMsg, wParam, lParam);
        }

 internal KeyboardKeyAction GetKeyboardKeyAction(WindowMessage message)
 {
     KeyboardKeyAction action;
     if (!_mappings.WindowMessageToKeyboardKeyAction.TryGetValue(message, out action))
     {
         action = KeyboardKeyAction.None;
     }
     return action;
 }

 public void SendWindowMsg(WindowID targetWindow, WindowMessage msg, params object[] args)
 {
     if (!AllWindowScript.ContainsKey(targetWindow)) {
         return;
     }
     if (!AllWindowScript[targetWindow]) {
         return;
     }
     AllWindowScript[targetWindow].SendWindowMsg(msg, args);
 }

        protected override unsafe bool DialogProc(IntPtr hwndDlg, WindowMessage uMsg, IntPtr wParam, IntPtr lParam)
        {
            switch (uMsg)
            {
                case WindowMessage.InitDialog:
                    {
                        Rect initialSize;

                        initialSize.left = 0;
                        initialSize.top = 0;
                        initialSize.right = 260;
                        initialSize.bottom = 260;
                        NativeApi.MapDialogRect(hwndDlg, ref initialSize);
                        this.Size = new System.Drawing.Size(initialSize.right, initialSize.bottom);
                    }
                    break;
                case WindowMessage.ShowWindow:
                    if (!_layoutInitialized)
                    {
                        void* dialogItem = NativeApi.PhAddPropPageLayoutItem(
                            hwndDlg,
                            hwndDlg,
                            (void*)0x1, // PH_PROP_PAGE_TAB_CONTROL_PARENT
                            0xf // PH_ANCHOR_ALL
                            );

                        // Resize our .NET-based control automatically as well.
                        NativeApi.PhAddPropPageLayoutItem(
                            hwndDlg,
                            this.Handle,
                            dialogItem,
                            0xf // PH_ANCHOR_ALL
                            );

                        NativeApi.PhDoPropPageLayout(hwndDlg);

                        _layoutInitialized = true;
                    }
                    break;
            }

            return base.DialogProc(hwndDlg, uMsg, wParam, lParam);
        }

 public static Boolean ScrollToBottom(IntPtr Handle, Boolean Blocking)
 {
     WindowMessage Message = new WindowMessage();
     Message.Handle = Handle;
     Message.InVal = KEYWORDS.WM_VSCROLL;
     Message.PtrLparam = new IntPtr(0);
     Message.PtrWparam = KEYWORDS.SB_BOTTOM;
     if (Blocking)
     {
         return System.Boolean.Equals(true, SendWindowMessage(Message));
     }
     else
     {
         ParameterizedThreadStart pts = new ParameterizedThreadStart(SendWindowMessage);
         Thread t = new Thread(pts);
         t.Start(Message);
         return false;
     }
 }

 void HandleXButtonDown(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
 {
     Functions.SetCapture(window.Handle);
     mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) == 1 ?
         MouseButton.Button1 : MouseButton.Button2] = true;
 }

 void HandleRButtonDown(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
 {
     Functions.SetCapture(window.Handle);
     mouse[MouseButton.Right] = true;
 }

		/// <summary>
		/// Filters out a mouse message before it is dispatched
		/// </summary>
		/// <param name="target">The Control that will receive the message</param>
		/// <param name="msg">A WindowMessage that represents the message to process</param>
		/// <param name="wParam">Specifies the WParam field of the message</param>
		/// <param name="lParam">Specifies the LParam field of the message</param>
		/// <returns>true to filter the message and prevent it from being dispatched; 
		/// false to allow the message to continue to the next filter or control</returns>
		public override bool ProcessMouseMessage(Control target, WindowMessage msg, int wParam, int lParam)
		{
			if (this.DroppedDown)
			{
				if (msg == WindowMessage.WM_LBUTTONDOWN || msg == WindowMessage.WM_RBUTTONDOWN || 
					msg == WindowMessage.WM_MBUTTONDOWN || msg == WindowMessage.WM_XBUTTONDOWN || 
					msg == WindowMessage.WM_NCLBUTTONDOWN || msg == WindowMessage.WM_NCRBUTTONDOWN || 
					msg == WindowMessage.WM_NCMBUTTONDOWN || msg == WindowMessage.WM_NCXBUTTONDOWN)
				{	
					Point cursorPos = Cursor.Position;
				
					if (!this.DropDown.Bounds.Contains(cursorPos))
					{
						if (target != this.EditingTable && target != this.TextBox)
						{
							if (this.ShouldStopEditing(target, cursorPos))
							{
								this.EditingTable.StopEditing();
							}
						}
					}
				}
				else if (msg == WindowMessage.WM_MOUSEMOVE)
				{
					Point cursorPos = Cursor.Position;
				
					if (this.DropDown.Bounds.Contains(cursorPos))
					{
						if (!this.containsMouse)
						{
							this.containsMouse = true;

							this.EditingTable.RaiseCellMouseLeave(this.EditingCellPos);
						}
					}
					else
					{
						this.containsMouse = true;
					}
				}
			}
			
			return false;
		}

 protected override IntPtr WindowProcedure(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
 {
     switch (message)
       {
     case WindowMessage.INPUT:
       int Size = 0;
       Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, IntPtr.Zero, out Size, API.RawInputHeaderSize);
       if (Size == Functions.GetRawInputData(lParam, GetRawInputDataEnum.INPUT, out WinRawInput.data, out Size, API.RawInputHeaderSize))
       {
     switch (WinRawInput.data.Header.Type)
     {
       case RawInputDeviceType.MOUSE:
         if (((WinRawMouse) this.MouseDriver).ProcessMouseEvent(WinRawInput.data))
           return IntPtr.Zero;
         else
           break;
       case RawInputDeviceType.KEYBOARD:
         if (((WinRawKeyboard) this.KeyboardDriver).ProcessKeyboardEvent(WinRawInput.data))
           return IntPtr.Zero;
         else
           break;
     }
       }
       else
     break;
     case WindowMessage.DEVICECHANGE:
       ((WinRawKeyboard) this.KeyboardDriver).RefreshDevices();
       ((WinRawMouse) this.MouseDriver).RefreshDevices();
       break;
       }
       return base.WindowProcedure(handle, message, wParam, lParam);
 }

        void HandleDestroy(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            exists = false;

            if (handle == window.Handle)
            {
                Functions.UnregisterClass(ClassName, Instance);
            }
            window.Dispose();
            child_window.Dispose();

            Closed(this, EventArgs.Empty);
        }

        void HandleCreate(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            CreateStruct cs = (CreateStruct)Marshal.PtrToStructure(lParam, typeof(CreateStruct));
            if (cs.hwndParent == IntPtr.Zero)
            {
                bounds.X = cs.x;
                bounds.Y = cs.y;
                bounds.Width = cs.cx;
                bounds.Height = cs.cy;

                Win32Rectangle rect;
                Functions.GetClientRect(handle, out rect);
                client_rectangle = rect.ToRectangle();

                invisible_since_creation = true;
            }
        }

        void HandleKeyboard(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            bool pressed =
                message == WindowMessage.KEYDOWN ||
                message == WindowMessage.SYSKEYDOWN;

            // Shift/Control/Alt behave strangely when e.g. ShiftRight is held down and ShiftLeft is pressed
            // and released. It looks like neither key is released in this case, or that the wrong key is
            // released in the case of Control and Alt.
            // To combat this, we are going to release both keys when either is released. Hacky, but should work.
            // Win95 does not distinguish left/right key constants (GetAsyncKeyState returns 0).
            // In this case, both keys will be reported as pressed.

            bool extended = (lParam.ToInt64() & ExtendedBit) != 0;
            short scancode = (short)((lParam.ToInt64() >> 16) & 0xFF);
            VirtualKeys vkey = (VirtualKeys)wParam;
            bool is_valid;
            Key key = KeyMap.TranslateKey(scancode, vkey, extended, false, out is_valid);

            if (is_valid)
            {
                keyboard.SetKey(key, (byte)scancode, pressed);

                if (pressed)
                {
                    key_down.Key = key;
                    key_down.Modifiers = keyboard.GetModifiers();
                    KeyDown(this, key_down);
                }
                else
                {
                    key_up.Key = key;
                    key_up.Modifiers = keyboard.GetModifiers();
                    KeyUp(this, key_up);
                }
            }
        }

 void HandleRButtonUp(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
 {
     Functions.ReleaseCapture();
     mouse[MouseButton.Right] = false;
 }

 void HandleXButtonUp(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
 {
     Functions.ReleaseCapture();
     mouse[((wParam.ToInt32() & 0xFFFF0000) >> 16) == 1 ?
         MouseButton.Button1 : MouseButton.Button2] = false;
 }

        void HandleStyleChanged(IntPtr handle, WindowMessage message, IntPtr wParam, IntPtr lParam)
        {
            WindowBorder old_border = windowBorder;
            WindowBorder new_border = old_border;

            unsafe
            {
                GWL get_window_style = (GWL)unchecked(wParam.ToInt32());
                if ((get_window_style & (GWL.STYLE | GWL.EXSTYLE)) != 0)
                {
                    WindowStyle style = ((StyleStruct*)lParam)->New;
                    if ((style & WindowStyle.Popup) != 0)
                        new_border = WindowBorder.Hidden;
                    else if ((style & WindowStyle.ThickFrame) != 0)
                        new_border = WindowBorder.Resizable;
                    else if ((style & ~(WindowStyle.ThickFrame | WindowStyle.MaximizeBox)) != 0)
                        new_border = WindowBorder.Fixed;
                }
            }

            if (new_border != windowBorder)
            {
                // Ensure cursor remains grabbed
                if (!CursorVisible)
                    GrabCursor();

                windowBorder = new_border;
                WindowBorderChanged(this, EventArgs.Empty);
            }
        }