Contrôles standard dans Xamarin.Mac

Cet article traite de l’utilisation des contrôles AppKit standard tels que les boutons, les étiquettes, les champs de texte, les zones case activée et les contrôles segmentés dans une application Xamarin.Mac. Il décrit leur ajout à une interface avec Interface Builder et l’interaction avec eux dans le code.

Lorsque vous travaillez avec C# et .NET dans une application Xamarin.Mac, vous avez accès aux mêmes contrôles AppKit que les développeurs travaillant dans Objective-C et Xcode . Étant donné que Xamarin.Mac s’intègre directement à Xcode, vous pouvez utiliser le Générateur d’interface de Xcode pour créer et gérer vos contrôles Appkit (ou éventuellement les créer directement dans le code C#).

Les contrôles AppKit sont les éléments d’interface utilisateur utilisés pour créer l’interface utilisateur de votre application Xamarin.Mac. Ils se composent d’éléments tels que boutons, étiquettes, champs de texte, cases à cocher et contrôles segmentés, et provoquent des actions instantanées ou des résultats visibles lorsqu’un utilisateur les manipule.

Dans cet article, nous allons aborder les principes fondamentaux de l’utilisation des contrôles AppKit dans une application Xamarin.Mac. Il est fortement suggéré que vous travaillez tout d’abord dans l’article Hello, Mac , en particulier les sections Introduction to Xcode and Interface Builder et Outlets and Actions , car elle couvre les concepts et techniques clés que nous utiliserons dans cet article.

Vous pouvez également examiner les classes /méthodes C# exposantes dansObjective-Cla section du document interne Xamarin.Mac, ainsi que les RegisterExport instructions utilisées pour connecter vos classes C# à des objets et des Objective-C éléments d’interface utilisateur.

Présentation des contrôles et des vues

macOS (anciennement Mac OS X) fournit un ensemble standard de contrôles d’interface utilisateur via AppKit Framework. Ils se composent d’éléments tels que boutons, étiquettes, champs de texte, cases à cocher et contrôles segmentés, et provoquent des actions instantanées ou des résultats visibles lorsqu’un utilisateur les manipule.

Tous les contrôles AppKit ont une apparence intégrée standard qui sera appropriée pour la plupart des utilisations, certains spécifient une autre apparence à utiliser dans une zone frame de fenêtre ou dans un contexte d’effet Vibrance, comme dans une zone de barre latérale ou dans un widget du Centre de notification.

Apple suggère les instructions suivantes lors de l’utilisation des contrôles AppKit :

• Évitez de mélanger les tailles de contrôle dans la même vue.
• En général, évitez de redimensionner les contrôles verticalement.
• Utilisez la police système et la taille de texte appropriée dans un contrôle.
• Utilisez l’espacement approprié entre les contrôles.

Pour plus d’informations, consultez la section About Controls and Views (À propos des contrôles et vues) des instructions relatives à l’interface humaine OS X d’Apple.

Utilisation de contrôles dans un cadre de fenêtre

Il existe un sous-ensemble de contrôles AppKit qui incluent un style d’affichage qui leur permet d’être inclus dans la zone Frame d’une fenêtre. Pour obtenir un exemple, consultez la barre d’outils de l’application courrier :

• Bouton texturé rond - A NSButton avec un style de NSTexturedRoundedBezelStyle.
• Contrôle segmenté arrondi texturé - A NSSegmentedControl avec un style de NSSegmentStyleTexturedRounded.
• Contrôle segmenté arrondi texturé - A NSSegmentedControl avec un style de NSSegmentStyleSeparated.
• Menu contextuel arrondi - A NSPopUpButton avec un style de NSTexturedRoundedBezelStyle.
• Menu déroulant arrondi - A NSPopUpButton avec un style de NSTexturedRoundedBezelStyle.
• Barre de recherche - A NSSearchField.

Apple suggère les instructions suivantes lors de l’utilisation des contrôles AppKit dans un cadre de fenêtre :

• N’utilisez pas de styles de contrôle spécifiques au cadre de fenêtre dans le corps de la fenêtre.
• N’utilisez pas de contrôles ou de styles corps de fenêtre dans le cadre de la fenêtre.

Pour plus d’informations, consultez la section About Controls and Views (À propos des contrôles et vues) des instructions relatives à l’interface humaine OS X d’Apple.

