zoukankan      html  css  js  c++  java
  • WPF自定义窗口最大化显示任务栏

    当我们要自定义WPF窗口样式时,通常是采用设计窗口的属性 WindowStyle="None" ,然后为窗口自定义放大,缩小,关闭按钮的样式。

    然而这样的话,当通过代码设置窗口(代码如下)放大时,窗口会把任务栏给遮档住。

    private void Max_Click(object sender, RoutedEventArgs e)
            {
                if (this.WindowState != WindowState.Maximized)
                {
                    this.WindowState = WindowState.Maximized;
                    
                }
                else
                {
                    this.WindowState = WindowState.Normal;
                    
                }
            }

    这样的问题想必也同样困绕着你。下面可以通过采用win32编程的方式把任务栏显示出来。Idea源于网络上的资料,如果你在其他地方找到类似的,那祝贺你!

    首先你的窗口代码文件引用两个命名空间:

    using WinInterop = System.Windows.Interop;
    using System.Runtime.InteropServices;

    然后在窗口构造函数加入

    this.SourceInitialized += new EventHandler(win_SourceInitialized);
    win_SourceInitialized 函数及相关代码如下:
    #region 最大化显示任务栏
    
            void win_SourceInitialized(object sender, EventArgs e)
            {
                System.IntPtr handle = (new WinInterop.WindowInteropHelper(this)).Handle;
                WinInterop.HwndSource.FromHwnd(handle).AddHook(new WinInterop.HwndSourceHook(WindowProc));
            }
    
            private static System.IntPtr WindowProc(
                  System.IntPtr hwnd,
                  int msg,
                  System.IntPtr wParam,
                  System.IntPtr lParam,
                  ref bool handled)
            {
                switch (msg)
                {
                    case 0x0024:
                        WmGetMinMaxInfo(hwnd, lParam);
                        handled = true;
                        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);
                }
    
                Marshal.StructureToPtr(mmi, lParam, true);
            }
    
    
            /// <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;
            };
    
    
    
            /// <summary>
            /// </summary>
            [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;
            }
    
    
            /// <summary> Win32 </summary>
            [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;
                }
    
                /// <summary> Win32 </summary>
                public bool IsEmpty
                {
                    get
                    {
                        // BUGBUG : On Bidi OS (hebrew arabic) left > right
                        return left >= right || top >= bottom;
                    }
                }
                /// <summary> Return a user friendly representation of this struct </summary>
                public override string ToString()
                {
                    if (this == RECT.Empty) { return "RECT {Empty}"; }
                    return "RECT { left : " + left + " / top : " + top + " / right : " + right + " / bottom : " + bottom + " }";
                }
    
                /// <summary> Determine if 2 RECT are equal (deep compare) </summary>
                public override bool Equals(object obj)
                {
                    if (!(obj is Rect)) { return false; }
                    return (this == (RECT)obj);
                }
    
                /// <summary>Return the HashCode for this struct (not garanteed to be unique)</summary>
                public override int GetHashCode()
                {
                    return left.GetHashCode() + top.GetHashCode() + right.GetHashCode() + bottom.GetHashCode();
                }
    
    
                /// <summary> Determine if 2 RECT are equal (deep compare)</summary>
                public static bool operator ==(RECT rect1, RECT rect2)
                {
                    return (rect1.left == rect2.left && rect1.top == rect2.top && rect1.right == rect2.right && rect1.bottom == rect2.bottom);
                }
    
                /// <summary> Determine if 2 RECT are different(deep compare)</summary>
                public static bool operator !=(RECT rect1, RECT rect2)
                {
                    return !(rect1 == rect2);
                }
    
    
            }
    
            [DllImport("user32")]
            internal static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);
    
            /// <summary>
            /// 
            /// </summary>
            [DllImport("User32")]
            internal static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);
    
            #endregion

    最后F5,你会看到你所期望效果。

    Thank you!

  • 相关阅读:
    /etc/sysctl.conf 控制内核相关配置文件
    python 并发编程 非阻塞IO模型
    python 并发编程 多路复用IO模型
    python 并发编程 异步IO模型
    python 并发编程 阻塞IO模型
    python 并发编程 基于gevent模块 协程池 实现并发的套接字通信
    python 并发编程 基于gevent模块实现并发的套接字通信
    python 并发编程 io模型 目录
    python 并发编程 socket 服务端 客户端 阻塞io行为
    python 并发编程 IO模型介绍
  • 原文地址:https://www.cnblogs.com/lisweden/p/3166617.html
Copyright © 2011-2022 走看看