WPF Window Resizing(WindowResizer.dll)改進

原創 jiangxinyu 2020-06-27 11:23

WPF Window Resizing(CodeProject原文)

原文中的代碼演示瞭如何動態實時改變WPF窗口的方法,不過在測試中發現一個小問題,即當鼠標按下後一直向一個方向縮小窗口的時候,當鼠標超過了另一條邊的時候(在左邊框按下,一直向右拖動鼠標,直到鼠標超過右邊框時,異常就出現了,其他四個方向同理)會引發異常.

以下代碼在原來的基礎上,主要修改了updateSize函數,解決了問題.


2013-04-02：新問題，找時間修改

      1，當拖動左邊框的時候，右邊框應固定不動，但現在右邊框則在不停的閃動，雖然最後的位置是正確的。同樣，上下拖動也存在相同的問題。是因爲時時改變了當前窗口的左上角座標點位置，重繪引起的閃動。


完整代碼示例:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Runtime.InteropServices;
using System.Windows.Interop;
using System.Threading;
using System.Windows.Media.Effects;

namespace DNBSoft.WPF
{
    public class WindowResizer
    {
        private Window target = null;

        private bool resizeRight = false;
        private bool resizeLeft = false;
        private bool resizeUp = false;
        private bool resizeDown = false;

        private Dictionary<UIElement, short> leftElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> rightElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> upElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> downElements = new Dictionary<UIElement, short>();

        private PointAPI startMousePoint = new PointAPI();          //鼠標左鍵點下時的座標點
        private Size startWindowSize = new Size();                  //鼠標左鍵點下時,窗口的大小
        private Point startWindowLeftUpPoint = new Point();         //鼠標左鍵點下時,窗口左上角座標點位置

        public int minWidth = 10;
        public int minHeight = 10;

        private delegate void RefreshDelegate();

        public WindowResizer(Window target)
        {
            this.target = target;

            if (target == null)
            {
                throw new Exception("Invalid Window handle");
            }
        }

        #region add resize components
        private void connectMouseHandlers(UIElement element)
        {
            element.MouseLeftButtonDown += new MouseButtonEventHandler(element_MouseLeftButtonDown);
            element.MouseEnter += new MouseEventHandler(element_MouseEnter);
            element.MouseLeave += new MouseEventHandler(setArrowCursor);
        }

        public void addResizerRight(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
        }

        public void addResizerLeft(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
        }

        public void addResizerUp(UIElement element)
        {
            connectMouseHandlers(element);
            upElements.Add(element, 0);
        }

        public void addResizerDown(UIElement element)
        {
            connectMouseHandlers(element);
            downElements.Add(element, 0);
        }

        public void addResizerRightDown(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
            downElements.Add(element, 0);
        }

        public void addResizerLeftDown(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
            downElements.Add(element, 0);
        }

        public void addResizerRightUp(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
            upElements.Add(element, 0);
        }

        public void addResizerLeftUp(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
            upElements.Add(element, 0);
        }
        #endregion

        #region resize handlers
        private void element_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            GetCursorPos(out startMousePoint);
            startWindowSize = new Size(target.Width, target.Height);
            startWindowLeftUpPoint = new Point(target.Left, target.Top);

            #region updateResizeDirection
            UIElement sourceSender = (UIElement)sender;
            if (leftElements.ContainsKey(sourceSender))
            {
                resizeLeft = true;
            }
            if (rightElements.ContainsKey(sourceSender))
            {
                resizeRight = true;
            }
            if (upElements.ContainsKey(sourceSender))
            {
                resizeUp = true;
            }
            if (downElements.ContainsKey(sourceSender))
            {
                resizeDown = true;
            }
            #endregion

            Thread t = new Thread(new ThreadStart(updateSizeLoop));
            t.Name = "Mouse Position Poll Thread";
            t.Start();
        }