Création d’une interface utilisateur dans le Générateur d’interface

Lorsque vous créez une application Xamarin.Mac Cocoa, vous obtenez une fenêtre vide standard par défaut. Cette fenêtre est définie dans un .storyboard fichier automatiquement inclus dans le projet. Pour modifier votre conception windows, dans le Explorateur de solutions, double-cliquez sur le Main.storyboard fichier :

Cela ouvre la conception de fenêtre dans le Générateur d’interface de Xcode :

Pour créer votre interface utilisateur, vous allez faire glisser des éléments d’interface utilisateur (contrôles AppKit) de l’inspecteur de bibliothèque vers l’éditeur d’interface dans le Générateur d’interface. Dans l’exemple ci-dessous, un contrôle De fractionnement vertical a été médicamenté à partir de l’inspecteur de bibliothèque et placé sur la fenêtre dans l’éditeur d’interface :

Pour plus d’informations sur la création d’une interface utilisateur dans interface Builder, consultez notre documentation Introduction à Xcode et Interface Builder .

Dimensionnement et positionnement

Une fois qu’un contrôle a été inclus dans l’interface utilisateur, utilisez l’éditeur de contrainte pour définir son emplacement et sa taille en entrant manuellement des valeurs et en contrôlant la position et la taille du contrôle lorsque la fenêtre ou la vue parente est redimensionnée :

Utilisez les rayons I rouges autour de l’extérieur de la boîte de redimensionnement automatique pour coller un contrôle à un emplacement donné (x,y). Par exemple :

Spécifie que le contrôle sélectionné (dans l’éditeur d’interface et d’affichage de hiérarchie) est bloqué dans l’emplacement supérieur et droit de la fenêtre ou de la vue, car il est redimensionné ou déplacé.

Autres éléments des propriétés de contrôle de l’éditeur, telles que Height et Width :

Vous pouvez également contrôler l’alignement des éléments avec des contraintes à l’aide de l’Éditeur d’alignement :

Important

Contrairement à iOS où (0,0) est le coin supérieur gauche de l’écran, dans macOS (0,0) est le coin inférieur gauche. Cela est dû au fait que macOS utilise un système de coordonnées mathématiques avec les valeurs numériques qui augmentent en valeur vers le haut et à droite. Vous devez tenir compte de cela lors du placement de contrôles AppKit sur une interface utilisateur.

Définition d’une classe personnalisée

Il existe des moments où vous utilisez des contrôles AppKit que vous devez sous-classe et un contrôle existant et créer votre propre version personnalisée de cette classe. Par exemple, définition d’une version personnalisée de la liste source :

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
    }
}

Où l’instruction [Register("SourceListView")] expose la SourceListView classe pour Objective-C qu’elle puisse être utilisée dans Le Générateur d’interface. Pour plus d’informations, consultez les classes /méthodes Exposing C# dansObjective-Cla section du document interne Xamarin.Mac, elle explique les Register commandes utilisées Export pour connecter vos classes C# à des objets et des Objective-C éléments d’interface utilisateur.

Avec le code ci-dessus en place, vous pouvez faire glisser un contrôle AppKit, du type de base que vous étendez, sur l’aire de conception (dans l’exemple ci-dessous, une liste de sources), basculer vers l’inspecteur d’identité et définir la classe personnalisée sur le nom que vous avez exposé (Objective-CexempleSourceListView) :

Exposition de points de sortie et d’actions

Avant qu’un contrôle AppKit soit accessible dans le code C#, il doit être exposé sous la forme d’une sortie ou d’une action. Pour ce faire, sélectionnez le contrôle donné dans la hiérarchie d’interface ou l’éditeurd’interface et basculez vers l’affichage Assistant (vérifiez que vous disposez de la .h fenêtre sélectionnée pour modification) :

Faites glisser le contrôle à partir du contrôle AppKit sur le fichier donner .h pour commencer à créer une sortie ou une action :

Sélectionnez le type d’exposition à créer et attribuez à la sortie ou à l’action un nom :

Pour plus d’informations sur l’utilisation des points de vente et des actions, consultez la section Points de vente et actions de notre documentation Introduction à Xcode et Interface Builder .

Synchronisation des modifications avec Xcode

Lorsque vous revenez à Visual Studio pour Mac de Xcode, toutes les modifications apportées dans Xcode seront automatiquement synchronisées avec votre projet Xamarin.Mac.

