Пример #1
0
        protected override void DefWndProc(ref Message m)
        {
            switch (m.Msg)
            {
            case WM_COPYDATA:

                COPYDATASTRUCT myStr  = new COPYDATASTRUCT();
                Type           myType = myStr.GetType();
                myStr = (COPYDATASTRUCT)m.GetLParam(myType);        //m中获取LParam参数以myType类型的方式,让后转换问结构体。
                if (myStr.lpData != null)
                {
                    MainUrl = myStr.lpData;
                    changeImage(myStr.lpData);
                }
                break;

            case 0x0083:
                if (Convert.ToBoolean(m.WParam.ToInt32()))
                {
                    NCCALCSIZE_PARAMS t = (NCCALCSIZE_PARAMS)m.GetLParam(typeof(NCCALCSIZE_PARAMS));
                    int CaptionHeight   = GetSystemMetrics(4);
                    int Border3DWidth   = System.Windows.Forms.SystemInformation.Border3DSize.Width;
                    //这里使用FW或者API都可以取到窗体的相关属性
                    int BorderWidth = System.Windows.Forms.SystemInformation.BorderSize.Width;

                    //尝试过了,只有修改RECT[0]才有效果撒…
                    Graphics currentGraphics = Graphics.FromHwnd(this.Handle);
                    double   dpixRatio       = currentGraphics.DpiX / 96; //获取屏幕DPI放大倍数
                    int      x = t.rect0.top - this.Height;
                    t.rect0.top = t.rect0.top - (CaptionHeight) - (int)((double)7 * dpixRatio) - 1;


                    Marshal.StructureToPtr(t, m.LParam, false);    // 结构体转指针

                    // base.WndProc(ref m);
                    //t.rect0.top = t.rect0.top - CaptionHeight - Border3DWidth - BorderWidth  - 5;
                    //t.rect0.top = t.rect0.top - 35;

                    //t.rect0.left = t.rect0.left ;

                    //t.rect0.right = t.rect0.right;
                    //59d8d69e44858dad3d90875bb8d5e097

                    //t.rect0.bottom = t.rect0.bottom ;
                }
                break;

            default:
                break;
            }
            base.DefWndProc(ref m);
        }
Пример #2
0
        protected override void WndProc(ref Message m)
        {
            if (!VisualStyleRenderer.IsSupported || !_aeroEnabled)
            {
                base.WndProc(ref m);
                return;
            }

            int WM_NCCALCSIZE = 0x83;

            IntPtr result;

            int dwmHandled = DwmDefWindowProc(m.HWnd, m.Msg, m.WParam, m.LParam, out result);

            if (dwmHandled == 1)
            {
                m.Result = result;
                return;
            }

            if (m.Msg == WM_NCCALCSIZE && (int)m.WParam == 1)
            {
                NCCALCSIZE_PARAMS nccsp = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));

                // Adjust (shrink) the client rectangle to accommodate the border:
                nccsp.rect0.Top    += 0;
                nccsp.rect0.Bottom += 0;
                nccsp.rect0.Left   += 0;
                nccsp.rect0.Right  += 0;

                if (!_setMargins)
                {
                    //Set what client area would be for passing to DwmExtendIntoClientArea
                    _dwmMargins.cyTopHeight    = nccsp.rect2.Top - nccsp.rect1.Top;
                    _dwmMargins.cxLeftWidth    = nccsp.rect2.Left - nccsp.rect1.Left;
                    _dwmMargins.cyBottomHeight = _buttonSize.Height + 2;
                    _dwmMargins.cxRightWidth   = nccsp.rect1.Right - nccsp.rect2.Right;
                    _setMargins = true;
                }

                Marshal.StructureToPtr(nccsp, m.LParam, false);

                m.Result = IntPtr.Zero;
            }

            else
            {
                base.WndProc(ref m);
            }
        }
Пример #3
0
        /// <summary>
        /// WNDs the proc.
        /// </summary>
        /// <param name="m">The Windows <see cref="T:System.Windows.Forms.Message" /> to process.</param>
        protected override void WndProc(ref Message m)
        {
            int    WM_NCCALCSIZE = 0x83;
            int    WM_NCHITTEST  = 0x84;
            IntPtr result        = default(IntPtr);

            int dwmHandled = Window.DwmDefWindowProc(m.HWnd, m.Msg, m.WParam, m.LParam, out result);

            if (dwmHandled == 1)
            {
                m.Result = result;
                return;
            }

            if (m.Msg == WM_NCCALCSIZE && m.WParam.ToInt32() == 1)
            {
                NCCALCSIZE_PARAMS nccsp = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));

                // Adjust (shrink) the client rectangle to accommodate the border:
                nccsp.rect0.Top    += 0;
                nccsp.rect0.Bottom += 0;
                nccsp.rect0.Left   += 0;
                nccsp.rect0.Right  += 0;

                if (!_marginOk)
                {
                    //Set what client area would be for passing to DwmExtendIntoClientArea.
                    //Also remember that at least one of these values NEEDS TO BE > 1, else
                    //it won't work.
                    _dwmMargins.cyTopHeight    = 0;
                    _dwmMargins.cxLeftWidth    = 0;
                    _dwmMargins.cyBottomHeight = 3;
                    _dwmMargins.cxRightWidth   = 0;
                    _marginOk = true;
                }

                Marshal.StructureToPtr(nccsp, m.LParam, false);
                m.Result = IntPtr.Zero;
            }
            else if (m.Msg == WM_NCHITTEST && m.Result.ToInt32() == 0)
            {
                m.Result = HitTestNCA(m.HWnd, m.WParam, m.LParam);
            }
            else
            {
                base.WndProc(ref m);
            }
        }
Пример #4
0
        protected override void WndProc(ref System.Windows.Forms.Message m)
        {
            const int WM_NCPAINT = 0x85;

            switch (m.Msg)
            {
            case WM_NCPAINT:
                base.WndProc(ref m);
                if (_rectangeUpdated)
                {
                    IntPtr hdc = GetWindowDC(m.HWnd);
                    if ((int)hdc != 0)
                    {
                        Graphics g = Graphics.FromHdc(hdc);
                        g.DrawImage(Properties.Resources.Welcome_Scan, _rectange);
                        g.DrawLine(new Pen(Color.Blue), new Point(1, 1), new Point(50, 50));
                        g.Flush();
                        ReleaseDC(m.HWnd, hdc);
                        _rectangeUpdated = false;
                    }
                }
                break;

            case WM_NCCALCSIZE:
            {
                base.WndProc(ref m);
                if (m.WParam != IntPtr.Zero && _titleHight != 0)
                {
                    if (m.HWnd == this.Handle)
                    {
                        NCCALCSIZE_PARAMS rcsize = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                        _rectange        = new Rectangle(_borderWidth, _titleHight, rcsize.rcNewWindow.right - rcsize.rcNewWindow.left, rcsize.rcNewWindow.bottom - rcsize.rcNewWindow.top);
                        _rectangeUpdated = true;
                    }
                }

                m.Result = new IntPtr(1);
            }
            break;

            default:
                base.WndProc(ref m);
                break;
            }
        }
