public void FromMessage(ref Message msg)
 {
     this.Hwnd = msg.HWnd;
     this.Msg = msg.Msg;
     this.WParam = msg.WParam;
     this.LParam = msg.LParam;
 }

 protected override void WndProc(ref Message m)
 {
     if (m.Msg == 0x0203) // WM_LBUTTONDBLCLK
     {
         // Do nothing:
         // This prevents embedded RichText objects from being edited by double-clicking them from a
         // RichText control.  See:  http://stackoverflow.com/questions/1149811/net-framework-how-to-make-richtextbox-true-read-only
     }
     else if (m.Msg == 0x000F) // WM_PAINT
     {
         if (!Drawing)
         {
             base.WndProc(ref m); // if we decided to paint this control, just call the RichTextBox WndProc
         }
         else
         {
             m.Result = IntPtr.Zero; // not painting, must set this to IntPtr.Zero if not painting otherwise serious problems.
         }
     }
     else
     {
         try
         {
             base.WndProc(ref m);
         }
         catch { }
     }
 }

        /// <summary>
        /// The filter message.
        /// </summary>
        public bool PreFilterMessage(ref Message m)
        {
            bool handled = false;
            Keys key = Keys.None;

            switch (m.Msg)
            {
                case WM_KEYUP:
                    key = (Keys)m.WParam;
                    handled = HandleModifier(key, false);
                    break;

                case WM_KEYDOWN:
                    key = (Keys)m.WParam;
                    handled = HandleModifier(key, true);
                    if (false == handled)
                    {
                        // If one of the defined keys was pressed then we
                        // raise an event.
                        handled = HandleDefinedKey(key);
                    }
                    break;
            }

            return handled;
        }

 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 void WndProc(ref Message m)
        {
            if (m.Msg == Program.WM_ACTIVATEAPP && m.WParam.ToInt32() == Program.ProgramId)
                ShowWindow();
            else if (m.Msg == WinAPI.WM_COPYDATA)
            {
                ShowWindow();
                logger.Log(LogLevel.Trace, "Received message WM_COPYDATA");
                try
                {

                    WinAPI.CopyDataStruct data = (WinAPI.CopyDataStruct)m.GetLParam(typeof(WinAPI.CopyDataStruct));
                    string message = string.Empty;
                    unsafe
                    {
                        message = new string((char*)(data.lpData), 0, data.cbData / 2);
                    }
                    logger.Log(LogLevel.Trace, "\tdata: " + message);

                    m.Result = new IntPtr(1); //return "True" to caller

                    ShowNotification("Received message: " + message);
                    if (!model.LoadTorrent(message))
                        ShowNotification("Error loading torrent " + message);
                }
                catch (Exception ex)
                {
                    logger.Log(LogLevel.Error, "Error retrieving message data");
                }
            }
            else
                base.WndProc(ref m);
        }

        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case WM_CLIPBOARDUPDATE:
                    var args = new ClipbardUpdatedEventArgs();
                    OnClipboardUpdated(args);
                    if (args.Handled) m.Result = IntPtr.Zero;
                    return;
                case WM_DESTROY:
#if DEBUG
                    Console.WriteLine("ClipboardMonitor: WM_DESTROY");
#endif
                    StopMonitor();
                    break;
                case WM_CLOSE:
#if DEBUG
                    Console.WriteLine("ClipboardMonitor: WM_CLOSE");
