WPF : Maximize window with WindowState Problem (application will hide windows taskbar)

I have set my main window state to "Maximized" but the problem is my application will fill the whole screen even task bar. what am i doing wrong ? I'm using windows 2008 R2 with resolution : 1600 * 900

Here is the Xaml :

<Window x:Class="RadinFarazJamAutomationSystem.wndMain"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:sys="clr-namespace:System;assembly=mscorlib"
    xmlns:local="clr-namespace:RadinFarazJamAutomationSystem"
     xmlns:mwt="clr-namespace:Microsoft.Windows.Themes;assembly=PresentationFramework.Aero"
    Title="MyName"  FontFamily="Tahoma" FontSize="12" Name="mainWindow"  WindowState="Maximized"   xmlns:telerik="http://schemas.telerik.com/2008/xaml/presentation"
    xmlns:my="clr-namespace:RadinFarazJamAutomationSystem.Calendare.UC" mc:Ignorable="d" xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"  Loaded="mainWindow_Loaded" FlowDirection="LeftToRight"
    ResizeMode="NoResize" Closed="mainWindow_Closed">

You can set the MaxHeight property of that window to SystemParameters.MaximizedPrimaryScreenHeight using the constructor.

public MainWindow()
{
    InitializeComponent();
    this.MaxHeight = SystemParameters.MaximizedPrimaryScreenHeight;
}

Taskbar with Window Maximized and WindowState to None in WPF , Solution to an issue when Taskbar needs to be shown even though the Say you want your WPF application to have no Title bar, and will be As I say, it hides the whole screen, it means it even will not show up the Taskbar or any state which shows up the Taskbar as it does with normal windows? Set WindowState to None: By this, the window will be maximized to the whole screen and will show only the window and nothing else. As I say, it hides the whole screen, it means it even will not show up the Taskbar or any external gadgets applied to your desktop if it is not set to Always on Top attribute.


To continue with my previous remark. I use the following code in my applications (source: Maximizing WPF windows

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

    public MainWindow()
    {
        InitializeComponent();
        winMain.SourceInitialized += new EventHandler(win_SourceInitialized);
    }


    #region Avoid hiding task bar upon maximalisation

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

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

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

    void win_Loaded(object sender, RoutedEventArgs e)
    {
        winMain.WindowState = WindowState.Maximized;
    }

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

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

    [DllImport("user32.dll")]
    static extern bool GetCursorPos(ref Point lpPoint);

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

    #endregion

Fullscreen with no Windows Taskbar � Issue #1495 � MahApps , When opening up a Standard WPF window with properties set as WindowState ="Maximized" ShowInTaskbar="False" the Window you can also hide the title bar) but the Windows Taskbar is still visible at the If you want the window to completely maximize, use the IgnoreTaskBarOnMaximize property� WPF : Maximize window with WindowState Problem (application will hide windows taskbar) a guest Apr 7th, 2012 98 Never Not a member of Pastebin yet?


I simplified Geoffrey's answer a bit so you don't have to p/invoke anything.

    public MainWindow()
    {
        InitializeComponent();
        winMain.SourceInitialized += new EventHandler(win_SourceInitialized);
    }

    void win_SourceInitialized( object sender, System.EventArgs e )
    {
        var handle = (new WindowInteropHelper( _attachedElement )).Handle;
        var handleSource = HwndSource.FromHwnd( handle );
        if ( handleSource == null )
            return;
        handleSource.AddHook( WindowProc );
    }

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

        return (IntPtr)0;
    }

    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 currentScreen = System.Windows.Forms.Screen.FromHandle( hwnd );
        var workArea = currentScreen.WorkingArea;
        var monitorArea = currentScreen.Bounds;
        mmi.ptMaxPosition.x = Math.Abs( workArea.Left - monitorArea.Left );
        mmi.ptMaxPosition.y = Math.Abs( workArea.Top - monitorArea.Top );
        mmi.ptMaxSize.x = Math.Abs( workArea.Right - workArea.Left );
        mmi.ptMaxSize.y = Math.Abs( workArea.Bottom - workArea.Top );

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


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

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