Пример #5
0
 public static void ChangeClientRectalgle(ref Message message, Padding padding)
 {
     if (message.Msg == WindowMessage.WM_NCCALCSIZE)
     {
         if (message.WParam != IntPtr.Zero)
         {
             NCCALCSIZE_PARAMS rcsize = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(message.LParam, typeof(NCCALCSIZE_PARAMS));
             AdjustClientRect(ref rcsize.rcNewWindow, padding);
             Marshal.StructureToPtr(rcsize, message.LParam, false);
         }
         else
         {
             RECT rcsize = (RECT)Marshal.PtrToStructure(message.LParam, typeof(RECT));
             AdjustClientRect(ref rcsize, padding);
             Marshal.StructureToPtr(rcsize, message.LParam, false);
         }
         message.Result = new IntPtr(1);
     }
 }
Пример #6
0
        static void HandleNcCalcSize(IntPtr hwnd, IntPtr wParam, IntPtr lParam)
        {
            if (wParam == BasicValues.TRUE)
            {
                var wpl = default(WINDOWPLACEMENT);
                wpl.length = (uint)Marshal.SizeOf(typeof(WINDOWPLACEMENT));

                if (User32.GetWindowPlacement(hwnd, ref wpl))
                {
                    // detect if maximizd and set to workspace remove padding
                    if (wpl.showCmd == ShowWindowOption.SW_MAXIMIZE)
                    {
                        // in multi-monitor case where app is minimized to a monitor on the right/bottom
                        // the MonitorFromWindow will incorrectly return the leftmost monitor due to the minimized
                        // window being set to the far left, so this routine now uses the proposed rect to correctly
                        // identify the real nearest monitor to calc the nc size.

                        NCCALCSIZE_PARAMS para = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(lParam, typeof(NCCALCSIZE_PARAMS));

                        var    windowRect = para.rectProposed;
                        IntPtr hMonitor   = User32.MonitorFromRect(ref windowRect, MonitorOption.MONITOR_DEFAULTTONEAREST);// MonitorFromWindow(hWnd, 2);
                        if (hMonitor != IntPtr.Zero)
                        {
                            MONITORINFO lpmi = new MONITORINFO();
                            lpmi.cbSize = (uint)Marshal.SizeOf(typeof(MONITORINFO));
                            if (User32.GetMonitorInfo(hMonitor, ref lpmi))
                            {
                                var workArea = lpmi.rcWork;
                                User32Ex.AdjustForAutoHideTaskbar(hMonitor, ref workArea);
                                Debug.WriteLine("NCCalc original = {0}x{1} @ {2}x{3}, new ={4}x{5} @ {6}x{7}",
                                                para.rectProposed.Width, para.rectProposed.Height,
                                                para.rectProposed.left, para.rectProposed.top,
                                                workArea.Width, workArea.Height,
                                                workArea.left, workArea.top);
                                para.rectProposed = workArea;
                                Marshal.StructureToPtr(para, lParam, true);
                            }
                        }
                    }
                }
            }
        }
Пример #7
0
 protected virtual void WmNcCalcSize(ref Message m)
 {
     if (m.WParam != IntPtr.Zero)
     {
         NCCALCSIZE_PARAMS ncsize = (NCCALCSIZE_PARAMS)m.GetLParam(
             typeof(NCCALCSIZE_PARAMS));
         ncsize.rgrc0.Left   += _borderWidth;
         ncsize.rgrc0.Right  -= _borderWidth;
         ncsize.rgrc0.Top    += _borderWidth;
         ncsize.rgrc0.Bottom -= _borderWidth;
         Marshal.StructureToPtr(ncsize, m.LParam, false);
     }
     else
     {
         RECT rc = (RECT)m.GetLParam(typeof(RECT));
         rc.Left   += _borderWidth;
         rc.Right  -= _borderWidth;
         rc.Top    += _borderWidth;
         rc.Bottom -= _borderWidth;
         Marshal.StructureToPtr(rc, m.LParam, true);
     }
     m.Result = Result.FALSE;
 }
Пример #8
0
        protected virtual void OnWmNcCalcSize(ref Message m, NuGenWndProcDelegate baseWndProc)
        {
            Debug.Assert(m != null, "m != null");
            Debug.Assert(baseWndProc != null, "baseWndProc != null");
            Debug.Assert(User32.IsWindow(m.HWnd), "User32.IsWindow(m.HWnd)");

            baseWndProc(ref m);

            if (m.WParam == Common.FALSE)
            {
                RECT rect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));

                Marshal.StructureToPtr(
                    (RECT)this.GetClientRectangle(m.HWnd, (Rectangle)rect),
                    m.LParam,
                    false
                    );

                m.Result = Common.FALSE;
            }
            else
            {
                NCCALCSIZE_PARAMS calcSizeParams = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                WINDOWPOS         wndPos         = (WINDOWPOS)Marshal.PtrToStructure(calcSizeParams.lppos, typeof(WINDOWPOS));
                RECT bufferRect = (RECT)this.GetClientRectangle(
                    m.HWnd,
                    new Rectangle(wndPos.x, wndPos.y, wndPos.width, wndPos.height)
                    );

                calcSizeParams.rectProposed   = bufferRect;
                calcSizeParams.rectBeforeMove = bufferRect;

                Marshal.StructureToPtr(calcSizeParams, m.LParam, false);

                m.Result = new IntPtr(WinUser.WVR_VALIDRECTS);
            }
        }
Пример #9
0
        /// <summary>
        /// Calculates the size of the window frame and client area of the RichTextBox
        /// </summary>
        private void WmNcCalcSize(ref Message m)
        {
            // let the richtextbox control draw the scrollbar if necessary.
            base.WndProc(ref m);

            // we visual styles are not enabled and BorderStyle is not Fixed3D then we have nothing more to do.
            if (!RenderWithVisualStyles())
            {
                return;
            }

            // contains detailed information about WM_NCCALCSIZE message
            NCCALCSIZE_PARAMS par = new NCCALCSIZE_PARAMS();

            // contains the window frame RECT
            RECT windowRect;

            if (m.WParam == IntPtr.Zero) // LParam points to a RECT struct
            {
                windowRect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));
            }
            else // LParam points to a NCCALCSIZE_PARAMS struct
            {
                par        = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                windowRect = par.rgrc0;
            }

            // contains the client area of the control
            RECT contentRect;

            // get the DC
            IntPtr hDC = GetWindowDC(Handle);

            // open theme data
            IntPtr hTheme = OpenThemeData(Handle, "EDIT");

            // find out how much space the borders needs
            if (GetThemeBackgroundContentRect(hTheme, hDC, EP_EDITTEXT, GetState()
                                              , ref windowRect
                                              , out contentRect) == S_OK)
            {
                // shrink the client area the make more space for containing text.
                contentRect.Left   += 1 + Padding.Left;
                contentRect.Top    += 1 + Padding.Top;
                contentRect.Right  -= 1 + Padding.Right;
                contentRect.Bottom -= 1 + Padding.Bottom;

                // remember the space of the borders
                _borderRect = new RECT(contentRect.Left - windowRect.Left
                                       , contentRect.Top - windowRect.Top
                                       , windowRect.Right - contentRect.Right
                                       , windowRect.Bottom - contentRect.Bottom);

                // update LParam of the message with the new client area
                if (m.WParam == IntPtr.Zero)
                {
                    Marshal.StructureToPtr(contentRect, m.LParam, false);
                }
                else
                {
                    par.rgrc0 = contentRect;
                    Marshal.StructureToPtr(par, m.LParam, false);
                }

                // force the control to redraw it´s client area
                m.Result = new IntPtr(WVR_REDRAW);
            }

            // release theme data handle
            CloseThemeData(hTheme);

            // release DC
            ReleaseDC(Handle, hDC);
        }
