Standardowe kontrolki na platformie Xamarin.Mac

W tym artykule opisano pracę ze standardowymi kontrolkami AppKit, takimi jak przyciski, etykiety, pola tekstowe, pola wyboru i segmentowane kontrolki w aplikacji platformy Xamarin.Mac. W tym artykule opisano dodawanie ich do interfejsu za pomocą narzędzia Interface Builder i interakcję z nimi w kodzie.

Podczas pracy z językiem C# i platformą .NET w aplikacji platformy Xamarin.Mac masz dostęp do tych samych kontrolek zestawu AppKit, które wykonuje deweloper pracujący w Objective-C środowisku I Xcode . Ponieważ platforma Xamarin.Mac integruje się bezpośrednio z programem Xcode, możesz użyć narzędzia Interface Builder środowiska Xcode, aby utworzyć i obsługiwać kontrolki zestawu appkit (lub opcjonalnie utworzyć je bezpośrednio w kodzie języka C#).

Kontrolki AppKit to elementy interfejsu użytkownika używane do tworzenia interfejsu użytkownika aplikacji platformy Xamarin.Mac. Składają się one z elementów, takich jak Przyciski, Etykiety, Pola tekstowe, Pola wyboru i Kontrolki segmentowane oraz powodują natychmiastowe akcje lub widoczne wyniki podczas manipulowania nimi przez użytkownika.

W tym artykule omówimy podstawy pracy z kontrolkami AppKit w aplikacji platformy Xamarin.Mac. Zdecydowanie zaleca się, aby najpierw zapoznać się z artykułem Hello, Mac , w szczególności wprowadzenie do narzędzi Xcode i Interface Builder i Outlet and Actions , ponieważ obejmuje ona kluczowe pojęcia i techniki, których będziemy używać w tym artykule.

Warto zapoznać się również z sekcją Uwidacznianie klas/ metod Objective-C języka C# w dokumencie Xamarin.Mac Internals . Register Objaśnienie poleceń i Export używanych do podłączania klas języka C# do Objective-C obiektów i elementów interfejsu użytkownika.

Wprowadzenie do kontrolek i widoków

System macOS (wcześniej znany jako Mac OS X) udostępnia standardowy zestaw kontrolek interfejsu użytkownika za pośrednictwem struktury AppKit Framework. Składają się one z elementów, takich jak Przyciski, Etykiety, Pola tekstowe, Pola wyboru i Kontrolki segmentowane oraz powodują natychmiastowe akcje lub widoczne wyniki podczas manipulowania nimi przez użytkownika.

Wszystkie kontrolki Zestawu AppKit mają standardowy, wbudowany wygląd, który będzie odpowiedni dla większości zastosowań, niektóre określają alternatywny wygląd do użycia w obszarze ramki okna lub w kontekście efektu vibrance, na przykład w obszarze Paska bocznego lub w widżecie Centrum powiadomień.

Firma Apple sugeruje następujące wytyczne podczas pracy z kontrolkami AppKit:

• Unikaj mieszania rozmiarów kontrolek w tym samym widoku.
• Ogólnie rzecz biorąc, unikaj zmiany rozmiaru kontrolek w pionie.
• Użyj czcionki systemowej i odpowiedniego rozmiaru tekstu w kontrolce.
• Użyj odpowiedniego odstępu między kontrolkami.

Aby uzyskać więcej informacji, zobacz sekcję About Controls and Views (Informacje o kontrolkach i widokach) w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Używanie kontrolek w ramce okna

Istnieje podzbiór kontrolek AppKit, który zawiera styl wyświetlania, który umożliwia ich uwzględnienie w obszarze Ramka okna. Aby zapoznać się z przykładem, zobacz pasek narzędzi aplikacji Poczta:

