c# - tamaño - redimensionar form visual basic

.NET/Windows Forms: recuerda el tamaño y la ubicación de las ventanas

Question

Tengo una aplicación de Windows Forms con una ventana normal. Ahora cuando cierro la aplicación y la reinicio, quiero que la ventana principal aparezca en la misma ubicación en mi pantalla con el mismo tamaño del momento en que se cerró.

¿Hay alguna manera fácil en Windows Forms de recordar la ubicación de la pantalla y el tamaño de la ventana (y si es posible el estado de la ventana) o todo tiene que hacerse a mano?

Answer 1

Deberá guardar la ubicación y el tamaño de la ventana en la configuración de su aplicación. Aquí hay un buen article C # para mostrarte cómo.

EDITAR

Puede guardar prácticamente todo lo que desee en la configuración de la aplicación. En la columna Tipo de la cuadrícula de configuración puede navegar a cualquier tipo de .NET. WindowState se encuentra en System.Windows.Forms y figura como FormWindowState. También hay una propiedad para FormStartPosition.

Answer 2

Intenté algunos métodos diferentes; esto es lo que terminó trabajando para mí. (En este caso, en el primer lanzamiento, los valores predeterminados aún no se han conservado, por lo que el formulario utilizará los valores establecidos en el diseñador)

1. Agregue las configuraciones al proyecto (manualmente - no confíe en Visual Studio):

2. Agregue el siguiente código a su formulario:

   private void Form1_Load(object sender, EventArgs e)
   {
       this.RestoreWindowPosition();
   }
   
   private void Form1_FormClosing(object sender, FormClosingEventArgs e)
   {
       this.SaveWindowPosition();
   }
   
   private void RestoreWindowPosition()
   {
       if (Settings.Default.HasSetDefaults)
       {
           this.WindowState = Settings.Default.WindowState;
           this.Location = Settings.Default.Location;
           this.Size = Settings.Default.Size;
       }
   }
   
   private void SaveWindowPosition()
   {
       Settings.Default.WindowState = this.WindowState;
   
       if (this.WindowState == FormWindowState.Normal)
       {
           Settings.Default.Location = this.Location;
           Settings.Default.Size = this.Size;
       }
       else
       {
           Settings.Default.Location = this.RestoreBounds.Location;
           Settings.Default.Size = this.RestoreBounds.Size;
       }
   
       Settings.Default.HasSetDefaults = true;
   
       Settings.Default.Save();
   }

Answer 3

Las soluciones anteriores no funcionaron para mí. Después de jugar un rato, terminé con el siguiente código que:

• conserva el estado maximizado y normal
• reemplaza el estado minimizado con la posición predeterminada

• en caso de cambios en el tamaño de la pantalla (monitor desconectado, conexión remota, ...) no llevará al usuario a un estado frustrante con la aplicación abierta fuera de la pantalla.

  private void MyForm_Load(object sender, EventArgs e)
  {
      if (Properties.Settings.Default.IsMaximized)
          WindowState = FormWindowState.Maximized;
      else if (Screen.AllScreens.Any(screen => screen.WorkingArea.IntersectsWith(Properties.Settings.Default.WindowPosition)))
      {
          StartPosition = FormStartPosition.Manual;
          DesktopBounds = Properties.Settings.Default.WindowPosition;
          WindowState = FormWindowState.Normal;
      }
  }
  
  private void MyForm_FormClosing(object sender, FormClosingEventArgs e)
  {
      Properties.Settings.Default.IsMaximized = WindowState == FormWindowState.Maximized;
      Properties.Settings.Default.WindowPosition = DesktopBounds;
      Properties.Settings.Default.Save();
  }

ajustes de usuario:

    <userSettings>
    <WindowsFormsApplication2.Properties.Settings>
        <setting name="WindowPosition" serializeAs="String">
            <value>0, 0, -1, -1</value>
        </setting>
        <setting name="IsMaximized" serializeAs="String">
            <value>False</value>
        </setting>
    </WindowsFormsApplication2.Properties.Settings>
