Windows en Xamarin.Mac

En este artículo se explica cómo trabajar con ventanas y paneles en una aplicación de Xamarin.Mac. Describe cómo crear ventanas y paneles en Xcode y Interface Builder, cargarlos desde guiones gráficos y archivos .xib y trabajar con ellos mediante programación.

Al trabajar con C# y .NET en una aplicación de Xamarin.Mac, tiene acceso a los mismos Windows y paneles en los que trabaja un desarrollador y Objective-CObjective-C Dado que Xamarin.Mac se integra directamente con Xcode, puede usar el Interface Builder de Xcode para crear y mantener los paneles y Windows (o, opcionalmente, crearlos directamente en código de C#).

En función de su propósito, una aplicación de Xamarin.Mac puede presentar una o varias Windows en pantalla para administrar y coordinar la información con la que se muestra y funciona. Las funciones principales de una ventana son:

1. Para proporcionar un área en la que se pueden colocar y administrar vistas y controles.
2. Para aceptar y responder a eventos en respuesta a la interacción del usuario con el teclado y el mouse.

Windows se puede usar en un estado Modeless (por ejemplo, un editor de texto que puede tener varios documentos abiertos a la vez) o Modal (por ejemplo, un cuadro de diálogo Exportar que se debe descartar para que la aplicación pueda continuar).

Los paneles son un tipo especial de Ventana (una subclase de la clase base), que normalmente sirve una función auxiliar en una aplicación, como ventanas de utilidad como inspectores de formato de texto y sistemas NSWindow Selector de colores.

En este artículo, se tratarán los aspectos básicos del trabajo con Windows y paneles en una aplicación de Xamarin.Mac. Se recomienda encarecidamente que trabaje primero en el artículo Hello, Mac, en concreto en las secciones Introduction to Xcode and Interface Builder and Outlets and Actions (Introducción a Xcode y Interface Builder y salidas y acciones), ya que trata los conceptos y técnicas clave que se usarán en este artículo.

También puede echar un vistazo a la sección del documento Exposing C# classes / methods to Objective-CExposing C# classes / methods to Objective-C internos de Xamarin.Mac), donde se explican los comandos y que se usan para conectar las clases de C# a objetos y elementos de interfaz de RegisterExportObjective-C usuario.

Introducción a las ventanas

Como se indicó anteriormente, una ventana proporciona un área en la que se pueden colocar y administrar vistas y controles, y responde a eventos en función de la interacción del usuario (ya sea mediante el teclado o el mouse).

Según Apple, hay cinco tipos principales de Windows en una aplicación macOS:

• Ventana de documento: una ventana de documento contiene datos de usuario basados en archivos, como una hoja de cálculo o un documento de texto.
• Ventana de la aplicación: una ventana de aplicación es la ventana principal de una aplicación que no está basada en documentos (como la aplicación Calendario en un equipo Mac).
• Panel: un panel flota sobre otras ventanas y proporciona herramientas o controles con los que los usuarios pueden trabajar mientras los documentos están abiertos. En algunos casos, un panel puede ser translúcido (por ejemplo, cuando se trabaja con gráficos grandes).
• Diálogo: aparece un cuadro de diálogo en respuesta a una acción del usuario y normalmente proporciona formas en que los usuarios pueden completar la acción. Un cuadro de diálogo requiere una respuesta del usuario antes de que se pueda cerrar. (Vea Trabajar con diálogos)
• Alertas: una alerta es un tipo especial de diálogo que aparece cuando se produce un problema grave (por ejemplo, un error) o como una advertencia (como preparar la eliminación de un archivo). Dado que una alerta es un cuadro de diálogo, también requiere una respuesta del usuario para poder cerrarla. (Consulte Trabajar con alertas)

Para más información, consulte la sección Acerca de Windows de temas de diseño de macOS deApple.

Ventanas principales, de clave e inactivas

Windows en una aplicación de Xamarin.Mac puede tener un aspecto y un comportamiento distintos en función de cómo interactúe actualmente el usuario con ellos. La ventana principal de documento o aplicación que actualmente es el foco de atención del usuario se denomina ventana principal. En la mayoría de los casos, esta ventana también será la ventana clave (la ventana que acepta actualmente la entrada del usuario). Pero esto no siempre es así, por ejemplo, un Selector de colores podría estar abierto y ser la ventana Clave con la que el usuario interactúa para cambiar el estado de un elemento en la ventana de documento (que seguiría siendo la ventana principal).