• Okrągły przycisk teksturowany — A NSButton ze stylem NSTexturedRoundedBezelStyle.
• Teksturowana zaokrąglona kontrolka segmentowana — A NSSegmentedControl ze stylem NSSegmentStyleTexturedRounded.
• Teksturowana zaokrąglona kontrolka segmentowana — A NSSegmentedControl ze stylem NSSegmentStyleSeparated.
• Menu podręczne z zaokrąglonymi teksturami — A NSPopUpButton ze stylem NSTexturedRoundedBezelStyle.
• Menu rozwijane z zaokrąglonymi teksturami — A NSPopUpButton ze stylem NSTexturedRoundedBezelStyle.
• Pasek wyszukiwania — A NSSearchField.

Firma Apple sugeruje następujące wskazówki dotyczące pracy z kontrolkami AppKit w ramce okna:

• Nie używaj stylów kontrolek specyficznych dla ramki okna w treści okna.
• Nie używaj kontrolek ani stylów treści okna w ramce okna.

Aby uzyskać więcej informacji, zobacz sekcję About Controls and Views (Informacje o kontrolkach i widokach) w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Tworzenie interfejsu użytkownika w narzędziu Interface Builder

Podczas tworzenia nowej aplikacji platformy Xamarin.Mac Cocoa domyślnie zostanie wyświetlone standardowe puste okno. Te okna są definiowane w pliku automatycznie dołączonym .storyboard do projektu. Aby edytować projekt systemu Windows, w Eksplorator rozwiązań kliknij Main.storyboard dwukrotnie plik:

Spowoduje to otwarcie projektu okna w narzędziu Interface Builder programu Xcode:

Aby utworzyć interfejs użytkownika, przeciągnij elementy interfejsu użytkownika (kontrolki AppKit) z inspektora biblioteki do edytora interfejsu w narzędziu Interface Builder. W poniższym przykładzie kontrolka Pionowy widok podziału została uchwycona przez Inspektora biblioteki i umieszczona w oknie w Edytorze interfejsów:

Aby uzyskać więcej informacji na temat tworzenia interfejsu użytkownika w narzędziu Interface Builder, zobacz dokumentację Wprowadzenie do środowiska Xcode i narzędzia Interface Builder .

Ustalanie rozmiaru i pozycjonowanie

Gdy kontrolka została dołączona do interfejsu użytkownika, użyj edytora ograniczeń, aby ustawić jego lokalizację i rozmiar, wprowadzając wartości ręcznie i kontrolując, jak kontrolka jest automatycznie ustawiana i zmieniana rozmiar po zmianie rozmiaru okna nadrzędnego lub widoku:

Użyj czerwonych promieni I wokół zewnątrz pola Autoresizing, aby trzymać kontrolkę do danej lokalizacji (x,y). Na przykład:

Określa, że wybrana kontrolka (w Edytorze widoków hierarchii i interfejsu) zostanie zablokowana w górnej i prawej lokalizacji okna lub widoku w miarę zmiany rozmiaru lub przeniesienia.

Inne elementy właściwości kontrolki edytora, takie jak Height i Width:

Możesz również kontrolować wyrównanie elementów z ograniczeniami przy użyciu Edytora wyrównania:

Ważne

W przeciwieństwie do systemu iOS, gdzie (0,0) jest lewym górnym rogu ekranu, w systemie macOS (0,0) jest lewym dolnym rogu. Dzieje się tak, ponieważ system macOS używa systemu współrzędnych matematycznych z wartościami liczbowymi rosnącymi w górę i po prawej stronie. Należy wziąć to pod uwagę podczas umieszczania kontrolek AppKit w interfejsie użytkownika.

Ustawianie klasy niestandardowej

Podczas pracy z kontrolkami AppKit należy utworzyć własną niestandardową wersję tej klasy i klasę podrzędną oraz istniejącą kontrolkę. Na przykład zdefiniowanie niestandardowej wersji listy źródłowej:

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

[Register("SourceListView")] Gdzie instrukcja uwidacznia klasę Objective-C tak, aby można było jej użyć w narzędziu SourceListView Interface Builder. Aby uzyskać więcej informacji, zobacz sekcję Uwidacznianie klas/ metod Objective-C języka C# w dokumencie Xamarin.Mac Internals , objaśnienie Register poleceń i Export używanych do podłączania klas języka C# do Objective-C obiektów i elementów interfejsu użytkownika.

