it-swarm.com.de

WPF-Fenster auf dem aktuellen Bildschirm maximieren

Ich habe eine fensterlose Wpf-Anwendung. Immer wenn ich den Fensterstatus auf "maximiert" gesetzt habe, wird er auf der primären Anzeige maximiert.

Was ich gerne machen möchte, ist, dass es maximiert wird, auf welcher Anzeige die Anwendung läuft.

Also eine Idee wie ich das machen würde?

Mein Code ist im Moment gerade

private void titleBarThumb_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            if (this.WindowState == System.Windows.WindowState.Normal)
            {
                this.WindowState = System.Windows.WindowState.Maximized;
            }
            else
            {
                this.WindowState = System.Windows.WindowState.Normal;
            }
        }
41
electricsheep

Ich habe diese Zeile in meinen MainWindow-Konstruktor (erstes Steuerelement) eingefügt:

Application.Current.MainWindow.WindowState = WindowState.Maximized;
37
Web Developer

Aufgrund der Taskleiste sollten Sie die Größe des Arbeitsbereichs des Benutzers verwenden:

this.Width=SystemParameters.WorkArea.Width;
this.Height=SystemParameters.WorkArea.Height;

Sie können dies im Konstruktor der Ansicht verwenden

11
Navid Rahmani

Eine Frage mit 7 Punkten verdient die richtige Antwort. : D

Verwenden Sie dieses Fenster anstelle des normalen Fensters und dann kümmert sich Maxmize/Minimize/Normalize um sich.

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

public partial class MyWindow : Window
{
    public MyWindow ()
    {
        this.InitializeComponent();

        this.SourceInitialized += this.OnSourceInitialized;
    }

    #endregion

    #region Methods

