ventanas - WPF: Maximizar la ventana con el problema de WindowState(la aplicación ocultará la barra de tareas de Windows)




navegacion entre ventanas wpf (3)

Para continuar con mi comentario anterior. Uso el siguiente código en mis aplicaciones (fuente: Maximización de ventanas de WPF

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

He establecido el estado de mi ventana principal en "Maximizado", pero el problema es que mi aplicación llenará toda la barra de tareas de la pantalla. Qué estoy haciendo mal ? Estoy usando Windows 2008 R2 con resolución: 1600 * 900

Aquí está el 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">

Puede establecer la propiedad MaxHeight de esa ventana en SystemParameters.MaximizedPrimaryScreenHeight usando el constructor.

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

Simplifiqué un poco la respuesta de Geoffrey para que no tenga que invocar nada.

    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