Controlli standard in Xamarin.Mac

Questo articolo illustra l'uso dei controlli AppKit standard, ad esempio pulsanti, etichette, campi di testo, caselle di controllo e controlli segmentati in un'applicazione Xamarin.Mac. Descrive l'aggiunta a un'interfaccia con Interface Builder e l'interazione con essi nel codice.

Quando si lavora con C# e .NET in un'applicazione Xamarin.Mac, è possibile accedere agli stessi controlli AppKit che uno sviluppatore lavora in Objective-C e Xcode . Poiché Xamarin.Mac si integra direttamente con Xcode, è possibile usare Interface Builder di Xcode per creare e gestire i controlli Appkit (o, facoltativamente, crearli direttamente nel codice C#).

I controlli AppKit sono gli elementi dell'interfaccia utente usati per creare l'interfaccia utente dell'applicazione Xamarin.Mac. Sono costituiti da elementi quali pulsanti, etichette, campi di testo, caselle di controllo e controlli segmentati e causano azioni istantanee o risultati visibili quando un utente li modifica.

In questo articolo verranno illustrate le nozioni di base sull'uso dei controlli AppKit in un'applicazione Xamarin.Mac. È consigliabile usare prima di tutto l'articolo Hello, Mac , in particolare le sezioni Introduzione a Xcode e Interface Builder e Outlet e Actions , in quanto illustra i concetti e le tecniche chiave che verranno usati in questo articolo.

È possibile esaminare anche la sezione Esposizione di classi/metodi C# alObjective-Cdocumento Internals di Xamarin.Mac, che illustra anche i Register comandi e Export usati per collegare le classi C# agli oggetti e agli Objective-C elementi dell'interfaccia utente.

Introduzione a controlli e visualizzazioni

macOS (in precedenza noto come Mac OS X) fornisce un set standard di controlli dell'interfaccia utente tramite AppKit Framework. Sono costituiti da elementi quali pulsanti, etichette, campi di testo, caselle di controllo e controlli segmentati e causano azioni istantanee o risultati visibili quando un utente li modifica.

Tutti i controlli AppKit hanno un aspetto predefinito standard che sarà appropriato per la maggior parte degli usi, alcuni specificano un aspetto alternativo per l'uso in un'area cornice finestra o in un contesto dell'effetto Vibrance, ad esempio in un'area barra laterale o in un widget centro notifiche.

Apple suggerisce le linee guida seguenti quando si lavora con i controlli AppKit:

• Evitare di combinare le dimensioni dei controlli nella stessa visualizzazione.
• In generale, evitare il ridimensionamento verticale dei controlli.
• Utilizzare il tipo di carattere di sistema e le dimensioni del testo appropriate all'interno di un controllo .
• Usare la spaziatura corretta tra i controlli.

Per altre informazioni, vedere la sezione About Controls and Views (Informazioni su controlli e visualizzazioni) delle linee guida dell'interfaccia umana os X di Apple.

Uso di controlli in una cornice di finestra

Esistono un subset di controlli AppKit che includono uno stile di visualizzazione che consente di includerli nell'area Frame di una finestra. Per un esempio, vedi la barra degli strumenti dell'app Posta:

• Pulsante Arrotondato : oggetto NSButton con uno stile di NSTexturedRoundedBezelStyle.
• Controllo segmentato arrotondato con trama : oggetto NSSegmentedControl con uno stile di NSSegmentStyleTexturedRounded.
• Controllo segmentato arrotondato con trama : oggetto NSSegmentedControl con uno stile di NSSegmentStyleSeparated.
• Menu a comparsa arrotondato a trama : oggetto NSPopUpButton con uno stile di NSTexturedRoundedBezelStyle.
• Menu a discesa a trama arrotondato : oggetto NSPopUpButton con uno stile di NSTexturedRoundedBezelStyle.
• Barra di ricerca - A NSSearchField.

Apple suggerisce le linee guida seguenti quando si lavora con i controlli AppKit in un frame di finestra:

• Non usare stili di controllo specifici di Window Frame nel corpo della finestra.
• Non usare i controlli Corpo finestra o gli stili in Frame finestra.

Per altre informazioni, vedere la sezione About Controls and Views (Informazioni su controlli e visualizzazioni) delle linee guida dell'interfaccia umana os X di Apple.