Po utworzeniu powyższego kodu możesz przeciągnąć kontrolkę AppKit o typie podstawowym, który rozszerzasz, na powierzchni projektowej (w poniższym przykładzie lista źródłowa), przełączyć się na inspektora tożsamości i ustawić klasę niestandardową na nazwę uwidocznioną Objective-C na (przykładSourceListView):

Uwidacznianie placówek i akcji

Aby można było uzyskać dostęp do kontrolki AppKit w kodzie języka C#, należy ją uwidocznić jako ujście lub akcję. Aby to zrobić, wybierz daną kontrolkę w hierarchii interfejsu lub Edytor interfejsu i przejdź do widoku Asystenta (upewnij się, że do .h edycji wybrano okno):

Przeciągnij kontrolkę z kontrolki AppKit do pliku nadaj .h , aby rozpocząć tworzenie elementu Outlet lub Action:

Wybierz typ ekspozycji do utworzenia i nadaj akcji nazwę wylotu lub akcji:

Aby uzyskać więcej informacji na temat pracy z punktami i akcjami, zobacz sekcję Placówki i akcje w naszej dokumentacji Wprowadzenie do programu Xcode i narzędzia Interface Builder.

Synchronizowanie zmian za pomocą programu Xcode

Po powrocie do Visual Studio dla komputerów Mac z programu Xcode wszelkie zmiany wprowadzone w programie Xcode zostaną automatycznie zsynchronizowane z projektem Xamarin.Mac.

Jeśli wybierzesz SplitViewController.designer.cs element w Eksplorator rozwiązań zobaczysz, jak twój punkt wylotowy i akcja zostały połączone w naszym kodzie języka C#:

Zwróć uwagę, jak definicja w SplitViewController.designer.cs pliku:

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

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

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

Utwórz wiersz z definicją w pliku w programie MainWindow.h 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;

Jak widać, Visual Studio dla komputerów Mac nasłuchuje zmian w .h pliku, a następnie automatycznie synchronizuje te zmiany w odpowiednim .designer.cs pliku, aby uwidocznić je w aplikacji. Można również zauważyć, że SplitViewController.designer.cs jest to klasa częściowa, więc Visual Studio dla komputerów Mac nie musi modyfikowaćSplitViewController.cs, co spowoduje zastąpienie wszelkich zmian wprowadzonych w klasie.

Zwykle nigdy nie trzeba otwierać SplitViewController.designer.cs siebie, został przedstawiony tutaj tylko w celach edukacyjnych.

Ważne

W większości sytuacji Visual Studio dla komputerów Mac automatycznie zobaczy wszelkie zmiany wprowadzone w środowisku Xcode i zsynchronizuje je z projektem Xamarin.Mac. W przypadku wystąpienia wyłączenia, które synchronizacja nie jest wykonywana automatycznie, przełącz się z powrotem do środowiska Xcode i wróć do Visual Studio dla komputerów Mac ponownie. Zwykle rozpoczyna się to cykl synchronizacji.

Praca z przyciskami

Zestaw AppKit udostępnia kilka typów przycisków, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Przyciski wytycznych dotyczących interfejsu ludzkiego systemu OS X firmy Apple.

Jeśli przycisk został uwidoczniony za pośrednictwem gniazda, następujący kod odpowie na naciśnięcie przycisku:

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

W przypadku przycisków, które zostały ujawnione za pośrednictwem akcji, public partial zostanie automatycznie utworzona metoda z nazwą wybraną w programie Xcode. Aby odpowiedzieć na akcję, ukończ metodę częściową w klasie, w ramach którego zdefiniowano akcję . Na przykład:

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

W przypadku przycisków, które mają stan (np . Włączone i Wyłączone), stan można sprawdzić lub ustawić za pomocą State właściwości wyliczenia NSCellStateValue . Na przykład:

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