        private void updateSizeLoop()
        {
            try
            {
                while (resizeDown || resizeLeft || resizeRight || resizeUp)
                {
                    target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateSize));
                    target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateMouseDown));
                    Thread.Sleep(20);
                }

                target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(setArrowCursor));
            }
            catch (Exception)
            {
            }
        }

        #region updates
        private void updateSize()
        {
            PointAPI currentMousePoint = new PointAPI();
            GetCursorPos(out currentMousePoint);

            try
            {
                if (resizeRight)
                {
                    //如果當鼠標左鍵點下時,窗口的寬度已經達到最小值,
                    if (target.Width == minWidth)
                    {
                        //鼠標向右移動,表示當前是將窗口變大,此時窗口只能變大,因爲已經達到最小寬度了
                        if ((startMousePoint.X - currentMousePoint.X) < 0)
                        {
                            target.Width = this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X);
                        }
                    }
                    else
                    {
                        //此時,窗口可大可小
                        if ((this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X)) >= minWidth)
                        {
                            target.Width = this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X);
                        }
                        else
                        {
                            //此時,只能限制窗口爲最小值,不能繼續變小
                            target.Width = minWidth;
                        }
                    }
                }

                if (resizeDown)
                {
                    if (target.Height == minHeight)
                    {
                        if ((startMousePoint.Y - currentMousePoint.Y) < 0)
                        {
                            target.Height = startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y);
                        }
                    }
                    else
                    {
                        if ((startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) >= minHeight)
                        {
                            target.Height = startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y);
                        }
                        else
                        {
                            target.Height = minHeight;
                        }
                    }
                }

                if (resizeLeft)
                {
                    if (target.Width == minWidth)
                    {
                        if ((startMousePoint.X - currentMousePoint.X) > 0)
                        {
                            target.Width = startWindowSize.Width + (startMousePoint.X - currentMousePoint.X);
                            target.Left = startWindowLeftUpPoint.X - (startMousePoint.X - currentMousePoint.X);
                        }
                    }
                    else
                    {
                        if ((this.startWindowSize.Width + (startMousePoint.X - currentMousePoint.X)) >= minWidth)
                        {
                            target.Width = startWindowSize.Width + (startMousePoint.X - currentMousePoint.X);
                            target.Left = startWindowLeftUpPoint.X - (startMousePoint.X - currentMousePoint.X);
                        }
                        else
                        {
                            target.Width = minWidth;
                            target.Left = startWindowLeftUpPoint.X + startWindowSize.Width - target.Width;
                        }
                    }
                }

                if (resizeUp)
                {
                    if (target.Height == minHeight)
                    {
                        if ((startMousePoint.Y - currentMousePoint.Y) > 0)
                        {
                            target.Height = startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y);
                            target.Top = startWindowLeftUpPoint.Y - (startMousePoint.Y - currentMousePoint.Y);
                        }
                        else
                        {
                            target.Height = minHeight;
                            target.Top = startWindowLeftUpPoint.Y + startWindowSize.Height - target.Height;
                        }
                    }
                    else
                    {
                        if ((startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y)) >= minHeight)
                        {
                            target.Height = startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y);
                            target.Top = startWindowLeftUpPoint.Y - (startMousePoint.Y - currentMousePoint.Y);
                        }
                        else
                        {
                            target.Height = minHeight;
                            target.Top = startWindowLeftUpPoint.Y + startWindowSize.Height - target.Height;
                        }
                    }
                }
            }
            catch
            {
            }
        }

        private void updateMouseDown()
        {
            if (Mouse.LeftButton == MouseButtonState.Released)
            {
                resizeRight = false;
                resizeLeft = false;
                resizeUp = false;
                resizeDown = false;
            }
        }
        #endregion
        #endregion

        #region cursor updates
        private void element_MouseEnter(object sender, MouseEventArgs e)
        {
            bool resizeRight = false;
            bool resizeLeft = false;
            bool resizeUp = false;
            bool resizeDown = false;

            UIElement sourceSender = (UIElement)sender;
            if (leftElements.ContainsKey(sourceSender))
            {
                resizeLeft = true;
            }
            if (rightElements.ContainsKey(sourceSender))
            {
                resizeRight = true;
            }
            if (upElements.ContainsKey(sourceSender))
            {
                resizeUp = true;
            }
            if (downElements.ContainsKey(sourceSender))
            {
                resizeDown = true;
            }

            if ((resizeLeft && resizeDown) || (resizeRight && resizeUp))
            {
                setNESWCursor(sender, e);
            }
            else if ((resizeRight && resizeDown) || (resizeLeft && resizeUp))
            {
                setNWSECursor(sender, e);
            }
            else if (resizeLeft || resizeRight)
            {
                setWECursor(sender, e);
            }
            else if (resizeUp || resizeDown)
            {
                setNSCursor(sender, e);
            }
        }

        private void setWECursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeWE;
        }

        private void setNSCursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNS;
        }

        private void setNESWCursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNESW;
        }

        private void setNWSECursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNWSE;
        }

        private void setArrowCursor(object sender, MouseEventArgs e)
        {
            if (!resizeDown && !resizeLeft && !resizeRight && !resizeUp)
            {
                target.Cursor = Cursors.Arrow;
            }
        }

        private void setArrowCursor()
        {
            target.Cursor = Cursors.Arrow;
        }
        #endregion

        #region external call
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool GetCursorPos(out PointAPI lpPoint);

        private struct PointAPI
        {
            public int X;
            public int Y;
        }
        #endregion
    }
}