</userSettings>

Nota: WindowsPosition está intencionalmente equivocado, por lo que durante la primera aplicación de lanzamiento usará la ubicación predeterminada.

Answer 4

Matt: para guardar WindowState como configuración de usuario, en el cuadro de diálogo Configuración, en el menú desplegable "Tipo", desplácese hasta la parte inferior y seleccione "Buscar".

En el cuadro de diálogo "Seleccionar un tipo", expanda System.Windows.Forms y puede elegir "FormWindowState" como tipo.

(Lo siento, no veo un botón que me permita comentar el comentario ...)

Answer 5

Mi respuesta está adaptada de la respuesta de ChrisF ♦ , pero he corregido una cosa que no me gustó: si la ventana se minimiza al momento del cierre, parecería minimizada en el próximo inicio.

Mi código maneja ese caso correctamente recordando si la ventana fue maximizada o normal en el momento de su minimización, y estableciendo el estado persistente en consecuencia.

Desafortunadamente, Winforms no expone esa información directamente, por lo que tuve que anular WndProc y almacenarla yo mismo. Consulte Comprobar si la ventana minimizada actualmente estaba en estado maximizado o normal en el momento de la minimización

partial class Form1 : Form
{
    protected override void WndProc(ref Message m)
    {
        if (m.Msg == WM_SYSCOMMAND)
        {
            int wparam = m.WParam.ToInt32() & 0xfff0;

            if (wparam == SC_MAXIMIZE)
                LastWindowState = FormWindowState.Maximized;
            else if (wparam == SC_RESTORE)
                LastWindowState = FormWindowState.Normal;
        }

        base.WndProc(ref m);
    }

    private const int WM_SYSCOMMAND = 0x0112;
    private const int SC_MAXIMIZE = 0xf030;
    private const int SC_RESTORE = 0xf120;
    private FormWindowState LastWindowState;

    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        if (WindowState == FormWindowState.Normal)
        {
            Properties.Settings.Default.WindowLocation = Location;
            Properties.Settings.Default.WindowSize = Size;
        }
        else
        {
            Properties.Settings.Default.WindowLocation = RestoreBounds.Location;
            Properties.Settings.Default.WindowSize = RestoreBounds.Size;
        }

        if (WindowState == FormWindowState.Minimized)
        {
            Properties.Settings.Default.WindowState = LastWindowState;
        }
        else
        {
            Properties.Settings.Default.WindowState = WindowState;
        }

        Properties.Settings.Default.Save();
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        if (Properties.Settings.Default.WindowSize != new Size(0, 0))
        {
            Location = Properties.Settings.Default.WindowLocation;
            Size = Properties.Settings.Default.WindowSize;
            WindowState = Properties.Settings.Default.WindowState;
        }
    }

Answer 6

Si tiene más de 1 formulario, puede usar algo como esto ...

Agregue esta parte toda la forma carga vacía

var AbbA = Program.LoadFormLocationAndSize(this);
            this.Location = new Point(AbbA[0], AbbA[1]);
            this.Size = new Size(AbbA[2], AbbA[3]);
            this.FormClosing += new FormClosingEventHandler(Program.SaveFormLocationAndSize);

Guarde la ubicación y el tamaño del formulario en app.config xml

public static void SaveFormLocationAndSize(object sender, FormClosingEventArgs e)
{
    Form xForm = sender as Form;
    Configuration config = ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath);
    if (ConfigurationManager.AppSettings.AllKeys.Contains(xForm.Name))
        config.AppSettings.Settings[xForm.Name].Value = String.Format("{0};{1};{2};{3}", xForm.Location.X, xForm.Location.Y, xForm.Size.Width, xForm.Size.Height);
    else
        config.AppSettings.Settings.Add(xForm.Name, String.Format("{0};{1};{2};{3}", xForm.Location.X, xForm.Location.Y, xForm.Size.Width, xForm.Size.Height));
    config.Save(ConfigurationSaveMode.Full);
}