Creazione di un'interfaccia utente in Interface Builder

Quando si crea una nuova applicazione Xamarin.Mac Cocoa, si ottiene una finestra vuota standard per impostazione predefinita. Questa finestra viene definita in un .storyboard file incluso automaticamente nel progetto. Per modificare la progettazione delle finestre, nella Esplora soluzioni fare doppio clic sul Main.storyboard file:

Verrà aperta la progettazione della finestra in Interface Builder di Xcode:

Per creare l'interfaccia utente, trascina gli elementi dell'interfaccia utente (controlli AppKit) da Controllo libreria all'editor dell'interfaccia in Interface Builder. Nell'esempio seguente, un controllo Vertical Split View è stato drogato da Controllo libreria e posizionato nella finestra nell'editor dell'interfaccia:

Per altre informazioni sulla creazione di un'interfaccia utente in Interface Builder, vedere la documentazione introduzione a Xcode e Interface Builder .

Ridimensionamento e posizionamento

Dopo che un controllo è stato incluso nell'interfaccia utente, usare l'editor vincoli per impostarne la posizione e le dimensioni immettendo manualmente i valori e controllando la modalità di posizionamento e ridimensionamento automatico del controllo quando viene ridimensionata la finestra o la visualizzazione padre:

Usa i raggi I rossi intorno all'esterno della casella di ridimensionamento automatico per attaccare un controllo a una determinata posizione (x,y). Ad esempio:

Specifica che il controllo selezionato (nella visualizzazione gerarchia e nell'editor dell'interfaccia) sarà bloccato nella posizione superiore e destra della finestra o della visualizzazione durante il ridimensionamento o lo spostamento.

Altri elementi delle proprietà del controllo editor, ad esempio Height e Width:

È anche possibile controllare l'allineamento degli elementi con vincoli usando l'editor di allineamento:

Importante

A differenza di iOS dove (0,0) è l'angolo superiore sinistro dello schermo, in macOS (0,0) è l'angolo inferiore sinistro. Questo avviene perché macOS usa un sistema di coordinate matematiche con i valori numerici che aumentano in valore verso l'alto e verso destra. È necessario prendere in considerazione questo aspetto quando si posizionano i controlli AppKit in un'interfaccia utente.

Impostazione di una classe personalizzata

In alcuni casi è necessario usare i controlli AppKit che è necessario sottoclassare e controllare esistente e creare una versione personalizzata di tale classe. Ad esempio, definendo una versione personalizzata dell'elenco di origine:

using System;
using AppKit;
using Foundation;

namespace AppKit
{
    [Register("SourceListView")]
    public class SourceListView : NSOutlineView
    {
        #region Computed Properties
        public SourceListDataSource Data {
            get {return (SourceListDataSource)this.DataSource; }
        }
        #endregion

        #region Constructors
        public SourceListView ()
        {

        }

        public SourceListView (IntPtr handle) : base(handle)
        {

        }

        public SourceListView (NSCoder coder) : base(coder)
        {

        }

        public SourceListView (NSObjectFlag t) : base(t)
        {

        }
        #endregion

        #region Override Methods
        public override void AwakeFromNib ()
        {
            base.AwakeFromNib ();

        }
        #endregion

        #region Public Methods
        public void Initialize() {

            // Initialize this instance
            this.DataSource = new SourceListDataSource (this);
            this.Delegate = new SourceListDelegate (this);

        }

        public void AddItem(SourceListItem item) {
            if (Data != null) {
                Data.Items.Add (item);
            }
        }
        #endregion

        #region Events
        public delegate void ItemSelectedDelegate(SourceListItem item);
        public event ItemSelectedDelegate ItemSelected;

        internal void RaiseItemSelected(SourceListItem item) {
            // Inform caller
            if (this.ItemSelected != null) {
                this.ItemSelected (item);
            }
        }
        #endregion
    }
}

Dove l'istruzione [Register("SourceListView")] espone la SourceListView classe a Objective-C in modo che possa essere usata in Interface Builder. Per altre informazioni, vedere la sezione Esposizione di classi/metodi C# al Objective-C documento Internals di Xamarin.Mac, illustra i Register comandi e Export usati per collegare le classi C# agli oggetti e agli Objective-C elementi dell'interfaccia utente.