Gdzie NSCellStateValue można:

• Włączone — przycisk jest wypychany lub jest zaznaczona kontrolka (na przykład zaewidencjonowanie pola wyboru).
• Wyłączone — przycisk nie jest wypychany lub kontrolka nie jest zaznaczona.
• Mieszane — mieszanka stanów wł . i wył .

Oznaczanie przycisku jako domyślnego i ustawianie równoważnego klucza

W przypadku każdego przycisku dodanego do projektu interfejsu użytkownika możesz oznaczyć ten przycisk jako przycisk Domyślny , który zostanie aktywowany po naciśnięciu klawisza Return/Enter na klawiaturze. W systemie macOS ten przycisk domyślnie otrzyma niebieski kolor tła.

Aby ustawić przycisk jako domyślny, wybierz go w narzędziu Interface Builder programu Xcode. Następnie w Inspektorze atrybutów wybierz pole Odpowiednik klucza i naciśnij klawisz Return/Enter:

Podobnie można przypisać dowolną sekwencję klawiszy, która może służyć do aktywowania przycisku za pomocą klawiatury zamiast myszy. Na przykład przez naciśnięcie klawiszy Command-C na powyższej ilustracji.

Gdy aplikacja zostanie uruchomiona, a okno z przyciskiem to Klawisz i Fokus, jeśli użytkownik naciśnie polecenie C, akcja przycisku zostanie aktywowana (tak jakby użytkownik kliknął przycisk).

Praca z polami wyboru i przyciskami radiowymi

Zestaw AppKit udostępnia kilka typów pól wyboru i grup przycisków radiowych, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Przyciski wytycznych dotyczących interfejsu ludzkiego systemu OS X firmy Apple.

Pola wyboru i przyciski radiowe (uwidocznione za pośrednictwem placówek) mają stan (na przykład włączone i wyłączone), stan można zaznaczyć lub ustawić z właściwością StateNSCellStateValue względem wyliczenia. Na przykład:

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

Gdzie NSCellStateValue można:

• Włączone — przycisk jest wypychany lub jest zaznaczona kontrolka (na przykład zaewidencjonowanie pola wyboru).
• Wyłączone — przycisk nie jest wypychany lub kontrolka nie jest zaznaczona.
• Mieszane — mieszanka stanów wł . i wył .

Aby wybrać przycisk w grupie przycisków radiowych, uwidocznij przycisk radiowy, aby wybrać jako gniazdo i ustawić jego State właściwość. Na przykład:

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

Aby uzyskać kolekcję przycisków radiowych, które będą działać jako grupa i automatycznie obsłużyć wybrany stan, utwórz nową akcję i dołącz do niej każdy przycisk w grupie:

Następnie przypisz unikatowy Tag przycisk radiowy do każdego przycisku radiowego w Inspektorze atrybutów:

Zapisz zmiany i wróć do Visual Studio dla komputerów Mac, dodaj kod, aby obsłużyć akcję dołączoną do wszystkich przycisków radiowych:

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

Możesz użyć Tag właściwości , aby zobaczyć, który przycisk radiowy został wybrany.

Praca z kontrolkami menu

Zestaw AppKit udostępnia kilka typów kontrolek menu, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Kontrolki menu w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Udostępnianie danych kontrolki menu

Kontrolki menu dostępne dla systemu macOS można ustawić tak, aby wypełnić listę rozwijaną z listy wewnętrznej (którą można wstępnie zdefiniować w narzędziu Interface Builder lub wypełnić za pomocą kodu) lub podając własne niestandardowe, zewnętrzne źródło danych.

Praca z danymi wewnętrznymi

Oprócz definiowania elementów w narzędziu Interface Builder, kontrolki menu (takie jak NSComboBox), udostępniają pełny zestaw metod, które umożliwiają dodawanie, edytowanie lub usuwanie elementów z listy wewnętrznej, którą utrzymują:

• Add — Dodaje nowy element na końcu listy.
• GetItem — Zwraca element w danym indeksie.
• Insert — Wstawia nowy element na liście w danej lokalizacji.
• IndexOf — Zwraca indeks danego elementu.
• Remove — Usuwa dany element z listy.
• RemoveAll — Usuwa wszystkie elementy z listy.
• RemoveAt — Usuwa element w danym indeksie.
• Count — Zwraca liczbę elementów na liście.

Ważne

Jeśli używasz źródła danych Extern (UsesDataSource = true), wywołanie dowolnej z powyższych metod spowoduje zgłoszenie wyjątku.

Praca z zewnętrznym źródłem danych

Zamiast używać wbudowanych danych wewnętrznych do udostępniania wierszy dla kontrolki menu, możesz opcjonalnie użyć zewnętrznego źródła danych i udostępnić własny magazyn zapasowy dla elementów (takich jak baza danych SQLite).

Aby pracować z zewnętrznym źródłem danych, utworzysz wystąpienie źródła danych kontrolki menu (NSComboBoxDataSource na przykład) i zastąpisz kilka metod, aby zapewnić niezbędne dane:

• ItemCount — Zwraca liczbę elementów na liście.
• ObjectValueForItem — Zwraca wartość elementu dla danego indeksu.
• IndexOfItem — Zwraca indeks dla wartości elementu nadaj.
• CompletedString — Zwraca pierwszą zgodną wartość elementu dla częściowo wpisanej wartości elementu. Ta metoda jest wywoływana tylko wtedy, gdy funkcja autouzupełniania została włączona (Completes = true).

Aby uzyskać więcej informacji, zobacz sekcję Bazy danych i pola kombi w dokumencie Praca z bazami danych .

Dostosowywanie wyglądu listy

Dostępne są następujące metody dostosowywania wyglądu kontrolki menu:

• HasVerticalScroller - Jeśli truekontrolka wyświetli pionowy pasek przewijania.
• VisibleItems - Dostosuj liczbę elementów wyświetlanych po otwarciu kontrolki. Wartość domyślna to pięć (5).
• IntercellSpacing - Dostosuj ilość miejsca wokół danego elementu, podając NSSize miejsce, w którym Width określa lewe i prawe marginesy oraz Height określa spację przed i po elemencie.
• ItemHeight - Określa wysokość każdego elementu na liście.

W przypadku typów list rozwijanych w elemencie NSPopupButtonspierwszy element menu zawiera tytuł kontrolki. Na przykład:

Aby zmienić tytuł, uwidocznij ten element jako punkt wyjścia i użyj kodu podobnego do następującego:

DropDownSelected.Title = "Item 1";

Manipulowanie wybranymi elementami

Następujące metody i właściwości umożliwiają manipulowanie wybranymi elementami na liście kontrolki menu:

• SelectItem - Wybiera element w danym indeksie.
• Select - Wybierz daną wartość elementu.
• DeselectItem — usuwa zaznaczenie elementu w danym indeksie.
• SelectedIndex — Zwraca indeks aktualnie wybranego elementu.
• SelectedValue — Zwraca wartość aktualnie wybranego elementu.

Użyj elementu ScrollItemAtIndexToTop , aby przedstawić element w danym indeksie w górnej części listy, a element ScrollItemAtIndexToVisible , aby przewinąć listę do momentu, aż element w danym indeksie będzie widoczny.

Reagowanie na zdarzenia

Kontrolki menu zapewniają następujące zdarzenia, aby reagować na interakcję użytkownika:

• SelectionChanged — jest wywoływany, gdy użytkownik wybrał wartość z listy.
• SelectionIsChanging - Jest wywoływany, zanim nowy element wybrany przez użytkownika stanie się aktywnym wyborem.
• WillPopup — Jest wywoływana przed wyświetleniem listy rozwijanej elementów.
• WillDismiss — Jest wywoływana przed zamknięciem listy rozwijanej elementów.