Пример #10
0
        protected void CustomProc(ref Message m)
        {
            switch (m.Msg)
            {
            case WM_PAINT:
            {
                PAINTSTRUCT ps = new PAINTSTRUCT();
                if (!_bPainting)
                {
                    _bPainting = true;
                    BeginPaint(m.HWnd, ref ps);
                    PaintThis(ps.hdc, ps.rcPaint);
                    EndPaint(m.HWnd, ref ps);
                    _bPainting = false;
                    base.WndProc(ref m);
                }
                else
                {
                    base.WndProc(ref m);
                }
                break;
            }

            case WM_CREATE:
            {
                GetFrameSize();
                FrameChanged();
                m.Result = MSG_HANDLED;
                base.WndProc(ref m);
                break;
            }

            case WM_NCCALCSIZE:
            {
                if (m.WParam != IntPtr.Zero && m.Result == IntPtr.Zero)
                {
                    if (_bExtendIntoFrame)
                    {
                        NCCALCSIZE_PARAMS nc = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                        nc.rect0.Top -= (_tMargins.cyTopHeight > CaptionHeight ? CaptionHeight : _tMargins.cyTopHeight);
                        nc.rect1      = nc.rect0;
                        Marshal.StructureToPtr(nc, m.LParam, false);
                        m.Result = (IntPtr)WVR_VALIDRECTS;
                    }
                    base.WndProc(ref m);
                }
                else
                {
                    base.WndProc(ref m);
                }
                break;
            }

            case WM_SYSCOMMAND:
            {
                UInt32 param;
                if (IntPtr.Size == 4)
                {
                    param = (UInt32)(m.WParam.ToInt32());
                }
                else
                {
                    param = (UInt32)(m.WParam.ToInt64());
                }
                if ((param & 0xFFF0) == SC_RESTORE)
                {
                    this.Height = _iStoreHeight;
                }
                else if (this.WindowState == FormWindowState.Normal)
                {
                    _iStoreHeight = this.Height;
                }
                base.WndProc(ref m);
                break;
            }

            case WM_NCHITTEST:
            {
                if (m.Result == (IntPtr)HIT_CONSTANTS.HTNOWHERE)
                {
                    IntPtr res = IntPtr.Zero;
                    if (DwmDefWindowProc(m.HWnd, (uint)m.Msg, m.WParam, m.LParam, ref res))
                    {
                        m.Result = res;
                    }
                    else
                    {
                        m.Result = (IntPtr)HitTest();
                    }
                }
                else
                {
                    base.WndProc(ref m);
                }
                break;
            }

            case WM_DWMCOMPOSITIONCHANGED:
            case WM_ACTIVATE:
            {
                DwmExtendFrameIntoClientArea(this.Handle, ref _tMargins);
                m.Result = MSG_HANDLED;
                base.WndProc(ref m);
                break;
            }

            default:
            {
                base.WndProc(ref m);
                break;
            }
            }
        }
Пример #11
0
        protected override void WndProc(ref Message m)
        {
            if (!isEnabled || IsDisposed)
            {
                base.WndProc(ref m);
                return;
            }

            var msg = m.Msg;

            switch (msg)
            {
            case (int)WindowsMessages.WM_NCACTIVATE:
                if (m.WParam == Win32DataUtils.FALSE)
                {
                    m.Result = MESSAGE_HANDLED;
                }
                User32.InvalidateWindow(parentWindowHWnd);
                break;

            case (int)WindowsMessages.WM_ACTIVATEAPP:
            case (int)WindowsMessages.WM_MOVE:
                base.WndProc(ref m);

                User32.InvalidateWindow(parentWindowHWnd);

                break;

            case (int)WindowsMessages.WM_SIZE:
                if (m.WParam == (IntPtr)0 && isMaximized)
                {
                    isMaximized = false;
                    isMinimized = false;
                    //fix: In Win7 or higher, drag a window maximized will casue ncpaint error, so force window to calculate size of the nonclient area.
                    //fix: 在Win7系统下面如果窗体最大化,拖动窗体会造成非客户区绘制错误,因为没有触发WM_NCCALCSIZE,所以强制触发这个消息来使非客户去重新计算大小。
                    User32.SendFrameChanged(parentWindowHWnd);
                }

                if (m.WParam == (IntPtr)2)
                {
                    isMaximized = true;
                    isMinimized = false;

                    User32.SendFrameChanged(parentWindowHWnd);
                }

                //User32.InvalidateWindow(parentWindowHWnd);


                base.WndProc(ref m);

                break;

            case (int)WindowsMessages.WM_NCLBUTTONDOWN:
                if (m.WParam == (IntPtr)2 && isMaximized)
                {
                    User32.SendFrameChanged(parentWindowHWnd);
                }

                base.WndProc(ref m);
                break;

            case (int)WindowsMessages.WM_SYSCOMMAND:

                if (m.WParam == (IntPtr)SystemCommandFlags.SC_MAXIMIZE)
                {
                    isMaximized = true;
                    isMinimized = false;
                }
                else if (m.WParam == (IntPtr)SystemCommandFlags.SC_MINIMIZE)
                {
                    isMinimized = true;
                }
                else if (m.WParam == (IntPtr)SystemCommandFlags.SC_RESTORE)
                {
                    if (isMinimized)
                    {
                        isMinimized = false;
                    }
                    else
                    {
                        isMaximized = false;
                    }
                }


                base.WndProc(ref m);

                break;

            case (int)WindowsMessages.WM_NCCALCSIZE:
                if (m.WParam != FALSE)
                {
                    NCCALCSIZE_PARAMS ncsize = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));

                    WINDOWPOS pos = (WINDOWPOS)Marshal.PtrToStructure(ncsize.lppos, typeof(WINDOWPOS));
                    if (!isFrameSizeStored)
                    {
                        isFrameSizeStored = true;
                        ncCaptionHeight   = ncsize.rectClientBeforeMove.top - ncsize.rectProposed.top;;

                        ncFrameWidth = ncsize.rectClientBeforeMove.left - ncsize.rectProposed.left;

                        ncFrameHeight = ncsize.rectBeforeMove.bottom - ncsize.rectClientBeforeMove.bottom;
                    }


                    RECT rc = ncsize.rectProposed;

                    ncsize.rectProposed   = CalculateFrameSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
                    ncsize.rectBeforeMove = ncsize.rectProposed;


                    Marshal.StructureToPtr(ncsize, m.LParam, false);
                    m.Result = WVR_VALIDRECTS;

                    User32.InvalidateWindow(parentWindowHWnd);
                }
                else
                {
                    RECT rc = (RECT)m.GetLParam(typeof(RECT));
                    rc = CalculateFrameSize(rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top);
                    Marshal.StructureToPtr(rc, m.LParam, true);
                    m.Result = MESSAGE_PROCESS;
                }



                base.WndProc(ref m);
                break;

            case (int)WindowsMessages.WM_NCPAINT:
                if (User32.IsWindowVisible(parentWindowHWnd))
                {
                    m.Result = MESSAGE_HANDLED;
                    DrawNCArea(m.WParam);
                }
                break;

            case (int)WindowsMessages.WM_NCUAHDRAWCAPTION:
            case (int)WindowsMessages.WM_NCUAHDRAWFRAME:
                User32.InvalidateWindow(parentWindowHWnd);
                break;

            default:
                base.WndProc(ref m);
                break;
            }
        }