Si vous sélectionnez le SplitViewController.designer.csExplorateur de solutions vous pourrez voir comment votre sortie et votre action ont été câblées dans notre code C# :

Notez comment la définition dans le SplitViewController.designer.cs fichier :

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

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

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

Inscrivez-vous avec la définition dans le MainWindow.h fichier dans 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;

Comme vous pouvez le voir, Visual Studio pour Mac écoute les modifications apportées au .h fichier, puis synchronise automatiquement ces modifications dans le fichier respectif .designer.cs pour les exposer à votre application. Vous pouvez également remarquer qu’il SplitViewController.designer.cs s’agit d’une classe partielle, afin que Visual Studio pour Mac n’ait pas à modifier SplitViewController.cs ce qui remplacerait les modifications que nous avons apportées à la classe.

Normalement, vous n’aurez jamais besoin de vous ouvrir vous-même SplitViewController.designer.cs , il a été présenté ici uniquement à des fins éducatives.

Important

Dans la plupart des cas, Visual Studio pour Mac verra automatiquement les modifications apportées dans Xcode et les synchronisera avec votre projet Xamarin.Mac. Dans le cas isolé où la synchronisation ne se produit pas automatiquement, revenez à Xcode, puis à nouveau à Visual Studio pour Mac. Cela déclenche normalement un cycle de synchronisation.

Utilisation des boutons

AppKit fournit plusieurs types de boutons qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Boutons des instructions relatives à l’interface humaine OS X d’Apple.

Si un bouton a été exposé via une sortie, le code suivant répond à celui-ci en cas d’appui :

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

Pour les boutons qui ont été exposés via Actions, une public partial méthode est automatiquement créée pour vous avec le nom que vous avez choisi dans Xcode. Pour répondre à l’action, terminez la méthode partielle dans la classe sur laquelle l’action a été définie. Par exemple :

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

Pour les boutons dont l’état est activé et désactivé, l’état peut être case activée ou défini avec la State propriété par rapport à l’énumérationNSCellStateValue. Par exemple :

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

Où NSCellStateValue peut être :

• Activé : le bouton est enfoncé ou le contrôle est sélectionné (par exemple, un case activée dans une case à cocher).
• Désactivé : le bouton n’est pas poussé ou le contrôle n’est pas sélectionné.
• Mixte - Mélange d’états On et Off .

Marquer un bouton comme équivalent par défaut et définir la clé équivalente

Pour tout bouton que vous avez ajouté à une conception d’interface utilisateur, vous pouvez marquer ce bouton comme bouton par défaut qui sera activé lorsque l’utilisateur appuie sur la touche Retour/Entrée sur le clavier. Dans macOS, ce bouton reçoit une couleur d’arrière-plan bleue par défaut.

Pour définir un bouton comme valeur par défaut, sélectionnez-le dans le Générateur d’interface de Xcode. Ensuite, dans l’inspecteur d’attribut, sélectionnez le champ Key Equivalent et appuyez sur la touche Retour/Entrée :

De même, vous pouvez affecter n’importe quelle séquence de touches qui peut être utilisée pour activer le bouton à l’aide du clavier au lieu de la souris. Par exemple, en appuyant sur les touches Command-C dans l’image ci-dessus.

Lorsque l’application est exécutée et que la fenêtre avec le bouton est Touche et Focus, si l’utilisateur appuie sur Command-C, l’action du bouton est activée (comme si l’utilisateur avait cliqué sur le bouton).

Utilisation des cases à cocher et des cases d’option

AppKit fournit plusieurs types de cases à cocher et de groupes de cases d’option qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Boutons des instructions relatives à l’interface humaine OS X d’Apple.

Les cases à cocher et les cases d’option (exposées via des points de vente) ont un état (comme Activé et Désactivé), l’état peut être case activée ou défini avec la propriété par rapport à l’énumération StateNSCellStateValue. Par exemple :

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

Où NSCellStateValue peut être :

• Activé : le bouton est enfoncé ou le contrôle est sélectionné (par exemple, un case activée dans une case à cocher).
• Désactivé : le bouton n’est pas poussé ou le contrôle n’est pas sélectionné.
• Mixte - Mélange d’états On et Off .

Pour sélectionner un bouton dans un groupe de cases d’option, exposez la case d’option à sélectionner en tant que sortie et définissez sa State propriété. Par exemple :

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