代碼下載

以下代碼加入了控制窗口最大化的時候不遮蓋任務欄

1,加入最小寬度，最小高度的限制

2,限制最大高度不超過屏幕的工作區域，避免向下拖動時，拖動到任務欄以下的區域，被任務欄遮蓋。

在窗口的構造函數中調用。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Shapes;
using System.Runtime.InteropServices;
using System.Windows.Interop;
using System.Threading;
using System.Windows.Media.Effects;

namespace DNBSoft.WPF
{
    public class WindowResizer
    {
        private Window target = null;

        private bool resizeRight = false;
        private bool resizeLeft = false;
        private bool resizeUp = false;
        private bool resizeDown = false;

        private Dictionary<UIElement, short> leftElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> rightElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> upElements = new Dictionary<UIElement, short>();
        private Dictionary<UIElement, short> downElements = new Dictionary<UIElement, short>();

        private PointAPI startMousePoint = new PointAPI();          //鼠標左鍵點下時的座標點
        private Size startWindowSize = new Size();                  //鼠標左鍵點下時,窗口的大小
        private Point startWindowLeftUpPoint = new Point();         //鼠標左鍵點下時,窗口左上角座標點位置
        private static int workAreaMaxHeight = -1;                          //工作區域最大高度

        public int minWidth = 10;
        public int minHeight = 10;

        private HwndSource hs;

        private delegate void RefreshDelegate();

        public WindowResizer(Window target)
        {
            this.target = target;

            if (target == null)
            {
                throw new Exception("Invalid Window handle");
            }

            //窗口大小發生變化時，及時調整窗口最大高度和寬度，防止遮蓋任務欄
            this.target.SourceInitialized += new EventHandler(MyMacClass_SourceInitialized);
        }

        #region 這一部分用於最大化時不遮蔽任務欄

        private void MyMacClass_SourceInitialized(object sender, EventArgs e)
        {
            hs = PresentationSource.FromVisual((Visual)sender) as HwndSource;
            hs.AddHook(new HwndSourceHook(WndProc));
        }

        private IntPtr WndProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
        {
            switch (msg)
            {
                case 0x0024:/* WM_GETMINMAXINFO */
                    WmGetMinMaxInfo(hwnd, lParam);
                    handled = true;
                    break;
                default: break;
            }
            return (System.IntPtr)0;
        }