Пример #12
0
        private IntPtr GlowWindowHost_WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            //Prepare
            RECT rect, clnRect;

            //Handle message
            switch ((WindowMessages)msg)
            {
            case WindowMessages.WM_MOVE:
                if (User32.GetWindowRect(hwnd, out rect))
                {
                    //Set position
                    LeftGlow_SizePos(leftHandle.Handle, rect);
                    TopGlow_SizePos(topHandle.Handle, rect);
                    RightGlow_SizePos(rightHandle.Handle, rect);
                    BottomGlow_SizePos(bottomHandle.Handle, rect);
                }
                break;

            case WindowMessages.WM_SIZE:
                if (User32.GetWindowRect(hwnd, out rect))
                {
                    //Set visibility
                    int wmSizeWParam = wParam.ToInt32();
                    switch (wParam.ToInt32())
                    {
                    case 1:
                    case 2: BordersVisible = false; break;

                    case 0: BordersVisible = true; break;
                    }

                    //Set size
                    LeftGlow_SizePos(leftHandle.Handle, rect);
                    TopGlow_SizePos(topHandle.Handle, rect);
                    RightGlow_SizePos(rightHandle.Handle, rect);
                    BottomGlow_SizePos(bottomHandle.Handle, rect);

                    //Check
                    if (wmSizeWParam != this.wmSizeWParam)
                    {
                        this.wmSizeWParam = wmSizeWParam;
                        Point sz = new Point(lParam.ToInt32());
                        User32.SetWindowPos(hwnd, IntPtr.Zero, 0, 0, sz.X, sz.Y, 0x0020 | 0x0002);
                    }
                }
                break;

            case WindowMessages.WM_NCCALCSIZE:
                handled = true;
                if (wParam != IntPtr.Zero)      //check if wParam is TRUE
                {
                    //Copy NCCALCSIZE_PARAMS from memory
                    NCCALCSIZE_PARAMS nccsp = Marshal.PtrToStructure <NCCALCSIZE_PARAMS>(lParam);

                    //Request client rectangle
                    clnRect     = GlowWindowHost_RequestClientRectangle(nccsp.rgrc0);
                    nccsp.rgrc0 = clnRect;

                    //Copy NCCALCSIZE_PARAMS into memory
                    Marshal.StructureToPtr(nccsp, lParam, true);
                }
                else
                {
                    //Get window rect from lParam
                    rect = Marshal.PtrToStructure <RECT>(lParam);

                    //Request client rectangle
                    clnRect = GlowWindowHost_RequestClientRectangle(rect);

                    //Copy RECT into memory
                    Marshal.StructureToPtr(clnRect, lParam, true);
                }

                //Return
                return(IntPtr.Zero);

            case WindowMessages.WM_NCHITTEST:
                Point htPoint = new Point(lParam.ToInt32());
                if (User32.GetWindowRect(hwnd, out RECT wndRect))
                {
                    //Hit-test
                    DpiScale      dpi    = VisualTreeHelper.GetDpi(this);
                    HitTestResult result = VisualTreeHelper.HitTest(this, new WpfPoint(
                                                                        (htPoint.X - wndRect.Left) * dpi.DpiScaleX,
                                                                        (htPoint.Y - wndRect.Top) * dpi.DpiScaleY));
                    if (result?.VisualHit is UIElement element)
                    {
                        if (element.GetValue(NonClientActionProperty) is NonClientHitAction action)
                        {
                            //Set
                            handled = true;

                            //Handle action
                            switch (action)
                            {
                            case NonClientHitAction.Caption:
                                return((IntPtr)2);

                            case NonClientHitAction.Icon:
                                return((IntPtr)3);

                            case NonClientHitAction.Top:
                                return((IntPtr)12);

                            case NonClientHitAction.Left:
                                return((IntPtr)10);

                            case NonClientHitAction.Right:
                                return((IntPtr)11);

                            case NonClientHitAction.Bottom:
                                return((IntPtr)15);

                            case NonClientHitAction.TopLeft:
                                return((IntPtr)13);

                            case NonClientHitAction.TopRight:
                                return((IntPtr)14);

                            case NonClientHitAction.BottomLeft:
                                return((IntPtr)16);

                            case NonClientHitAction.BottomRight:
                                return((IntPtr)17);

                            default: return((IntPtr)1);
                            }
                        }
                    }
                }
                break;

            case WindowMessages.WM_ACTIVATE:
                bool isActive           = true;
                bool isGlowWindowActive = (lParam == leftHandle.Handle || lParam == topHandle.Handle || lParam == rightHandle.Handle || lParam == bottomHandle.Handle);
                if (wParam == IntPtr.Zero && !isGlowWindowActive)
                {
                    isActive = false;
                }

                //Check
                if (isActive != this.isActive)
                {
                    WpfColor color = new WpfColor();
                    if (isActive)
                    {
                        color = ActiveGlowColor;
                    }
                    else
                    {
                        color = InactiveGlowColor;
                    }

                    //Set icon
                    CurrentIcon = isActive ? ActiveIcon : InactiveIcon;

                    //Render
                    glowTextures.Render(Color.FromArgb(color.R, color.G, color.B));

                    //Re-draw edges
                    GlowWindow_DrawLayeredWindow(leftHandle.Handle);
                    GlowWindow_DrawLayeredWindow(topHandle.Handle);
                    GlowWindow_DrawLayeredWindow(rightHandle.Handle);
                    GlowWindow_DrawLayeredWindow(bottomHandle.Handle);

                    //Set
                    this.isActive = isActive;
                    InvalidateVisual();
                }
                break;

            case WindowMessages.WM_DESTROY:
                hostDictionary.Remove(hwnd);        //Unregister
                break;
            }

            //Return
            return(IntPtr.Zero);
        }
