Archivo de la etiqueta: Windows

Cambiar el tamaño de la ventana de Windows (WinUI) en app de .NET MAUI

Pues eso… ahora le toca lo de cambiar el tamaño de una ventana de Windows (WinUI que es como se llama la plataforma de Windows en .NET MAUI (en Xamarin es UWP), aquí solo te voy a mostrar el código de un tamaño fijo, ya que no me he puesto a experimentar cómo usar el tamaño predeterminado, ya que la forma de hacerlo es con otras APIs y… pues eso… que no me gusta demasiado el .NET MAUI como para dedicarle más tiempo de lo justo y necesario… 😉

Lo que si te quiero decir, es que precisamente me puse a mirar todo esto de cambiar el tamaño porque a diferencia de las aplicaciones con Xamarin.Forms, als de .NET MAUI «no recuerdan» el tamaño de la ventana en las siguientes veces que se use la aplicación, algo que en las de Xamarin sí hace, es decir, se muestra con el tamaño predeterminado y si cambias el tamaño de la ventana, la próxima vez que se utilice usará ese último tamaño.

Pero en las aplicaciones de .NET MAUI, siempre usa el tamaño «grande» y… pues como que no, por eso me puse a investigar, primero para hacerlo en .NET MAUI, y ya puestos me puse a mirar para Xamarin.

¿Cómo cambiar el tamaño de la ventana de Windows (WinUI) en un proyecto de .NET MAUI?

Es muy simple, el código se pone en el constructor de la clase App principal (no la del proyecto de Windows) y el código podría ser como este que te muestro para poner la ventana en un tamaño de 800 x 900 (ancho x alto).

namespace CambiarTamañoWindows_MAUI;

public partial class App : Application
{
    public App()
    {
         InitializeComponent();


        // Indicar el tamaño para la app de Windows.
        Microsoft.Maui.Handlers.WindowHandler.Mapper.AppendToMapping(nameof(IWindow), (handler, view) =>
        {
#if WINDOWS
            // Asignar manualmente el tamaño. 
            int winWidth = 800;
            int winHeight = 900;

                        var mauiWindow = handler.VirtualView;
                        var nativeWindow = handler.PlatformView;
                        nativeWindow.Activate();
                        IntPtr windowHandle = WinRT.Interop.WindowNative.GetWindowHandle(nativeWindow);
                        var windowId = Microsoft.UI.Win32Interop.GetWindowIdFromWindow(windowHandle);
                        var appWindow = Microsoft.UI.Windowing.AppWindow.GetFromWindowId(windowId);
                        appWindow.Resize(new Windows.Graphics.SizeInt32(winWidth, winHeight));
#endif
        });

        MainPage = new AppShell();
    }
}

Y esto es todo lo que hay que hacer… simple, ¿verdad? pues sí, para qué engañarnos, aunque eso de tener que ponerlo en un condicional de compilación es un rollo, pero tiene sentido ya que solo es para un proyecto de Windows. El problema es que no te muestra nada el «intellisense» ni nada de esas monerías que tenía en el proyecto para Xamarin.

Una captura con el programa en funcionamiento.

Figura 1. La aplicación en funcionamiento.

Y esto es todo… ahora subiré el código (o parte de él) a GitHub y después te pondré el enlace.

Acuérdate de (si quieres) hacer un donativo en PayPal para poder seguir teniendo este sitio en funcionamiento, gracias.

Nos vemos.
Guillermo

P.S.
El código de ejemplo en GitHub: Cambiar Tamaño de la ventana de Windows (WinUI) con .NET MAUI.

Crear acceso directo a una máquina virtual (para no tener que abrirla desde el Hyper-V Manager)

Pues eso… que estoy usando algunas máquinas virtuales de Hyper-V para los canales de Windows Insider, una de ellas con la del canal Dev (más inestable) y otra con el canal Beta (algo más estable) y cada vez que enciendo el equipo (o lo reinicio tras una actualización) tengo que abrir el Hyper-V Manager para poder acceder a esas máquinas virtuales.

Pensando (algunas veces me da por pensar estas cosas) que lo más simple sería poder tener un acceso directo y abrir las máquinas sin tener que usar el administrador de Hyper-V, así que… buscando en la red me encontré que es fácil hacerlo… pero como suelo darle nombres (con espacios) a esas máquinas virtuales, en esos ejemplos no aclaraban cómo hacerlo, así que… me he decido a publicar esto para que quede constancia de cómo hacerlo (ya sabes, después de un tiempo puede que se me olvide y así podré encontrarlo al hacer una búsqueda en la red de redes 😉 )

Y de paso, te lo explico por si quieres hacerlo.

Primero lo primero

Lo primero a tener en cuenta es cómo crear ese acceso directo.

Para crear un acceso directo lo puedes hacer de dos formas.

La primera: Te posicionas en el directorio donde quieres crear ese acceso directo, por ejemplo, en el escritorio (que es la opción más rápida si quieres evitar tener que abrir esa carpeta con el acceso directo), pulsas en el botón secundario y de las opciones mostradas (ver captura 1 que es de Windows 11, pero en las versiones anteriores de Windows será algo parecido, pero con otro look) es elegir Nuevo > Acceso directo (New > Shortcut).

Captura 1. Crear un acceso directo en Windows 11.

A continuación, escribe el path del administrador de Hyper-V, que es el siguiente:
C:\Windows\System32\vmconnect.exe (ver captura 2).

Captura 2. Indicar el path de vmconnect.exe

Tip:
No lo busques en la carpeta de Archivo de Programas > Hyper-V, que ahí no está, ya que suele estar en C:\Windows\System32.

Pulsa en Siguiente (Next) y si quieres le cambias el nombre del nuevo acceso directo y finalmente pulsas en Finalizar (Fisnish) (ver captura 3).

Captura 3. Indicar el nombre del acceso directo

La segunda: Abre la ubicación de vmconnect.exe (que tal como te he indicado antes está en C:\Windows \System32, si en lugar de C usas otro nombre de unidad como arranque, indica ese nombre de unidad).

Busca el fichero vmconnect.exe y pulsa sobre la aplicación con en el botón secundario (el derecho para diestros, el izquierdo para zurdos) y selecciona crear acceso directo (como no podrás crearlo en la ubicación del programa, te preguntará si quieres crearlo en el escritorio).

El acceso directo estará en el escritorio.

Una vez creado el acceso directo a vmconnect.exe

Selecciona el acceso directo y pulsa con el botón secundario para elegir propiedades.

Después de la ubicación de vmconnect.exe indica el nombre del servidor de Hyper-V seguido del nombre de la máquina virtual.

En mi caso, sería GUILLE-JUL1421 «Windows 11Pro Dev» (ver captura 4).

Fíjate en las comillas dobles para el nombre de la máquina virtual, esto es así porque contiene espacios. Si el nombre de la máquina virtual no tiene espacios no es necesario ponerlo dentro de comillas dobles.

Captura 4. Usar comillas dobles si alguno de los parámetros tienen espacios

 

Dale permisos de administrador al acceso directo

Es necesario que le des acceso de administrador al acceso directo.

Para ello, en las propiedades del acceso directo, pulsa en el botón Avanzado (Advanced) y marca la casilla de Ejecutar como administrador (Run as administrator) (ver la captura 5), y acepta hasta cerrar la ventana de propiedades.

Captura 5. Indicar que el acceso directo se ejecute como administrador

Para saber con seguridad cómo se llama el servidor de Hyper-V y la máquina virtual, puedes verlo abriendo el administrador de Hyper-V (Hyper-V Manager) y así estar seguro (ver captura 6).

Captura 5. El administrador de Hyper-V

 

Nota:
En algunas ocasiones, al abrir los 2 accesos directos que suelo utilizar, en Windows 11, me los muestra en la barra de tareas como 2 iconos (ver captura 7) y otras veces como un solo icono, mostrando las dos opciones al pasar el ratón sobre él (ver captura 8).
En las versiones anteriores de Windows te los mostrará según tengas configurada la barra de tareas para mostrar los iconos relacionados con una misma aplicación.

Si abres las 2 máquinas virtuales desde el administrador de Hyper-V siempre te los mostrará como un solo icono.

Captura 7. En Windows 11 algunas veces (usando los accesos directos) los muestra como 2 iconos separados

 

Captura 8. La forma habitual de mostrar los iconos de un mismo tipo de aplicación en Windows 11

 

Y esto es todo… espero que te sea de utilidad… y si así ha sido (o no), no te olvides de invitarme a un «refresco virtual» 😉
(pulsando en el botón donar de PayPal).
Gracias.

Nos vemos.
Guillermo

Windows 11 maneja mejor la memoria en las app para Windows UWP de Xamarin.Forms

Pues eso… en la app para mobile en la que estoy inmerso desde hace meses, desarrollada con Visual Studio 2019 y Xamarin.Forms para Android, iOS y Windows UWP; uno de los problemillas que me he encontrado con la versión para Windows UWP (Universal Windows Platform) es que cuando le da el punto empieza a consumir memoria como ella sola… llegando hasta casi un GIGA y ni que la minimices ni nada, no para de subir, y normalmente también se ralentiza.

Sin embargo, en las pruebas que he hecho en el Windows 11, en una máquina virtual, ya que los de Windows Insiders dicen que mis equipos (un portátil con 3 años y una torre de hace un mes) no cumplen las características requeridas, y eso que la máquina virtual usa los recursos (procesador, memoria) desde el «computador» donde se está ejecutando esa máquina virtual. Pero ese es otro tema. Lo que te decía, en las pruebas hechas en el Windows 11 el consumo es muchísimo menor, además de que al minimizar la aplicación libera esa memoria, según indica el administrador de tareas (Task Manager) del propio Windows.
En las figuras 1 y 2 puedes ver las capturas de esos dos casos.

 

Figura 1. La app abierta en Windows 11 (159,8 MB)

 

Figura 2. La app minimizada baja a 7,0 MB el consumo de la memoria y con el simbolico ese verde 😉

La versión de Windows 11 que tengo instalada es Windows 11 Pro versión 21H2 build 22000.168 co_release. Esta creo que se instaló usando el «canal» Dev Channel (que instala lo último que tengan), aunque momentáneamente lo cambié al Beta Channel por aquello de que mandaron un email recomendando que se utilizara ese canal y en la ventana de Windows Insider Program la marcan como recomendada.

Aparte de esto, el Windows 11 me está gustando… antes me parecía que los cambios eran prácticamente estéticos (el look), pero ahora veo que hay algo más 😉

Y ya no te entretengo más… que hoy es sábado, sabadate… camisa nueva y p*****e (o eso dicen).

 

Nos vemos.
Guillermo

P.S.
He actualizado las fotos, para que se vena mejor y ocupen menos espacio, que no es plan de utilizar más datos de la cuenta 😉

Cambiar el tamaño de los controles de un formulario automáticamente

Pues eso… que lo que publiqué anteayer sobre ajustar automáticamente la fuente de un formulario según la configuración del sistema (Cambiar automáticamente las fuentes de nuestro formulario a las de Windows), estaba muy bien, pero no era lo que yo andaba buscando… yo lo que quería era que los controles también cambiaran.

La batallita del Guille

Y me puse a ello… como soy un poquillo torpe, ya sabes, no tengo estudios informáticos ni de otros tipos, pues… empecé a escribir el código para cambiar cada uno de los controles del formulario, y por supuesto también el del formulario, ahí si llego ;-). Sí, lo hice, escribí todo el código, con métodos recursivos, etc. En fin… :-/

