Развернуть окно WPF на текущем экране

Question

У меня есть приложение wpf без окон, всякий раз, когда я устанавливаю состояние окна как максимизированное, оно максимизирует его на основном дисплее.

То, что я хотел бы сделать, - это максимизировать, на котором когда-либо отображалось приложение.

Так есть идеи, как бы я это сделал?

Мой код на данный момент просто

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

Answer 1

Я включил эту строку в свой конструктор MainWindow (первый элемент управления):

Application.Current.MainWindow.WindowState = WindowState.Maximized;

Answer 2

Из-за панели задач вы должны использовать размер рабочей области пользователя:

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

Вы можете использовать это в конструкторе представления

Answer 3

Я не уверен, что на этот вопрос еще есть ответ - я создал образец приложения с

WindowStyle = WindowStyle.None;

. Я создал кнопку, и обработчик щелчков сделал это -

WindowState = WindowState.Maximized

Я подключил обработчик MouseLeftButtonDown для окна, чтобы перетаскивать move-

this.MouseLeftButtonDown += new(MainWindow_MouseLeftButtonDown);

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

Когда я перетаскивал окно на второй монитор и нажимал кнопку «Развернуть», оно развернулось в текущем окне, а не в окне запуска.Я использовал VS2010 и .NET 4. Дайте мне знать, если это поможет.

Answer 4

Вопрос с 7 ответами заслуживает правильного ответа. : D

Используйте это окно вместо обычного, а затем Maxmize / Minimize / normalize позаботится о себе.

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

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

Answer 5

Я задал похожий вопрос, который может оказаться полезным. Как развернуть окно WPF на экране с помощью курсора мыши?

Answer 6

Посмотрите на этот вопрос и ответ: Как центрировать приложение WPF на экране?

Вы можете использовать описанные функции в Windows.Forms.Screen, чтобы получить текущий экран.Тогда, возможно, установив Windows StartupLocation на этот экран (до того, как вы максимизируете, как вы уже сделали), можно добиться того, чего вы хотите, но я, честно говоря, не потратил время, чтобы попробовать это сам.

Answer 7

Мы не можем развернуть окно до тех пор, пока оно не загрузится. Таким образом, перехватывая событие Loaded в fullScreenWindow и обрабатывая его в соответствии с:

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

Answer 8

У меня было максимальное развертывание приложения на дополнительном экране при выполнении этого

Добавьте это вверху главного окна:

using Screen = System.Windows.Forms.Screen;

Добавьте это в обработчик максимизации:

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

Вот и мы!

Answer 9

Я просто столкнулся с той же проблемой. В моем случае оказалось, что я скрывал всплывающее окно, когда закончил с ним. Поэтому, если бы я позвонил в следующий раз и попросил Максимизировать, он сделал бы это на исходном экране. Как только я начал закрывать его, он начал максимизироваться на соответствующем экране.

Answer 10

Приложение

c # сначала запускается на основном дисплее, если ваш код не будет перемещен.Однако, если ваше приложение wpf будет перемещено на другой дисплей, новое местоположение может быть записано и сохранено в локальном конфигурационном файле.Но ваше приложение не будет иметь границ или каких-либо других встроенных элементов управления, поэтому вам также придется реализовать движущуюся часть.и когда ваше окно будет перемещено, вы сможете захватить индекс отображения с помощью SystemParameters.

Удачи