Las ventanas Main y Key Windows (si son independientes) siempre están activas, Windows inactivas son ventanas abiertas que no están en primer plano. Por ejemplo, una aplicación de editor de texto podría tener más de un documento abierto a la vez, solo la ventana principal estaría activa y todas las demás estarían inactivas.

Para más información, consulte la sección Acerca de Windows de temas de diseño de macOS deApple.

Ventanas de nomenclatura

Una ventana puede mostrar una barra de título y, cuando se muestra el título, suele ser el nombre de la aplicación, el nombre del documento en el que se trabaja o la función de la ventana (por ejemplo, Inspector). Algunas aplicaciones no muestran una barra de título porque son reconocibles por visión y no funcionan con documentos.

Apple sugiere las siguientes directrices:

• Use el nombre de la aplicación para el título de una ventana principal que no es de documento.
• Asigne un nombre a una nueva ventana de untitled documento. Para el primer documento nuevo, no anexe un número al título (por ejemplo, untitled 1 ). Si el usuario crea otro documento antes de guardar y poner en orden el primero, llame a esa untitled 2 ventana untitled 3 , , etc.

Para más información, consulte la sección Naming Windows of Apple's macOS design themes (Temas de diseño de macOS deApple).

Ventanas de pantalla completa

En macOS, la ventana de una aplicación puede pasar a pantalla completa ocultando todo lo que incluye la barra de menús de la aplicación (que se puede mostrar moviendo el cursor a la parte superior de la pantalla) para proporcionar interacción libre de distracciones con su contenido.

Apple sugiere las siguientes directrices:

• Determine si tiene sentido que una ventana vaya a pantalla completa. Las aplicaciones que proporcionan interacciones breves (como una calculadora) no deben proporcionar un modo de pantalla completa.
• Muestre la barra de herramientas si la tarea de pantalla completa lo requiere. Normalmente, la barra de herramientas está oculta mientras está en modo de pantalla completa.
• La ventana de pantalla completa debe tener todas las características que los usuarios necesitan para completar la tarea.
• Si es posible, evite la interacción de Finder mientras el usuario está en una ventana de pantalla completa.
• Aproveche el aumento del espacio de pantalla sin desplazar el foco de la tarea principal.

Para obtener más información, consulte la sección de pantalla completa Windows temas de diseño de macOS deApple.

Paneles

Un panel es una ventana auxiliar que contiene controles y opciones que afectan al documento o selección activos (por ejemplo, el sistema Selector de colores):

Los paneles pueden ser específicos de la aplicacióno de todo el sistema. App-Specific paneles flotantes sobre la parte superior de las ventanas de documentos de la aplicación y desaparecen cuando la aplicación está en segundo plano. Paneles de todo el sistema (como el panel Fuentes), flotante sobre todas las ventanas abiertas independientemente de la aplicación.

Apple sugiere las siguientes directrices:

• En general, use un panel estándar, los paneles transparentes solo se deben usar con moderación y para tareas gráficamente intensivas.
• Considere la posibilidad de usar un panel para proporcionar a los usuarios un acceso sencillo a controles importantes o información que afecte directamente a su tarea.
• Oculte y muestre los paneles según sea necesario.
• Los paneles siempre deben incluir la barra de título.
• Los paneles no deben incluir un botón minimizar activo.

Inspectores

La mayoría de las aplicaciones macOS modernas presentan controles auxiliares y opciones que afectan al documento activo o a la selección como inspectores que forman parte de la ventana principal (como la aplicación Pages que se muestra a continuación), en lugar de usar panel Windows:

Para más información, consulte la sección Paneles de los temas de diseño de macOS de Apple y nuestra aplicación de ejemplo MacInspector para obtener una implementación completa de una interfaz inspector en una aplicación xamarin.mac.

Creación y mantenimiento de ventanas en Xcode

Cuando se crea una nueva aplicación Xamarin.Mac Cocoa, se obtiene una ventana estándar en blanco de forma predeterminada. Esta ventana se define en un .storyboard archivo incluido automáticamente en el proyecto. Para editar el diseño de windows, en la Explorador de soluciones, haga doble clic en el archivo:

Se abrirá el diseño de la ventana en la ventana de Xcode Interface Builder:

En el Inspector de atributos, hay varias propiedades que puede usar para definir y controlar la ventana:

• Título: este es el texto que se mostrará en la barra de título de la ventana.
• Autoguardar: esta es la clave que se usará para identificar la ventana cuando la posición y la configuración se guarden automáticamente.
• Barra de título: muestra una barra de título en la ventana.
• Título unificado y barra de herramientas: si la ventana incluye una barra de herramientas, debe formar parte de la barra de título.
• Vista de contenido de tamaño completo: permite que el área de contenido de la ventana esté bajo la barra Título.
• Sombra: tiene una sombra en la ventana.
• Textura: las ventanas con textura pueden usar efectos (como vibración) y se pueden mover arrastrando a cualquier parte del cuerpo.
• Cerrar: la ventana tiene un botón Cerrar.
• Minimizar: la ventana tiene un botón minimizar.
• Cambiar tamaño: tiene un control de cambio de tamaño en la ventana.
• Botón barra de herramientas: la ventana tiene un botón ocultar o mostrar de la barra de herramientas.
• Restaurable: la posición y la configuración de la ventana se guardan y restauran automáticamente.
• Visible al iniciar: es la ventana que se muestra automáticamente cuando se carga el archivo.
• Ocultar al desactivar: es la ventana oculta cuando la aplicación entra en segundo plano.
• Liberar cuando se cierra: es la ventana que se purga de la memoria cuando se cierra.
• Mostrar siempre información sobre herramientas: se muestra constantemente la información sobre herramientas.
• Recalcula el bucle de vista: se vuelve a calcular el orden de la vista antes de dibujar la ventana.
• Espacios,Exposé y Ciclo: todos definen cómo se comporta la ventana en esos entornos de macOS.
• Pantalla completa: determina si esta ventana puede entrar en el modo de pantalla completa.
• Animación: controla el tipo de animación disponible para la ventana.
• Apariencia: controla la apariencia de la ventana. Por ahora solo hay una apariencia, Aqua.

Consulte la documentación de Introducción a apple Windows y NSWindow para obtener más detalles.

Establecimiento del tamaño y la ubicación predeterminados

Para establecer la posición inicial de la ventana y controlar su tamaño, cambie a Size Inspector:

Desde aquí puede establecer el tamaño inicial de la ventana, darle un tamaño mínimo y máximo, establecer la ubicación inicial en la pantalla y controlar los bordes alrededor de la ventana.

Establecimiento de un controlador de ventana principal personalizado

Para poder crear salidas y acciones para exponer elementos de la interfaz de usuario al código de C#, la aplicación Xamarin.Mac debe usar un controlador de ventana personalizado.

Haga lo siguiente:

1. Abra el guión gráfico de la aplicación en el Interface Builder de Xcode.

2. Seleccione en NSWindowController la Superficie de diseño.

3. Cambie a la vista Inspector de identidad y escriba como nombre de clase:

   

4. Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar.

5. Se WindowController.cs agregará un archivo a la Project en la WindowController.cs en Visual Studio para Mac:

   

6. Vuelva a abrir el guión gráfico en el Interface Builder de Xcode.

7. El WindowController.h archivo estará disponible para su uso:

   

Agregar elementos de la interfaz de usuario

Para definir el contenido de una ventana, arrastre controles desde el Inspector de biblioteca hasta el Editor de interfaz. Consulte nuestra introducción a Xcode y Interface Builder documentación para obtener más información sobre el uso de Interface Builder para crear y habilitar controles.

Por ejemplo, vamos a arrastrar una barra de herramientas desde el Inspector de biblioteca a la ventana del Editor de interfaces:

A continuación, arrastre una vista de texto y de tamaño para rellenar el área debajo de la barra de herramientas:

Puesto que queremos que la vista de texto se reduzca y crezca a medida que cambia el tamaño de la ventana, cambiemos al Editor de restricciones y agreguemos las restricciones siguientes:

Al hacer clic en los cuatro rayos I rojos situados en la parte superior del editor y hacer clic en Agregar 4 restricciones, se le dice a la vista de texto que se ajuste a las coordenadas X,Y especificadas y que crezca o reduzca horizontal y verticalmente a medida que se cambia el tamaño de la ventana.

Por último, exponga la vista de texto al código mediante una salida (asegúrese de seleccionar el archivo):

Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar con Xcode.

Para obtener más información sobre cómo trabajar con salidas y acciones,consulte nuestra documentación de salida y acción.

Flujo de trabajo de ventana estándar

Para cualquier ventana que cree y trabaje con la aplicación de Xamarin.Mac, el proceso es básicamente el mismo que el que hemos hecho anteriormente:

1. Para las nuevas ventanas que no son el valor predeterminado agregado automáticamente al proyecto, agregue una nueva definición de ventana al proyecto. Esto se analizará con detalle a continuación.
2. Haga doble clic en el archivo para abrir el diseño de ventana para editarlo en la página Main.storyboard de Interface Builder Xcode.
3. Arrastre una nueva ventana al diseño del Interfaz de usuario y enlace la ventana a la ventana principal mediante Segues (para obtener más información, consulte la sección Segues de nuestra documentación sobre cómo trabajar con guiones gráficos).
4. Establezca las propiedades de ventana necesarias en el Inspector de atributos y el Inspector de tamaño.
5. Arrastre los controles necesarios para compilar la interfaz y configurarlos en el Inspector de atributos.
6. Use el Inspector de tamaño para controlar el tamaño de los elementos de la interfaz de usuario.
7. Exponga los elementos de la interfaz de usuario de la ventana al código de C# a través de salidas y acciones.
8. Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar con Xcode.

Ahora que se ha creado una ventana básica, veremos los procesos típicos que realiza una aplicación de Xamarin.Mac al trabajar con ventanas.

Mostrar la ventana predeterminada

De forma predeterminada, una nueva aplicación de Xamarin.Mac mostrará automáticamente la ventana definida en el MainWindow.xib archivo cuando se inicie:

Puesto que modificamos el diseño de esa ventana anterior, ahora incluye un control predeterminado Barra de herramientas y Vista de texto. La siguiente sección del Info.plist archivo es responsable de mostrar esta ventana:

La lista desplegable Interfaz principal se usa para seleccionar el guión gráfico que se usará como interfaz de usuario de la aplicación principal (en este caso).

Se agrega automáticamente un controlador de vistas al proyecto para controlar la Windows principal que se muestra (junto con su vista principal). Se define en el archivo y se adjunta al propietario del archivo en ViewController.cs Interface Builder el Inspector de identidad: ViewController.cs

Para nuestra ventana, nos gustaría que tenga un título de la primera vez que se abra, así que vamos a invalidar el método en para que tenga untitled un aspecto parecido al ViewWillAppearViewController.cs siguiente:

public override void ViewWillAppear ()
{
    base.ViewWillAppear ();

    // Set Window Title
    this.View.Window.Title = "untitled";
}

Cerrar una ventana mediante programación

Puede haber ocasiones en las que quiera cerrar mediante programación una ventana en una aplicación de Xamarin.Mac, aparte de hacer que el usuario haga clic en el botón Cerrar de la ventana o que use un elemento de menú. macOS proporciona dos maneras diferentes de cerrar un mediante NSWindow programación: PerformClose y Close .

PerformClose

Llamar al método de un simula que el usuario hace clic en el botón Cerrar de la ventana resaltando momentáneamente el botón y cerrando PerformCloseNSWindow la ventana. PerformClose

Si la aplicación implementa el evento del , se genera NSWindow antes de que se cierre la WillClose ventana. Si el evento devuelve false , la ventana no se cerrará. Si la ventana no tiene un botón Cerrar o no se puede cerrar por cualquier motivo, el sistema operativo emitirá el sonido de alerta.

Por ejemplo:

MyWindow.PerformClose(this);

Intentaría cerrar la MyWindowNSWindow instancia. Si se ha realizado correctamente, se cerrará la ventana; de lo contrario, se emitirá el sonido de alerta y permanecerá abierto.

Cerrar

Llamar al método de no simula que el usuario haga clic en el botón Cerrar de la ventana resaltando momentáneamente el botón, simplemente CloseNSWindow cierra la ventana. Close

No es necesario que una ventana esté visible para cerrarse y se publicará una notificación en el Centro de notificaciones predeterminado para la NSWindowWillCloseNotification ventana que se va a cerrar.

El Close método difiere de dos maneras importantes del método PerformClose :

1. No intenta generar el WillClose evento .
2. No simula que el usuario haga clic en el botón Cerrar resaltando momentáneamente el botón.

Por ejemplo:

MyWindow.Close();

Se cerrará la MyWindowNSWindow instancia de .

Contenido de Windows modificado

En macOS, Apple ha proporcionado una manera de informar al usuario de que el contenido de una ventana ( ) ha sido modificado por el usuario y debe NSWindow guardarse. Si la ventana contiene contenido modificado, se mostrará un pequeño punto negro en su widget Cerrar:

Si el usuario intenta cerrar la ventana o salir de la aplicación mac mientras hay cambios no guardados en el contenido de la ventana, debe presentar un cuadro de diálogo o una hoja modal y permitir que el usuario guarde primero los cambios:

Marcar una ventana como modificada

Para marcar una ventana como contenido modificado, use el código siguiente:

// Mark Window content as modified
Window.DocumentEdited = true;

Y una vez guardado el cambio, borre la marca modificada mediante:

// Mark Window content as not modified
Window.DocumentEdited = false;

Guardar los cambios antes de cerrar una ventana

Para observar si el usuario cierra una ventana y le permite guardar contenido modificado de antemano, deberá crear una subclase de e NSWindowDelegate invalidar su WindowShouldClose método. Por ejemplo:

using System;
using AppKit;
using System.IO;
using Foundation;

namespace SourceWriter
{
    public class EditorWindowDelegate : NSWindowDelegate
    {
        #region Computed Properties
        public NSWindow Window { get; set;}
        #endregion

        #region constructors
        public EditorWindowDelegate (NSWindow window)
        {
            // Initialize
            this.Window = window;

        }
        #endregion

        #region Override Methods
        public override bool WindowShouldClose (Foundation.NSObject sender)
        {
            // is the window dirty?
            if (Window.DocumentEdited) {
                var alert = new NSAlert () {
                    AlertStyle = NSAlertStyle.Critical,
                    InformativeText = "Save changes to document before closing window?",
                    MessageText = "Save Document",
                };
                alert.AddButton ("Save");
                alert.AddButton ("Lose Changes");
                alert.AddButton ("Cancel");
                var result = alert.RunSheetModal (Window);

                // Take action based on result
                switch (result) {
                case 1000:
                    // Grab controller
                    var viewController = Window.ContentViewController as ViewController;

                    // Already saved?
                    if (Window.RepresentedUrl != null) {
                        var path = Window.RepresentedUrl.Path;

                        // Save changes to file
                        File.WriteAllText (path, viewController.Text);
                        return true;
                    } else {
                        var dlg = new NSSavePanel ();
                        dlg.Title = "Save Document";
                        dlg.BeginSheet (Window, (rslt) => {
                            // File selected?
                            if (rslt == 1) {
                                var path = dlg.Url.Path;
                                File.WriteAllText (path, viewController.Text);
                                Window.DocumentEdited = false;
                                viewController.View.Window.SetTitleWithRepresentedFilename (Path.GetFileName(path));
                                viewController.View.Window.RepresentedUrl = dlg.Url;
                                Window.Close();
                            }
                        });
                        return true;
                    }
                    return false;
                case 1001:
                    // Lose Changes
                    return true;
                case 1002:
                    // Cancel
                    return false;
                }
            }

            return true;
        }
        #endregion
    }
}

Use el código siguiente para adjuntar una instancia de este delegado a la ventana:

// Set delegate
Window.Delegate = new EditorWindowDelegate(Window);

Guardar los cambios antes de cerrar la aplicación

Por último, la aplicación xamarin.mac debe comprobar si alguna de sus Windows contenido modificado y permitir al usuario guardar los cambios antes de salir. Para ello, edite el AppDelegate.cs archivo, invalide ApplicationShouldTerminate el método y haga que sea parecido al siguiente:

public override NSApplicationTerminateReply ApplicationShouldTerminate (NSApplication sender)
{
    // See if any window needs to be saved first
    foreach (NSWindow window in NSApplication.SharedApplication.Windows) {
        if (window.Delegate != null && !window.Delegate.WindowShouldClose (this)) {
            // Did the window terminate the close?
            return NSApplicationTerminateReply.Cancel;
        }
    }

    // Allow normal termination
    return NSApplicationTerminateReply.Now;
}

Trabajar con varias ventanas

La mayoría de las aplicaciones Mac basadas en documentos pueden editar varios documentos al mismo tiempo. Por ejemplo, un editor de texto puede tener varios archivos de texto abiertos para su edición al mismo tiempo. De forma predeterminada, una nueva aplicación de Xamarin.Mac tiene un menú Archivo con un nuevo elemento conectado automáticamente a la acción.

El código siguiente activará este nuevo elemento y permitirá al usuario abrir varias copias de la ventana principal para editar varios documentos a la vez.

Edite AppDelegate.cs el archivo y agregue la siguiente propiedad calculada:

public int UntitledWindowCount { get; set;} =1;

