una - evitar que las ventanas se maximicen c#

Deshabilite el botón Maximizar de la ventana WPF, manteniendo intacta la función de cambio de tamaño

Question

Así que las ventanas de WPF solo tienen cuatro opciones de modo de cambio de tamaño: NoResize , CanMinimize , CanResize y CanResizeWithGrip . Desafortunadamente, las opciones que permiten el cambio de tamaño también permiten maximizar la ventana, y las que no son inútiles para mí.

¿Existe una opción para desactivar el botón Maximizar mientras se mantiene la función de cambio de tamaño?

Preferiría soluciones que no impliquen cosas WinAPI .

Answer 1

Otra opción es capturar el evento StateChanged que se StateChanged cuando la ventana está maximizada. Luego, simplemente configure WindowState en "Normal".

¡Sin embargo, esto no oculta la caja de maximizar!

private void Window_StateChanged(object sender, EventArgs e)
{
    if (WindowState == WindowState.Maximized)
    {
        WindowState = WindowState.Normal;
    }
}

Answer 2

Puede crear una ventana personalizada configurando WindowStyle en Ninguno, que elimina los botones Minimizar, Maximizar y Cerrar, y cree usted mismo los botones que necesita. Ese es un gran ejemplo para esto:

http://www.codeproject.com/Articles/131515/WPF-Custom-Chrome-Library

Te da un trabajo extra, pero si realmente no quieres usar WinAPI, esa es una opción.

Answer 3

Si configura

WindowStyle="ToolWindow"

En las propiedades de su ventana, le dará una ventana redimensionable sin botones minimizar o maximizar en la parte superior. Será cuadrado y el botón de cerrar también es cuadrado, pero al menos minimizar y maximizar no están allí.

Answer 4

WPF no tiene la capacidad nativa para desactivar el botón Maximizar solo, como puede hacer con WinForms. Tendrá que recurrir a una llamada WinAPI. No da miedo:

[DllImport("user32.dll")]
private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
[DllImport("user32.dll")]
private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

private const int GWL_STYLE = -16;
private const int WS_MAXIMIZEBOX = 0x10000;

private void Window_SourceInitialized(object sender, EventArgs e)
{
    var hwnd = new WindowInteropHelper((Window)sender).Handle;
    var value = GetWindowLong(hwnd, GWL_STYLE);
    SetWindowLong(hwnd, GWL_STYLE, (int)(value & ~WS_MAXIMIZEBOX));
}

Answer 5

Método P / invocar

La forma más fácil de llamar al código no administrado (C ++ en este caso) desde el código administrado (.NET) es usar los Servicios de invocación de plataforma, también conocidos como P / Invoke. Simplemente le proporciona al compilador una declaración de la función no administrada y la llama como si llamara a cualquier otro método administrado. Existe un método SetWindowLong no administrado que se puede usar para cambiar un atributo de una ventana especificada. Para poder llamar a este método desde su clase de ventana de WPF usando P / Invoke, simplemente agrega la siguiente declaración a la clase de ventana:

[DllImport("user32.dll")]
private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int dwNewLong);

El atributo DllImport especifica el nombre de la DLL que contiene el método y la palabra clave extern le dice al compilador de C # que el método se implementó externamente y que no encontrará ninguna implementación o cuerpo de método para ello al compilar la aplicación. El primer argumento que se pasará al método SetWindowLong es un identificador para la ventana para la cual desea desactivar cualquiera de los botones mencionados. Puede obtener el control para una ventana WPF creando una instancia de la clase ManageInteropHelper administrada y acceder a su propiedad Handle en un controlador de eventos para el evento SourceInitialized de la ventana. Este evento se produce cuando el identificador ha sido creado por completo. El segundo argumento del método SetWindowLong especifica el atributo o el valor de la ventana que se establecerá, expresada como un valor entero constante. Cuando desee cambiar el estilo de la ventana, debe pasar la constante GWL_STYLE (= -16) como segundo argumento del método.

private const int GWL_STYLE = -16;

Finalmente, el tercer argumento especifica el valor de reemplazo. Hay un conjunto de constantes que puedes usar aquí:

private const int WS_MAXIMIZEBOX = 0x10000; //maximize button
private const int WS_MINIMIZEBOX = 0x20000; //minimize button

Sin embargo, tenga en cuenta que dado que se supone que debe pasar un DWORD que especifica el valor completo para la "propiedad" especificada por el segundo argumento, es decir, el estilo de ventana en este caso, no puede simplemente pasar cualquiera de estas constantes como el tercer argumento al método. Hay otro método GetWindowLong que recupera el valor actual de una propiedad específica, de nuevo GWL_STYLE en este caso, y luego puede usar operadores bit a bit para obtener el valor correcto del tercer parámetro para pasar al método SetWindowLong. A continuación se muestra un ejemplo de código completo de cómo, por ejemplo, podría deshabilitar el botón de minimizar una ventana en WPF:

public partial class MainWindow : Window
{
 [DllImport("user32.dll")]
 private static extern int GetWindowLong(IntPtr hWnd, int nIndex);
 [DllImport("user32.dll")]
 private static extern int SetWindowLong(IntPtr hWnd, int nIndex, int  dwNewLong);

 private const int GWL_STYLE = -16;

 private const int WS_MAXIMIZEBOX = 0x10000; //maximize button
 private const int WS_MINIMIZEBOX = 0x20000; //minimize button

 public MainWindow() {
  InitializeComponent();
  this.SourceInitialized += MainWindow_SourceInitialized;
}

private IntPtr _windowHandle;
private void MainWindow_SourceInitialized(object sender, EventArgs e) {
_windowHandle = new WindowInteropHelper(this).Handle;

 //disable minimize button
 DisableMinimizeButton();
}

protected void DisableMinimizeButton() {
  if (_windowHandle == IntPtr.Zero)
    throw new InvalidOperationException("The window has not yet been completely initialized");

   SetWindowLong(_windowHandle, GWL_STYLE, GetWindowLong(_windowHandle,  GWL_STYLE) & ~WS_MAXIMIZEBOX);
 }
}

Desactivar el botón de minimizar es simplemente una cuestión de reemplazar la constante WS_MAXIMIZEBOX con WS_MINIMIZEBOX

Answer 6

Solo para discapacitados Maximizar:

ResizeMode="CanMinimize"