Пример #13
0
        protected override void WndProc(ref Message m)
        {
            if (DesignMode)
            {
                base.WndProc(ref m);
                return;
            }
            if (m.Msg == WM_NCCALCSIZE)
            {
                if (m.WParam.ToInt32() == 1)
                {
                    MARGINS borderless = new MARGINS()
                    {
                        cxLeftWidth = 1, cxRightWidth = 1, cyBottomHeight = 1, cyTopHeight = 1
                    };
                    DwmExtendFrameIntoClientArea(Handle, ref borderless);

                    WINDOWPLACEMENT pl = new WINDOWPLACEMENT();
                    GetWindowPlacement(m.HWnd, ref pl);

                    if (pl.ShowCmd == ShowWindowCommands.Maximize)
                    {
                        NCCALCSIZE_PARAMS p = Marshal.PtrToStructure <NCCALCSIZE_PARAMS>(m.LParam);

                        p.rgrc[0].Left   += 7;
                        p.rgrc[0].Right  -= 8;
                        p.rgrc[0].Top    += 7;
                        p.rgrc[0].Bottom -= 8;

                        Marshal.StructureToPtr(p, m.LParam, true);
                    }
                }

                m.Result = IntPtr.Zero;
                return;
            }
            else if (m.Msg == WM_NCHITTEST)
            {
                Point mousePos = PointToClient(new Point((m.LParam.ToInt32() & 0xFFFF), (m.LParam.ToInt32() >> 16)));
                foreach (CaptionButton b in CaptionButtons)
                {
                    if (mousePos.X >= b.X && mousePos.X < b.X + b.Width && mousePos.Y >= b.Y && mousePos.Y < b.Y + b.Height)
                    {
                        m.Result = new IntPtr(b.HitTestCode);
                        return;
                    }
                }
                m.Result = new IntPtr(mousePos.X >= 0 && mousePos.X < Width && mousePos.Y >= 0 && mousePos.Y < Height ? HT_CAPTION : HT_NOWHERE);
                if (SizeBorder && WindowState == FormWindowState.Normal)
                {
                    int res = m.Result.ToInt32();
                    int col = 0;
                    if (mousePos.X >= ClientSize.Width - 5)
                    {
                        col = 2;
                    }
                    else if (mousePos.X > 5)
                    {
                        col = 1;
                    }

                    int row = 0;
                    if (mousePos.Y >= ClientSize.Height - 5)
                    {
                        row = 2;
                    }
                    else if (mousePos.Y > 5)
                    {
                        row = 1;
                    }

                    if (col == 0)
                    {
                        if (row == 0)
                        {
                            res = HT_TOPLEFT;
                        }
                        if (row == 1)
                        {
                            res = HT_LEFT;
                        }
                        if (row == 2)
                        {
                            res = HT_BOTTOMLEFT;
                        }
                    }
                    if (col == 1)
                    {
                        if (row == 0)
                        {
                            res = HT_TOP;
                        }
                        if (row == 2)
                        {
                            res = HT_BOTTOM;
                        }
                    }
                    if (col == 2)
                    {
                        if (row == 0)
                        {
                            res = HT_TOPRIGHT;
                        }
                        if (row == 1)
                        {
                            res = HT_RIGHT;
                        }
                        if (row == 2)
                        {
                            res = HT_BOTTOMRIGHT;
                        }
                    }

                    m.Result = new IntPtr(res);
                }
                return;
            }

            base.WndProc(ref m);
        }
Пример #14
0
        /// <summary>
        /// </summary>
        protected override void WndProc(ref Message m)
        {
            switch (m.Msg)
            {
            case WinUser.WM_NCCALCSIZE:
            {
                if (m.WParam == IntPtr.Zero)
                {
                    RECT rect = (RECT)m.GetLParam(typeof(RECT));
                    this.CalculateClientBounds(ref rect);
                    Marshal.StructureToPtr(rect, m.LParam, true);
                }
                else
                {
                    NCCALCSIZE_PARAMS calc = (NCCALCSIZE_PARAMS)m.GetLParam(typeof(NCCALCSIZE_PARAMS));
                    this.CalculateClientBounds(ref calc.rectProposed);
                    Marshal.StructureToPtr(calc, m.LParam, true);
                }

                m.Result = new IntPtr(WinUser.WVR_REDRAW);
                break;
            }

            case WinUser.WM_NCHITTEST:
            {
                /* Map all mouse messages to client area. */
                m.Result = (IntPtr)WinUser.HTCLIENT;
                return;
            }

            case WinUser.WM_NCPAINT:
            {
                base.DefWndProc(ref m);

                IntPtr hDC = User32.GetWindowDC(m.HWnd);

                if (hDC == IntPtr.Zero)
                {
                    return;
                }

                RECT bounds = new RECT();
                User32.GetWindowRect(m.HWnd, ref bounds);

                if (bounds.Width < 1 || bounds.Height < 1)
                {
                    return;
                }

                using (NuGenNativeGrfx grfx = new NuGenNativeGrfx(hDC, bounds.Size))
                {
                    this.DrawHeader(grfx.Graphics, this.RectangleToClient(bounds));
                    grfx.DrawToTargetGraphics();
                }

                User32.ReleaseDC(m.HWnd, hDC);
                m.Result = IntPtr.Zero;

                return;
            }
            }

            base.WndProc(ref m);
        }
