private static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
        {
            POINT lMousePosition;
            GetCursorPos(out lMousePosition);

            IntPtr lPrimaryScreen = MonitorFromPoint(new POINT(0, 0), MonitorOptions.MONITOR_DEFAULTTOPRIMARY);
            MONITORINFO lPrimaryScreenInfo = new MONITORINFO();
            if (GetMonitorInfo(lPrimaryScreen, lPrimaryScreenInfo) == false)
            {
                return;
            }

            IntPtr lCurrentScreen = MonitorFromPoint(lMousePosition, MonitorOptions.MONITOR_DEFAULTTONEAREST);

            MINMAXINFO lMmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

            if (lPrimaryScreen.Equals(lCurrentScreen))
            {
                lMmi.ptMaxPosition.X = lPrimaryScreenInfo.rcWork.Left;
                lMmi.ptMaxPosition.Y = lPrimaryScreenInfo.rcWork.Top;
                lMmi.ptMaxSize.X = lPrimaryScreenInfo.rcWork.Right - lPrimaryScreenInfo.rcWork.Left;
                lMmi.ptMaxSize.Y = lPrimaryScreenInfo.rcWork.Bottom - lPrimaryScreenInfo.rcWork.Top;
            }
            else
            {
                lMmi.ptMaxPosition.X = lPrimaryScreenInfo.rcMonitor.Left;
                lMmi.ptMaxPosition.Y = lPrimaryScreenInfo.rcMonitor.Top;
                lMmi.ptMaxSize.X = lPrimaryScreenInfo.rcMonitor.Right - lPrimaryScreenInfo.rcMonitor.Left;
                lMmi.ptMaxSize.Y = lPrimaryScreenInfo.rcMonitor.Bottom - lPrimaryScreenInfo.rcMonitor.Top;
            }

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

        internal static void WmGetMinMaxInfo(IntPtr hwnd, 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.
            Int32 MONITOR_DEFAULTTONEAREST = 0x00000002;

            IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
            if (monitor != IntPtr.Zero)
            {
                MONITORINFO monitorInfo = new MONITORINFO();
                GetMonitorInfo(monitor, monitorInfo);

                RECT rcWorkArea = monitorInfo.m_rcWork;
                RECT rcMonitorArea = monitorInfo.m_rcMonitor;

                mmi.m_ptMaxPosition.m_x = Math.Abs(rcWorkArea.m_left - rcMonitorArea.m_left);
                mmi.m_ptMaxPosition.m_y = Math.Abs(rcWorkArea.m_top - rcMonitorArea.m_top);

                mmi.m_ptMaxSize.m_x = Math.Abs(rcWorkArea.m_right - rcWorkArea.m_left);
                mmi.m_ptMaxSize.m_y = Math.Abs(rcWorkArea.m_bottom - rcWorkArea.m_top);
            }

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

        private void WmGetMinMaxInfo(IntPtr hwnd, 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;
            IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);

            if (monitor != 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);

                // Convert pixel sizes based on current DPI settings.
                // Window.MinHeight/MinWidth are 1/96th of an inch.
                PresentationSource presentationSource = PresentationSource.FromVisual(this);
                if (presentationSource != null)
                {
                    if (presentationSource.CompositionTarget != null)
                    {
                        Point minSize = presentationSource.CompositionTarget.TransformToDevice.Transform(new Point(MinWidth, MinHeight));
                        mmi.ptMinTrackSize.x = (int)minSize.X;
                        mmi.ptMinTrackSize.y = (int)minSize.Y;
                    }
                }
            }

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

 private static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
 {
     MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));
     int MONITOR_DEFAULTTONEAREST = 0x00000002;
     IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
     if (monitor != 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);
     }
     Marshal.StructureToPtr(mmi, lParam, true);
 }

        private static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
        {
            var structure = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));
            var hMonitor = MonitorFromWindow(hwnd, 2);

            if (hMonitor != IntPtr.Zero)
            {
                var lpmi = new MONITORINFO();
                GetMonitorInfo(hMonitor, lpmi);
                RECT rcWork = lpmi.rcWork;
                RECT rcMonitor = lpmi.rcMonitor;
                structure.ptMaxPosition.x = Math.Abs((int)(rcWork.left - rcMonitor.left));
                structure.ptMaxPosition.y = Math.Abs((int)(rcWork.top - rcMonitor.top));
                structure.ptMaxSize.x = Math.Abs((int)(rcWork.right - rcWork.left));
                structure.ptMaxSize.y = Math.Abs((int)(rcWork.bottom - rcWork.top));
                structure.ptMinTrackSize.x = (int)Application.Current.MainWindow.MinWidth;
                structure.ptMinTrackSize.y = (int)Application.Current.MainWindow.MinHeight;
            }
            Marshal.StructureToPtr(structure, lParam, true);
        }

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

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

            if (monitor != IntPtr.Zero) {
                var monitorInfo = new MONITORINFO();
                GetMonitorInfo(monitor, monitorInfo);
                var rcWorkArea = monitorInfo.rcWork;
                var 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);
            }

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

 private void getNativeMonitorResolution(out int width, out int height)
 {
     var monitor = MonitorFromWindow(GetActiveWindow(), MONITOR_DEFAULTTONEAREST);
     MONITORINFO monitorInfo = new MONITORINFO();
     monitorInfo.cbSize = Marshal.SizeOf(monitorInfo);
     if (!GetMonitorInfo(monitor, ref monitorInfo))
     {
         width = Screen.width;
         height = Screen.height;
     }
     else
     {
         width = monitorInfo.rcMonitor.Width;
         height = monitorInfo.rcMonitor.Height;
     }
 }

 public static extern int GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);

        public static Monitor GetMonitor(IntPtr hMonitor)
        {
            MONITORINFO _info = new MONITORINFO();
            _info.cbSize = Marshal.SizeOf(_info);

            NativeMethods.GetMonitorInfo(hMonitor, ref _info);

            uint _dpiX = Monitor.DPICONST;
            uint _dpiY = Monitor.DPICONST;

            if (OS.SupportDPI)
            {
                NativeMethods.GetDpiForMonitor(hMonitor, MONITOR_DPI_TYPE.MDT_EFFECTIVE_DPI, out _dpiX, out _dpiY);
            }

            return new Monitor()
            {
                Size = _info.Size,
                WorkArea = _info.WorkArea,
                DPIx = _dpiX,
                DPIy = _dpiY,
                IsPrimary = _info.IsPrimary
            };
        }

        /*---------------------------------------------------------------------------------*/
        public bool IsFullScreen(string[] classNamesExcluded)
        {
            if (m_hWnd == IntPtr.Zero)
                return false;

            // 컨트롤의 최상위 핸들을 얻어옵니다.
            IntPtr hWnd = GetAncestor(m_hWnd, GetAncestorFlags.GetRoot);
            if (hWnd == IntPtr.Zero)
                return false;

            // 클래스이름을 얻어옵니다.
            StringBuilder className = new StringBuilder(256);
            if (GetClassName(hWnd, className, className.Capacity) == 0)
                return false;

            // 제외목록에서 하나라도 해당되는지 확인.
            if (classNamesExcluded.Any((string s) => s == className.ToString()))
                return false;

            // 현재 컨트롤이 속하는 모니터의 사각영역을 얻어옵니다.
            RECT desktop;
            IntPtr monitor = MonitorFromWindow(hWnd, MONITOR_DEFAULTTONEAREST);
            if (monitor == IntPtr.Zero)
            {
                // 모니터를 찾을 수 없으면 현재 윈도우 화면의 핸들로 설정한다.
                IntPtr desktopWnd = GetDesktopWindow();
                if (desktopWnd == IntPtr.Zero)
                    return false;

                if (GetWindowRect(desktopWnd, out desktop) == false)
                    return false;
            }
            else
            {
                MONITORINFO info = new MONITORINFO();
                info.cbSize = Marshal.SizeOf(info);
                if (GetMonitorInfo(monitor, ref info) == false)
                    return false;

                desktop = info.rcMonitor;
            }

            // 컨트롤의 작업영역을 알아낸다.
            RECT client;
            if (GetClientRect(hWnd, out client) == false)
                return false;

            // 컨트롤의 크기가 모니터 크기보다 작으면 전체화면이 아니다.
            if (client.Width < desktop.Width
                ||
                client.Height < desktop.Height)
                return false;

            // 여기까지 도달했으면 전체화면이다.
            return true;
        }

        private static void GetActualScreenData(ABEdge edge, Window appbarWindow, ref int leftOffset, ref int topOffset, ref int actualScreenWidth, ref int actualScreenHeight)
        {
            IntPtr handle = new WindowInteropHelper(appbarWindow).Handle;
            IntPtr monitorHandle = MonitorFromWindow(handle, MONITOR_DEFAULTTONEAREST);

            MONITORINFO mi = new MONITORINFO();
            mi.cbSize = Marshal.SizeOf(mi);

            if (GetMonitorInfo(monitorHandle, ref mi))
            {
                if (mi.dwFlags == MONITORINFOF_PRIMARY)
                {
                    return;
                }
                leftOffset = mi.rcWork.left;
                topOffset = mi.rcWork.top;
                actualScreenWidth = mi.rcWork.right - leftOffset;
                actualScreenHeight = mi.rcWork.bottom - mi.rcWork.top;
            }
        }

        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);
        }

 public static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO info);

 private static extern bool GetMonitorInfo(IntPtr monitor, ref MONITORINFO info);

 internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);

 internal static extern IntPtr MonitorFromPoint(POINT pt, MONITORINFO.MonitorOptions dwFlags);

 private static extern bool GetMonitorInfo(IntPtr hMonitor, ref MONITORINFO lpmi);

        /// <summary>
        /// Creates and populates the MINMAXINFO structure for a maximized window.
        /// Puts the structure into memory address given by lParam.
        /// Only used to process a WM_GETMINMAXINFO message.
        /// </summary>
        /// <param name="hwnd">The window handle.</param>
        /// <param name="lParam">The lParam.</param>
        private static void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
        {
            // Get the MINMAXINFO structure from memory location given by lParam
            MINMAXINFO mmi = (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

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

            if (monitor != 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);
            }

            // Copy the structure to memory location specified by lParam.
            // This concludes processing of WM_GETMINMAXINFO.
            Marshal.StructureToPtr(mmi, lParam, true);
        }

 public static WriteableBitmap Capture()
 {
     try
     {
         IntPtr hMonitor = MonitorFromPoint(new POINT(), MonitorOptions.MONITOR_DEFAULTTOPRIMARY);
         Debug.Assert(hMonitor != IntPtr.Zero);
         MONITORINFO mi = new MONITORINFO();
         mi.cbSize = (uint)Marshal.SizeOf(mi);
         bool bln = GetMonitorInfo(hMonitor, ref mi);
         Debug.Assert(bln);
         int W = mi.rcMonitor.right - mi.rcMonitor.left;
         int H = mi.rcMonitor.bottom - mi.rcMonitor.top;
         BITMAPINFOHEADER bmi = new BITMAPINFOHEADER();
         bmi.Init(W, H, 32);
         IntPtr hdcDesktop = GetDC(IntPtr.Zero);
         Debug.Assert(hdcDesktop != IntPtr.Zero);
         try
         {
             IntPtr hdcMem = CreateCompatibleDC(hdcDesktop);
             Debug.Assert(hdcMem != IntPtr.Zero);
             try
             {
                 IntPtr ppvBits = IntPtr.Zero;
                 IntPtr hbm = CreateDIBSection(hdcMem, ref bmi, 0, out ppvBits, IntPtr.Zero, 0);
                 Debug.Assert(hbm != IntPtr.Zero);
                 try
                 {
                     Debug.Assert(ppvBits != IntPtr.Zero);
                     IntPtr hOldObj = SelectObject(hdcMem, hbm);
                     bln = BitBlt(hdcMem, 0, 0, W, H, hdcDesktop, mi.rcMonitor.left, mi.rcMonitor.top, 0x00CC0020 /* SRCCOPY */);
                     Debug.Assert(bln);
                     GdiFlush();
                     ReleaseDC(IntPtr.Zero, hdcDesktop);
                     hdcDesktop = IntPtr.Zero;
                     WriteableBitmap wb = new WriteableBitmap(W, H);
                     int[] buf = wb.Pixels;
                     for (int ofs = 0; ofs < H; ++ofs)
                     {
                         Marshal.Copy(new IntPtr(ppvBits.ToInt64() + 4 * W * ofs), buf, (H - 1 - ofs) * W, W);
                     }
                     DeleteDC(hdcMem);
                     hdcMem = IntPtr.Zero;
                     DeleteObject(hbm);
                     hbm = IntPtr.Zero;
                     return wb;
                 }
                 finally
                 {
                     if(hbm != IntPtr.Zero)
                     {
                         DeleteObject(hbm);
                     }
                 }
             }
             finally
             {
                 if(hdcMem != IntPtr.Zero)
                 {
                     DeleteDC(hdcMem);
                 }
             }
         }
         finally
         {
             if(hdcDesktop != IntPtr.Zero)
             {
                 ReleaseDC(IntPtr.Zero, hdcDesktop);
             }
         }
     }
     catch(Exception e)
     {
         for (Exception r = e; r != null; r = r.InnerException)
         {
             Debug.WriteLine(r.Message);
             Debug.WriteLine(r.StackTrace);
         }
         return null;
     }
 }

        /// <summary>
        /// The WmGetMinMaxInfo function creates and populates the MINMAXINFO structure for a maximized window.
        /// Puts the structure into memory address given by lParam.
        /// Only used to process a WM_GETMINMAXINFO message.
        /// </summary>
        /// <param name="hwnd">The window handle.</param>
        /// <param name="lParam">The lParam.</param>
        private void WmGetMinMaxInfo(IntPtr hwnd, IntPtr lParam)
        {
            // Get the MINMAXINFO structure from memory location given by lParam
            MINMAXINFO mmi =
                (MINMAXINFO)Marshal.PtrToStructure(lParam, typeof(MINMAXINFO));

            // Get the monitor that overlaps the window or the nearest
            IntPtr monitor = MonitorFromWindow(hwnd, MONITOR_DEFAULTTONEAREST);
            if (monitor != IntPtr.Zero)
            {
                // Get monitor information
                MONITORINFO monitorInfo = new MONITORINFO();
                monitorInfo.Size = Marshal.SizeOf(typeof(MONITORINFO));
                GetMonitorInfo(monitor, ref monitorInfo);

                // The display monitor rectangle.
                // If the monitor is not the primary display monitor,
                // some of the rectangle's coordinates may be negative values
                RECT rcWorkArea = monitorInfo.WorkArea;
                RECT rcMonitorArea = monitorInfo.Monitor;

                // Set the dimensions of the window in maximized state
                mmi.MaxPosition.X = Math.Abs(rcWorkArea.Left - rcMonitorArea.Left);
                mmi.MaxPosition.Y = Math.Abs(rcWorkArea.Top - rcMonitorArea.Top);
                mmi.MaxSize.X = Math.Abs(rcWorkArea.Right - rcWorkArea.Left);
                mmi.MaxSize.Y = Math.Abs(rcWorkArea.Bottom - rcWorkArea.Top);

                // Set the maximum drag X size for the window
                mmi.MaxTrackSize.X = mmi.MaxSize.X;
                // Set the maximum drag Y size for the window
                mmi.MaxTrackSize.Y = mmi.MaxSize.Y;
                mmi.MinTrackSize.X = (int)MinWidowWidth;
                mmi.MinTrackSize.Y = (int)MinWidowHeight;

                // Set the working area depending of TaskBar position and AutoHide status
                mmi = AdjustWorkingAreaForAutoHide(monitor, mmi);
            }

            // Copy the structure to memory location specified by lParam.
            // This concludes processing of WM_GETMINMAXINFO.
            Marshal.StructureToPtr(mmi, lParam, true);
        }