        private static void WmGetMinMaxInfo(System.IntPtr hwnd, System.IntPtr lParam)
        {
            MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

            // Adjust the maximized size and position to fit the work area of the correct monitor
            int MONITOR_DEFAULTTONEAREST = 0x00000002;
            System.IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

            if (monitor != System.IntPtr.Zero)
            {
                MONITORINFO monitorInfo = new MONITORINFO();
                GetMonitorInfo(monitor, monitorInfo);
                RECT rcWorkArea = monitorInfo.rcWork;
                RECT rcMonitorArea = monitorInfo.rcMonitor;
                mmi.ptMaxPosition.x = Math.Abs(rcWorkArea.left - rcMonitorArea.left);
                mmi.ptMaxPosition.y = Math.Abs(rcWorkArea.top - rcMonitorArea.top);

                // 這行如果不註釋掉在多顯示器情況下顯示會有問題！ 
                // mmi.ptMaxSize.x = Math.Abs(rcWorkArea.right - rcWorkArea.left);
                mmi.ptMaxSize.y = Math.Abs(rcWorkArea.bottom - rcWorkArea.top);
                workAreaMaxHeight = mmi.ptMaxSize.y;

                //當窗口的任務欄自動隱藏時，最大化的時候最下邊要留幾個像素的空白，否則此窗口將屏幕鋪滿，則鼠標移到最下邊時，任務欄無法自動彈出
                if (rcWorkArea.Height == rcMonitorArea.Height)
                {
                    mmi.ptMaxSize.y -= 2;
                }
            }

            Marshal.StructureToPtr(mmi, lParam, true);
        }

        [DllImport("user32")]
        internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);