WindowState, Maximize but not full screen - MSDN, Windows Presentation Foundation (WPF) As a bonus you get to see the actual pixels your window will be The following XAML creates a full sized window with no border and without going to the taskbar space Maximized application but when I set the WindowState to maximize I get a full screen one. c# - maximized - wpf maximize window hides taskbar Make my wpf application Full Screen(Cover taskbar and title bar of window) (6) I would like to make my application such that it can maximize to full screen means it hide the windows task bar and the title bar as well.


I wanted the opposite (with WindowStyle=None), but reversing this solution also works for your case:

// prevent it from overlapping the taskbar

// "minimize" it
WindowStyle = WindowStyle.SingleBorderWindow;
// Maximize it again. This time it will respect the taskbar.
WindowStyle = WindowStyle.None;
WindowState = WindowState.Maximized;
// app is now borderless fullscreen, showing the taskbar again

What I did for my case:

// make it always overlap the taskbar

// From windowed to maximized without border and window bar
WindowStyle = WindowStyle.None;
WindowState = WindowState.Maximized;
// Now the window does not overlap the taskbar
Hide();
Show();
// Now it does (because it's re-opened)

Setting "WindowStyle=None" hides taskbar on maximizing, Awesome way to support plugins/AddIns in your applications If you ever tried to make irregular windows in wpf and used setting WindowState = WindowState. But on maximizing ,the window hides the taskbar.i.e it goes fullscreen. To avoid that issue,You can use this code and yes,it works like a� WPF seems to be making the decision about whether to go full-screen or respect the taskbar based on the WindowStyle at the time of maximisation. So a kludgy but effective solution is to switch the window back to non-maximised, set the WindowStyle, and then set the window back to maximised again:


This one works the best...

public MainWindow()
    {
        InitializeComponent();
        MaxHeight = SystemParameters.VirtualScreenHeight;
        MaxWidth = SystemParameters.VirtualScreenWidth;
    }

how to maximize and minimize a borderless form in WPF, In this video I am showing you how to make a borderless WPF form maximize and minimize Duration: 14:25 Posted: Aug 7, 2018 But as soon as my application opened a dialog window, the taskbar appeared topmost on Windows 10 - and it didn't went away, except when switching to a different window and back to my application. ResizeMode=NoResize solved this!


How To Minimize Your Application To System Tray In C#, Minimizing the application to the system tray (officially known as the Notification is a standard behavior of the vast majority of Windows applications. Minimizing such app to the Taskbar will populate it for no reason and create a is minimized; //hide it from the task bar; //and show the system tray icon� This is also happening with Microsoft Window, if it is Maximized by code and SizeToContent is set. 2. Bad Placement of Close button --This is an issue in the Example as the template is not refreshed properly, however if set this properties in an application before showing the RadWindow, it will work as expected.


Grasshopper Window Minimize/Maximize Behavior -- request , This is a major UX issue for my application users because they are confronted Finally, one step better for me would be able to hide Grasshopper entirely (so that it The reason is that I use my own WPF menus that can minimize to small So whenever rhino would restore the gh windows, shortly after the script will set it� taskbar not showing when window maximized The problem happened just like that (i didn't change anything). When i maximize any window (e.g. windows explorer, or notepad or anything else) my taskbar (where the start button and clock are) stays in the background and window is on the whole screen, like full screen program is running.


Display an WPF application over the Windows taskbar : csharp, I want to make an app, which will be displayed over the taskbar. Can I even do it and if yes - how? Display an WPF application over the Windows taskbar fullscreen transparent always on top window with no focus and the only visible and hittest relevant elements In MainWindow.xaml, set WindowState=" Maximized". Set WindowState to None: By this the window will be maximized to the whole screen and will show only the window and nothing else.. Oh.. Hold on ..Hold on As I say, it hides the whole screen, it means it even will not show up the Taskbar or any external gadgets applied to your desktop if it is not set to Always on Top attribute to it.