c# - tutorial - wpf visual studio

Maximice la ventana de WPF en la pantalla actual

Question

Tengo una aplicación wpf sin ventanas, cada vez que configuro el estado de la ventana como maximizado, lo maximizo en la pantalla principal.

Lo que me gustaría hacer es maximizarlo para que se muestre la aplicación que se está ejecutando.

¿Alguna idea de cómo haría esto?

Mi código en este momento es solo

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

Debido a la barra de tareas, debe usar el tamaño del área de trabajo del usuario:

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

Puedes usar esto en el constructor de la vista

Answer 2

He incluido esta línea en mi constructor MainWindow (primer control):

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

Answer 3

Hice que mi aplicación se maximizara en la pantalla secundaria al hacer esto

Agregue esto en la parte superior de la ventana principal:

using Screen = System.Windows.Forms.Screen;

Agregue esto en el controlador de maximizar:

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

Aquí vamos !

Answer 4

Hice una pregunta similar que podría ser útil. ¿Cómo puedo hacer que una ventana WPF maximizada en la pantalla con el cursor del mouse?

Answer 5

La aplicación c # comienza primero en la pantalla principal, a menos que se mueva, su código funcionará. Sin embargo, si su aplicación wpf se moverá a otra pantalla, la nueva ubicación se puede grabar y almacenar en un archivo de configuración local. Sin embargo, su aplicación no tendrá fronteras ni otros controles nativos, por lo que también deberá implementar el bit en movimiento. y cuando se mueve su ventana, podrá capturar el índice de visualización utilizando SystemParameters.

Buena suerte

Answer 6

Me encontré con el mismo problema. En mi caso, resultó ser el hecho de que estaba ocultando mi ventana emergente cuando terminé con ella. Entonces, si lo llamé la próxima vez y le pedí Maximize, lo haría en la pantalla original. Una vez que comencé Cerrando en cambio, comenzó a maximizar en la pantalla adecuada.

Answer 7

Mire esta pregunta y respuesta: ¿Cómo centrar una aplicación WPF en la pantalla?

Puede usar las funciones descritas en Windows.Forms.Screen para obtener la pantalla actual. Entonces, tal vez establezca Windows StartupLocation en esta pantalla (antes de maximizar como lo hizo) puede lograr lo que quiere, pero no me tomé el tiempo para probarlo, para ser honesto.

Answer 8

No estoy seguro si esto todavía está respondido. Creé una aplicación de muestra con el

WindowStyle = WindowStyle.None;

Creé un botón y en el controlador de clic lo hice-

WindowState = WindowState.Maximized

Conecté el controlador MouseLeftButtonDown para la ventana para arrastrar el movimiento

this.MouseLeftButtonDown += new(MainWindow_MouseLeftButtonDown);
private void MainWindow_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
DragMove();
}

Cuando arrastré mi ventana a mi segundo monitor y hice clic en el botón maximizar, se maximizó en la ventana actual, no en la ventana de inicio. Estaba usando VS2010 y .NET 4. Avíseme si esto ayuda.

Answer 9

No podemos maximizar la ventana hasta que esté cargada. Entonces conectando el evento Loaded de fullScreenWindow y manejando el evento a lo largo de las líneas de:

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

Answer 10

Una pregunta con 7 upvotes merece la respuesta correcta. :RE

Utilice esta ventana en lugar de la ventana normal y luego Maxmize / Minimize / normalize se encargará solo.

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

Importaciones y declaraciones de 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);