Pour obtenir une collection de cases d’option pour agir en tant que groupe et gérer automatiquement l’état sélectionné, créez une action et attachez chaque bouton du groupe à celui-ci :

Ensuite, affectez une option unique Tag à chaque case d’option dans l’inspecteur d’attribut :

Enregistrez vos modifications et revenez à Visual Studio pour Mac, ajoutez le code pour gérer l’action à laquelle toutes les cases d’option sont attachées :

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

Vous pouvez utiliser la Tag propriété pour voir quelle case d’option a été sélectionnée.

Utilisation des contrôles de menu

AppKit fournit plusieurs types de contrôles de menu qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Contrôles de menu des instructions relatives à l’interface humaine OS X d’Apple.

Fournir des données de contrôle de menu

Les contrôles de menu disponibles pour macOS peuvent être définis pour remplir la liste déroulante à partir d’une liste interne (qui peut être prédéfinie dans le Générateur d’interface ou renseignée via du code) ou en fournissant votre propre source de données externe personnalisée.

Utilisation des données internes

Outre la définition d’éléments dans le Générateur d’interface, les contrôles de menu (par exemple NSComboBox), fournissent un ensemble complet de méthodes qui vous permettent d’ajouter, de modifier ou de supprimer les éléments de la liste interne qu’ils gèrent :

• Add - Ajoute un nouvel élément à la fin de la liste.
• GetItem - Retourne l’élément à l’index donné.
• Insert - Insère un nouvel élément dans la liste à l’emplacement donné.
• IndexOf - Retourne l’index de l’élément donné.
• Remove - Supprime l’élément donné de la liste.
• RemoveAll - Supprime tous les éléments de la liste.
• RemoveAt - Supprime l’élément à l’index donné.
• Count - Retourne le nombre d’éléments de la liste.

Important

Si vous utilisez une source de données Extern (UsesDataSource = true), l’appel de l’une des méthodes ci-dessus lève une exception.

Utilisation d’une source de données externe

Au lieu d’utiliser les données internes intégrées pour fournir les lignes de votre contrôle de menu, vous pouvez éventuellement utiliser une source de données externe et fournir votre propre magasin de stockage pour les éléments (par exemple, une base de données SQLite).

Pour utiliser une source de données externe, vous allez créer une instance de la source de données du contrôle de menu (NSComboBoxDataSource par exemple) et remplacer plusieurs méthodes pour fournir les données nécessaires :

• ItemCount - Retourne le nombre d’éléments de la liste.
• ObjectValueForItem - Retourne la valeur de l’élément pour un index donné.
• IndexOfItem - Retourne l’index de la valeur d’élément donné.
• CompletedString - Retourne la première valeur d’élément correspondant pour la valeur d’élément partiellement typée. Cette méthode est appelée uniquement si la saisie semi-automatique a été activée (Completes = true).

Pour plus d’informations, consultez la section Bases de données et ComboBoxes du document Working with Databases .

Ajustement de l’apparence de la liste

Les méthodes suivantes sont disponibles pour ajuster l’apparence du contrôle de menu :

• HasVerticalScroller - Si true, le contrôle affiche une barre de défilement verticale.
• VisibleItems - Ajustez le nombre d’éléments affichés lorsque le contrôle est ouvert. La valeur par défaut est cinq (5).
• IntercellSpacing - Ajustez la quantité d’espace autour d’un élément donné en fournissant un NSSize emplacement où les Width marges gauche et droite sont spécifiées et l’espace Height avant et après un élément.
• ItemHeight - Spécifie la hauteur de chaque élément de la liste.

Pour les types déroulants de , le premier élément de NSPopupButtonsmenu fournit le titre du contrôle. Par exemple :

Pour modifier le titre, exposez cet élément en tant que point de sortie et utilisez du code comme suit :

DropDownSelected.Title = "Item 1";

Manipulation des éléments sélectionnés

Les méthodes et propriétés suivantes vous permettent de manipuler les éléments sélectionnés dans la liste du contrôle de menu :

• SelectItem - Sélectionne l’élément à l’index donné.
• Select - Sélectionnez la valeur d’élément donnée.
• DeselectItem - Désélectionne l’élément à l’index donné.
• SelectedIndex - Retourne l’index de l’élément actuellement sélectionné.
• SelectedValue - Retourne la valeur de l’élément actuellement sélectionné.