La cuestión es que pensé que también estaría guay (cool) poder cambiar las fuentes, así todo estaría más grande… o más pequeño, ya que en el formulario de prueba (ver figura 1) puse la opción de ampliar o reducir.

Figura 1. La aplicación en modo inicial (usando la configuración del usuario de Windows)
Figura 1. La aplicación en modo inicial (usando la configuración del usuario de Windows)

Pero aquello era un caos, cuando ampliaba, lo hacía según el ancho y el alto y claro, si los controles no tienen todos los Anchor necesarios, pues… se te quedaba espacio vacío por aquí y por allá… no tengo capturas (¡gracias a Dios! si no, ya no vendrás más a visitarme 😛 )

Con decirte que hice hasta una clase para que manejase el tema este del cambio de los controles y así hacerlo más cool… con un evento que indicaba que se estaban haciendo los cambios, etc.; sí, lo que yo te diga, en fin…

Bueno, vale… otro día hago la captura y así ves cómo se puede uno embrollar con lo que después resultó ser algo muy simple de codificar.

La solución (muy fácil y sencilla)

Pues eso, la solución, para esto de que se cambien los controles de tamaño según indiquemos, es muy simple, tanto que… bueno… mejor me callo… ¡ay zeñó!

Y todo surgió porque los controles quedaban muy mal al cambiar el tamaño, y me dio por probar (esto aún podría estar en la batallita del Guille, pero bueno…) quitando el cambio del tamaño del formulario y de los controles, y dejar solo el cambio del tamaño de la fuente y… ¡voilà, todo va a la perfección!. No sabes la de cabezazos que me hubiera dado contra la pared… menos mal que ahora me he pelado al 2 y no era plan… 🙂