Пример #15
0
        protected override void WndProc(ref Message m)
        {
            if (this.Owner.FormBorderStyle == System.Windows.Forms.FormBorderStyle.None)
            {
                this.Owner.DefWndProcInternal(ref m);
                return;
            }
            switch (m.Msg)
            {
                #region WM_NCCALCSIZE (修改客户端区域)
            case WM.WM_NCCALCSIZE:
                if (m.WParam != IntPtr.Zero)
                {
                    NCCALCSIZE_PARAMS rcsize = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                    rcsize.rcNewWindow.Left   += (this.Owner.BorderWidthInternal - 8);
                    rcsize.rcNewWindow.Top    += this.Owner.CaptionHeightInternal - SystemInformation.CaptionHeight - 6;
                    rcsize.rcNewWindow.Right  -= (this.Owner.BorderWidthInternal - 8);
                    rcsize.rcNewWindow.Bottom -= (this.Owner.BorderWidthInternal - 8);
                    Marshal.StructureToPtr(rcsize, m.LParam, false);
                }
                m.Result = new IntPtr(1);
                break;

                #endregion
                #region WM_NCLBUTTONDOWN (标题栏区域鼠标左键按下)
            case WM.WM_NCLBUTTONDOWN:
                WmCaptionMouseDown(ref m, MouseButtons.Left, 1);
                this.stateMouseClick      = true;
                this.stateMouseDown       = true;
                this.stateMouseDownButton = MouseButtons.Left;
                return;

                #endregion
                #region WM_NCRBUTTONDOWN (标题栏区域鼠标右键按下)
            case WM.WM_NCRBUTTONDOWN:
                WmCaptionMouseDown(ref m, MouseButtons.Right, 1);
                this.stateMouseClick      = true;
                this.stateMouseDown       = true;
                this.stateMouseDownButton = MouseButtons.Left;
                return;

                #endregion
                #region WM_NCMOUSEMOVE (标题栏区域鼠标移动)
            case WM.WM_NCMOUSEMOVE:
                if (stateMouseDown && MouseButtons == System.Windows.Forms.MouseButtons.None)
                {
                    WmCaptionMouseUp(ref m, this.stateMouseDownButton, 1);
                    this.stateMouseDown = false;
                }
                else
                {
                    WmCaptionMouseMove(ref m, MouseButtons, 0);
                }
                break;

                #endregion
                #region WM_NCLBUTTONUP (标题栏区域鼠标左键弹起)
            case WM.WM_NCLBUTTONUP:
                WmCaptionMouseUp(ref m, MouseButtons.Left, 1);
                return;

                #endregion
                #region WM_NCRBUTTONUP (标题栏区域鼠标右键弹起)
            case WM.WM_NCRBUTTONUP:
                WmCaptionMouseUp(ref m, MouseButtons.Right, 1);
                return;

                #endregion
                #region WM_NCLBUTTONDBLCLK (标题栏区域鼠标左键双击)
            case WM.WM_NCLBUTTONDBLCLK:
                WmCaptionMouseDown(ref m, MouseButtons.Left, 2);
                this.stateMouseDoubleClick = true;
                return;

                #endregion
                #region WM_NCRBUTTONDBLCLK (标题栏区域鼠标右键双击)
            case WM.WM_NCRBUTTONDBLCLK:
                WmCaptionMouseDown(ref m, MouseButtons.Right, 2);
                this.stateMouseDoubleClick = true;
                return;

                #endregion
                #region WM_NCMOUSELEAVE (鼠标离开)
            case WM.WM_NCMOUSELEAVE:
                if (!this.stateMouseDown)
                {
                    if (this.DUIControlShare.MouseMoveDUIControl != null)
                    {
                        this.DUIControlShare.MouseMoveDUIControl.DoMouseLeave(EventArgs.Empty);
                        this.DUIControlShare.MouseMoveDUIControl = null;
                    }
                    this.stateMouseClick       = false;
                    this.stateMouseDoubleClick = false;
                }
                break;

                #endregion
                #region WM_NCMOUSEHOVER (鼠标停留)
            case WM.WM_NCMOUSEHOVER:
                this.DoMouseHover(EventArgs.Empty);
                return;

                #endregion
                #region WM_NCPAINT (标题栏绘制)
            //case WM.WM_SETCURSOR:
            case WM.WM_NCUAHDRAWCAPTION:
                this.Invalidate();
                return;

            case WM.WM_NCACTIVATE:
                this.Owner.DefWndProcInternal(ref m);
                this.Invalidate();
                return;

            case WM.WM_NCPAINT:
                this.Invalidate();
                return;

                #endregion
                #region WM_SYSCOMMAND (系统命令,最大化最小化关闭之类的)
            case WM.WM_SYSCOMMAND:
                if (m.WParam.ToInt32() == SC.SC_RESTORE)
                {
                    this.Owner.DoNormal();
                    return;
                }
                if (m.WParam.ToInt32() == SC.SC_MINIMIZE)
                {
                    this.Owner.DoMinimize();
                    return;
                }
                if (m.WParam.ToInt32() == SC.SC_MAXIMIZE)
                {
                    this.Owner.DoMaximize();
                    return;
                }
                if (m.WParam.ToInt32() == SC.SC_MOUSEMENU)
                {
                    return;
                }
                break;
                #endregion
            }
            //base.WndProc(ref m);
            this.Owner.DefWndProcInternal(ref m);
        }
Пример #16
0
        private void WmNccalcsize(ref Message m)
        {
            // we visual styles are not enabled and BorderStyle is not Fixed3D then we have nothing more to do.
            if (!UxThemeManager.VisualStylesEnabled())
            {
                return;
            }

            // contains detailed information about WM_NCCALCSIZE message
            NCCALCSIZE_PARAMS par = new NCCALCSIZE_PARAMS();

            // contains the window frame RECT
            RECT windowRect;

            if (m.WParam == IntPtr.Zero) // LParam points to a RECT struct
            {
                windowRect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));
            }
            else // LParam points to a NCCALCSIZE_PARAMS struct
            {
                par        = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                windowRect = par.rgrc0;
            }

            // contains the client area of the control
            RECT contentRect;

            // get the DC
            IntPtr hDC = Win32.GetWindowDC(this.Handle);

            // find out how much space the borders needs
            if (m_ThemeManager[this].GetThemeBackgroundContentRect(UxThemeElements.COMBOBOX, hDC, (int)ComboBoxPart.Border, (int)ComboBoxState.Normal, ref windowRect, out contentRect))
            {
                // shrink the client area the make more space for containing text.
                contentRect.Inflate(-1, -1);

                // remember the space of the borders
                this.borderRect = new RECT(contentRect.Left - windowRect.Left
                                           , contentRect.Top - windowRect.Top
                                           , windowRect.Right - contentRect.Right
                                           , windowRect.Bottom - contentRect.Bottom);

                // update LParam of the message with the new client area
                if (m.WParam == IntPtr.Zero)
                {
                    Marshal.StructureToPtr(contentRect, m.LParam, false);
                }
                else
                {
                    par.rgrc0 = contentRect;
                    Marshal.StructureToPtr(par, m.LParam, false);
                }

                // force the control to redraw it´s client area
                m.Result = new IntPtr(0x200 | 0x100);
            }

            // release DC
            Win32.ReleaseDC(this.Handle, hDC);

            base.WndProc(ref m);
        }
Пример #17
0
        /// <summary>
        /// Calculates the size of the window frame and client area of the RichTextBox
        /// </summary>
        private void WmNcCalcSize(ref Message m)
        {
            // let the richtextbox control draw the scrollbar if necessary.
            base.WndProc(ref m);

            // we visual styles are not enabled and BorderStyle is not Fixed3D then we have nothing more to do.
            if (!RenderWithVisualStyles())
                return;

            // contains detailed information about WM_NCCALCSIZE message
            NCCALCSIZE_PARAMS par = new NCCALCSIZE_PARAMS();

            // contains the window frame RECT
            RECT windowRect;

            if (m.WParam == IntPtr.Zero) // LParam points to a RECT struct
            {
                windowRect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));
            }
            else // LParam points to a NCCALCSIZE_PARAMS struct
            {
                par = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));
                windowRect = par.rgrc0;
            }

            // contains the client area of the control
            RECT contentRect;

            // get the DC
            IntPtr hDC = GetWindowDC(Handle);

            // open theme data
            IntPtr hTheme = OpenThemeData(Handle, "EDIT");

            // find out how much space the borders needs
            if (GetThemeBackgroundContentRect(hTheme, hDC, EP_EDITTEXT, GetState()
                , ref windowRect
                , out contentRect) == S_OK)
            {
                // shrink the client area the make more space for containing text.
                contentRect.Left += 1 + Padding.Left;
                contentRect.Top += 1 + Padding.Top;
                contentRect.Right -= 1 + Padding.Right;
                contentRect.Bottom -= 1 + Padding.Bottom;

                // remember the space of the borders
                _borderRect = new RECT(contentRect.Left - windowRect.Left
                    , contentRect.Top - windowRect.Top
                    , windowRect.Right - contentRect.Right
                    , windowRect.Bottom - contentRect.Bottom);

                // update LParam of the message with the new client area
                if (m.WParam == IntPtr.Zero)
                {
                    Marshal.StructureToPtr(contentRect, m.LParam, false);
                }
                else
                {
                    par.rgrc0 = contentRect;
                    Marshal.StructureToPtr(par, m.LParam, false);
                }

                // force the control to redraw it´s client area
                m.Result = new IntPtr(WVR_REDRAW);
            }

            // release theme data handle
            CloseThemeData(hTheme);

            // release DC
            ReleaseDC(Handle, hDC);
        }