    private static IntPtr WindowProc(IntPtr hwnd, int msg, IntPtr wParam, IntPtr lParam, ref bool handled)
    {
        switch (msg)
        {
            case 0x0024:
                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
        IntPtr monitor = MonitorFromWindow(hwnd, (int)MonitorFromWindowFlags.MONITOR_DEFAULTTONEAREST);

        if (monitor != IntPtr.Zero)
        {
            var 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 void OnSourceInitialized(object sender, EventArgs e)
    {
        var window = sender as Window;

        if (window != null)
        {
            IntPtr handle = (new WindowInteropHelper(window)).Handle;
            HwndSource.FromHwnd(handle).AddHook(WindowProc);
        }
    }
}

DLL-Importe und Deklarationen

[StructLayout(LayoutKind.Sequential)]
public struct MINMAXINFO
{
    public POINT ptReserved;

    public POINT ptMaxSize;

    public POINT ptMaxPosition;

    public POINT ptMinTrackSize;

    public POINT ptMaxTrackSize;
} ;

public enum MonitorFromWindowFlags
{
    MONITOR_DEFAULTTONEAREST = 0x00000002
}

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

    public RECT rcMonitor;

    public RECT rcWork;

    public int dwFlags;
}

[StructLayout(LayoutKind.Sequential, Pack = 0)]
public struct RECT
{
    public int Left;

    public int Top;

    public int Right;

    public int Bottom;

    public static readonly RECT Empty;

    public int Width
    {
        get
        {
            return Math.Abs(this.Right - this.Left);
        } // Abs needed for BIDI OS
    }

    public int Height
    {
        get
        {
            return this.Bottom - this.Top;
        }
    }

    public RECT(int left, int top, int right, int bottom)
    {
        this.Left = left;
        this.Top = top;
        this.Right = right;
        this.Bottom = bottom;
    }

    public RECT(RECT rcSrc)
    {
        this.Left = rcSrc.Left;
        this.Top = rcSrc.Top;
        this.Right = rcSrc.Right;
        this.Bottom = rcSrc.Bottom;
    }

    public bool IsEmpty
    {
        get
        {
            // BUGBUG : On Bidi OS (hebrew arabic) left > right
            return this.Left >= this.Right || this.Top >= this.Bottom;
        }
    }

    public override string ToString()
    {
        if (this == Empty)
        {
            return "RECT {Empty}";
        }
        return "RECT { left : " + this.Left + " / top : " + this.Top + " / right : " + this.Right + " / bottom : " +
               this.Bottom + " }";
    }

    public override bool Equals(object obj)
    {
        if (!(obj is RECT))
        {
            return false;
        }
        return (this == (RECT)obj);
    }

    public override int GetHashCode()
    {
        return this.Left.GetHashCode() + this.Top.GetHashCode() + this.Right.GetHashCode() +
               this.Bottom.GetHashCode();
    }

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

    public static bool operator !=(RECT rect1, RECT rect2)
    {
        return !(rect1 == rect2);
    }
}
[DllImport("user32.dll", SetLastError = true)]
public static extern bool GetMonitorInfo(IntPtr hMonitor, MONITORINFO lpmi);

[DllImport("user32.dll", SetLastError = true)]
public static extern IntPtr MonitorFromWindow(IntPtr handle, int flags);
4
NVM

Ich bin mir nicht sicher, ob das noch beantwortet wird - ich habe eine Beispiel-App mit der erstellt 

WindowStyle = WindowStyle.None;

Ich habe einen Button erstellt und auf dem Click-Handler

WindowState = WindowState.Maximized

Ich habe den MouseLeftButtonDown-Handler für das Fenster zum Ziehen von

this.MouseLeftButtonDown += new(MainWindow_MouseLeftButtonDown);

private void MainWindow_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
   DragMove();
}

Wenn ich mein Fenster auf meinen zweiten Monitor gezogen habe und auf die Schaltfläche zum Maximieren geklickt habe, wurde es im aktuellen Fenster und nicht im Startfenster maximiert. Ich habe VS2010 und .NET 4 verwendet. Lassen Sie mich wissen, ob dies hilft. 

4
thebringking

Sehen Sie sich diese Frage an und antworten Sie: Wie zentriert man eine WPF-App auf dem Bildschirm?

Sie können die beschriebenen Funktionen in Windows.Forms.Screen verwenden, um den aktuellen Bildschirm abzurufen. Wenn Sie dann den StartupLocation des Fensters auf diesen Bildschirm setzen (bevor Sie ihn maximieren, wie Sie es bereits getan haben), kann dies möglicherweise das erreichen, was Sie möchten, aber ich habe es nicht getan Nehmen Sie sich die Zeit, um es selbst auszuprobieren, um ehrlich zu sein.

2
Simon D.

Ich habe eine ähnliche Frage gestellt, die Sie möglicherweise hilfreich finden. Wie kann ich ein WPF-Fenster mit dem Mauszeiger auf dem Bildschirm maximieren lassen?

2
Eben Geer

Wir können das Fenster erst maximieren, wenn es geladen ist. Hängen Sie also das Loaded-Ereignis von fullScreenWindow ein und bearbeiten Sie das Ereignis wie folgt:

private void Window_Loaded(object sender, RoutedEventArgs e) 
{
    WindowState = WindowState.Maximized;
}
1
Sibin

Meine Anwendung wurde dadurch auf dem sekundären Bildschirm maximiert

Fügen Sie dies am oberen Rand des Hauptfensters hinzu:

using Screen = System.Windows.Forms.Screen;

Fügen Sie dies im Maximize-Handler hinzu:

private void AdjustWindowSize()
    {
        if (this.WindowState == WindowState.Maximized)
        {
            this.WindowState = WindowState.Normal;
        }
        else
        {
            System.Drawing.Rectangle r = Screen.GetWorkingArea(new System.Drawing.Point((int)this.Left, (int)this.Top));
            this.MaxWidth = r.Width;
            this.MaxHeight = r.Height;
            this.WindowState = WindowState.Maximized;
        }
    }

Auf geht's !

0
Christophe

c # application startet zuerst auf der primären Anzeige, es sei denn, es wird verschoben, und Ihr Code funktioniert. Wenn Ihre Wpf-App jedoch in eine andere Anzeige verschoben wird, kann ein neuer Speicherort aufgezeichnet und in einer lokalen Konfigurationsdatei gespeichert werden. Ihre App verfügt jedoch über keine Rahmen oder andere native Steuerelemente, sodass Sie auch das Verschiebungsbit implementieren müssen. Wenn Ihr Fenster verschoben wird, können Sie den Anzeigeindex mithilfe von SystemParameters erfassen.

Viel Glück

0
zukas

Ich bin gerade auf das gleiche Problem gestoßen. In meinem Fall stellte sich heraus, dass ich mein Popup-Fenster versteckt hatte, als ich damit fertig war. Wenn ich es also das nächste Mal anrief und nach Maximize fragte, würde dies auf dem ursprünglichen Bildschirm geschehen. Sobald ich es geschlossen hatte, begann es auf dem richtigen Bildschirm zu maximieren.

0
Eternal21