Utilisez l’élément ScrollItemAtIndexToTop pour présenter l’élément à l’index donné en haut de la liste et pour ScrollItemAtIndexToVisible faire défiler la liste jusqu’à ce que l’élément à l’index donné soit visible.

Réponse aux événements

Les contrôles de menu fournissent les événements suivants pour répondre à l’interaction utilisateur :

• SelectionChanged - Est appelé lorsque l’utilisateur a sélectionné une valeur dans la liste.
• SelectionIsChanging - Est appelé avant que le nouvel élément sélectionné par l’utilisateur devienne la sélection active.
• WillPopup - Est appelé avant l’affichage de la liste déroulante des éléments.
• WillDismiss - Est appelé avant la fermeture de la liste déroulante des éléments.

Pour NSComboBox les contrôles, ils incluent tous les mêmes événements que l’événement NSTextField, tel que l’événement Changed appelé chaque fois que l’utilisateur modifie la valeur du texte dans la zone de liste déroulante.

Si vous le souhaitez, vous pouvez répondre aux éléments de menu de données internes définis dans le Générateur d’interface sélectionnés en attachant l’élément à une action et en utilisant du code comme suit pour répondre à l’action déclenchée par l’utilisateur :

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

Pour plus d’informations sur l’utilisation des menus et des contrôles de menu, consultez notre documentation menus et menu contextuel et listes déroulantes .

Utilisation des contrôles de sélection

AppKit fournit plusieurs types de contrôles de sélection qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Contrôles de sélection des instructions relatives à l’interface humaine OS X d’Apple.

Il existe deux façons de suivre quand un contrôle de sélection a une interaction utilisateur, en l’exposant en tant qu’action. Par exemple :

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

Ou en attachant un délégué à l’événement Activated . Par exemple :

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

Pour définir ou lire la valeur d’un contrôle Selection, utilisez la IntValue propriété. Par exemple :

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

Les contrôles spécialisés (tels que Color Well et Image Well) ont des propriétés spécifiques pour leurs types valeur. Par exemple :

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

Les NSDatePicker propriétés suivantes permettent d’utiliser directement la date et l’heure :

• DateValue : valeur de date et d’heure actuelle en tant que NSDate.
• Local : emplacement de l’utilisateur en tant que NSLocal.
• TimeInterval - Valeur de temps en tant que Double.
• Fuseau horaire de l’utilisateur en tant que NSTimeZone.

Utilisation des contrôles d’indicateur

AppKit fournit plusieurs types de contrôles d’indicateur qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Contrôles d’indicateur des instructions relatives à l’interface humaine OS X d’Apple.

Il existe deux façons de suivre quand un contrôle d’indicateur a une interaction utilisateur, soit en l’exposant en tant qu’action, soit en attachant un délégué à l’événementActivated. Par exemple :

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

Pour lire ou définir la valeur du contrôle d’indicateur, utilisez la DoubleValue propriété. Par exemple :

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

Les indicateurs de progression indéterminés et asynchrones doivent être animés lorsqu’ils sont affichés. Utilisez la StartAnimation méthode pour démarrer l’animation lorsqu’elles sont affichées. Par exemple :

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

L’appel de la StopAnimation méthode arrête l’animation.

Utilisation des contrôles de texte

AppKit fournit plusieurs types de contrôles de texte qui peuvent être utilisés dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Contrôles de texte des instructions relatives à l’interface humaine OS X d’Apple.

Pour les champs de texte (NSTextField), les événements suivants peuvent être utilisés pour suivre l’interaction utilisateur :

• Modifié : est déclenché chaque fois que l’utilisateur modifie la valeur du champ. Par exemple, sur chaque caractère typé.
• EditingBegan : est déclenché lorsque l’utilisateur sélectionne le champ à modifier.
• EditingEnded : lorsque l’utilisateur appuie sur la touche Entrée dans le champ ou quitte le champ.

Utilisez la StringValue propriété pour lire ou définir la valeur du champ. Par exemple :

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

Pour les champs qui affichent ou modifient des valeurs numériques, vous pouvez utiliser la IntValue propriété. Par exemple :

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

Une NSTextView zone d’affichage et de modification de texte complète offre une mise en forme intégrée. À l’instar d’un NSTextField, utilisez la StringValue propriété pour lire ou définir la valeur de la zone.