W przypadku NSComboBox kontrolek zawierają wszystkie te same zdarzenia co , takie jak NSTextFieldChanged zdarzenie wywoływane za każdym razem, gdy użytkownik edytuje wartość tekstu w polu kombi.

Opcjonalnie możesz odpowiedzieć na wewnętrzne elementy menu danych zdefiniowane w konstruktorze interfejsu, dołączając element do akcji i używając kodu, takiego jak następujące, aby odpowiedzieć na akcję wyzwalaną przez użytkownika:

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

Aby uzyskać więcej informacji na temat pracy z menu i kontrolkami menu, zobacz dokumentację menu i wyskakujących przycisków oraz list rozwijanych.

Praca z kontrolkami wyboru

Zestaw AppKit udostępnia kilka typów kontrolek wyboru, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Selection Controls (Kontrolki wyboru) wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Istnieją dwa sposoby śledzenia, kiedy kontrolka wyboru ma interakcję użytkownika, uwidaczniając ją jako akcję. Na przykład:

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

Możesz też dołączyć pełnomocnikaActivated do zdarzenia. Na przykład:

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

Aby ustawić lub odczytać wartość kontrolki Wyboru, użyj IntValue właściwości . Na przykład:

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

Kontrolki specjalne (takie jak Seler kolorów i Studnia obrazu) mają określone właściwości dla ich typów wartości. Na przykład:

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

Element NSDatePicker ma następujące właściwości do pracy bezpośrednio z datą i godziną:

• DateValue — bieżąca wartość daty i godziny jako NSDate.
• Local — lokalizacja użytkownika jako .NSLocal
• TimeInterval — wartość godziny jako Double.
• Strefa czasowa — strefa czasowa użytkownika jako NSTimeZone.

Praca z kontrolkami wskaźnika

Zestaw AppKit udostępnia kilka typów kontrolek wskaźników, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Kontrolki wskaźnika w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Istnieją dwa sposoby śledzenia, gdy kontrolka wskaźnika ma interakcję użytkownika, uwidaczniając ją jako akcję lub gniazdo i dołączając delegataActivated do zdarzenia. Na przykład:

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

Aby odczytać lub ustawić wartość kontrolki wskaźnika, użyj DoubleValue właściwości . Na przykład:

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

Wskaźniki postępu nieokreślonego i asynchronicznego powinny być animowane po wyświetleniu. StartAnimation Użyj metody , aby uruchomić animację po ich wyświetleniu. Na przykład:

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

StopAnimation Wywołanie metody spowoduje zatrzymanie animacji.

Praca z kontrolkami tekstu

Zestaw AppKit udostępnia kilka typów kontrolek tekstu, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Kontrolki tekstu w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

W przypadku pól tekstowych (NSTextField) następujące zdarzenia mogą służyć do śledzenia interakcji użytkownika:

• Zmieniono — jest uruchamiany za każdym razem, gdy użytkownik zmieni wartość pola. Na przykład na każdym typie znaku.
• EditingBegan — jest wyzwalany, gdy użytkownik wybierze pole do edycji.
• EditingEnded — gdy użytkownik naciska klawisz Enter w polu lub opuszcza pole.

StringValue Użyj właściwości , aby odczytać lub ustawić wartość pola. Na przykład:

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

W przypadku pól, które wyświetlają lub edytują wartości liczbowe, można użyć IntValue właściwości . Na przykład:

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

Element NSTextView zapewnia pełny obszar edycji tekstu i wyświetlania z wbudowanym formatowaniem. Podobnie jak w przypadku elementu NSTextField, użyj StringValue właściwości , aby odczytać lub ustawić wartość obszaru.

Praca z widokami zawartości

Zestaw AppKit udostępnia kilka typów widoków zawartości, które mogą być używane w projekcie interfejsu użytkownika. Aby uzyskać więcej informacji, zobacz sekcję Content Views (Widoki zawartości) w wytycznych dotyczących interfejsu użytkownika systemu OS X firmy Apple.