        [DllImport("User32")]
        internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);

        /// <summary>
        /// POINT aka POINTAPI
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct POINT
        {
            /// <summary>
            /// x coordinate of point.
            /// </summary>
            public int x;
            /// <summary>
            /// y coordinate of point.
            /// </summary>
            public int y;

            /// <summary>
            /// Construct a point of coordinates (x,y).
            /// </summary>
            public POINT(int x, int y)
            {
                this.x = x;
                this.y = y;
            }
        }

        [StructLayout(LayoutKind.Sequential)]
        public struct MINMAXINFO
        {
            public POINT ptReserved;
            public POINT ptMaxSize;
            public POINT ptMaxPosition;
            public POINT ptMinTrackSize;
            public POINT ptMaxTrackSize;
        };

        [StructLayout(LayoutKind.Sequential, Pack = 0)]
        public struct RECT
        {
            /// <summary> Win32 </summary>
            public int left;
            /// <summary> Win32 </summary>
            public int top;
            /// <summary> Win32 </summary>
            public int right;
            /// <summary> Win32 </summary>
            public int bottom;

            /// <summary> Win32 </summary>
            public static readonly RECT Empty = new RECT();

            /// <summary> Win32 </summary>
            public int Width
            {
                get { return Math.Abs(right - left); }  // Abs needed for BIDI OS
            }
            /// <summary> Win32 </summary>
            public int Height
            {
                get { return bottom - top; }
            }

            /// <summary> Win32 </summary>
            public RECT(int left, int top, int right, int bottom)
            {
                this.left = left;
                this.top = top;
                this.right = right;
                this.bottom = bottom;
            }


            /// <summary> Win32 </summary>
            public RECT(RECT rcSrc)
            {
                this.left = rcSrc.left;
                this.top = rcSrc.top;
                this.right = rcSrc.right;
                this.bottom = rcSrc.bottom;
            }
        }

        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
        public class MONITORINFO
        {
            /// <summary>
            /// </summary>            
            public int cbSize = Marshal.SizeOf(typeof(MONITORINFO));

            /// <summary>
            /// </summary>            
            public RECT rcMonitor = new RECT();

            /// <summary>
            /// </summary>            
            public RECT rcWork = new RECT();

            /// <summary>
            /// </summary>            
            public int dwFlags = 0;
        }

        #endregion

        #region add resize components
        private void connectMouseHandlers(UIElement element)
        {
            element.MouseLeftButtonDown += new MouseButtonEventHandler(element_MouseLeftButtonDown);
            element.MouseEnter += new MouseEventHandler(element_MouseEnter);
            element.MouseLeave += new MouseEventHandler(setArrowCursor);
        }

        public void addResizerRight(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
        }

        public void addResizerLeft(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
        }

        public void addResizerUp(UIElement element)
        {
            connectMouseHandlers(element);
            upElements.Add(element, 0);
        }

        public void addResizerDown(UIElement element)
        {
            connectMouseHandlers(element);
            downElements.Add(element, 0);
        }

        public void addResizerRightDown(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
            downElements.Add(element, 0);
        }

        public void addResizerLeftDown(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
            downElements.Add(element, 0);
        }

        public void addResizerRightUp(UIElement element)
        {
            connectMouseHandlers(element);
            rightElements.Add(element, 0);
            upElements.Add(element, 0);
        }

        public void addResizerLeftUp(UIElement element)
        {
            connectMouseHandlers(element);
            leftElements.Add(element, 0);
            upElements.Add(element, 0);
        }
        #endregion

        #region resize handlers
        private void element_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
        {
            GetCursorPos(out startMousePoint);
            startWindowSize = new Size(target.Width, target.Height);
            startWindowLeftUpPoint = new Point(target.Left, target.Top);

            #region updateResizeDirection
            UIElement sourceSender = (UIElement)sender;
            if (leftElements.ContainsKey(sourceSender))
            {
                resizeLeft = true;
            }
            if (rightElements.ContainsKey(sourceSender))
            {
                resizeRight = true;
            }
            if (upElements.ContainsKey(sourceSender))
            {
                resizeUp = true;
            }
            if (downElements.ContainsKey(sourceSender))
            {
                resizeDown = true;
            }
            #endregion

            Thread t = new Thread(new ThreadStart(updateSizeLoop));
            t.Name = "Mouse Position Poll Thread";
            t.Start();
        }

        private void updateSizeLoop()
        {
            try
            {
                while (resizeDown || resizeLeft || resizeRight || resizeUp)
                {
                    target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateSize));
                    target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(updateMouseDown));
                    Thread.Sleep(25);
                }

                target.Dispatcher.Invoke(System.Windows.Threading.DispatcherPriority.Render, new RefreshDelegate(setArrowCursor));
            }
            catch (Exception)
            {
            }
        }

        #region updates
        private void updateSize()
        {
            PointAPI currentMousePoint = new PointAPI();
            GetCursorPos(out currentMousePoint);

            try
            {
                if (resizeRight)
                {
                    //如果當鼠標左鍵點下時,窗口的寬度已經達到最小值,
                    if (target.Width == minWidth)
                    {
                        //鼠標向右移動,表示當前是將窗口變大,此時窗口只能變大,因爲已經達到最小寬度了
                        if ((startMousePoint.X - currentMousePoint.X) < 0)
                        {
                            target.Width = this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X);
                        }
                    }
                    else
                    {
                        //此時,窗口可大可小
                        if ((this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X)) >= minWidth)
                        {
                            target.Width = this.startWindowSize.Width - (startMousePoint.X - currentMousePoint.X);
                        }
                        else
                        {
                            //此時,只能限制窗口爲最小值,不能繼續變小
                            target.Width = minWidth;
                        }
                    }
                }

                if (resizeDown)
                {
                    if (target.Height == minHeight)
                    {
                        if ((startMousePoint.Y - currentMousePoint.Y) < 0)
                        {
                            //限制窗口的最底端，不能低於任務欄，即不能被任務欄遮擋
                            if (workAreaMaxHeight > 0)
                            {
                                target.Height = (((startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) + target.Top) <= workAreaMaxHeight) ? (startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) : (workAreaMaxHeight - target.Top);
                            }
                            else
                            {
                                target.Height = startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y);
                            }
                        }
                    }
                    else
                    {
                        if ((startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) >= minHeight)
                        {
                            if (workAreaMaxHeight > 0)
                            {
                                target.Height = (((startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) + target.Top) <= workAreaMaxHeight) ? (startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y)) : (workAreaMaxHeight - target.Top);
                            }
                            else
                            {
                                target.Height = startWindowSize.Height - (startMousePoint.Y - currentMousePoint.Y);
                            }
                        }
                        else
                        {
                            target.Height = minHeight;
                        }
                    }
                }

                if (resizeLeft)
                {
                    if (target.Width == minWidth)
                    {
                        if ((startMousePoint.X - currentMousePoint.X) > 0)
                        {
                            target.Width = startWindowSize.Width + (startMousePoint.X - currentMousePoint.X);
                            target.Left = startWindowLeftUpPoint.X - (startMousePoint.X - currentMousePoint.X);
                        }
                    }
                    else
                    {
                        if ((this.startWindowSize.Width + (startMousePoint.X - currentMousePoint.X)) >= minWidth)
                        {
                            target.Width = startWindowSize.Width + (startMousePoint.X - currentMousePoint.X);
                            target.Left = startWindowLeftUpPoint.X - (startMousePoint.X - currentMousePoint.X);
                        }
                        else
                        {
                            target.Width = minWidth;
                            target.Left = startWindowLeftUpPoint.X + startWindowSize.Width - target.Width;
                        }
                    }
                }

                if (resizeUp)
                {
                    if (target.Height == minHeight)
                    {
                        if ((startMousePoint.Y - currentMousePoint.Y) > 0)
                        {
                            target.Height = startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y);
                            target.Top = startWindowLeftUpPoint.Y - (startMousePoint.Y - currentMousePoint.Y);
                        }
                        else
                        {
                            target.Height = minHeight;
                            target.Top = startWindowLeftUpPoint.Y + startWindowSize.Height - target.Height;
                        }
                    }
                    else
                    {
                        if ((startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y)) >= minHeight)
                        {
                            target.Height = startWindowSize.Height + (startMousePoint.Y - currentMousePoint.Y);
                            target.Top = startWindowLeftUpPoint.Y - (startMousePoint.Y - currentMousePoint.Y);
                        }
                        else
                        {
                            target.Height = minHeight;
                            target.Top = startWindowLeftUpPoint.Y + startWindowSize.Height - target.Height;
                        }
                    }
                }
            }
            catch
            {
            }
        }

        private void updateMouseDown()
        {
            if (Mouse.LeftButton == MouseButtonState.Released)
            {
                resizeRight = false;
                resizeLeft = false;
                resizeUp = false;
                resizeDown = false;
            }
        }
        #endregion
        #endregion

        #region cursor updates
        private void element_MouseEnter(object sender, MouseEventArgs e)
        {
            bool resizeRight = false;
            bool resizeLeft = false;
            bool resizeUp = false;
            bool resizeDown = false;

            UIElement sourceSender = (UIElement)sender;
            if (leftElements.ContainsKey(sourceSender))
            {
                resizeLeft = true;
            }
            if (rightElements.ContainsKey(sourceSender))
            {
                resizeRight = true;
            }
            if (upElements.ContainsKey(sourceSender))
            {
                resizeUp = true;
            }
            if (downElements.ContainsKey(sourceSender))
            {
                resizeDown = true;
            }

            if ((resizeLeft && resizeDown) || (resizeRight && resizeUp))
            {
                setNESWCursor(sender, e);
            }
            else if ((resizeRight && resizeDown) || (resizeLeft && resizeUp))
            {
                setNWSECursor(sender, e);
            }
            else if (resizeLeft || resizeRight)
            {
                setWECursor(sender, e);
            }
            else if (resizeUp || resizeDown)
            {
                setNSCursor(sender, e);
            }
        }

        private void setWECursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeWE;
        }

        private void setNSCursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNS;
        }

        private void setNESWCursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNESW;
        }

        private void setNWSECursor(object sender, MouseEventArgs e)
        {
            target.Cursor = Cursors.SizeNWSE;
        }

        private void setArrowCursor(object sender, MouseEventArgs e)
        {
            if (!resizeDown && !resizeLeft && !resizeRight && !resizeUp)
            {
                target.Cursor = Cursors.Arrow;
            }
        }

        private void setArrowCursor()
        {
            target.Cursor = Cursors.Arrow;
        }
        #endregion

        #region external call
        [DllImport("user32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool GetCursorPos(out PointAPI lpPoint);

        private struct PointAPI
        {
            public int X;
            public int Y;
        }
        #endregion
    }
}