Te muestro un par de capturas con el 25% de ampliación y el 50% para que te hagas una idea de lo bien que funciona 🙂 y después te muestro el código tanto para Visual Basic como para C#.

Figura 2. Aspecto de la aplicación en funcionamiento usando el 25% de ampliación
Figura 2. Aspecto de la aplicación en funcionamiento usando el 25% de ampliación
Figura 3. Aspecto de la aplicación en funcionamiento usando un 50% de ampliación
Figura 3. Aspecto de la aplicación en funcionamiento usando un 50% de ampliación

Nota:
Según parece, la imagen 1 y 2 son iguales, pero si te fijas en la figura 3, en la que muestro el IDE de Visual Studio, comprobarás que el tamaño del formulario es significativamente más grande que el mostrado en el diseñador de VS.

Pulsa en las imágenes para verlas en grande.

El código para cambiar el tamaño de los controles de un formulario

Comentarte que todo está en cambiar el tamaño de la fuente del formulario, por tanto debes tener asignado el valor Font a la propiedad AutoScaleMode del formulario (es el valor predeterminado al crear un nuevo formulario).

El código para Visual Basic

'--------------------------------------------------------------------------
' Métodos para cambiar el tamaño del formulario
' y de sus controles
'--------------------------------------------------------------------------

''' <summary>
''' Cambia el tamaño del formulario (o control) indicado,
''' ampliando o reduciendo según un porcentaje.
''' Recomendado es solo cambiar el formulario.
''' </summary>
Private Sub cambia(ctr As Control, ampliar As Boolean, por As Integer)
    If ampliar = False Then
        por = -por
    End If

    '----------------------------------------------------------------------
    ' El ancho y alto es mejor no cambiarlo,
    ' las proporciones de los controles se verán bien
    ' pero si el Anchor no está "pensado" para todos
    ' los controles, quedarán espacios vacíos con
    ' respecto al diseño original.
    ' Al cambiar la fuente del formulario,
    ' el aspecto original no se pierde.
    '----------------------------------------------------------------------


    '----------------------------------------------------------------------
    ' Al cambiar el tamaño de la fuente del formulario
    ' los controles se adaptan al nuevo tamaño de fuente,
    ' sin perder el aspecto del diseño original.
    '
    ' El formulario debe tener asignada la propiedad
    ' AutoScaleMode = Font
    '----------------------------------------------------------------------

    '
    ' Se debería poner un máximo y mínimo a las fuentes
    '

    Dim fntSize = ctr.Font.Size
    fntSize = calculaPorcentaje(fntSize, por)

    ' No admitir valores menores de uno
    ' ni valores mayores de 3 veces la fuente
    If fntSize < 1 OrElse fntSize > ctr.Font.Size * 3 Then
        fntSize = ctr.Font.Size
    End If

    ctr.Font = New Font(ctr.Font.FontFamily,
                        fntSize, ctr.Font.Style,
                        ctr.Font.Unit, ctr.Font.GdiCharSet,
                        ctr.Font.GdiVerticalFont)
End Sub

''' <summary>
''' Calcula el porcentaje a partir de un valor Single,
''' para el tamaño de la fuente.
''' </summary>
Private Function calculaPorcentaje(valor As Single, porcentaje As Integer) As Single
    Return valor + (valor * porcentaje / 100)
End Function

El código para C#

// --------------------------------------------------------------------------
// Métodos para cambiar el tamaño del formulario
// y de sus controles
// --------------------------------------------------------------------------

/// <summary>
/// Cambia el tamaño del formulario (o control) indicado,
/// ampliando o reduciendo según un porcentaje.
/// Recomendado es solo cambiar el formulario.
/// </summary>
private void cambia(Control ctr, bool ampliar, int por)
{
    if (ampliar == false)
        por = -por;

    // ----------------------------------------------------------------------
    // El ancho y alto es mejor no cambiarlo,
    // las proporciones de los controles se verán bien
    // pero si el Anchor no está "pensado" para todos
    // los controles, quedarán espacios vacíos con
    // respecto al diseño original.
    // Al cambiar la fuente del formulario,
    // el aspecto original no se pierde.
    // ----------------------------------------------------------------------


    // ----------------------------------------------------------------------
    // Al cambiar el tamaño de la fuente del formulario
    // los controles se adaptan al nuevo tamaño de fuente,
    // sin perder el aspecto del diseño original.
    // 
    // El formulario debe tener asignada la propiedad
    // AutoScaleMode = Font
    // ----------------------------------------------------------------------

    // 
    // Se debería poner un máximo y mínimo a las fuentes
    // 

    var fntSize = ctr.Font.Size;
    fntSize = calculaPorcentaje(fntSize, por);

    // No admitir valores menores de uno
    // ni valores mayores de 3 veces la fuente
    if (fntSize < 1 || fntSize > ctr.Font.Size * 3)
        fntSize = ctr.Font.Size;

    ctr.Font = new Font(ctr.Font.FontFamily, fntSize, 
                        ctr.Font.Style, ctr.Font.Unit, 
                        ctr.Font.GdiCharSet, ctr.Font.GdiVerticalFont);
}

/// <summary>
/// Calcula el porcentaje a partir de un valor Single,
/// para el tamaño de la fuente.
/// </summary>
private float calculaPorcentaje(float valor, int porcentaje)
{
    return valor + (valor * porcentaje / 100);

}

Al método cambia le pasamos el control o formulario (recomendable el formulario) en el que queremos hacer el cambio de tamaño, el valor de ampliar es si queremos ampliar (true) o reducir (false) y por es el porcentaje, que es un valor entero y puede ser 0 (cero) para no hacer nada o dejarlo como estaba, o cualquier otro tamaño (no te recomiendo un valor mayor de 175 si no, pues… te faltará pantalla… 🙂

Como puedes comprobar, he puesto una comprobación para que el tamaño de la fuente no sea menor de 1 ni mayor de 3 veces el tamaño inicial.
Si quieres cambiarlo, hazlo, pero al menos deja la comprobación de que no sea menor de uno (o cero) ya que so es cero (0) te dará error.

Y ahora pasemos al código que he usado para cambiar el tamaño del formulario y sus controles.

El código de ejemplo para cambiar el tamaño según un porcentaje

En el ejemplo que he hecho (ver cualquiera de las figuras) he puesto la opción de Ampliar o Reducir, un combo con los porcentajes a usar y el botón Cambiar para aplicar el cambio.

También he puesto un botón para restaurar el tamaño al inicial (Restablecer fuente) pero en realidad no es necesario, ya que al indicar 0% se deja todo como estaba al inicio.

Lo que si hago es que ese porcentaje sea fijo, es decir, siempre que pulses en, por ejemplo, 50% se cambiará al 50% del valor inicial.

Te aclaro esto porque inicialmente (ya sabes: la torpeza del Guille) ese porcentaje lo aplicaba al valor que ya hubiese de antes, por tanto, si inicialmente lo habías ampliado al 10% y después seleccionabas el 50% este último se aplicaba sobre la ampliación (o reducción) anterior, y… bueno, que no quedaba nada bien.

Para conseguir esto, que siempre se aplique el porcentaje según la fuente inicial, he creado una variable llamada miWinFont, esa es la fuente que tiene el sistema, ya que he usado el mismo código que te mostré en el artículo anterior (Cambiar automáticamente las fuentes de nuestro formulario a las de Windows) para utilizar la fuente indicada en Windows.

La asignación de esa variable se hace al inicio del programa (en el constructor) y después se usa para reiniciar el tamaño de la fuente antes de hacer el cambio, ahora lo verás en el código.

Como tip te puedo decir que puedes usar otra forma de hacerlo, por ejemplo usando el valor de fntSize a partir del valor de miWinFont en vez de la fuente del formulario, pero no he cambiado el código porque eso se me acaba de ocurrir mientras escribo el artículo, y ya no es plan de cambiar el código 😉

Vamos a lo que vamos.

Empecemos con el código de Visual Basic, pero tanto en el de VB como en el de C# lo que hago es lo mismo: hacer el cambio usando el evento Click del botón Cambiar.

El código para Visual Basic de los métodos de evento

'
' Los métodos de evento para el cambio de la fuente
'
Private Sub btnCambiarTamaño_Click(sender As Object, e As EventArgs) Handles _
                                            btnCambiarTamaño.Click
    ' Cambiar solo el tamaño de la fuente del formulario
    txtInfo.Text = "Cambiando el tamaño de los controles..."
    Application.DoEvents()

    Me.Hide()

    ' restablecer a la fuente inicial
    Me.Font = miWinFont

    ' hacer el cambio de tamaño
    cambia(Me, optAmpliar.Checked, CInt(cboTamaños.SelectedItem))

    Me.Show()

    txtInfo.Text = "Cambiado el tamaño de los controles."
    Application.DoEvents()
End Sub

Private Sub btnRestablecerFuente_Click(sender As Object, e As EventArgs) Handles _
                                                btnRestablecerFuente.Click
    ' Restablecer siempre a la fuente del sistema
    ' si no queremos usar la del sistema,
    ' asignar al valor de miFuente (la original al diseñar)
    Me.Font = miWinFont


End Sub

Ahora después te muestro dónde declaro miWinFont y dónde la asigno.

El código para C# de los métodos de evento

//
// Los métodos de evento para el cambio de la fuente
//

private void btnCambiarTamaño_Click(object sender, EventArgs e)
{
    // Cambiar solo el tamaño de la fuente del formulario
    txtInfo.Text = "Cambiando el tamaño de los controles...";
    Application.DoEvents();
    this.Hide();
    
    // restablecer a la fuente inicial
    this.Font = miWinFont;
    
    // hacer el cambio de tamaño
    cambia(this, optAmpliar.Checked, Convert.ToInt32(cboTamaños.SelectedItem));

    this.Show();
    txtInfo.Text = "Cambiado el tamaño de los controles.";
    Application.DoEvents();

}

private void btnRestablecerFuente_Click(object sender, EventArgs e)
{
    // Restablecer siempre a la fuente del sistema
    // si no queremos usar la del sistema,
    // asignar al valor de miFuente (la original al diseñar)
    this.Font = miWinFont;

}

Este es el código donde se define y se asigna miWinFont.

Adivina cuál es el de VB y cuál el de C# 😉

Public Class Form1
    ''' <summary>
    ''' La fuente del sistema
    ''' </summary>
    Private miWinFont As Font