Cargue la ubicación y el tamaño de la forma desde app.config xml

public static int[] LoadFormLocationAndSize(Form xForm)
{
    int[] LocationAndSize = new int[] { xForm.Location.X, xForm.Location.Y, xForm.Size.Width, xForm.Size.Height };
    //---//
    try
    {
        Configuration config = ConfigurationManager.OpenExeConfiguration(Application.ExecutablePath);
        var AbbA = config.AppSettings.Settings[xForm.Name].Value.Split('';'');
        //---//
        LocationAndSize[0] = Convert.ToInt32(AbbA.GetValue(0));
        LocationAndSize[1] = Convert.ToInt32(AbbA.GetValue(1));
        LocationAndSize[2] = Convert.ToInt32(AbbA.GetValue(2));
        LocationAndSize[3] = Convert.ToInt32(AbbA.GetValue(3));
    }
    catch (Exception ex)
    {
        MessageBox.Show(ex.Message);
    }
    //---//
    return LocationAndSize;
}

Answer 7

Si utiliza la fabulosa biblioteca de código abierto - Jot , puede olvidarse de los tediosos archivos .settings y simplemente haga esto:

public MainWindow()
{
    InitializeComponent();

    _stateTracker.Configure(this)
        .IdentifyAs("MyMainWindow")
        .AddProperties(nameof(Height), nameof(Width), nameof(Left), nameof(Top), nameof(WindowState))
        .RegisterPersistTrigger(nameof(Closed))
        .Apply();
}

También hay un paquete Nuget, y puede configurar prácticamente todo sobre cómo / cuándo / dónde se almacenan los datos.

Descargo de responsabilidad: soy el autor, pero la biblioteca es completamente de código abierto (bajo la licencia de MIT).

Answer 8

Tendrá que guardar la información manualmente en alguna parte. Sugiero hacerlo como configuración de la aplicación, almacenándolas en el almacenamiento aislado específico del usuario.

Una vez que cargues, lee la configuración y luego cambia el tamaño / mueve tu formulario.

Answer 9

Si agrega este código a su controlador de evento FormClosing :

if (WindowState == FormWindowState.Maximized)
{
    Properties.Settings.Default.Location = RestoreBounds.Location;
    Properties.Settings.Default.Size = RestoreBounds.Size;
    Properties.Settings.Default.Maximised = true;
    Properties.Settings.Default.Minimised = false;
}
else if (WindowState == FormWindowState.Normal)
{
    Properties.Settings.Default.Location = Location;
    Properties.Settings.Default.Size = Size;
    Properties.Settings.Default.Maximised = false;
    Properties.Settings.Default.Minimised = false;
}
else
{
    Properties.Settings.Default.Location = RestoreBounds.Location;
    Properties.Settings.Default.Size = RestoreBounds.Size;
    Properties.Settings.Default.Maximised = false;
    Properties.Settings.Default.Minimised = true;
}
Properties.Settings.Default.Save();

Salvará el estado actual.

A continuación, agregue este código al controlador OnLoad su formulario:

if (Properties.Settings.Default.Maximised)
{
    WindowState = FormWindowState.Maximized;
    Location = Properties.Settings.Default.Location;
    Size = Properties.Settings.Default.Size;
}
else if (Properties.Settings.Default.Minimised)
{
    WindowState = FormWindowState.Minimized;
    Location = Properties.Settings.Default.Location;
    Size = Properties.Settings.Default.Size;
}
else
{
    Location = Properties.Settings.Default.Location;
    Size = Properties.Settings.Default.Size;
}

Restaurará el último estado.

Incluso recuerda en qué monitor de la aplicación se maximizó la monitorización en un monitor múltiple.