發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

WPF編程，WPF項目中使用Echart控件畫圖的使用方法

Echarts官網 Echarts js文件下載 注意： ** 源碼是不能直接調用的，需要下載編譯後的dist文件夾下的echarts.js文件。通過查看文件可以看出，源碼echarts.js裏面調用很多別的文件，各種i

子不语 2020-07-05 16:42:49

WPF 在Canvas拖動多個控件的獨立移動的具體實現

寫這篇文章的理由： 觸發機制——單個功能點用時一個工作日的核心代碼實現 具體需求 在Canvas畫布上動態添加可移動的標籤（就是實現截圖功能的文本備註功能）。 主要說移動多個控件功能，在網上找的移動功能都只支持一個文本的移動或者是多個控

wengpiwang 2020-07-05 08:18:14

WPF RICHTEXTBOX 和數據庫讀寫圖文的方法

做一個項目，需要圖文一起存入數據庫，在網上瀏覽了很久。終於實現了在RICHTEXTBOX裏面和數據庫讀寫圖文的方法。 存入數據庫。   public string toxaml()         {            // Str

idebian 2020-07-04 21:34:25

Namespace in xaml

傳統的我們在xaml中引用自己的類型都需要寫xmlns，比如說， 在WpfApplication1中定義Test01 namespace WpfApplication1 {  public class Test01 : UIElement

idebian 2020-07-04 20:52:58

WPF中圖像模糊的處理方法

參考： https://www.cnblogs.com/TianFang/archive/2009/07/02/1515553.html https://www.cnblogs.com/xiaokang088/p/3200431.html

狂奔之林 2020-07-07 15:14:07

WPF 打印

PrintDialog dialog = new PrintDialog(); if (dialog.ShowDialog() == true) { dialog.PrintVisual(printAre

反叛的利昂 2020-07-07 08:39:30

WPF 使用 SHGetFileInfo 造成內存泄漏問題

使用WPF自己做一個文件管理。其中，需要回去文件圖標進行顯示，使用win32接口進行，代碼如下 /// <summary> /// 獲取文件圖標需要的結構體，作爲出參，不需要初始化 /// </summary> [Struc

马小坡 2020-07-07 06:57:17

WPF 創建透明顏色

正常的顏色應該是6個十六進制表示，這樣是沒有透明顏色的。 例如： BackGround = "#FF0000" 想使用透明顏色，需要用到8個十六進制，這樣就可以設置透明色了： BackGround = “#00000000”

马小坡 2020-07-07 06:57:17

L是無外觀

ItemsControl: 'L' is for Lookless (a.k.a., "Styles, Templates, andTriggers… Oh My!")在這片文章中，我們將研究WPF控件如何通過樣式和模板獲取可視化展示。然

月影 2020-07-06 15:54:54

C#純技術——GroupBox自定義Style

So Long Time Not Write Essay  Hope My Fans Don't Leave Me 🤭  今天給大家帶來一款自己寫的GrouBox希望我的粉絲們喜歡！ <UserControl.Resources

文三胖 2020-07-06 02:41:53

Matlab與WPF——分析矩陣生成圖表

引言：矩陣轉換，是Matlab到.NET環境非常重要的數據轉換技術；閱讀本文前提是已經會Matlab在.NET環境下需要做的環境配置操作，本文實現WPF調用已設計好的Matlab算法程序。 爲了讓讀者更加清楚Matlab在.NET環境下的

文三胖 2020-07-06 02:41:53

WPF ListBox,ListView添加ToolTip顯示當前選擇項

      今天碰到一個需求，使用ListBox顯示多文字。因爲每個選項文字較長，ListBoxItem的寬度有限，這時候爲了體現界面友好，增加ToolTip是一個好的選擇：代碼如下： MainWindow.xaml: <Window

楚楚3107 2020-07-05 18:02:37

WPF編程，通過在主界面中設置系統托盤圖標的一種方法。

這裏給出WPF下，使用任務欄托盤圖標的一種方法。不需要增加第三方的DLL引用，只需要增加框架本身自帶的一些引用。 代碼如下： private NotifyIcon notifyIcon = null; W

子不语 2020-07-05 16:43:00

WPF控件旋轉

  你要旋轉控件角度的話，可以設置其RenderTransform或是LayoutTransform屬性，然後爲其設置一個RotateTransform實例，並且設置Angle屬性。下面是一個小例子供參考。     <StackPanel

lovelan1748 2020-07-05 05:32:16

WPF 實現窗口的最大化和最小化，窗口大小鎖定，一啓動就爲最大化

如果你覺得我這篇博客有用的話，點個贊吧~  /// <summary> /// 最大化和最小化 /// </summary> /// <param name="sender"></param> /// <param name="e"

养鼠的猫 2020-07-05 01:00:09