Пример #18
0
    protected override void WndProc(ref Message m)
    {
        const uint WM_NCHITTEST  = 0x0084;
        const uint WM_MOUSEMOVE  = 0x0200;
        const uint HTLEFT        = 10;
        const uint HTRIGHT       = 11;
        const uint HTBOTTOMRIGHT = 17;
        const uint HTBOTTOM      = 15;
        const uint HTBOTTOMLEFT  = 16;
        const uint HTTOP         = 12;
        const uint HTTOPLEFT     = 13;
        const uint HTTOPRIGHT    = 14;

        const int WM_NCLBUTTONDOWN = 0xA1;
        const int HT_CAPTION       = 0x2;
        const int WM_NCCALCSIZE    = 0x83;

        const int RESIZE_HANDLE_SIZE = 10;
        bool      handled            = false;

        if (m.Msg == WM_NCHITTEST || m.Msg == WM_MOUSEMOVE)
        {
            Size  formSize    = this.Size;
            Point screenPoint = new Point(m.LParam.ToInt32());
            Point clientPoint = this.PointToClient(screenPoint);

            Dictionary <uint, Rectangle> boxes = new Dictionary <uint, Rectangle>()
            {
                { HTBOTTOMLEFT, new Rectangle(0, formSize.Height - RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTBOTTOM, new Rectangle(RESIZE_HANDLE_SIZE, formSize.Height - RESIZE_HANDLE_SIZE, formSize.Width - 2 * RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTBOTTOMRIGHT, new Rectangle(formSize.Width - RESIZE_HANDLE_SIZE, formSize.Height - RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTRIGHT, new Rectangle(formSize.Width - RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE, formSize.Height - 2 * RESIZE_HANDLE_SIZE) },
                { HTTOPRIGHT, new Rectangle(formSize.Width - RESIZE_HANDLE_SIZE, 0, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTTOP, new Rectangle(RESIZE_HANDLE_SIZE, 0, formSize.Width - 2 * RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTTOPLEFT, new Rectangle(0, 0, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE) },
                { HTLEFT, new Rectangle(0, RESIZE_HANDLE_SIZE, RESIZE_HANDLE_SIZE, formSize.Height - 2 * RESIZE_HANDLE_SIZE) }
            };

            foreach (KeyValuePair <uint, Rectangle> hitBox in boxes)
            {
                if (hitBox.Value.Contains(clientPoint))
                {
                    m.Result = (IntPtr)hitBox.Key;
                    handled  = true;
                    break;
                }
            }
        }

        if (m.Msg == WM_NCCALCSIZE)
        {
            if (m.WParam.Equals(IntPtr.Zero))
            {
                RECT      rc = (RECT)m.GetLParam(typeof(RECT));
                Rectangle r  = rc.ToRectangle();
                //r.Inflate(0, 0);
                Marshal.StructureToPtr(new RECT(r), m.LParam, true);
            }
            else
            {
                NCCALCSIZE_PARAMS csp = (NCCALCSIZE_PARAMS)m.GetLParam(typeof(NCCALCSIZE_PARAMS));
                Rectangle         r   = csp.rgrc0.ToRectangle();
                //r.Inflate(0,0);
                csp.rgrc0 = new RECT(r);
                Marshal.StructureToPtr(csp, m.LParam, true);
            }
            m.Result = IntPtr.Zero;
            handled  = true;
        }


        if (!handled)
        {
            base.WndProc(ref m);
        }
    }
Пример #19
0
        protected override void WndProc(ref Message m)
        {
            #region WndProc debug code
            // Use the following code in debug mode to view the windows messages by name optionally excluding some:
            #if DEBUG && SHOWMSGS
            string s = MsgType.GetMessageName(m.Msg, false,
                                              // Messages containing the following substrings will be ignored:
                                              "WM_USER", "WM_REFLECT", "NOTIFY", "TIMER", "HIT", "MOUSE", "CURSOR", "FOCUS", "IME_", "_KEY", "_CHAR", "_GETDLG");
            Debug.WriteLineIf(s.Length > 0, s);
            #endif
            #endregion WndProc debug code

            switch (m.Msg)
            {
                #region case WM_NCCALCSIZE:
            case (int)Win32Messages.WM_NCCALCSIZE:
                #region Non-client area definition

                /*
                 * The non-client area is the part of the window managed by the operating
                 * system and responsible for the appearance of borders, size-grippers and
                 * title-bars. This can be managed in Windows Forms by overriding WndProc and
                 * handling the WM_NCCALCSIZE, WM_NCPAINT, etc. message family.
                 */
                #endregion Non-client area definition

                #region WM_NCCALCSIZE message parameters

                /*
                 *  Parameters:
                 *
                 *  wParam
                 *  If wParam is TRUE, it specifies that the application should indicate which part of the
                 *  client area contains valid information. The system copies the valid information to the
                 *  specified area within the new client area.
                 *
                 *  If wParam is FALSE, the application does not need to indicate the valid part of the client area.
                 *
                 *  lParam
                 *  If wParam is TRUE, lParam points to an NCCALCSIZE_PARAMS structure that contains
                 *  information an application can use to calculate the new size and position of the client rectangle.
                 *  If wParam is FALSE, lParam points to a RECT structure. On entry, the structure
                 *  contains the proposed window rectangle for the window. On exit, the structure should
                 *  contain the screen coordinates of the corresponding window client area.
                 *
                 *  Return Value
                 *  If the wParam parameter is FALSE, the application should return zero.
                 *
                 *  If wParam is TRUE and an application returns zero, the old client area is preserved and
                 *  is aligned with the upper-left corner of the new client area.
                 */

                #region Return values

                /*
                 *  If wParam is TRUE, the application should return zero or a combination of the following values:
                 *  WVR_ALIGNTOP    Specifies that the client area of the window is to be preserved and aligned with
                 *                  the top of the new position of the window. For example, to align the client area
                 *                  to the upper-left corner, return the WVR_ALIGNTOP and WVR_ALIGNLEFT values.
                 *  WVR_ALIGNRIGHT  Specifies that the client area of the window is to be preserved and aligned with
                 *                  the right side of the new position of the window. For example, to align the client
                 *                  area to the lower-right corner, return the WVR_ALIGNRIGHT and WVR_ALIGNBOTTOM values.
                 *  WVR_ALIGNLEFT   Specifies that the client area of the window is to be preserved and aligned with
                 *                  the left side of the new position of the window. For example, to align the client
                 *                  area to the lower-left corner, return the WVR_ALIGNLEFT and WVR_ALIGNBOTTOM values.
                 *  WVR_ALIGNBOTTOM Specifies that the client area of the window is to be preserved and aligned with
                 *                  the bottom of the new position of the window. For example, to align the client area
                 *                  to the top-left corner, return the WVR_ALIGNTOP and WVR_ALIGNLEFT values.
                 *  WVR_HREDRAW     Used in combination with any other values, except WVR_VALIDRECTS, causes the window
                 *                  to be completely redrawn if the client rectangle changes size horizontally. This
                 *                  value is similar to CS_HREDRAW class style
                 *  WVR_VREDRAW     Used in combination with any other values, except WVR_VALIDRECTS, causes the window
                 *                  to be completely redrawn if the client rectangle changes size vertically. This value
                 *                  is similar to CS_VREDRAW class style
                 *  WVR_REDRAW      This value causes the entire window to be redrawn. It is a combination of WVR_HREDRAW
                 *                  and WVR_VREDRAW values.
                 *  WVR_VALIDRECTS  This value indicates that, upon return from WM_NCCALCSIZE, the rectangles specified
                 *                  by the rgrc[1] and rgrc[2] members of the NCCALCSIZE_PARAMS structure contain valid
                 *                  destination and source area rectangles, respectively. The system combines these
                 *                  rectangles to calculate the area of the window to be preserved. The system copies
                 *                  any part of the window image that is within the source rectangle and clips the image
                 *                  to the destination rectangle. Both rectangles are in parent-relative or screen-relative
                 *                  coordinates. This flag cannot be combined with any other flags.
                 *                  This return value allows an application to implement more elaborate client-area
                 *                  preservation strategies, such as centering or preserving a subset of the client area.
                 */
                #endregion Return values
                #endregion WM_NCCALCSIZE message parameters

                int adjustment = this.BorderStyle == BorderStyle.FixedSingle ? 2 : 0;

                if ((int)m.WParam == 0)                         // False
                {
                    #region Marshal.PtrToStructure summary

                    /* Marshal.PtrToStructure
                     * Summary:
                     *      Marshals data from an unmanaged block of memory to a newly allocated managed
                     *      object of the specified type.
                     *
                     * Parameters:
                     *      ptr: A pointer to an unmanaged block of memory.
                     *      structureType:
                     *          The System.Type of object to be created.
                     *          This type object must represent a formatted class or a structure.
                     *
                     * Returns:
                     *      A managed object containing the data pointed to by the ptr parameter.
                     */
                    #endregion Marshal.PtrToStructure summary

                    RECT rect = (RECT)Marshal.PtrToStructure(m.LParam, typeof(RECT));

                    // Adjust (shrink) the client rectangle to accommodate the border:
                    rect.Top    += m_BorderWidth - adjustment;
                    rect.Bottom -= m_BorderWidth - adjustment;
                    rect.Left   += m_BorderWidth - adjustment;
                    rect.Right  -= m_BorderWidth - adjustment;

                    #region Marshal.StructureToPtr summary

                    /* Marshal.StructureToPtr
                     * Summary:
                     *      Marshals data from a managed object to an unmanaged block of memory.
                     *
                     * Parameters:
                     *      ptr:
                     *          A pointer to an unmanaged block of memory, which must be allocated before
                     *          this method is called.
                     *      structure:
                     *          A managed object holding the data to be marshaled.
                     *          This object must be an instance of a formatted class.
                     *      fDeleteOld:
                     *          true to have the System.Runtime.InteropServices.Marshal.DestroyStructure
                     *          (System.IntPtr,System.Type) method called on the ptr parameter before
                     *          this method executes. Note that passing false can lead to a memory leak.
                     */
                    #endregion Marshal.StructureToPtr summary

                    Marshal.StructureToPtr(rect, m.LParam, false);

                    m.Result = IntPtr.Zero;
                }
                else if ((int)m.WParam == 1)                    // True
                {
                    #region Marshal.PtrToStructure summary

                    /* Marshal.PtrToStructure
                     * Summary:
                     *      Marshals data from an unmanaged block of memory to a newly allocated managed
                     *      object of the specified type.
                     *
                     * Parameters:
                     *      ptr: A pointer to an unmanaged block of memory.
                     *      structureType:
                     *          The System.Type of object to be created.
                     *          This type object must represent a formatted class or a structure.
                     *
                     * Returns:
                     *      A managed object containing the data pointed to by the ptr parameter.
                     */
                    #endregion Marshal.PtrToStructure summary

                    nccsp = (NCCALCSIZE_PARAMS)Marshal.PtrToStructure(m.LParam, typeof(NCCALCSIZE_PARAMS));

                    // Adjust (shrink) the client rectangle to accommodate the border:
                    nccsp.rect0.Top    += m_BorderWidth - adjustment;
                    nccsp.rect0.Bottom -= m_BorderWidth - adjustment;
                    nccsp.rect0.Left   += m_BorderWidth - adjustment;
                    nccsp.rect0.Right  -= m_BorderWidth - adjustment;

                    #region Marshal.StructureToPtr summary

                    /* Marshal.StructureToPtr
                     * Summary:
                     *      Marshals data from a managed object to an unmanaged block of memory.
                     *
                     * Parameters:
                     *      ptr:
                     *          A pointer to an unmanaged block of memory, which must be allocated before
                     *          this method is called.
                     *      structure:
                     *          A managed object holding the data to be marshaled.
                     *          This object must be an instance of a formatted class.
                     *      fDeleteOld:
                     *          true to have the System.Runtime.InteropServices.Marshal.DestroyStructure
                     *          (System.IntPtr,System.Type) method called on the ptr parameter before
                     *          this method executes. Note that passing false can lead to a memory leak.
                     */
                    #endregion Marshal.StructureToPtr summary

                    Marshal.StructureToPtr(nccsp, m.LParam, false);

                    m.Result = IntPtr.Zero;
                }

                base.WndProc(ref m);
                break;

                #endregion case WM_NCCALCSIZE

            case (int)Win32Messages.WM_PAINT:
                // Hide the caret if the text is readonly:
                hideCaret = this.ReadOnly;
                base.WndProc(ref m);
                break;

            case (int)Win32Messages.WM_NCPAINT:
                base.WndProc(ref m);
                doPaint = true;

                #region DEBUG paintCount++
                    #if DEBUG
                paintCount++;
                    #endif
                #endregion DEBUG paintCount++

                break;

                #region Deprecated code
                // This message is manually posted when the control is resized.  It is necessary to "redraw" the
                // control whenever this occurs.
                //case REDRAW_MSG_NUMBER:
                //    base.WndProc(ref m);
                //    Redraw();
                //    break;
                #endregion Deprecated code

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