Con il codice precedente sul posto, è possibile trascinare un controllo AppKit, del tipo di base che si sta estendendo, nell'area di progettazione (nell'esempio seguente, un elenco di origine), passare a Identity Inspector e impostare la classe personalizzata sul nome esposto a Objective-C (esempio SourceListView):

Esposizione di outlet e azioni

Prima di poter accedere a un controllo AppKit nel codice C#, deve essere esposto come outlet o azione. A tale scopo, selezionare il controllo specificato nella gerarchia dell'interfaccia o nell'editor dell'interfaccia e passare alla visualizzazione Assistente (assicurarsi di avere selezionato il .h controllo della finestra per la modifica):

Trascinare il controllo dal controllo AppKit al .h file give per iniziare a creare un outlet o un'azione:

Selezionare il tipo di esposizione da creare e assegnare all'outlet o all'azione un nome:

Per altre informazioni sull'uso di outlet e azioni, vedere la sezione Outlet e azioni della documentazione introduttiva a Xcode e Interface Builder.

Sincronizzazione delle modifiche con Xcode

Quando si torna a Visual Studio per Mac da Xcode, tutte le modifiche apportate in Xcode verranno sincronizzate automaticamente con il progetto Xamarin.Mac.

Se si seleziona nel SplitViewController.designer.csEsplora soluzioni si sarà in grado di vedere come l'outlet e l'azione sono stati collegati nel codice C#:

Si noti come la definizione nel SplitViewController.designer.cs file:

[Outlet]
AppKit.NSSplitViewItem LeftController { get; set; }

[Outlet]
AppKit.NSSplitViewItem RightController { get; set; }

[Outlet]
AppKit.NSSplitView SplitView { get; set; }

Allinearsi con la definizione nel MainWindow.h file in Xcode:

@interface SplitViewController : NSSplitViewController {
    NSSplitViewItem *_LeftController;
    NSSplitViewItem *_RightController;
    NSSplitView *_SplitView;
}

@property (nonatomic, retain) IBOutlet NSSplitViewItem *LeftController;

@property (nonatomic, retain) IBOutlet NSSplitViewItem *RightController;

@property (nonatomic, retain) IBOutlet NSSplitView *SplitView;

Come si può notare, Visual Studio per Mac rimane in ascolto delle modifiche apportate al .h file e quindi sincronizza automaticamente tali modifiche nel rispettivo .designer.cs file per esporle all'applicazione. È anche possibile notare che SplitViewController.designer.cs è una classe parziale, in modo che Visual Studio per Mac non sia necessario modificare SplitViewController.cs il che sovrascrive le modifiche apportate alla classe.

Normalmente non avrai mai bisogno di aprire te SplitViewController.designer.cs stesso, è stato presentato qui solo a scopo educativo.

Importante

Nella maggior parte dei casi, Visual Studio per Mac visualizzerà automaticamente le modifiche apportate in Xcode e le sincronizza con il progetto Xamarin.Mac. Se la sincronizzazione non viene eseguita automaticamente, tornare a Xcode e quindi di nuovo in Visual Studio per Mac. Questa operazione avvia solitamente un ciclo di sincronizzazione.

Utilizzo dei pulsanti

AppKit offre diversi tipi di pulsante che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Pulsanti delle linee guida sull'interfaccia umana di OS X di Apple.

Se un pulsante è stato esposto tramite un outlet, il codice seguente risponderà alla pressione:

ButtonOutlet.Activated += (sender, e) => {
        FeedbackLabel.StringValue = "Button Outlet Pressed";
};

Per i pulsanti esposti tramite Azioni, verrà creato automaticamente un public partial metodo con il nome scelto in Xcode. Per rispondere all'azione, completare il metodo parziale nella classe su cui è stata definita l'azione. Ad esempio:

partial void ButtonAction (Foundation.NSObject sender) {
    // Do something in response to the Action
    FeedbackLabel.StringValue = "Button Action Pressed";
}

Per i pulsanti con stato (ad esempio Attivato e Disattivato), lo stato può essere controllato o impostato con la State proprietà sull'enumerazione NSCellStateValue . Ad esempio:

DisclosureButton.Activated += (sender, e) => {
    LorumIpsum.Hidden = (DisclosureButton.State == NSCellStateValue.On);
};

Dove NSCellStateValue può essere:

• On : il pulsante viene premuto o il controllo è selezionato ,ad esempio un controllo in una casella di controllo.
• Disattivato : il pulsante non viene premuto o il controllo non è selezionato.
• Misto : combinazione di stati On e Off .

Contrassegnare un pulsante come predefinito e impostare l'equivalente della chiave

Per qualsiasi pulsante aggiunto a una progettazione dell'interfaccia utente, è possibile contrassegnare tale pulsante come pulsante predefinito che verrà attivato quando l'utente preme il tasto Invio/Invio sulla tastiera. In macOS questo pulsante riceverà un colore di sfondo blu per impostazione predefinita.

Per impostare un pulsante come predefinito, selezionarlo in Interface Builder di Xcode. Successivamente, in Controllo attributi selezionare il campo Key Equivalent (Equivalente chiave) e premere il tasto Return/Enter :Next, in the Attribute Inspector, select the Key Equivalent field and press the Return/Enter key:

Allo stesso modo, è possibile assegnare qualsiasi sequenza di tasti che può essere usata per attivare il pulsante usando la tastiera anziché il mouse. Ad esempio, premendo i tasti Command-C nell'immagine precedente.

Quando l'app viene eseguita e la finestra con il pulsante è Key e Focus, se l'utente preme Command-C, l'azione per il pulsante verrà attivata (come se l'utente avesse fatto clic sul pulsante).

Utilizzo di caselle di controllo e pulsanti di opzione

AppKit offre diversi tipi di caselle di controllo e gruppi di pulsanti di opzione che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Pulsanti delle linee guida sull'interfaccia umana di OS X di Apple.

Le caselle di controllo e i pulsanti di opzione (esposti tramite outlet) hanno uno stato (ad esempio Attivato e Disattivato), lo stato può essere selezionato o impostato con la State proprietà sull'enumerazione NSCellStateValue . Ad esempio:

AdjustTime.Activated += (sender, e) => {
    FeedbackLabel.StringValue = string.Format("Adjust Time: {0}",AdjustTime.State == NSCellStateValue.On);
};

Dove NSCellStateValue può essere:

• On : il pulsante viene premuto o il controllo è selezionato ,ad esempio un controllo in una casella di controllo.
• Disattivato : il pulsante non viene premuto o il controllo non è selezionato.
• Misto : combinazione di stati On e Off .

Per selezionare un pulsante in un gruppo di pulsanti di opzione, esporre il pulsante di opzione per selezionare come outlet e impostarne la State proprietà. Ad esempio:

partial void SelectCar (Foundation.NSObject sender) {
    TransportationCar.State = NSCellStateValue.On;
    FeedbackLabel.StringValue = "Car Selected";
}

Per ottenere una raccolta di pulsanti di opzione da usare come gruppo e gestire automaticamente lo stato selezionato, creare una nuova azione e allegare ogni pulsante nel gruppo:

Assegnare quindi un valore univoco Tag a ogni pulsante di opzione in Controllo attributi:

Salvare le modifiche e tornare a Visual Studio per Mac, aggiungere il codice per gestire l'azione a cui sono collegati tutti i pulsanti di opzione:

partial void NumberChanged(Foundation.NSObject sender)
{
    var check = sender as NSButton;
    Console.WriteLine("Changed to {0}", check.Tag);
}

È possibile utilizzare la Tag proprietà per visualizzare il pulsante di opzione selezionato.

Utilizzo dei controlli menu

AppKit offre diversi tipi di controlli menu che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Controlli menu delle linee guida sull'interfaccia umana os X di Apple.

Fornire dati di controllo menu

I controlli menu disponibili per macOS possono essere impostati per popolare l'elenco a discesa da un elenco interno (che può essere predefinito in Interface Builder o popolato tramite codice) oppure fornendo un'origine dati personalizzata esterna personalizzata.

Uso dei dati interni

Oltre a definire elementi in Interface Builder, i controlli menu (ad esempio NSComboBox), forniscono un set completo di metodi che consentono di aggiungere, modificare o eliminare gli elementi dall'elenco interno gestiti:

• Add - Aggiunge un nuovo elemento alla fine dell'elenco.
• GetItem : restituisce l'elemento in corrispondenza dell'indice specificato.
• Insert - Inserisce un nuovo elemento nell'elenco nella posizione specificata.
• IndexOf : restituisce l'indice dell'elemento specificato.
• Remove - Rimuove l'elemento specificato dall'elenco.
• RemoveAll - Rimuove tutti gli elementi dall'elenco.
• RemoveAt - Rimuove l'elemento in corrispondenza dell'indice specificato.
• Count : restituisce il numero di elementi nell'elenco.

Importante

Se si usa un'origine dati extern (UsesDataSource = true), la chiamata a uno dei metodi precedenti genererà un'eccezione.

Utilizzo di un'origine dati esterna

Anziché usare i dati interni predefiniti per fornire le righe per il controllo menu, è possibile usare facoltativamente un'origine dati esterna e fornire il proprio archivio di backup per gli elementi, ad esempio un database SQLite.

Per usare un'origine dati esterna, si creerà un'istanza dell'origine dati del controllo menu (NSComboBoxDataSource ad esempio) ed eseguirà l'override di diversi metodi per fornire i dati necessari:

• ItemCount : restituisce il numero di elementi nell'elenco.
• ObjectValueForItem : restituisce il valore dell'elemento per un determinato indice.
• IndexOfItem : restituisce l'indice per il valore dell'elemento.
• CompletedString : restituisce il primo valore dell'elemento corrispondente per il valore dell'elemento parzialmente tipizzato. Questo metodo viene chiamato solo se il completamento automatico è stato abilitato (Completes = true).

Per altri dettagli, vedere la sezione Database e ComboBoxes del documento Utilizzo dei database .

Modifica dell'aspetto dell'elenco

Per regolare l'aspetto del controllo menu sono disponibili i metodi seguenti:

• HasVerticalScroller - Se true, il controllo visualizzerà una barra di scorrimento verticale.
• VisibleItems - Regolare il numero di elementi visualizzati all'apertura del controllo. Il valore predefinito è cinque (5).
• IntercellSpacing - Regolare la quantità di spazio intorno a un determinato elemento specificando un NSSize oggetto in cui Width specifica i margini sinistro e destro e Height specifica lo spazio prima e dopo un elemento.
• ItemHeight - Specifica l'altezza di ogni elemento nell'elenco.

Per i tipi a discesa di , la prima voce di NSPopupButtonsmenu fornisce il titolo per il controllo. Ad esempio:

Per modificare il titolo, esporre questo elemento come outlet e usare codice simile al seguente:

DropDownSelected.Title = "Item 1";

Modifica degli elementi selezionati

I metodi e le proprietà seguenti consentono di modificare le voci selezionate nell'elenco di Controllo menu:

• SelectItem - Seleziona l'elemento in corrispondenza dell'indice specificato.
• Select - Selezionare il valore dell'elemento specificato.
• DeselectItem - Deseleziona l'elemento in corrispondenza dell'indice specificato.
• SelectedIndex : restituisce l'indice dell'elemento attualmente selezionato.
• SelectedValue : restituisce il valore dell'elemento attualmente selezionato.

ScrollItemAtIndexToTop Utilizzare per presentare l'elemento in corrispondenza dell'indice specificato all'inizio dell'elenco e ScrollItemAtIndexToVisible per scorrere fino a quando l'elemento in corrispondenza dell'indice specificato non è visibile.

Risposta agli eventi

I controlli menu forniscono gli eventi seguenti per rispondere all'interazione dell'utente:

• SelectionChanged - Viene chiamato quando l'utente ha selezionato un valore dall'elenco.
• SelectionIsChanging - Viene chiamato prima che il nuovo elemento selezionato dall'utente diventi la selezione attiva.
• WillPopup - Viene chiamato prima della visualizzazione dell'elenco a discesa di elementi.
• WillDismiss - Viene chiamato prima della chiusura dell'elenco a discesa di elementi.

Per NSComboBox i controlli, includono tutti gli stessi eventi NSTextFielddi , ad esempio l'evento Changed chiamato ogni volta che l'utente modifica il valore del testo nella casella combinata.