#endif
                    StopMonitor();
                    break;
            }

            base.WndProc(ref m);
        }

 /// <summary>
 /// Should the mouse down be eaten when the tracking has been ended.
 /// </summary>
 /// <param name="m">Original message.</param>
 /// <param name="pt">Screen coordinates point.</param>
 /// <returns>True to eat message; otherwise false.</returns>
 public override bool DoesMouseDownGetEaten(Message m, Point pt)
 {
     // If the user dismissed the context menu by clicking down on the drop down button of
     // the KryptonDateTimePicker then eat the down message to prevent the down press from
     // opening the menu again.
     return _dropScreenRect.Contains(new Point(pt.X, pt.Y));
 }

        protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
        {
            switch (keyData)
            {
                case Keys.F5:
                    _refresh.PerformClick();
                    return true;

                case Keys.Home:
                    _home.PerformClick();
                    return true;

                case Keys.Control | Keys.F:
                    _search.Focus();
                    _search.SelectAll();
                    break;

                case Keys.Escape:
                    if (_isNavigating)
                        _stop.PerformClick();
                    else
                        Close();

                    return true;

                case Keys.Control | Keys.P:
                    _print.PerformClick();
                    break;
            }

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

        protected override void WndProc(ref Message m)
        {
            if (m.Msg == _globalMsgV41)
            {
                if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.GlobalEvent.SnarlQuit)
                {
                    AppController.Stop();
                }
                else if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.GlobalEvent.SnarlLaunched)
                {
                    AppController.Current.RegisterWithSnarl();
                }
            }
            else if (m.Msg == ReplyMsgV41)
            {
                if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.MessageEvent.NotificationAck)
                {
                     AppController.Current.MousebuttonHasBeenClicked("left", (Int32)m.LParam);
                }
                else if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.MessageEvent.NotificationCancelled)
                {
                    AppController.Current.MousebuttonHasBeenClicked("right", (Int32)m.LParam);
                }
                else if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.MessageEvent.NotificationMiddleButton)
                {
                    AppController.Current.MousebuttonHasBeenClicked("middle", (Int32)m.LParam);
                }
                else if (m.WParam == (IntPtr)Snarl.V41.SnarlConnector.MessageEvent.NotificationTimedOut)
                {

                }
            }
            base.WndProc(ref m);
        }

        protected void MessageEvent(object sender, ref Message m, ref bool handled) {
            //Handle WM_Hotkey event
            if (handled) {
                return;
            }

            switch ((Win32Msgs)m.Msg) {
                case Win32Msgs.WM_DRAWCLIPBOARD:
                    handled = true;

                    if (Changed != null) {
                        Changed(this, EventArgs.Empty);
                    }

                    User32.SendMessage(nextWindow, m.Msg, m.WParam, m.LParam);

                    break;

                case Win32Msgs.WM_CHANGECBCHAIN:
                    if (m.WParam == nextWindow) {
                        nextWindow = m.LParam;
                    } else {
                        User32.SendMessage(nextWindow, m.Msg, m.WParam, m.LParam);
                    }
                    break;
            }
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            int x = 0;
            int y = 0;

            if(m.Msg == 0xca)
            {
                x = Cursor.Position.X;
                y = Cursor.Position.Y;

                if(
                    (x < this.Location.X) ||
                    (this.Location.X + this.Width < x) ||
                    (y < this.Location.Y) ||
                    (this.Location.Y + this.Height < y)
                    )
                {
                    this.Close();
                    return;
                }

                this.Capture = true;
            }
        }

        protected override void WndProc(ref Message m)
        {
            base.WndProc(ref m);

            if (m.Msg == HotKeys.WM_HOTKEY)
                HotKeys.TriggerKey(this.id);
        }

 protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 {
     try {
         switch (keyData) {
             case Keys.Escape:
                 DialogResult = DialogResult.OK;
                 break;
             case Keys.E:
                 MessageBox.Show(EnvironmentInfo.EnvironmentToString(true));
                 break;
             case Keys.L:
                 try {
                     if (File.Exists( MainForm.LogFileLocation)) {
                         System.Diagnostics.Process.Start("\"" + MainForm.LogFileLocation + "\"");
                     } else {
                         MessageBox.Show("Greenshot can't write to logfile, otherwise it would be here: " + MainForm.LogFileLocation);
                     }
                 } catch (Exception) {
                     MessageBox.Show("Couldn't open the greenshot.log, it's located here: " + MainForm.LogFileLocation, "Error opening greeenshot.log", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                 }
                 break;
             case Keys.I:
                 try {
                     System.Diagnostics.Process.Start("\"" + IniFile.IniConfig.ConfigLocation + "\"");
                 } catch (Exception) {
                     MessageBox.Show("Couldn't open the greenshot.ini, it's located here: " + IniFile.IniConfig.ConfigLocation, "Error opening greeenshot.ini", MessageBoxButtons.OK, MessageBoxIcon.Asterisk);
                 }
                 break;
             default:
                 return base.ProcessCmdKey(ref msg, keyData);
         }
     } catch (Exception) {
     }
     return true;
 }

        /// <summary>
        /// 重载WbdProc,实现热键响应
        /// </summary>
        /// <param name="m"></param>
        protected override void WndProc(ref Message m)
        {
            const int WM_HOTKEY = 0x0312;

            //按快捷键
            if (m.Msg == WM_HOTKEY)
            {
                switch (m.WParam.ToInt32())
                {
                    case 100:
                        {
                            groupTree.Select();
                            statusLabel.Text = "按下F1键：焦点移到到选择组区。";
                        }
                        break;
                    case 1:    //按下的是F1，则相应
                        {
                            HotKey.UnregisterHotKey(Handle, 100);//注销热键
                            HotKey.UnregisterHotKey(Handle, 101);
                            HotKey.UnregisterHotKey(Handle, 102);
                        }
                        break;
                }
            }
            base.WndProc(ref m);
        }

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

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

 protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 {
     // http://support.microsoft.com/kb/320584
     const int WM_KEYDOWN = 0x100;
     if (msg.Msg == WM_KEYDOWN)
     {
         if (keyData.Equals(Keys.Control | Keys.A))
         {
             base.SelectAll();
             return true;
         }
         if (keyData.Equals(Keys.Control | Keys.Back))
         {
             if (SelectionStart - 1 < 0)
                 return true;
             int min = Math.Min(SelectionStart, Text.Length - 1);
             int lastSpace = Text.LastIndexOf(' ', min, min);
             if (lastSpace == -1) // we delete all except symbols after selection
             {
                 Text = Text.Substring(SelectionStart);
                 return true;
             }
             string start =  Text.Substring(0, lastSpace);
             string end = Text.Substring(Math.Min(SelectionStart, Text.Length));
             Text = start + end;
             base.Select(lastSpace, 0);
             return true;
         }
     }
     return base.ProcessCmdKey(ref msg, keyData);
 }

        protected override void WndProc(ref Message m)
        {
            // Swallow mouse messages that are not in the client area
                        if (m.Msg >= 0x201 && m.Msg <= 0x209)
                        {
                            Point pos = new Point((int) (m.LParam.ToInt64() & 0xffff), (int) (m.LParam.ToInt64() >> 16));
                            var hit = this.HitTest(pos);
                            switch (hit.Location)
                            {
                                case ListViewHitTestLocations.AboveClientArea:
                                case ListViewHitTestLocations.BelowClientArea:
                                case ListViewHitTestLocations.LeftOfClientArea:
                                case ListViewHitTestLocations.RightOfClientArea:
                                case ListViewHitTestLocations.None:
                                    return;
                            }
                        }

            //hide scroll
            switch (m.Msg)
            {
                case 0x83: // WM_NCCALCSIZE
                    int style = (int)GetWindowLong(this.Handle, GWL_STYLE);
                    if ((style & WS_HSCROLL) == WS_HSCROLL)
                        SetWindowLong(this.Handle, GWL_STYLE, style & ~WS_HSCROLL);
                    base.WndProc(ref m);
                    break;
                default:
                    base.WndProc(ref m);
                    break;
            }


        }

        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
                case User32.WM_PAINT:
                {
                    try
                    {
                        m_painting = true;
                        base.WndProc(ref m);

                        if (VirtualListSize == 0)
                        {
                            using (Graphics gfx = CreateGraphics())
                                DrawBackground(gfx, Bounds, BackColor);
                        }
                    }
                    finally
                    {
                        m_painting = false;
                    }
                }
                break;

                default:
                    base.WndProc(ref m);
                    break;
            }
        }

 protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
 {
     char cCaracter = (char)keyData;
     if (char.IsLetterOrDigit(cCaracter) || keyData == Keys.Space)
     {
         this.lblBusqueda.Text += cCaracter;
     }
     else
     {
         switch (keyData)
         {
             case Keys.Escape:
                 if (this.lblBusqueda.Text == "")
                     this.Close();
                 else
                     this.lblBusqueda.Text = "";
                 break;
             case Keys.Back:
                 if (this.lblBusqueda.Text != "")
                     this.lblBusqueda.Text = this.lblBusqueda.Text.Izquierda(this.lblBusqueda.Text.Length - 1);
                 break;
             case Keys.Enter:
                 this.dgvListado_CellDoubleClick(this, null);
                 break;
             case Keys.Up:
                 break;
             case Keys.Down:
                 break;
             // default:
                 // return base.ProcessCmdKey(ref msg, keyData);
         }
     }
     return false;
 }

        protected override void WndProc(ref Message message)
        {
            switch (message.Msg)
            {
                case Win32.WM_INPUT:
                    {
                        _keyboardDriver.ProcessRawInput(message.LParam);
                    }
                    break;

                case Win32.WM_USB_DEVICECHANGE:
                    {
                        if (delemiter == 1)
                        {
                            Debug.WriteLine("USB Device Arrival / Removal");
                            _keyboardDriver.EnumerateDevices();
                            delemiter = 0;
                        }
                        else
                            delemiter = 1;
                    }
                    break;
            }

            base.WndProc(ref message);
        }