Pour obtenir un exemple complexe d’utilisation des vues de texte dans une application Xamarin.Mac, consultez l’exemple d’application SourceWriter. SourceWriter est un éditeur de code source simple qui assure la prise en charge de la complétion de code et de la coloration syntaxique de base.

Le code SourceWriter a été entièrement commenté et, le cas échéant, des liens ont être fournis entre les principales technologies ou méthodes et des informations pertinentes dans la documentation des guides Xamarin.Mac.

Utilisation des vues de contenu

AppKit fournit plusieurs types de vues de contenu qui peuvent être utilisées dans votre conception d’interface utilisateur. Pour plus d’informations, consultez la section Affichages de contenu des instructions relatives à l’interface humaine OS X d’Apple.

Fenêtres contextuelles

Une fenêtre contextuelle est un élément d’interface utilisateur temporaire qui fournit des fonctionnalités directement liées à un contrôle spécifique ou à une zone à l’écran. Une fenêtre contextuelle flotte au-dessus de la fenêtre qui contient le contrôle ou la zone à laquelle il est lié, et sa bordure inclut une flèche pour indiquer le point à partir duquel il a émergé.

Pour créer une fenêtre contextuelle, procédez comme suit :

1. Ouvrez le .storyboard fichier de la fenêtre à laquelle vous souhaitez ajouter une fenêtre contextuelle en double-cliquant dessus dans le Explorateur de solutions

2. Faites glisser un contrôleur de vue de l’inspecteur de bibliothèque vers l’éditeur d’interface :

   

3. Définissez la taille et la disposition de l’affichage personnalisé :

   

4. Cliquez sur le contrôle et faites glisser à partir de la source de la fenêtre contextuelle sur le contrôleur d’affichage :

   

5. Sélectionnez Fenêtre contextuelle dans le menu contextuel :

   

6. Enregistrez vos modifications et revenez à Visual Studio pour Mac à synchroniser avec Xcode.

Affichages d’onglets

Les affichages onglets se composent d’une liste de tabulations (qui ressemble à un contrôle segmenté) combinée à un ensemble de vues appelées Volets. Lorsque l’utilisateur sélectionne un nouvel onglet, le volet attaché à celui-ci s’affiche. Chaque volet contient son propre ensemble de contrôles.

Lorsque vous utilisez un mode Tab dans le Générateur d’interface de Xcode, utilisez l’inspecteur d’attribut pour définir le nombre d’onglets :

Sélectionnez chaque onglet de la hiérarchie d’interface pour définir son titre et ajouter des éléments d’interface utilisateur à son volet :

Contrôles AppKit de liaison de données

En utilisant des techniques de codage clé-valeur et de liaison de données dans votre application Xamarin.Mac, vous pouvez réduire considérablement la quantité de code que vous devez écrire et gérer pour remplir et utiliser des éléments d’interface utilisateur. Vous bénéficiez également d’un découplage supplémentaire de vos données de stockage (modèle de données) de votre interface utilisateur frontale (modèle-vue-contrôleur), ce qui facilite la maintenance et la conception d’applications plus flexibles.

Le codage clé-valeur (KVC) est un mécanisme permettant d’accéder indirectement aux propriétés d’un objet, à l’aide de clés (chaînes spécialement mises en forme) pour identifier les propriétés au lieu de les accéder via des variables d’instance ou des méthodes d’accesseur (get/set). En implémentant des accesseurs conformes au codage clé-valeur dans votre application Xamarin.Mac, vous accédez à d’autres fonctionnalités macOS telles que l’observation de valeur clé (KVO), la liaison de données, les données principales, les liaisons Cocoa et la scriptabilité.

Pour plus d’informations, consultez la section Liaison de données simple de notre documentation sur la liaison de données et le codage clé-valeur.

Résumé

Cet article a examiné en détail l’utilisation des contrôles AppKit standard tels que boutons, étiquettes, champs de texte, cases à cocher et contrôles segmentés dans une application Xamarin.Mac. Il les a ajoutés à une conception d’interface utilisateur dans le Générateur d’interface de Xcode, les exposant au code via des points de sortie et des actions et en travaillant avec les contrôles AppKit dans le code C#.

Liens associés

• MacControls (exemple)
• Hello, Mac
• Windows
• Liaison de données et codage de clé-valeur
• OS X Human Interface Guidelines
• À propos des contrôles et des vues