Facoltativamente, è possibile rispondere alle voci di menu dati interne definite in Interface Builder associando l'elemento a un'azione e usando codice simile al seguente per rispondere all'attivazione dell'azione da parte dell'utente:

partial void ItemOne (Foundation.NSObject sender) {
    DropDownSelected.Title = "Item 1";
    FeedbackLabel.StringValue = "Item One Selected";
}

Per altre informazioni sull'uso dei menu e dei controlli menu, vedere la documentazione menu e pulsanti popup e elenchi a discesa .

Utilizzo dei controlli di selezione

AppKit offre diversi tipi di controlli di selezione che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Controlli di selezione delle linee guida sull'interfaccia umana os X di Apple.

Esistono due modi per tenere traccia quando un controllo di selezione ha interazione utente, esponendolo come azione. Ad esempio:

partial void SegmentButtonPressed (Foundation.NSObject sender) {
    FeedbackLabel.StringValue = string.Format("Button {0} Pressed",SegmentButtons.SelectedSegment);
}

Oppure collegando un delegato all'evento Activated . Ad esempio:

TickedSlider.Activated += (sender, e) => {
    FeedbackLabel.StringValue = string.Format("Stepper Value: {0:###}",TickedSlider.IntValue);
};

Per impostare o leggere il valore di un controllo di selezione, utilizzare la IntValue proprietà . Ad esempio:

FeedbackLabel.StringValue = string.Format("Stepper Value: {0:###}",TickedSlider.IntValue);

I controlli speciali (ad esempio Color Well e Image Well) hanno proprietà specifiche per i relativi tipi di valore. Ad esempio:

ColorWell.Color = NSColor.Red;
ImageWell.Image = NSImage.ImageNamed ("tag.png");

Ha NSDatePicker le proprietà seguenti per lavorare direttamente con Data e ora:

• DateValue: valore di data e ora corrente come .NSDate
• Locale: posizione dell'utente come .NSLocal
• TimeInterval: valore dell'ora come .Double
• Fuso orario: fuso orario dell'utente come .NSTimeZone

Uso dei controlli indicatore

AppKit offre diversi tipi di controlli indicatore che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Controlli indicatore delle linee guida sull'interfaccia umana os X di Apple.

Esistono due modi per tenere traccia quando un controllo indicatore ha interazione utente, esponendolo come azione o outlet e collegando un delegato all'eventoActivated. Ad esempio:

LevelIndicator.Activated += (sender, e) => {
    FeedbackLabel.StringValue = string.Format("Level: {0:###}",LevelIndicator.DoubleValue);
};

Per leggere o impostare il valore del controllo indicatore, utilizzare la DoubleValue proprietà . Ad esempio:

FeedbackLabel.StringValue = string.Format("Rating: {0:###}",Rating.DoubleValue);

Gli indicatori di stato indeterminato e asincroni devono essere animati quando vengono visualizzati. Usare il StartAnimation metodo per avviare l'animazione quando vengono visualizzate. Ad esempio:

Indeterminate.StartAnimation (this);
AsyncProgress.StartAnimation (this);

La chiamata al StopAnimation metodo interromperà l'animazione.

Utilizzo dei controlli di testo

AppKit offre diversi tipi di controlli di testo che possono essere usati nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Controlli di testo delle linee guida sull'interfaccia umana di OS X di Apple.

Per i campi di testo (NSTextField), è possibile usare gli eventi seguenti per tenere traccia dell'interazione dell'utente:

• Modifica: viene generato ogni volta che l'utente modifica il valore del campo. Ad esempio, in ogni carattere tipizzato.
• ModificaBegan : viene attivato quando l'utente seleziona il campo per la modifica.
• EditingEnded : quando l'utente preme il tasto INVIO nel campo o lascia il campo.

Utilizzare la StringValue proprietà per leggere o impostare il valore del campo. Ad esempio:

FeedbackLabel.StringValue = string.Format("User ID: {0}",UserField.StringValue);

Per i campi che visualizzano o modificano valori numerici, è possibile utilizzare la IntValue proprietà . Ad esempio:

FeedbackLabel.StringValue = string.Format("Number: {0}",NumberField.IntValue);

Un NSTextView oggetto fornisce un'area di modifica e visualizzazione completa del testo con formattazione predefinita. NSTextFieldAnalogamente a , usare la StringValue proprietà per leggere o impostare il valore dell'area.