Use esta opción para realizar un seguimiento del número de archivos no guardados para que podamos enviar comentarios al usuario (según las directrices de Apple descritas anteriormente).

A continuación, agregue el método siguiente:

[Export ("newDocument:")]
void NewDocument (NSObject sender) {
    // Get new window
    var storyboard = NSStoryboard.FromName ("Main", null);
    var controller = storyboard.InstantiateControllerWithIdentifier ("MainWindow") as NSWindowController;

    // Display
    controller.ShowWindow(this);

    // Set the title
    controller.Window.Title = (++UntitledWindowCount == 1) ? "untitled" : string.Format ("untitled {0}", UntitledWindowCount);
}

Este código crea una nueva versión de nuestro controlador de ventana, carga la nueva ventana, la convierte en la ventana principal y clave y la establece en el título. Ahora, si ejecutamos la aplicación y seleccionamos Nuevo en el menú Archivo, se abrirá y mostrará una nueva ventana del editor:

Si se abre el Windows, puede ver que la aplicación realiza automáticamente el seguimiento y el control de nuestras ventanas abiertas:

Para obtener más información sobre cómo trabajar con menús en una aplicación de Xamarin.Mac, consulte nuestra documentación trabajar con menús.

Obtención de la ventana activa actualmente

En una aplicación de Xamarin.Mac que puede abrir varias ventanas (documentos), hay ocasiones en las que tendrá que obtener la ventana actual más arriba (la ventana de clave). El código siguiente devolverá la ventana de claves:

var window = NSApplication.SharedApplication.KeyWindow;

Se puede llamar en cualquier clase o método que necesite acceder a la ventana de clave actual. Si no hay ninguna ventana abierta actualmente, devolverá null .

Acceso a todas las ventanas de la aplicación

Puede haber ocasiones en las que necesite acceder a todas las ventanas que la aplicación de Xamarin.Mac tiene abiertas actualmente. Por ejemplo, para ver si un archivo que el usuario desea abrir ya está abierto en una ventana de salida.

mantiene NSApplication.SharedApplication una propiedad que contiene una Windows matriz de todas las ventanas abiertas de la aplicación. Puede iterar por esta matriz para acceder a todas las ventanas actuales de la aplicación. Por ejemplo:

// Is the file already open?
for(int n=0; n<NSApplication.SharedApplication.Windows.Length; ++n) {
    var content = NSApplication.SharedApplication.Windows[n].ContentViewController as ViewController;
    if (content != null && path == content.FilePath) {
        // Bring window to front
        NSApplication.SharedApplication.Windows[n].MakeKeyAndOrderFront(this);
        return true;
    }
}

En el código de ejemplo, vamos a convertir cada ventana devuelta a la clase personalizada en nuestra aplicación y probar el valor de una propiedad personalizada con la ruta de acceso de un archivo que el usuario ViewControllerPath quiere abrir. Si el archivo ya está abierto, llevamos esa ventana al frente.

Ajustar el tamaño de la ventana en el código

Hay ocasiones en las que la aplicación necesita cambiar el tamaño de una ventana en el código. Para cambiar el tamaño y la posición de una ventana, se ajusta su Frame propiedad. Al ajustar el tamaño de una ventana, normalmente también debe ajustar su origen para mantener la ventana en la misma ubicación debido al sistema de coordenadas de macOS.

A diferencia de iOS, donde la esquina superior izquierda representa (0,0), macOS usa un sistema de coordenadas matemático donde la esquina inferior izquierda de la pantalla representa (0,0). En iOS, las coordenadas aumentan a medida que se desplaza hacia abajo hacia la derecha. En macOS, las coordenadas aumentan en valor hacia arriba a la derecha.

El código de ejemplo siguiente cambia el tamaño de una ventana:

nfloat y = 0;

// Calculate new origin
y = Frame.Y - (768 - Frame.Height);

// Resize and position window
CGRect frame = new CGRect (Frame.X, y, 1024, 768);
SetFrame (frame, true);

Supervisión de los cambios de tamaño de la ventana

Puede haber ocasiones en las que necesite supervisar los cambios en el tamaño de una ventana dentro de la aplicación xamarin.mac. Por ejemplo, para volver a dibujar el contenido para ajustarlo al nuevo tamaño.

Para supervisar los cambios de tamaño, primero asegúrese de que ha asignado una clase personalizada para el controlador de ventana en el Interface Builder de Xcode. Por ejemplo, MasterWindowController en lo siguiente:

A continuación, edite la clase de controlador de ventana personalizada y supervise el evento en la ventana del controlador para recibir notificaciones de DidResize los cambios de tamaño en directo. Por ejemplo:

public override void WindowDidLoad ()
{
    base.WindowDidLoad ();

    Window.DidResize += (sender, e) => {
        // Do something as the window is being live resized
    };
}

Opcionalmente, puede usar el evento para recibir una notificación solo después de que el DidEndLiveResize usuario haya terminado de cambiar el tamaño de la ventana. Por ejemplo:

public override void WindowDidLoad ()
{
    base.WindowDidLoad ();

        Window.DidEndLiveResize += (sender, e) => {
        // Do something after the user's finished resizing
        // the window
    };
}

Establecimiento del título y el archivo representado de una ventana

Cuando se trabaja con ventanas que representan documentos, tiene una propiedad que, si se establece en , muestra un punto pequeño en el botón Cerrar para dar al usuario una indicación de que el archivo se ha modificado y debe guardarse antes de NSWindowDocumentEditedtrue cerrarse.

Vamos a editar el ViewController.cs archivo y a realizar los siguientes cambios:

public bool DocumentEdited {
    get { return View.Window.DocumentEdited; }
    set { View.Window.DocumentEdited = value; }
}
...

public override void ViewWillAppear ()
{
    base.ViewWillAppear ();

    // Set Window Title
    this.View.Window.Title = "untitled";

    View.Window.WillClose += (sender, e) => {
        // is the window dirty?
        if (DocumentEdited) {
            var alert = new NSAlert () {
                AlertStyle = NSAlertStyle.Critical,
                InformativeText = "We need to give the user the ability to save the document here...",
                MessageText = "Save Document",
            };
            alert.RunModal ();
        }
    };
}

public override void AwakeFromNib ()
{
    base.AwakeFromNib ();

    // Show when the document is edited
    DocumentEditor.TextDidChange += (sender, e) => {
        // Mark the document as dirty
        DocumentEdited = true;
    };

    // Overriding this delegate is required to monitor the TextDidChange event
    DocumentEditor.ShouldChangeTextInRanges += (NSTextView view, NSValue[] values, string[] replacements) => {
        return true;
    };

}

También estamos supervisando el WillClose evento en la ventana y comprobando el estado de la propiedad DocumentEdited . Si es true así, es necesario dar al usuario la capacidad de guardar los cambios en el archivo. Si ejecutamos la aplicación y especificamos texto, se mostrará el punto:

Si intenta cerrar la ventana, recibe una alerta:

Si va a cargar un documento desde un archivo, establezca el título de la ventana en el nombre del archivo mediante el método (dado que es una cadena que representa el archivo que se window.SetTitleWithRepresentedFilename (Path.GetFileName(path));path va a abrir). Además, puede establecer la dirección URL del archivo mediante el window.RepresentedUrl = url; método .

Si la dirección URL apunta a un tipo de archivo conocido por el sistema operativo, su icono se mostrará en la barra de título. Si el usuario hace clic con el botón derecho en el icono, se mostrará la ruta de acceso al archivo.

Edite AppDelegate.cs el archivo y agregue el método siguiente:

[Export ("openDocument:")]
void OpenDialog (NSObject sender)
{
    var dlg = NSOpenPanel.OpenPanel;
    dlg.CanChooseFiles = true;
    dlg.CanChooseDirectories = false;

    if (dlg.RunModal () == 1) {
        // Nab the first file
        var url = dlg.Urls [0];

        if (url != null) {
            var path = url.Path;

            // Get new window
            var storyboard = NSStoryboard.FromName ("Main", null);
            var controller = storyboard.InstantiateControllerWithIdentifier ("MainWindow") as NSWindowController;

            // Display
            controller.ShowWindow(this);

            // Load the text into the window
            var viewController = controller.Window.ContentViewController as ViewController;
            viewController.Text = File.ReadAllText(path);
                    viewController.View.Window.SetTitleWithRepresentedFilename (Path.GetFileName(path));
            viewController.View.Window.RepresentedUrl = url;

        }
    }
}

Ahora, si ejecutamos la aplicación, seleccione Abrir... en el menú Archivo, seleccione un archivo de texto en el cuadro de diálogo Abrir y ábralo:

Se mostrará el archivo y el título se establecerá con el icono del archivo:

Agregar una nueva ventana a un proyecto