Popovers

Popover to przejściowy element interfejsu użytkownika, który zapewnia funkcje bezpośrednio związane z określoną kontrolką lub obszarem ekranu. Wyskakujące okienko unosi się nad oknem zawierającym kontrolkę lub obszar, z którym jest powiązany, a jego obramowanie zawiera strzałkę wskazującą punkt, z którego się pojawił.

Aby utworzyć okno podręczne, wykonaj następujące czynności:

1. .storyboard Otwórz plik okna, do którego chcesz dodać okno podręczne, klikając go dwukrotnie w Eksplorator rozwiązań

2. Przeciągnij kontroler widoku z inspektora biblioteki do edytora interfejsu:

   

3. Zdefiniuj rozmiar i układ widoku niestandardowego:

   

4. Kliknij kontrolkę i przeciągnij ze źródła wyskakującego okienka na kontroler widoku:

   

5. Wybierz pozycję Wyskakujące okienko z menu podręcznego:

   

6. Zapisz zmiany i wróć do Visual Studio dla komputerów Mac, aby przeprowadzić synchronizację z programem Xcode.

Widoki kart

Widoki kart składają się z listy kart (która wygląda podobnie do kontrolki segmentowanej) w połączeniu z zestawem widoków nazywanych okienkami. Gdy użytkownik wybierze nową kartę, zostanie wyświetlone okienko dołączone do niej. Każde okienko zawiera własny zestaw kontrolek.

Podczas pracy z widokiem karty w konstruktorze interfejsu Xcode użyj Inspektora atrybutów, aby ustawić liczbę kart:

Wybierz każdą kartę w hierarchii interfejsu, aby ustawić tytułi dodać elementy interfejsu użytkownika do okienka:

Kontrolki AppKit powiązania danych

Korzystając z technik kodowania klucz-wartość i powiązania danych w aplikacji Xamarin.Mac, można znacznie zmniejszyć ilość kodu, który trzeba napisać i obsługiwać, aby wypełnić elementy interfejsu użytkownika i pracować z elementami interfejsu użytkownika. Masz również korzyść z dalszego oddzielenia danych zapasowych (modelu danych) od interfejsu użytkownika frontonu (Model-View-Controller), co prowadzi do łatwiejszego utrzymania, bardziej elastycznego projektowania aplikacji.

Kodowanie klucz-wartość (KVC) jest mechanizmem uzyskiwania dostępu do właściwości obiektu pośrednio przy użyciu kluczy (specjalnie sformatowanych ciągów) do identyfikowania właściwości zamiast uzyskiwania do nich dostępu za pośrednictwem zmiennych wystąpienia lub metod metod dostępu (get/set). Implementując metody dostępu zgodne z kodowaniem klucz-wartość w aplikacji Xamarin.Mac, uzyskujesz dostęp do innych funkcji systemu macOS, takich jak Obserwowanie wartości klucza (KVO), powiązanie danych, dane podstawowe, powiązania cocoa i możliwość tworzenia skryptów.

Aby uzyskać więcej informacji, zobacz sekcję Simple Data Binding (Proste powiązanie danych) w dokumentacji dotyczącej powiązania danych i kodowania klucz-wartość.

Podsumowanie

W tym artykule szczegółowo przedstawiono pracę ze standardowymi kontrolkami AppKit, takimi jak przyciski, etykiety, pola tekstowe, pola wyboru i kontrolki segmentowane w aplikacji platformy Xamarin.Mac. Omówiono dodawanie ich do projektu interfejsu użytkownika w narzędziu Xcode Interface Builder, uwidaczniając je w kodzie za pośrednictwem placówek i akcji oraz pracy z kontrolkami AppKit w kodzie języka C#.

Linki powiązane

• Witaj, Mac
• Windows
• Powiązanie danych i kodowanie klucz-wartość
• Wytyczne dotyczące interfejsu ludzkiego systemu OS X
• Informacje o kontrolkach i widokach