[...]

'
' El constructor del formulario
'
Sub New()

    ' This call is required by the designer.
    InitializeComponent()

    ' Add any initialization after the InitializeComponent() call.
    miFont = Me.Font

    Me.Font = SystemFonts.IconTitleFont
    AddHandler SystemEvents.UserPreferenceChanged,
                AddressOf SystemEvents_UserPreferenceChanged
    miWinFont = Me.Font

    infoFuentes()
End Sub

'
' Los métodos de evento para interactuar con la configuración de Windows
'
Private Sub SystemEvents_UserPreferenceChanged(ByVal sender As Object,
                                               ByVal e As UserPreferenceChangedEventArgs)
    If e.Category = UserPreferenceCategory.Window Then
        Me.Font = SystemFonts.IconTitleFont
        miWinFont = Me.Font
    End If

    mostrarInfoForm()
    txtInfo.Text = String.Format("UserPreferenceChanged.Category = {0} ({1:HH:mm:ss}){2}{3}",
                                 e.Category.ToString(), Date.Now,
                                 Microsoft.VisualBasic.vbCrLf,
                                 txtInfo.Text)

End Sub
public partial class Form1 : Form
{
    /// <summary>
    /// La fuente del sistema
    /// </summary>
    private Font miWinFont;

[...]

//
// El constructor del formulario
//
public Form1()
{

    // This call is required by the designer.
    InitializeComponent();

    // Add any initialization after the InitializeComponent() call.
    miFont = this.Font;

    this.Font = SystemFonts.IconTitleFont;
    SystemEvents.UserPreferenceChanged +=
                                SystemEvents_UserPreferenceChanged;
    this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);