Per un esempio complesso di utilizzo delle visualizzazioni di testo in un'app Xamarin.Mac, vedere l'app di esempio SourceWriter. SourceWriter è un editor di codice sorgente semplice che offre supporto per il completamento del codice e informazioni sulla sintassi.

Il codice SourceWriter include tutti i commenti e, dove possibile, sono stati indicati i collegamenti delle tecnologie e dei metodi principali alle informazioni corrispondenti nelle guide di Xamarin.Mac.

Utilizzo delle visualizzazioni contenuto

AppKit offre diversi tipi di visualizzazioni contenuto che possono essere usate nella progettazione dell'interfaccia utente. Per altre informazioni, vedere la sezione Visualizzazioni contenuto delle linee guida sull'interfaccia umana di OS X di Apple.

Popover

Un popover è un elemento dell'interfaccia utente temporaneo che fornisce funzionalità direttamente correlate a un controllo specifico o a un'area sullo schermo. Un popover galleggia sopra la finestra che contiene il controllo o l'area a cui è correlato e il bordo include una freccia per indicare il punto da cui è emerso.

Per creare un popover, eseguire le operazioni seguenti:

1. Aprire il .storyboard file della finestra a cui si vuole aggiungere un popover facendo doppio clic su di esso nel Esplora soluzioni

2. Trascinare un controller di visualizzazione da Controllo libreria nell'editor dell'interfaccia:

   

3. Definire le dimensioni e il layout della visualizzazione personalizzata:

   

4. Fare clic sul controllo e trascinare dall'origine del popup nel controller di visualizzazione:

   

5. Selezionare Popover dal menu popup:

   

6. Salvare le modifiche e tornare a Visual Studio per Mac per la sincronizzazione con Xcode.

Visualizzazioni schede

Le visualizzazioni tabulazioni sono costituite da un elenco di schede (simile a un controllo segmentato) combinato con un set di visualizzazioni denominate Riquadri. Quando l'utente seleziona una nuova scheda, verrà visualizzato il riquadro associato. Ogni riquadro contiene un proprio set di controlli.

Quando si usa una visualizzazione struttura a schede in Interface Builder di Xcode, usare Controllo attributi per impostare il numero di schede:

Selezionare ogni scheda nella gerarchia dell'interfaccia per impostare il titoloe aggiungere elementi dell'interfaccia utente al relativo riquadro:

Controlli AppKit di data binding

Usando le tecniche di codifica chiave-valore e data binding nell'applicazione Xamarin.Mac, è possibile ridurre notevolmente la quantità di codice che è necessario scrivere e gestire per popolare e usare gli elementi dell'interfaccia utente. È anche possibile separare ulteriormente i dati di backup (Modello di dati) dall'interfaccia utente front-end (Model-View-Controller), semplificando la gestione e la progettazione di applicazioni più flessibili.

Key-Value Coding (KVC) è un meccanismo per accedere indirettamente alle proprietà di un oggetto, usando chiavi (stringhe formattate appositamente) per identificare le proprietà anziché accedervi tramite variabili di istanza o metodi di accesso (get/set). Implementando funzioni di accesso conformi a Key-Value Coding nell'applicazione Xamarin.Mac, è possibile accedere ad altre funzionalità macOS, ad esempio Key-Value Observing (KVO), Data Binding, Core Data, Binding Cocoa e scriptability.

Per altre informazioni, vedere la sezione Associazione dati semplice della documentazione sul data binding e sulla codifica chiave-valore.

Riepilogo

Questo articolo ha esaminato in dettaglio l'uso dei controlli AppKit standard, ad esempio pulsanti, etichette, campi di testo, caselle di controllo e controlli segmentati in un'applicazione Xamarin.Mac. Sono stati illustrati come aggiungerli a una progettazione dell'interfaccia utente in Interface Builder di Xcode, esponendoli al codice tramite outlet e azioni e usando i controlli AppKit nel codice C#.

Collegamenti correlati

• MacControls (esempio)
• Hello, Mac
• Windows
• Data binding e codifica di chiave-valore
• Linee guida dell'interfaccia umana OS X
• Informazioni su controlli e visualizzazioni