Aparte de la ventana principal del documento, es posible que una aplicación de Xamarin.Mac tenga que mostrar otros tipos de ventanas al usuario, como Preferencias o Paneles de inspector.

Para agregar una nueva ventana, haga lo siguiente:

1. En el Explorador de soluciones, haga doble clic en el archivo para abrirlo para editarlo en la página de Xcode Interface Builder.

2. Arrastre un nuevo controlador de ventana desde la biblioteca y suéltelo en la Superficie de diseño:

   

3. En el Inspector de identidad,escriba para el identificador de guión gráfico:

   

4. Diseñe la interfaz:

   

5. Abra el menú Aplicación ( MacWindows ), seleccione MacWindows, Control-Click y arrastre a la nueva ventana:

   

6. Seleccione Mostrar en el menú emergente.

7. Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar con Xcode.

Si ejecutamos el código y seleccionamos preferencias... en el menú Aplicación, se mostrará la ventana:

Trabajar con paneles

Como se indicó al principio de este artículo, un panel flota sobre otras ventanas y proporciona herramientas o controles con los que los usuarios pueden trabajar mientras los documentos están abiertos.

Al igual que cualquier otro tipo de ventana que cree y trabaje con él en la aplicación de Xamarin.Mac, el proceso es básicamente el mismo:

1. Agregue una nueva definición de ventana al proyecto.
2. Haga doble clic en .xib el archivo para abrir el diseño de la ventana para editarlo en el Interface Builder de Xcode.
3. Establezca las propiedades de ventana necesarias en el Inspector de atributos y el Inspector de tamaño.
4. Arrastre los controles necesarios para compilar la interfaz y configurarlos en el Inspector de atributos.
5. Use el Inspector de tamaño para controlar el tamaño de los elementos de la interfaz de usuario.
6. Exponga los elementos de la interfaz de usuario de la ventana al código de C# a través de salidas y acciones.
7. Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar con Xcode.

En el Inspector de atributos, tiene las siguientes opciones específicas de Paneles:

• Estilo: permite ajustar el estilo del panel desde: Panel normal (parece una ventana estándar), Panel de utilidad (tiene una barra de título más pequeña), Panel hud (es translúcido y la barra de título forma parte del fondo).
• No activando: determina que en el panel se convierte en la ventana de claves.
• Modal del documento: si el documento es modal, el panel solo flotará encima de las ventanas de la aplicación; de lo contrario, flota sobre todo.

Para agregar un nuevo panel, haga lo siguiente:

1. En la Explorador de soluciones, haga clic con el botón derecho en el Project y seleccione Agregar nuevo archivo....

2. En el cuadro de diálogo Nuevo archivo, seleccione Xamarin.MacCocoa Window with Controller (Ventana de Cocoa de Xamarin.Mac con controlador):

   

3. Escriba DocumentPanel en Nombre DocumentPanel haga clic en el botón Nuevo.

4. Haga doble clic en DocumentPanel.xib el archivo para abrirlo para editarlo en Interface Builder:

   

5. Elimine la ventana existente y arrastre un panel desde el Inspector de biblioteca en el Editor de interfaces:

   

6. Enlace el panel a la ventana Propietariodel archivo Salida:

   

7. Cambie al Inspector de identidad y establezca la clase del panel en :

   

8. Guarde los cambios y vuelva a Visual Studio para Mac para sincronizar con Xcode.

9. Edite DocumentPanel.cs el archivo y cambie la definición de clase a lo siguiente:

   public partial class DocumentPanel : NSPanel

10. Guarde los cambios en el archivo.

Edite AppDelegate.cs el archivo y haga que el método sea parecido al DidFinishLaunching siguiente:

public override void DidFinishLaunching (NSNotification notification)
{
        // Display panel
    var panel = new DocumentPanelController ();
    panel.Window.MakeKeyAndOrderFront (this);
}

Si ejecutamos la aplicación, se mostrará el panel:

Resumen

En este artículo se ha detallado cómo trabajar con Windows y paneles en una aplicación de Xamarin.Mac. Vimos los diferentes tipos y usos de Windows y Paneles, cómo crear y mantener Windows y Paneles en el Interface Builder de Xcode y cómo trabajar con Windows y Paneles en código de C#.

Vínculos relacionados

• MacWindows (ejemplo)
• MacInspector (ejemplo)
• Hello, Mac
• Trabajar con menús
• Temas de diseño de macOS (Apple)
• Windows, paneles y pantallas (Apple)