    // Para que tenga dos m\f2étodos de evento el evento Load
    this.Load += new System.EventHandler(this.Form1_Load);

    miWinFont = this.Font;

    infoFuentes();
}

//
// Los métodos de evento para interactuar con la configuración de Windows
//

private void SystemEvents_UserPreferenceChanged(object sender,
                                        UserPreferenceChangedEventArgs e)
{
    if (e.Category == UserPreferenceCategory.Window) {
        this.Font = SystemFonts.IconTitleFont;
        miWinFont = this.Font;
    }

    mostrarInfoForm();
    txtInfo.Text = string.Format("UserPreferenceChanged.Category = {0}"+
                                 "({1:HH:mm:ss}){2}{3}",
                                 e.Category.ToString(), DateTime.Now,
                                 "\r\n", txtInfo.Text);

}

Nota:
No te preocupes por la definición de los métodos infoFuentes ni mostrarInfoForm, ese código está en el ZIP que te pondré al final con el código completo.

Y esto es todo… ya ves qué simple… 🙂

Espero que te sea de utilidad, ¡’esa es siempre la idea!

Nos vemos.
Guillermo.

P.S.
Comentarte que en el código completo (sí, para VB y C#) la aplicación lo que hace es permitir que selecciones un fichero (archivo) y te muestre las propiedades, nombre completo, directorio, fecha de creación, etc.

El código completo del ejemplo (solución para Visual Studio usando .NET 4.7.2)

El ZIP con el código completo (una solución de Visual Studio 2017 con los proyectos de Visual Basic y C#

ZIP: Cambiar tamaño controles.zip (254 KB)

MD5 Checksum: 0B5DDD8A525D61647F10070EFC198DCA

P.S. 2 (31/Dic/18)
Aquí tienes un ejemplo de cómo hacer que el resto de formularios de nuestra aplicación utilicen el tamaño asignado en el formulario principal:
Interceptar el cambio del tamaño de los controles de un formulario en otros formularios de la aplicación.

Cambiar automáticamente las fuentes de nuestro formulario a las de Windows

Pues eso… que como ahora «ando liado» con dos monitores, uno, el principal en el portátil (laptop) y el segundo uno de más resolución, pues… resulta que quiero que en el monitor se vean las fuentes más grandes y también el formulario y los controles, y antes de empezar a hacer «manualidades» (adaptar las cosas por la cuenta de la vieja, es decir, a mano) me he decidido a buscar en Internet a ver si había algo y resulta que sí, que lo hay (o casi), seguramente habrá más cosas pero lo que en principio me ha parecido una buena opción es lo que he encontrado en Cómo: Responder a los cambios de las combinaciones de fuentes en una aplicación de Windows Forms, concretamente en la sección: Para usar la fuente del escritorio y responder a los cambios de esquema de fuentes y concretamente el código mostrado en: Para cambiar manualmente la combinación de fuentes en Windows XP.

Por supuesto el código de ejemplo solo se muestra en C#, pero… no te preocupes aquí estoy yo para mostrarte cómo hacer eso que ahí dice en Visual Basic .NET (sí, y también en C# 😉 )

El código básicamente es como está en esa página que te he indicado, lo único que yo he añadido al ejemplo que te voy a poner es la opción de mostrar las fuentes originales (iniciales del formulario) o bien usar las que Windows te indique.

Para que te hagas una idea de lo que el código hace, te muestro dos capturas del formulario (Form1) en ejecución, la figura 1 es con las letras «normales» y la segunda captura (figura 2) es usando el código que hace que se adapte a las fuentes de Windows.

Nota:
Este código solo cambia el tamaño de las fuentes del formulario, no la de los controles.
Al cambiar la fuente del formulario, este cambia también de tamaño y «reubica los controles».

 

El formulario usando las fuentes normales
Figura 1. El formulario con las fuentes normales


El formulario usando las fuentes de Windows
Figura 2. El formulario usando las fuentes de Windows

No te asustes porque haya muchos controles 😉

Es que ese formulario lo tengo para hacer unas pruebas para convertir de Windows Forms a WPF / XAML y tengo que probar con prácticamente todos los controles (al menos los que yo suelo usar), lo que importa es que veas que el formulario de la figura 2 ha cambiado de tamaño y también el contenido de algunos de los controles (salvo los menús y la barra de botones).


No te voy a explicar en detalle cómo funciona esto, ya que en la página que te indiqué ya lo hacen 🙂 pero si te voy a mostrar el código necesario para que funcione así.


Si estás usando Visual Basic tendrás que agregar el código del constructor (Sub New) (el IDE de Visual Studio agrega el contenido necesario de forma automática) y añadimos las siguientes líneas de código después de la llamada a InitializeComponent:

El código de Visual Basic para el constructor (Sub New):

Sub New()

    ' This call is required by the designer.
    InitializeComponent()

    ' Add any initialization after the InitializeComponent() call.

    Me.Font = SystemFonts.IconTitleFont
    AddHandler SystemEvents.UserPreferenceChanged, AddressOf SystemEvents_UserPreferenceChanged

End Sub

El código de C# para el constructor:

public Form1()
{
    InitializeComponent();

    this.Font = SystemFonts.IconTitleFont;
    SystemEvents.UserPreferenceChanged += new UserPreferenceChangedEventHandler(SystemEvents_UserPreferenceChanged);
    this.FormClosing += new FormClosingEventHandler(Form1_FormClosing);
}

Si te fijas un poco, en el código de VB no he puesto el «manenejador de eventos» para el evento Form.Closing, ya que no es necesario, aunque se podría haber hecho como en C#, pero si Visual Basic facilita la creación de eventos, ¿por qué no usarla? (ya sabes, en la declaración del evento se añade la cláusula Handles y a continuación el nombre del evento a «capturar».


Te explico brevemente lo que hace ese código del constructor:

Asigna a la fuente del formulario la que hay definida en Windows, esto funciona desde Windows XP hasta el actual Windows 10 (actual en las fechas que estoy escribiendo esto, es decir el 27 de diciembre de 2018).


Después añade el manejador de eventos para la clase UserPreferenceChanged de SystemEvents, que es una clase definida en el espacio de nombres Microsoft.Win32, por tanto en el formulario hay que importar ese espacio de nombres, ya sabes:
Imports Microsoft.Win32 para Visual Basic o using Microsoft.Win32; para C#.


En C# también añade el controlador de eventos para el evento Form.Closing.


En realidad en el evento Form.Closing solo se desliga el manejador de eventos para UserPreferenceChanged.

Aquí tienes el código para VB y C#.

El código para Visual Basic:

Private Sub SystemEvents_UserPreferenceChanged(ByVal sender As Object,
                                               ByVal e As UserPreferenceChangedEventArgs)
    If e.Category = UserPreferenceCategory.Window Then
        Me.Font = SystemFonts.IconTitleFont
    End If
End Sub

Private Sub Form1_FormClosing(ByVal sender As Object,
                              ByVal e As FormClosingEventArgs) Handles Me.FormClosing
    RemoveHandler SystemEvents.UserPreferenceChanged,
            AddressOf SystemEvents_UserPreferenceChanged
End Sub

 

El código para C#:

void SystemEvents_UserPreferenceChanged(object sender, 
                                        UserPreferenceChangedEventArgs e)
{
    if (e.Category == UserPreferenceCategory.Window)
    {
        this.Font = SystemFonts.IconTitleFont;
    }
}

void Form1_FormClosing(object sender, 
                       FormClosingEventArgs e)
{
    SystemEvents.UserPreferenceChanged -= 
        new UserPreferenceChangedEventHandler(SystemEvents_UserPreferenceChanged);
}

Y esto es todo amigo 🙂


Si me decido a poner algún ejemplo completo, actualizaré esta «entrada» (o post) poniendo el enlace para la descarga.



Espero que te sirva 😉

Nos vemos.
Guillermo

P.S.
Si quieres que los controles de tu formulario cambien
al tamaño que tu indiques (un porcentaje), mira esta entrada:
Cambiar el tamaño de los controles de un formulario automáticamente

Saber la clave de Windows 10 usando RegEdit

 

Pues eso… que no encontraba en mis «chuletas» la clave del Windows 10 Pro que tengo instalado y busque en Internet cómo averiguarla, y en esta página de la web rooTear encontré la forma de verla completa usando REGEDIT.

Pero te lo explico aquí también y así tienes que «andar» menos Guiño

Averiguar la clave de activación de Windows 10

Abre el programa regedit (pulsa en la tecla de Windows y la tecla R (yo tengo el Windows en inglés)) y escribe REGEDIT y pulsa la tecla INTRO. Te aparecerá lo siguiente:

HKEY_LOCAL_MACHINE / SOFTWARE / Microsoft / Windows NT / CurrentVersion / SoftwareProtectionPlatform

 

Pulsa en SoftwareProtectionPlatform y te mostrará una imagen como la siguiente:

clave windows 10 26feb18
Figura 1- La clave SoftwareProtectionPlatform

En el panel derecho busca BackupProductKeyDefault y tendrás la clave de activación de Windows en el panel «Data/Datos» (el panel derecho junto a Type/Tipo) (ver figura 2)

clave windows 10 26feb18_edited
Figura 2- La clave de activación de Windows 10 está en BackupProductKeyDefault

¡Y esto es todo amigo! Sonrisa

 

Nos vemos.
Guillermo