Menüs in xamarin. MacMenus in Xamarin.Mac

In diesem Artikel wird das Arbeiten mit Menüs in einer xamarin. Mac-Anwendung behandelt. Es beschreibt das Erstellen und Verwalten von Menüs und Menü Elementen in Xcode und Interface Builder und Programm gesteuertes arbeiten mit Ihnen.This article covers working with menus in a Xamarin.Mac application. It describes creating and maintaining menus and menu items in Xcode and Interface Builder and working with them programmatically.

Wenn Sie mit c# und .net in einer xamarin. Mac-Anwendung arbeiten, haben Sie Zugriff auf die gleichen Cocoa-Menüs, die ein Entwickler in Ziel-C und Xcode verwendet.When working with C# and .NET in a Xamarin.Mac application, you have access to the same Cocoa menus that a developer working in Objective-C and Xcode does. Da xamarin. Mac direkt in Xcode integriert ist, können Sie die Interface Builder von Xcode verwenden, um die Menüleisten, Menüs und Menü Elemente zu erstellen und zu verwalten (oder Sie optional direkt in c#-Code zu erstellen).Because Xamarin.Mac integrates directly with Xcode, you can use Xcode's Interface Builder to create and maintain your menu bars, menus, and menu items (or optionally create them directly in C# code).

Menüs sind ein wesentlicher Bestandteil der Benutzeroberfläche einer Mac-Anwendung und werden im Allgemeinen in verschiedenen Teilen der Benutzeroberfläche angezeigt:Menus are an integral part of a Mac application's user experience and commonly appear in various parts of the user interface:

  • Die Menüleiste der Anwendung : Dies ist das Hauptmenü, das im oberen Bereich des Bildschirms für jede Mac-Anwendung angezeigt wird.The application's menu bar - This is the main menu that appears at the top of the screen for every Mac application.
  • Kontextmenüs : Diese werden angezeigt, wenn der Benutzer mit der rechten Maustaste klickt oder auf ein Element in einem Fenster klickt.Contextual menus - These appear when the user right-clicks or control-clicks an item in a window.
  • Die Statusleiste : Dies ist der Bereich ganz rechts in der Anwendungsmenü Leiste, der oben auf dem Bildschirm angezeigt wird (auf der linken Seite der Menüleiste) und nach links vergrößert wird, wenn Elemente hinzugefügt werden.The status bar - This is the area at the far right side of the application menu bar that appears at the top of the screen (to the left of the menu bar clock) and grows to the left as items are added to it.
  • Menü Andocken : das Menü für jede Anwendung im andocken, das angezeigt wird, wenn der Benutzer mit der rechten Maustaste klickt oder auf das Symbol der Anwendung klickt, oder wenn der Benutzer auf das Symbol klickt und die Maustaste gedrückt hält.Dock menu - The menu for each application in the dock that appears when the user right-clicks or control-clicks the application's icon, or when the user left-clicks the icon and holds the mouse button down.
  • Popup Schaltfläche und pulldownlisten : eine Popup Schaltfläche zeigt ein ausgewähltes Element an und zeigt eine Liste der Optionen an, die Sie auswählen können, wenn der Benutzer darauf klickt.Pop-up button and pull-down lists - A pop-up button displays a selected item and presents a list of options to select from when clicked by the user. Eine Pulldownliste ist ein Typ von Popup Schaltfläche, der in der Regel für die Auswahl von Befehlen verwendet wird, die für den Kontext der aktuellen Aufgabe spezifisch sind.A pull-down list is a type of pop-up button usually used for selecting commands specific to the context of the current task. Beides kann an beliebiger Stelle in einem Fenster angezeigt werden.Both can appear anywhere in a window.

Ein Beispiel MenüAn example menu

In diesem Artikel werden die Grundlagen der Arbeit mit Cocoa-Menüleisten, Menüs und Menü Elementen in einer xamarin. Mac-Anwendung behandelt.In this article, we'll cover the basics of working with Cocoa menu bars, menus, and menu items in a Xamarin.Mac application. Es wird dringend empfohlen, dass Sie zunächst den Artikel Hello, Mac , insbesondere die Einführung in Xcode und die Abschnitte zu Interface Builder und Outlets und Aktionen , durcharbeiten, da er wichtige Konzepte und Techniken behandelt, die wir in diesem Artikel verwenden werden.It is highly suggested that you work through the Hello, Mac article first, specifically the Introduction to Xcode and Interface Builder and Outlets and Actions sections, as it covers key concepts and techniques that we'll be using in this article.

Sie können sich auch den Abschnitt verfügbar machen von c#-Klassen/-Methoden für den Abschnitt "Ziel-c " im Dokument " xamarin. Mac " ansehen. darin werden die Attribute und erläutert, die Register zum Verknüpfen Export ihrer c#-Klassen mit Ziel-c-Objekten und Benutzeroberflächen Elementen verwendet werden.You may want to take a look at the Exposing C# classes / methods to Objective-C section of the Xamarin.Mac Internals document as well, it explains the Register and Export attributes used to wire-up your C# classes to Objective-C objects and UI elements.

Die Menüleiste der AnwendungThe application's menu bar

Anders als bei Anwendungen, die unter dem Windows-Betriebssystem ausgeführt werden, an das jedem Fenster eine eigene Menüleiste angefügt werden kann, verfügt jede Anwendung, die unter macOS ausgeführt wird, über eine einzelne Menüleiste, die für jedes Fenster in dieser Anwendung verwendet wird:Unlike applications running on the Windows OS where every window can have its own menu bar attached to it, every application running on macOS has a single menu bar that runs along the top of the screen that's used for every window in that application:

Eine MenüleisteA menu bar

Elemente in dieser Menüleiste werden basierend auf dem aktuellen Kontext oder Zustand der Anwendung und ihrer Benutzeroberfläche zu einem beliebigen Zeitpunkt aktiviert oder deaktiviert.Items on this menu bar are activated or deactivated based on the current context or state of the application and its user interface at any given moment. Beispiel: Wenn der Benutzer ein Textfeld auswählt, werden die Elemente im Menü Bearbeiten aktiviert, z. b. Kopieren und Ausschneiden.For example: if the user selects a text field, items on the Edit menu will be come enabled such as Copy and Cut.

Gemäß Apple und standardmäßig verfügen alle macOS-Anwendungen über einen Standardsatz von Menüs und Menü Elementen, die in der Menüleiste der Anwendung angezeigt werden:According to Apple and by default, all macOS applications have a standard set of menus and menu items that appear in the application's menu bar:

  • Apple-Menü : Dieses Menü ermöglicht den Zugriff auf systemweite Elemente, die für den Benutzer jederzeit verfügbar sind, unabhängig davon, welche Anwendung ausgeführt wird.Apple menu - This menu provides access to system wide items that are available to the user at all times, regardless of what application is running. Diese Elemente können vom Entwickler nicht geändert werden.These items cannot be modified by the developer.
  • App-Menü : in diesem Menü wird der Name der Anwendung in Fett Schrift angezeigt, und der Benutzer kann ermitteln, welche Anwendung derzeit ausgeführt wird.App menu - This menu displays the application's name in bold and helps the user identify what application is currently running. Sie enthält Elemente, die für die Anwendung als Ganzes gelten, nicht für ein bestimmtes Dokument oder einen Prozess, wie z. b. das Beenden der Anwendung.It contains items that apply to the application as a whole and not a given document or process such as quitting the application.
  • Menü "Datei ": Elemente, die zum Erstellen, öffnen oder Speichern von Dokumenten verwendet werden, mit denen die Anwendung arbeitet.File menu - Items used to create, open, or save documents that your application works with. Wenn Ihre Anwendung nicht Dokument basiert ist, kann dieses Menü umbenannt oder entfernt werden.If your application is not document-based, this menu can be renamed or removed.
  • Menü Bearbeiten : enthält Befehle wie Ausschneiden, Kopieren und Einfügen , die zum Bearbeiten oder Ändern von Elementen in der Benutzeroberfläche der Anwendung verwendet werden.Edit menu - Holds commands such as Cut, Copy, and Paste which are used to edit or modify elements in the application's user interface.
  • Menü "Format ": Wenn die Anwendung mit Text funktioniert, enthält dieses Menübefehle, mit denen die Formatierung des Texts angepasst wird.Format menu - If the application works with text, this menu holds commands to adjust the formatting of that text.
  • Menü anzeigen : enthält Befehle, die beeinflussen, wie Inhalt in der Benutzeroberfläche der Anwendung angezeigt wird (angezeigt).View menu - Holds commands that affect how content is displayed (viewed) in the application's user interface.
  • Anwendungsspezifische Menüs : Hierbei handelt es sich um Menüs, die für Ihre Anwendung spezifisch sind (z. b. ein Lesezeichen Menü für einen Webbrowser).Application-specific menus - These are any menus that are specific to your application (such as a bookmarks menu for a web browser). Sie sollten zwischen den Menüs Ansicht und Fenster auf der Leiste angezeigt werden.They should appear between the View and Window menus on the bar.
  • Fenstermenü : enthält Befehle für die Arbeit mit Fenstern in der Anwendung sowie eine Liste der aktuellen geöffneten Fenster.Window menu - Contains commands for working with windows in your application, as well as a list of current open windows.
  • Menü "Hilfe ": Wenn Ihre Anwendung die Bildschirm Hilfe bereitstellt, sollte das Menü "Hilfe" das ganz rechts Menü auf der Leiste enthalten.Help menu - If your application provides onscreen help, the Help menu should be the right-most menu on the bar.

Weitere Informationen zur Anwendungsmenü Leiste sowie zu Standardmenüs und Menü Elementen finden Sie in den Richtlinien für die Benutzeroberflächevon Apple.For more information about the application menu bar and standard menus and menu items, please see Apple's Human Interface Guidelines.

Die Standard Anwendungsmenü LeisteThe default application menu bar

Wenn Sie ein neues xamarin. Mac-Projekt erstellen, erhalten Sie automatisch eine standardmäßige Standard Anwendungsmenü Leiste, die die typischen Elemente enthält, die eine macOS-Anwendung normalerweise hätte (wie im obigen Abschnitt erläutert).Whenever you create a new Xamarin.Mac project, you automatically get a standard, default application menu bar that has the typical items that a macOS application would normally have (as discussed in the section above). Die Standardmenü Leiste Ihrer Anwendung wird in der Datei " Main. Storyboard " (zusammen mit dem Rest der Benutzeroberfläche Ihrer APP) unter dem Projekt im Lösungspad definiert:Your application's default menu bar is defined in the Main.storyboard file (along with the rest of your app's UI) under the project in the Solution Pad:

Wählen Sie das Haupt Storyboard aus.Select the main storyboard

Doppelklicken Sie auf die Datei Main. Storyboard , um Sie in der Interface Builder von Xcode zur Bearbeitung zu öffnen, und die Menü-Editor-Schnittstelle wird angezeigt:Double-click the Main.storyboard file to open it for editing in Xcode's Interface Builder and you'll be presented with the menu editor interface:

Bearbeiten der Benutzeroberfläche in Xcode, die das Haupt-Punkt-Storyboard anzeigt.Editing the UI in Xcode, showing the Main dot storyboard.

Hier können Sie auf Elemente wie das Menü Element Öffnen im Menü Datei klicken und ihre Eigenschaften im Attribute Inspector bearbeiten oder anpassen:From here we can click on items such as the Open menu item in the File menu and edit or adjust its properties in the Attributes Inspector:

Bearbeiten der Attribute eines MenüsEditing a menu's attributes

Wir werden später in diesem Artikel das Hinzufügen, bearbeiten und Löschen von Menüs und Elementen Unternehmen.We'll get into adding, editing, and deleting menus and items later in this article. Nun möchten wir nur noch sehen, welche Menüs und Menü Elemente standardmäßig verfügbar sind und wie Sie automatisch über einen Satz vordefinierter Outlets und Aktionen für Code verfügbar gemacht wurden (Weitere Informationen finden Sie in der Dokumentation zu Outlets und Aktionen ).For now we just want to see what menus and menu items are available by default and how they have been automatically exposed to code via a set of predefined outlets and actions (for more information see our Outlets and Actions documentation).

Wenn wir beispielsweise auf den Verbindungs Inspektor für das Menü Element " Öffnen " klicken, sehen wir, dass es automatisch mit der openDocument: Aktion verknüpft ist:For example, if we click on the Connection Inspector for the Open menu item we can see it is automatically wired up to the openDocument: action:

Anzeigen der angefügten AktionViewing the attached action

Wenn Sie den ersten Responder in der Schnittstellen Hierarchie auswählen und im Verbindungs Inspektor einen Bildlauf nach unten durchführen, sehen Sie die Definition der openDocument: Aktion, an die das Menü Element Öffnen angefügt wird (zusammen mit einigen anderen Standard Aktionen für die Anwendung, die nicht automatisch mit Steuerelementen verbunden sind):If you select the First Responder in the Interface Hierarchy and scroll down in the Connection Inspector, and you will see the definition of the openDocument: action that the Open menu item is attached to (along with several other default actions for the application that are and are not automatically wired up to controls):

Anzeigen aller angefügten AktionenViewing all attached actions

Warum ist dies wichtig?Why is this important? Im nächsten Abschnitt erfahren Sie, wie diese automatisch definierten Aktionen mit anderen Cocoa-Benutzeroberflächen Elementen funktionieren, um Menü Elemente automatisch zu aktivieren und zu deaktivieren sowie um integrierte Funktionen für die Elemente bereitzustellen.In the next section will see how these automatically-defined actions work with other Cocoa user interface elements to automatically enable and disable menu items, as well as, provide built-in functionality for the items.

Später werden diese integrierten Aktionen verwendet, um Elemente aus dem Code zu aktivieren und zu deaktivieren und um unsere eigene Funktionalität bereitzustellen, wenn Sie ausgewählt werden.Later we'll be using these built-in actions to enable and disable items from code and provide our own functionality when they are selected.

Integrierte Menü FunktionalitätBuilt-in menu functionality

Wenn Sie eine neu erstellte xamarin. Mac-Anwendung ausgeführt haben, bevor Sie Benutzeroberflächen Elemente oder-Code hinzugefügt haben, werden Sie bemerken, dass einige Elemente automatisch verdrahtet und für Sie aktiviert werden (mit vollständig integrierter Funktionalität), wie z. b. das Element " Beenden " im App -Menü:If you were the run a newly created Xamarin.Mac application before adding any UI items or code, you'll notice that some items are automatically wired-up and enabled for you (with fully functionality automatically built-in), such as the Quit item in the App menu:

Ein aktiviertes Menü ElementAn enabled menu item

Andere Menü Elemente, wie z. b. Ausschneiden, Kopieren und Einfügen , sind nicht:While other menu items, such as Cut, Copy, and Paste are not:

Deaktivierte Menü ElementeDisabled menu items

Nehmen wir an, dass die Anwendung beendet wird, und Doppel klicke auf die Datei " Main. Storyboard " im Lösungspad , um Sie zur Bearbeitung in der Interface Builder von Xcode zu öffnen.Let's stop the application and double-click the Main.storyboard file in the Solution Pad to open it for editing in Xcode's Interface Builder. Ziehen Sie als nächstes eine Text Ansicht aus der Bibliothek auf den Ansichts Controller des Fensters im Schnittstellen- Editor:Next, drag a Text View from the Library onto the window's view controller in the Interface Editor:

Auswählen einer Text Ansicht aus der BibliothekSelecting a Text View from the Library

Fügen Sie im Einschränkungs- Editor die Textansicht an die Ränder des Fensters an, und legen Sie Sie dort ab, wo Sie mit dem Fenster vergrößert und verkleinert wird, indem Sie auf alle vier roten I-Balken am oberen Rand des Editors klicken und dann auf die Schaltfläche 4 Einschränkungen hinzufügen klicken:In the Constraint Editor let's pin the text view to the window's edges and set it where it grows and shrinks with the window by clicking all four red I-beams at the top of the editor and clicking the Add 4 Constraints button:

Bearbeiten der EinschränkungenEditing the contraints

Speichern Sie die Änderungen am Design der Benutzeroberfläche, und wechseln Sie zurück zum Visual Studio für Mac, um die Änderungen mit Ihrem xamarin. Mac-Projekt zu synchronisieren.Save your changes to the user interface design and switch back the Visual Studio for Mac to synchronize the changes with your Xamarin.Mac project. Starten Sie nun die Anwendung, geben Sie Text in die Textansicht ein, wählen Sie Sie aus, und öffnen Sie das Menü Bearbeiten :Now start the application, type some text into the text view, select it, and open the Edit menu:

Die Menü Elemente werden automatisch aktiviert/deaktiviert.The menu items are automatically enabled/disabled

Beachten Sie, dass die Ausschneide-, Kopier-und Einfüge Elemente automatisch aktiviert und voll funktionsfähig sind, ohne eine einzige Codezeile schreiben zu müssen.Notice how the Cut, Copy, and Paste items are automatically enabled and fully functional, all without writing a single line of code.

Was geht da vor?What's going on here? Merken Sie sich die integrierten vordefinieren-Aktionen, die mit den Standardmenü Elementen verknüpft sind (wie oben dargestellt). die meisten Cocoa-Benutzeroberflächen Elemente, die Teil von macOS sind, haben in bestimmte Aktionen integriert (z copy: . b.).Remember the built-in predefine actions that come wired up to the default menu items (as presented above), most of the Cocoa user interface elements that are part of macOS have built in hooks to specific actions (such as copy:). Wenn Sie also einem Fenster hinzugefügt, aktiv und ausgewählt werden, werden die entsprechenden Menü Elemente bzw. Elemente, die an diese Aktion angefügt sind, automatisch aktiviert.So when they are added to a window, active, and selected, the corresponding menu item or items attached to that action are automatically enabled. Wenn der Benutzer das Menü Element auswählt, wird die Funktionalität, die in das UI-Element integriert ist, aufgerufen und ausgeführt, alle ohne Eingriff des Entwicklers.If the user selects that menu item, the functionality built into the UI element is called and executed, all without developer intervention.

Aktivieren und Deaktivieren von Menüs und ElementenEnabling and disabling menus and items

Standardmäßig wird jedes Mal, wenn ein Benutzer Ereignis auftritt, NSMenu automatisch jedes sichtbare Menü und Menü Element basierend auf dem Kontext der Anwendung aktiviert und deaktiviert.By default, every time a user event occurs, NSMenu automatically enables and disables each visible menu and menu item based on the context of the application. Es gibt drei Möglichkeiten, ein Element zu aktivieren/deaktivieren:There are three ways to enable/disable an item:

  • Automatisches Aktivieren des Menüs : ein Menü Element ist aktiviert NSMenu , wenn von ein entsprechendes Objekt gefunden werden kann, das auf die Aktion antwortet, mit der das Element verknüpft ist.Automatic menu enabling - A menu item is enabled if NSMenu can find an appropriate object that responds to the action that the item is wired-up to. Beispielsweise die oben genannte Textansicht, die über einen integrierten Hook für die copy: Aktion verfügt.For example, the text view above that had a built-in hook to the copy: action.
  • Benutzerdefinierte Aktionen und validatemenuitem:: für ein beliebiges Menü Element, das an ein Fenster oder eine benutzerdefinierte Aktion des Ansichts Controllersgebunden ist, können Sie die Aktion hinzufügen validateMenuItem: und Menü Elemente manuell aktivieren bzw. deaktivieren.Custom actions and validateMenuItem: - For any menu item that is bound to a window or view controller custom action, you can add the validateMenuItem: action and manually enable or disable menu items.
  • Manuelles Aktivieren des Menüs: Sie legen die- Enabled Eigenschaft jedes manuell fest NSMenuItem , um jedes Element einzeln in einem Menü zu aktivieren bzw. zu deaktivieren.Manual menu enabling - You manually set the Enabled property of each NSMenuItem to enable or disable each item in a menu individually.

Um ein System auszuwählen, legen Sie die- AutoEnablesItems Eigenschaft eines fest NSMenu .To choose a system, set the AutoEnablesItems property of a NSMenu. true ist automatisch (Standardverhalten) und false ist manuell.true is automatic (the default behavior) and false is manual.

Wichtig

Wenn Sie die manuelle Menü Aktivierung verwenden, werden keines der Menü Elemente, auch solche, die von AppKit-Klassen wie gesteuert werden, NSTextView automatisch aktualisiert.If you choose to use manual menu enabling, none of the menu items, even those controlled by AppKit classes like NSTextView, are updated automatically. Sie sind dafür verantwortlich, alle Elemente per Hand in Code zu aktivieren und zu deaktivieren.You will be responsible for enabling and disabling all items by hand in code.

Verwenden von validatemenuitemUsing validateMenuItem

Wie bereits erwähnt, können Sie für jedes Menü Element, das an ein Fenster oder eine benutzerdefinierte Aktion zum Anzeigen des Controllersgebunden ist, die Aktion hinzufügen validateMenuItem: und Menü Elemente manuell aktivieren oder deaktivieren.As stated above, for any menu item that is bound to a Window or View Controller Custom Action, you can add the validateMenuItem: action and manually enable or disable menu items.

Im folgenden Beispiel Tag wird die-Eigenschaft verwendet, um den Typ des Menü Elements zu entscheiden, das von der validateMenuItem: Aktion basierend auf dem Zustand des ausgewählten Texts in einem aktiviert bzw. deaktiviert wird NSTextView .In the following example, the Tag property will be used to decide the type of menu item that will be enabled/disabled by the validateMenuItem: action based on the state of selected text in a NSTextView. Die- Tag Eigenschaft wurde für jedes Menü Element in Interface Builder festgelegt:The Tag property has been set in Interface Builder for each menu item:

Festlegen der TageigenschaftSetting the Tag property

Der folgende Code wurde dem Ansichts Controller hinzugefügt:And the following code added to the View Controller:

[Action("validateMenuItem:")]
public bool ValidateMenuItem (NSMenuItem item) {

    // Take action based on the menu item type
    // (As specified in its Tag)
    switch (item.Tag) {
    case 1:
        // Wrap menu items should only be available if
        // a range of text is selected
        return (TextEditor.SelectedRange.Length > 0);
    case 2:
        // Quote menu items should only be available if
        // a range is NOT selected.
        return (TextEditor.SelectedRange.Length == 0);
    }

    return true;
}

Wenn dieser Code ausgeführt wird und in der kein Text ausgewählt ist NSTextView , werden die beiden Wrap-Menü Elemente deaktiviert (auch wenn Sie mit Aktionen auf dem Ansichts Controller verknüpft sind):When this code is run, and no text is selected in the NSTextView, the two wrap menu items are disabled (even though they are wired to actions on the view controller):

Anzeige deaktivierter ElementeShowing disabled items

Wenn ein Textabschnitt ausgewählt und das Menü erneut geöffnet wird, sind die beiden Menü Elemente für das Wrap verfügbar:If a section of text is selected and the menu reopened, the two wrap menu items will be available:

Aktivierte Elemente werden angezeigtShowing enabled items

Aktivieren von und Antworten auf Menü Elemente in CodeEnabling and responding to menu items in code

Wie bereits erwähnt, werden einige der Standardmenü Elemente nur durch Hinzufügen spezifischer Cocoa-Benutzeroberflächen Elemente zum UI-Design (z. b. ein Textfeld) aktiviert und funktionieren automatisch, ohne dass Sie Code schreiben müssen.As we have seen above, just by adding specific Cocoa user interface elements to our UI design (such as a text field), several of the default menu items will be enabled and function automatically, without having to write any code. Als nächstes sehen wir uns das Hinzufügen unseres eigenen c#-Codes zu unserem xamarin. Mac-Projekt an, um ein Menü Element zu aktivieren und Funktionen bereitzustellen, wenn der Benutzer es auswählt.Next let's look at adding our own C# code to our Xamarin.Mac project to enable a menu item and provide functionality when the user selects it.

Angenommen, der Benutzer soll das geöffnete Element im Menü Datei verwenden können, um einen Ordner auszuwählen.For example, let say we want the user to be able to use the Open item in the File menu to select a folder. Da dies eine Anwendungs weite Funktion sein soll, die nicht auf ein Give-Fenster oder ein UI-Element beschränkt ist, fügen wir den Code hinzu, um dies für den Anwendungs Delegaten zu verarbeiten.Since we want this to be an application-wide function and not limited to a give window or UI element, we're going to add the code to handle this to our application delegate.

Doppelklicken Sie im Lösungspad auf die AppDelegate.CS Datei, um Sie zur Bearbeitung zu öffnen:In the Solution Pad, double-click the AppDelegate.CS file to open it for editing:

Auswählen des App-DelegatenSelecting the app delegate

Fügen Sie unter der DidFinishLaunching-Methode folgenden Code hinzu:Add the following code below the DidFinishLaunching method:

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

    if (dlg.RunModal () == 1) {
        var alert = new NSAlert () {
            AlertStyle = NSAlertStyle.Informational,
            InformativeText = "At this point we should do something with the folder that the user just selected in the Open File Dialog box...",
            MessageText = "Folder Selected"
        };
        alert.RunModal ();
    }
}

Führen Sie die Anwendung jetzt aus, und öffnen Sie das Menü " Datei ":Let's run the application now and open the File menu:

![Menü "Datei"](menu-images/appmenu09.png "Menü "Datei"")The File menu

Beachten Sie, dass das Menü Element Öffnen jetzt aktiviert ist.Notice that the Open menu item is now enabled. Wenn Sie diese Option auswählen, wird das Dialogfeld Öffnen angezeigt:If we select it, the open dialog will be displayed:

Ein offenes DialogfeldAn open dialog

Wenn Sie auf die Schaltfläche " Öffnen " klicken, wird unsere Warnmeldung angezeigt:If we click the Open button, our alert message will be displayed:

Beispiel Dialogfeld MeldungAn example dialog message

Die wichtigste Zeile ist [Export ("openDocument:")] , NSMenu dass der appdelegat über eine-Methode verfügt, die void OpenDialog (NSObject sender) auf die openDocument: Aktion antwortet.The key line here was [Export ("openDocument:")], it tells NSMenu that our AppDelegate has a method void OpenDialog (NSObject sender) that responds to the openDocument: action. Wenn Sie sich weiter oben merken, wird das Menü Element Öffnen in Interface Builder standardmäßig automatisch mit dieser Aktion verknüpft:If you'll remember from above, the Open menu item is automatically wired-up to this action by default in Interface Builder:

Anzeigen der angefügten AktionenViewing the attached actions

Als nächstes sehen wir uns das Erstellen von eigenen Menüs, Menü Elementen und Aktionen an und Antworten im Code darauf.Next let's look at creating our own menu, menu items, and actions and responding to them in code.

Arbeiten mit dem Menü "zuletzt öffnen"Working with the open recent menu

Standardmäßig enthält das Menü Datei ein geöffnetes Aktuelles Element, mit dem die letzten Dateien nachverfolgt werden, die der Benutzer mit Ihrer APP geöffnet hat.By default, the File menu contains an Open Recent item that keeps track of the last several files that the user has opened with your app. Wenn Sie eine NSDocument basierte xamarin. Mac-app erstellen, wird dieses Menü automatisch behandelt.If you are creating a NSDocument based Xamarin.Mac app, this menu will be handled for you automatically. Für alle anderen Typen von xamarin. Mac-apps sind Sie dafür verantwortlich, dieses Menü Element manuell zu verwalten und darauf zu reagieren.For any other type of Xamarin.Mac app, you will be responsible for managing and responding to this menu item manually.

Um das Menü " zuletzt geöffnet " manuell zu behandeln, müssen Sie es zunächst darüber informieren, dass eine neue Datei geöffnet oder gespeichert wurde, indem Sie Folgendes verwenden:To manually handle the Open Recent menu, you will first need to inform it that a new file has been opened or saved using the following:

// Add document to the Open Recent menu
NSDocumentController.SharedDocumentController.NoteNewRecentDocumentURL(url);

Obwohl Ihre APP nicht verwendet NSDocuments , verwenden Sie trotzdem das, NSDocumentController um das Menü " zuletzt geöffnet " zu verwalten, indem Sie eine NSUrl mit dem Speicherort der Datei an die- NoteNewRecentDocumentURL Methode von senden SharedDocumentController .Even though your app is not using NSDocuments, you still use the NSDocumentController to maintain the Open Recent menu by sending a NSUrl with the location of the file to the NoteNewRecentDocumentURL method of the SharedDocumentController.

Als nächstes müssen Sie die- OpenFile Methode des App-Delegaten überschreiben, um eine beliebige Datei zu öffnen, die der Benutzer aus dem Menü " zuletzt geöffnet " auswählt.Next, you need to override the OpenFile method of the app delegate to open any file that the user selects from the Open Recent menu. Beispiel:For example:

public override bool OpenFile (NSApplication sender, string filename)
{
    // Trap all errors
    try {
        filename = filename.Replace (" ", "%20");
        var url = new NSUrl ("file://"+filename);
        return OpenFile(url);
    } catch {
        return false;
    }
}

trueWenn die Datei geöffnet werden kann, wird zurückgegeben, false und dem Benutzer wird eine integrierte Warnung angezeigt, dass die Datei nicht geöffnet werden konnte.Return true if the file can be opened, else return false and a built-in warning will be displayed to the user that the file could not be opened.

Da der Dateiname und der Pfad, die im Menü " zuletzt geöffnet " angezeigt werden, möglicherweise ein Leerzeichen enthalten, müssen wir dieses Zeichen vor dem Erstellen von ordnungsgemäß mit Escapezeichen versehen NSUrl .Because the filename and path returned from the Open Recent menu, might include a space, we need to properly escape this character before creating a NSUrl or we will get an error. Dies geschieht mit folgendem Code:We do that with the following code:

filename = filename.Replace (" ", "%20");

Schließlich erstellen wir ein-Objekt, NSUrl das auf die Datei verweist, und verwenden eine Hilfsmethode im App-Delegaten, um ein neues Fenster zu öffnen und die Datei in die Datei zu laden:Finally, we create a NSUrl that points to the file and use a helper method in the app delegate to open a new window and load the file into it:

var url = new NSUrl ("file://"+filename);
return OpenFile(url);

Um alles zusammenzuleiten, werfen wir einen Blick auf eine Beispiel Implementierung in einer AppDelegate.cs -Datei:To pull everything together, let's take a look at an example implementation in an AppDelegate.cs file:

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

namespace MacHyperlink
{
    [Register ("AppDelegate")]
    public class AppDelegate : NSApplicationDelegate
    {
        #region Computed Properties
        public int NewWindowNumber { get; set;} = -1;
        #endregion

        #region Constructors
        public AppDelegate ()
        {
        }
        #endregion

        #region Override Methods
        public override void DidFinishLaunching (NSNotification notification)
        {
            // Insert code here to initialize your application
        }

        public override void WillTerminate (NSNotification notification)
        {
            // Insert code here to tear down your application
        }

        public override bool OpenFile (NSApplication sender, string filename)
        {
            // Trap all errors
            try {
                filename = filename.Replace (" ", "%20");
                var url = new NSUrl ("file://"+filename);
                return OpenFile(url);
            } catch {
                return false;
            }
        }
        #endregion

        #region Private Methods
        private bool OpenFile(NSUrl url) {
            var good = false;

            // Trap all errors
            try {
                var path = url.Path;

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

                // 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.SetLanguageFromPath(path);
                viewController.View.Window.SetTitleWithRepresentedFilename (Path.GetFileName(path));
                viewController.View.Window.RepresentedUrl = url;

                // Add document to the Open Recent menu
                NSDocumentController.SharedDocumentController.NoteNewRecentDocumentURL(url);

                // Make as successful
                good = true;
            } catch {
                // Mark as bad file on error
                good = false;
            }

            // Return results
            return good;
        }
        #endregion

        #region actions
        [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) {
                    // Open the document in a new window
                    OpenFile (url);
                }
            }
        }
        #endregion
    }
}

Basierend auf den Anforderungen Ihrer APP soll der Benutzer möglicherweise nicht die gleiche Datei in mehr als einem Fenster gleichzeitig öffnen.Based on the requirements of your app, you might not want the user to open the same file in more than one window at the same time. In unserer Beispiel-APP, wenn der Benutzer eine Datei auswählt, die bereits geöffnet ist (entweder über das geöffnete "zuletzt geöffnet" oder " Öffnen".In our example app, if the user chooses a file that is already open (either from the Open Recent or Open.. Menü Elemente), das Fenster, das die Datei enthält, wird in den Vordergrund gestellt.menu items), the window that contains the file is brought to the front.

Um dies zu erreichen, haben wir den folgenden Code in unserer Hilfsmethode verwendet:To accomplish this, we used the following code in our helper method:

var path = url.Path;

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

Wir haben unsere Klasse so entworfen, dass Sie ViewController den Pfad zu der Datei in Ihrer- Path Eigenschaft enthält.We designed our ViewController class to hold the path to the file in its Path property. Als nächstes durchlaufen wir alle gegenwärtig geöffneten Fenster in der app.Next, we loop through all currently open windows in the app. Wenn die Datei bereits in einem der Fenster geöffnet ist, wird Sie mithilfe von an die Vorderseite aller anderen Fenster übertragen:If the file is already open in one of the windows, it is brought to the front of all other windows using:

NSApplication.SharedApplication.Windows[n].MakeKeyAndOrderFront(this);

Wenn keine Entsprechung gefunden wird, wird ein neues Fenster mit der geladenen Datei geöffnet, und die Datei wird im Menü " zuletzt geöffnet " angezeigt:If no match is found, a new window is opened with the file loaded and the file is noted in the Open Recent menu:

// 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.SetLanguageFromPath(path);
viewController.View.Window.SetTitleWithRepresentedFilename (Path.GetFileName(path));
viewController.View.Window.RepresentedUrl = url;

// Add document to the Open Recent menu
NSDocumentController.SharedDocumentController.NoteNewRecentDocumentURL(url);

Arbeiten mit benutzerdefinierten Fenster AktionenWorking with custom window actions

Ebenso wie die integrierten ersten Response -Aktionen, die mit Standardmenü Elementen vorverdrahtet werden, können Sie neue, benutzerdefinierte Aktionen erstellen und Sie an Menü Elemente in Interface Builder übertragen.Just like the built-in First Responder actions that come pre-wired to standard menu items, you can create new, custom actions and wire them to menu items in Interface Builder.

Definieren Sie zunächst eine benutzerdefinierte Aktion auf einem der Fenster Controller Ihrer APP.First, define a custom action on one of your app's window controllers. Beispiel:For example:

[Action("defineKeyword:")]
public void defineKeyword (NSObject sender) {
    // Preform some action when the menu is selected
    Console.WriteLine ("Request to define keyword");
}

Doppelklicken Sie im Lösungspad auf die storyboarddatei der APP, um Sie in der Interface Builder von Xcode zur Bearbeitung zu öffnen.Next, double-click the app's storyboard file in the Solution Pad to open it for editing in Xcode's Interface Builder. Wählen Sie in der Anwendungs Szene den ersten Responder aus, und wechseln Sie dann zum Attribut Inspektor:Select the First Responder under the Application Scene, then switch to the Attributes Inspector:

Der Attribut InspektorThe Attributes Inspector

Klicken Sie + unten im attributerinspektor auf die Schaltfläche, um eine neue benutzerdefinierte Aktion hinzuzufügen:Click the + button at the bottom of the Attributes Inspector to add a new custom action:

Hinzufügen einer neuen AktionAdding a new action

Benennen Sie den gleichen Namen wie die benutzerdefinierte Aktion, die Sie auf Ihrem Fenster Controller erstellt haben:Give it the same name as the custom action that you created on your window controller:

Bearbeiten des Aktions namensEditing the action name

Klicken Sie auf ein Menü Element, und ziehen Sie es von einem Menü Element auf den ersten Beantworter unter der Anwendungs Szene.Control-click and drag from a menu item to the First Responder under the Application Scene. Wählen Sie in der Popup Liste die neue Aktion aus, die Sie soeben erstellt haben ( defineKeyword: in diesem Beispiel):From the popup list, select the new action you just created (defineKeyword: in this example):

Anfügen einer AktionAttaching an action

Speichern Sie die Änderungen am Storyboard, und kehren Sie zu Visual Studio für Mac zurück, um die Änderungen zu synchronisieren.Save the changes to the storyboard and return to Visual Studio for Mac to sync the changes. Wenn Sie die app ausführen, wird das Menü Element, mit dem Sie die benutzerdefinierte Aktion verbunden haben, automatisch aktiviert/deaktiviert (basierend auf dem Fenster, in dem die Aktion geöffnet wird). Wenn Sie das Menü Element auswählen, wird die Aktion ausgelöst:If you run the app, the menu item that you connected the custom action to will automatically be enabled/disabled (based on the window with the action being open) and selecting the menu item will fire off the action:

Testen der neuen AktionTesting the new action

Hinzufügen, bearbeiten und Löschen von MenüsAdding, editing, and deleting menus

Wie aus den vorherigen Abschnitten ersichtlich ist, enthält eine xamarin. Mac-Anwendung eine vordefinierte Anzahl von Standardmenüs und Menü Elementen, auf die bestimmte UI-Steuerelemente automatisch aktiviert werden und auf die Sie reagieren.As we have seen in the previous sections, a Xamarin.Mac application comes with a preset number of default menus and menu items that specific UI controls will automatically activate and respond to. Wir haben auch gesehen, wie Sie der Anwendung Code hinzufügen, der diese Standardelemente ebenfalls aktiviert und antwortet.We have also seen how to add code to our application that will also enable and respond to these default items.

In diesem Abschnitt wird das Entfernen von nicht benötigten Menü Elementen, das Neuorganisieren von Menüs und das Hinzufügen neuer Menüs, Menü Elemente und Aktionen erläutert.In this section we will look at removing menu items that we don't need, reorganizing menus and adding new menus, menu items and actions.

Doppelklicken Sie auf die Datei " Main. Storyboard " im Lösungspad , um Sie zur Bearbeitung zu öffnen:Double-click the Main.storyboard file in the Solution Pad to open it for editing:

Doppelklicken Sie auf die storyboarddatei, um die Benutzeroberfläche in Xcode zu bearbeiten.Double-clicking the storyboard file to edit the UI in Xcode.

Für unsere spezifische xamarin. Mac-Anwendung verwenden wir nicht das Standardmenü " Ansicht ", um es zu entfernen.For our specific Xamarin.Mac application we are not going to be using the default View menu so we are going to remove it. Wählen Sie in der Schnittstellen Hierarchie das Menü Element Ansicht aus, das Teil der Hauptmenüleiste ist:In the Interface Hierarchy select the View menu item that is a part of the main menu bar:

![Auswählen des Menü Elements "Ansicht"](menu-images/maint02.png "Auswählen des Menü Elements "Ansicht"")Selecting the View menu item

Drücken Sie ENTF oder RÜCKTASTE, um das Menü zu löschen.Press delete or backspace to delete the menu. Als nächstes verwenden wir nicht alle Elemente im Menü " Format " und möchten die Elemente, die wir verwenden, aus den Untermenüs verschieben.Next, we aren't going to be using all of the items in the Format menu and we want to move the items we are going to use out from under the sub menus. Wählen Sie in der Schnittstellen Hierarchie die folgenden Menü Elemente aus:In the Interface Hierarchy select the following menu items:

Markieren mehrerer ElementeHighlighting multiple items

Ziehen Sie die Elemente unter dem übergeordneten Menü aus dem Untermenü, in dem Sie aktuell sind:Drag the items under the parent Menu from the sub-menu where they currently are:

Ziehen von Menü Elementen in das übergeordnete MenüDragging menu items to the parent menu

Das Menü sollte nun wie folgt aussehen:Your menu should now look like:

Die Elemente am neuen SpeicherortThe items in the new location

Ziehen Sie als nächstes das textsubmenü aus dem Menü Format aus, und platzieren Sie es in der Hauptmenüleiste zwischen den Menüs Format und Fenster :Next let's drag the Text sub-menu out from under the Format menu and place it on the main menu bar between the Format and Window menus:

Das TextmenüThe Text menu

Wechseln wir zurück zum Menü Format , und löschen Sie das unter Menü Element Schriftart .Let's go back under the Format menu and delete the Font sub-menu item. Wählen Sie als nächstes das Menü Format aus, und benennen Sie es "Font" um:Next, select the Format menu and rename it "Font":

Das Schriftart MenüThe Font menu

Als Nächstes erstellen wir ein benutzerdefiniertes Menü mit vordefinierenden Ausdrücken, die automatisch an den Text in der Textansicht angehängt werden, wenn Sie ausgewählt werden.Next, let's create a custom menu of predefine phrases that will automatically get appended to the text in the text view when they are selected. Geben Sie im Suchfeld im unteren Bereich des Bibliothek inspektortyps in "Menu" ein.In the search box at the bottom on the Library Inspector type in "menu." Dies erleichtert die Suche nach und die Arbeit mit allen Menü Elemente der Benutzeroberfläche:This will make it easier to find and work with all of the menu UI elements:

Der Bibliotheks InspektorThe Library Inspector

Führen Sie nun Folgendes aus, um das Menü zu erstellen:Now let's do the following to create our menu:

  1. Ziehen Sie ein Menü Element aus dem Bibliotheks Inspektor in die Menüleiste zwischen den Text -und Fenster Menüs:Drag a Menu Item from the Library Inspector onto the menu bar between the Text and Window menus:

    Auswählen eines neuen Menü Elements in der BibliothekSelecting a new menu item in the Library

  2. Benennen Sie das Element "Ausdrücke" um:Rename the item "Phrases":

    Festlegen des Menü namensSetting the menu name

  3. Ziehen Sie als nächstes ein Menü aus der Bibliothek Inspector:Next drag a Menu from the Library Inspector:

    Auswählen eines Menüs aus der BibliothekSelecting a menu from the Library

  4. Löschen Sie das Menü im neuen, soeben erstellten Menü Element , und ändern Sie den Namen in "Ausdrücke":Drop then Menu on the new Menu Item we just created and change its name to "Phrases":

    Bearbeiten des Menü namensEditing the menu name

  5. Benennen wir nun die drei Standard Menü Elemente "Address", "Date" und "Gruß" um:Now let's rename the three default Menu Items "Address", "Date," and "Greeting":

    ![Das Menü "Ausdrücke"](menu-images/maint13.png "Das Menü "Ausdrücke"")The Phrases menu

  6. Fügen Sie ein viertes Menü Element hinzu, indem Sie ein Menü Element aus dem Bibliotheks Inspektor ziehen und es "Signature" aufrufen:Let's add a fourth Menu Item by dragging a Menu Item from the Library Inspector and calling it "Signature":

    Bearbeiten des Menü Element namensEditing the menu item name

  7. Speichern Sie die Änderungen in der Menüleiste.Save the changes to the menu bar.

Nun erstellen wir einen Satz benutzerdefinierter Aktionen, damit unsere neuen Menü Elemente für c#-Code verfügbar gemacht werden.Now let's create a set of custom actions so that our new menu items are exposed to C# code. Wechseln Sie in Xcode zur Ansicht Assistant :In Xcode let's switch to the Assistant view:

Erstellen der erforderlichen AktionenCreating the required actions

Führen Sie die folgenden Schritte aus:Let's do the following:

  1. Steuerelement: ziehen Sie das Adress Menü Element in die Datei appdelegat. h .Control-drag from the Address menu item to the AppDelegate.h file.

  2. Wechseln Sie zum Verbindungstyp in Aktion:Switch the Connection type to Action:

    Auswählen des Aktions TypsSelecting the action type

  3. Geben Sie den Namen "phrasaddress" ein, und klicken Sie auf die Schaltfläche verbinden , um die neue Aktion zu erstellen:Enter a Name of "phraseAddress" and press the Connect button to create the new action:

    Konfigurieren Sie die Aktion, indem Sie einen Namen eingeben.Configuring the action by entering a name.

  4. Wiederholen Sie die obigen Schritte für die Menü Elemente " Datum", " Begrüßung" und " Signatur ":Repeat the above steps for the Date, Greeting, and Signature menu items:

    Abgeschlossene AktionenThe completed actions

  5. Speichern Sie die Änderungen in der Menüleiste.Save the changes to the menu bar.

Als nächstes müssen wir ein Outlet für unsere Textansicht erstellen, damit wir den Inhalt aus dem Code anpassen können.Next we need to create an outlet for our text view so that we can adjust its content from code. Wählen Sie im Assistenten-Editor die Datei " ViewController. h " aus, und erstellen Sie ein neues Outlet namens documentText :Select the ViewController.h file in the Assistant Editor and create a new outlet called documentText:

Erstellen eines OutletsCreating an outlet

Kehren Sie zu Visual Studio für Mac zurück, um die Änderungen von Xcode zu synchronisieren.Return to Visual Studio for Mac to sync the changes from Xcode. Bearbeiten Sie als nächstes die Datei ViewController.cs , und führen Sie Sie wie folgt aus:Next edit the ViewController.cs file and make it look like the following:

using System;

using AppKit;
using Foundation;

namespace MacMenus
{
    public partial class ViewController : NSViewController
    {
        #region Application Access
        public static AppDelegate App {
            get { return (AppDelegate)NSApplication.SharedApplication.Delegate; }
        }
        #endregion

        #region Computed Properties
        public override NSObject RepresentedObject {
            get {
                return base.RepresentedObject;
            }
            set {
                base.RepresentedObject = value;
                // Update the view, if already loaded.
            }
        }

        public string Text {
            get { return documentText.Value; }
            set { documentText.Value = value; }
        } 
        #endregion

        #region Constructors
        public ViewController (IntPtr handle) : base (handle)
        {
        }
        #endregion

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

            // Do any additional setup after loading the view.
        }

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

            App.textEditor = this;
        }

        public override void ViewWillDisappear ()
        {
            base.ViewDidDisappear ();

            App.textEditor = null;
        }
        #endregion
    }
}

Dadurch wird der Text der Textansicht außerhalb der Klasse angezeigt, ViewController und der APP-Delegat wird informiert, wenn das Fenster den Fokus erhält oder verliert.This exposes the text of our text view outside of the ViewController class and informs the app delegate when the window gains or loses focus. Bearbeiten Sie nun die Datei AppDelegate.cs , und führen Sie Sie wie folgt aus:Now edit the AppDelegate.cs file and make it look like the following:

using AppKit;
using Foundation;
using System;

namespace MacMenus
{
    [Register ("AppDelegate")]
    public partial class AppDelegate : NSApplicationDelegate
    {
        #region Computed Properties
        public ViewController textEditor { get; set;} = null;
        #endregion

        #region Constructors
        public AppDelegate ()
        {
        }
        #endregion

        #region Override Methods
        public override void DidFinishLaunching (NSNotification notification)
        {
            // Insert code here to initialize your application
        }

        public override void WillTerminate (NSNotification notification)
        {
            // Insert code here to tear down your application
        }
        #endregion

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

            if (dlg.RunModal () == 1) {
                var alert = new NSAlert () {
                    AlertStyle = NSAlertStyle.Informational,
                    InformativeText = "At this point we should do something with the folder that the user just selected in the Open File Dialog box...",
                    MessageText = "Folder Selected"
                };
                alert.RunModal ();
            }
        }

        partial void phrasesAddress (Foundation.NSObject sender) {

            textEditor.Text += "Xamarin HQ\n394 Pacific Ave, 4th Floor\nSan Francisco CA 94111\n\n";
        }

        partial void phrasesDate (Foundation.NSObject sender) {

            textEditor.Text += DateTime.Now.ToString("D");
        }

        partial void phrasesGreeting (Foundation.NSObject sender) {

            textEditor.Text += "Dear Sirs,\n\n";
        }

        partial void phrasesSignature (Foundation.NSObject sender) {

            textEditor.Text += "Sincerely,\n\nKevin Mullins\nXamarin,Inc.\n";
        }
        #endregion
    }
}

Hier haben wir AppDelegate eine partielle Klasse erstellt, damit wir die in Interface Builder definierten Aktionen und Outlets verwenden können.Here we've made the AppDelegate a partial class so that we can use the actions and outlets that we defined in Interface Builder. Wir machen außerdem eine verfügbar textEditor , um zu verfolgen, welches Fenster derzeit den Fokus hat.We also expose a textEditor to track which window is currently in focus.

Die folgenden Methoden werden verwendet, um das benutzerdefinierte Menü und die Menü Elemente zu behandeln:The following methods are used to handle our custom menu and menu items:

partial void phrasesAddress (Foundation.NSObject sender) {

    if (textEditor == null) return;
    textEditor.Text += "Xamarin HQ\n394 Pacific Ave, 4th Floor\nSan Francisco CA 94111\n\n";
}

partial void phrasesDate (Foundation.NSObject sender) {

    if (textEditor == null) return;
    textEditor.Text += DateTime.Now.ToString("D");
}

partial void phrasesGreeting (Foundation.NSObject sender) {

    if (textEditor == null) return;
    textEditor.Text += "Dear Sirs,\n\n";
}

partial void phrasesSignature (Foundation.NSObject sender) {

    if (textEditor == null) return;
    textEditor.Text += "Sincerely,\n\nKevin Mullins\nXamarin,Inc.\n";
}

Wenn wir nun die Anwendung ausführen, sind alle Elemente im Menü " Ausdruck " aktiv und fügen der Textansicht den Ausdruck "geben" hinzu, wenn Sie ausgewählt wird:Now if we run our application, all of the items in the Phrase menu will be active and will add the give phrase to the text view when selected:

Ein Beispiel für die Ausführung der APPAn example of the app running

Nun, da wir die Grundlagen der Arbeit mit der Menüleiste der Anwendung haben, sehen wir uns das Erstellen eines benutzerdefinierten Kontextmenüs an.Now that we have the basics of working with the application menu bar down, let's look at creating a custom contextual menu.

Erstellen von Menüs aus CodeCreating menus from code

Zusätzlich zum Erstellen von Menüs und Menü Elementen mit der Interface Builder von Xcode kann es vorkommen, dass eine xamarin. Mac-app ein Menü, ein Untermenü oder ein Menü Element aus dem Code erstellen, ändern oder entfernen muss.In addition to creating menus and menu items with Xcode's Interface Builder, there might be times when a Xamarin.Mac app needs to create, modify, or remove a menu, sub-menu, or menu item from code.

Im folgenden Beispiel wird eine Klasse erstellt, die die Informationen über die Menü Elemente und Untermenüs enthält, die dynamisch dynamisch erstellt werden:In the following example, a class is created to hold the information about the menu items and sub-menus that will be dynamically created on-the-fly:

using System;
using System.Collections.Generic;
using Foundation;
using AppKit;

namespace AppKit.TextKit.Formatter
{
    public class LanguageFormatCommand : NSObject
    {
        #region Computed Properties
        public string Title { get; set; } = "";
        public string Prefix { get; set; } = "";
        public string Postfix { get; set; } = "";
        public List<LanguageFormatCommand> SubCommands { get; set; } = new List<LanguageFormatCommand>();
        #endregion

        #region Constructors
        public LanguageFormatCommand () {

        }

        public LanguageFormatCommand (string title)
        {
            // Initialize
            this.Title = title;
        }

        public LanguageFormatCommand (string title, string prefix)
        {
            // Initialize
            this.Title = title;
            this.Prefix = prefix;
        }

        public LanguageFormatCommand (string title, string prefix, string postfix)
        {
            // Initialize
            this.Title = title;
            this.Prefix = prefix;
            this.Postfix = postfix;
        }
        #endregion
    }
}

Hinzufügen von Menüs und ElementenAdding menus and items

Wenn diese Klasse definiert ist, analysiert die folgende Routine eine Auflistung von LanguageFormatCommand Objekten und erstellt rekursiv neue Menüs und Menü Elemente, indem Sie an den unteren Rand des vorhandenen Menüs angehängt wird (in Interface Builder erstellt), das übergeben wurde:With this class defined, the following routine will parse a collection of LanguageFormatCommandobjects and recursively build new menus and menu items by appending them to the bottom of the existing menu (created in Interface Builder) that has been passed in:

private void AssembleMenu(NSMenu menu, List<LanguageFormatCommand> commands) {
    NSMenuItem menuItem;

    // Add any formatting commands to the Formatting menu
    foreach (LanguageFormatCommand command in commands) {
        // Add separator or item?
        if (command.Title == "") {
            menuItem = NSMenuItem.SeparatorItem;
        } else {
            menuItem = new NSMenuItem (command.Title);

            // Submenu?
            if (command.SubCommands.Count > 0) {
                // Yes, populate submenu
                menuItem.Submenu = new NSMenu (command.Title);
                AssembleMenu (menuItem.Submenu, command.SubCommands);
            } else {
                // No, add normal menu item
                menuItem.Activated += (sender, e) => {
                    // Apply the command on the selected text
                    TextEditor.PerformFormattingCommand (command);
                };
            }
        }
        menu.AddItem (menuItem);
    }
}

Für alle LanguageFormatCommand Objekte, die eine leere Title Eigenschaft haben, erstellt diese Routine ein Menü Element mit Trenn Zeichen (eine dünne graue Linie) zwischen menüabschnitten:For any LanguageFormatCommand object that has a blank Title property, this routine creates a Separator menu item (a thin gray line) between menu sections:

menuItem = NSMenuItem.SeparatorItem;

Wenn ein Titel angegeben wird, wird ein neues Menü Element mit diesem Titel erstellt:If a title is provided, a new menu item with that title is created:

menuItem = new NSMenuItem (command.Title);

Wenn das-Objekt untergeordnete LanguageFormatCommand LanguageFormatCommand Objekte enthält, wird ein Untermenü erstellt, und die- AssembleMenu Methode wird rekursiv aufgerufen, um das folgende Menü zu erstellen:If the LanguageFormatCommand object contains child LanguageFormatCommand objects, a sub-menu is created and the AssembleMenu method is recursively called to build out that menu:

menuItem.Submenu = new NSMenu (command.Title);
AssembleMenu (menuItem.Submenu, command.SubCommands);

Für jedes neue Menü Element, das keine Untermenüs enthält, wird Code hinzugefügt, um das Menü Element zu behandeln, das vom Benutzer ausgewählt wird:For any new menu item that does not have sub-menus, code is added to handle the menu item being selected by the user:

menuItem.Activated += (sender, e) => {
    // Do something when the menu item is selected
    ...
};

Testen der MenüerstellungTesting the menu creation

Wenn der gesamte obige Code vorhanden ist, wenn die folgende Auflistung von- LanguageFormatCommand Objekten erstellt wurde:With all of the above code in place, if the following collection of LanguageFormatCommand objects were created:

// Define formatting commands
FormattingCommands.Add(new LanguageFormatCommand("Strong","**","**"));
FormattingCommands.Add(new LanguageFormatCommand("Emphasize","_","_"));
FormattingCommands.Add(new LanguageFormatCommand("Inline Code","`","`"));
FormattingCommands.Add(new LanguageFormatCommand("Code Block","```\n","\n```"));
FormattingCommands.Add(new LanguageFormatCommand("Comment","<!--","-->"));
FormattingCommands.Add (new LanguageFormatCommand ());
FormattingCommands.Add(new LanguageFormatCommand("Unordered List","* "));
FormattingCommands.Add(new LanguageFormatCommand("Ordered List","1. "));
FormattingCommands.Add(new LanguageFormatCommand("Block Quote","> "));
FormattingCommands.Add (new LanguageFormatCommand ());

var Headings = new LanguageFormatCommand ("Headings");
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 1","# "));
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 2","## "));
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 3","### "));
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 4","#### "));
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 5","##### "));
Headings.SubCommands.Add(new LanguageFormatCommand("Heading 6","###### "));
FormattingCommands.Add (Headings);

FormattingCommands.Add(new LanguageFormatCommand ());
FormattingCommands.Add(new LanguageFormatCommand("Link","[","]()"));
FormattingCommands.Add(new LanguageFormatCommand("Image","![](",")"));
FormattingCommands.Add(new LanguageFormatCommand("Image Link","[![](",")](LinkImageHere)"));

Und diese Auflistung, die an die-Funktion übertragen AssembleMenu wird (das Menü Format ist als Basis festgelegt), werden die folgenden dynamischen Menüs und Menü Elemente erstellt:And that collection passed to the AssembleMenu function (with the Format Menu set as the base), the following dynamic menus and menu items would be created:

Die neuen Menü Elemente in der laufenden appThe new menu items in the running app

Entfernen von Menüs und ElementenRemoving menus and items

Wenn Sie ein Menü oder ein Menü Element von der Benutzeroberfläche der APP entfernen müssen, können Sie die- RemoveItemAt Methode der- NSMenu Klasse verwenden, indem Sie Ihr den NULL basierten Index des zu entfernenden Elements bereitstellen.If you need to remove any menu or menu item from the app's user interface, you can use the RemoveItemAt method of the NSMenu class simply by giving it the zero based index of the item to remove.

Wenn Sie z. b. die Menüs und Menü Elemente entfernen möchten, die von der obigen Routine erstellt wurden, können Sie den folgenden Code verwenden:For example, to remove the menus and menu items created by the routine above, you could use the following code:

public void UnpopulateFormattingMenu(NSMenu menu) {

    // Remove any additional items
    for (int n = (int)menu.Count - 1; n > 4; --n) {
        menu.RemoveItemAt (n);
    }
}

Im Fall des obigen Codes werden die ersten vier Menü Elemente in der Xcode-Interface Builder und in der App zur Verfügung gestellt, sodass Sie nicht dynamisch entfernt werden.In the case of the code above, the first four menu items are created in Xcode's Interface Builder and aways available in the app, so they are not removed dynamically.

KontextmenüsContextual menus

Kontextmenüs werden angezeigt, wenn der Benutzer mit der rechten Maustaste klickt oder auf ein Element in einem Fenster klickt.Contextual menus appear when the user right-clicks or control-clicks an item in a window. Standardmäßig verfügen mehrere in macOS integrierte Benutzeroberflächen Elemente bereits über Kontextmenüs (z. b. die Textansicht).By default, several of the UI elements built into macOS already have contextual menus attached to them (such as the text view). Es kann jedoch vorkommen, dass Sie eigene benutzerdefinierte Kontextmenüs für ein UI-Element erstellen möchten, das einem Fenster hinzugefügt wurde.However, there might be times when we want to create our own custom contextual menus for a UI element that we have added to a window.

Wir bearbeiten nun die Datei " Main. Storyboard " in Xcode und fügen dem Design ein Fenster Fenster hinzu, legen die Klasse auf "nspanel" im Identitäts Inspektor fest, fügen dem Menü " Fenster " ein neues Assistenten Element hinzu und fügen es mithilfe eines " Show segue" an das neue Fenster an:Let's edit our Main.storyboard file in Xcode and add a Window window to our design, set its Class to "NSPanel" in the Identity Inspector, add a new Assistant item to the Window menu, and attach it to the new window using a Show Segue:

![Legen Sie den Typ "Typ" in der Haupt-Punkt-storyboarddatei fest.](menu-images/context01.png "Festlegen des Typs "Typ"")Setting the segue type in the Main dot storyboard file.

Führen Sie die folgenden Schritte aus:Let's do the following:

  1. Ziehen Sie eine Bezeichnung aus dem Bibliotheks Inspektor in das Panel Fenster, und legen Sie den Text auf "Property" fest:Drag a Label from the Library Inspector onto the Panel window and set its text to "Property":

    Bearbeiten des Werts der BezeichnungEditing the label's value

  2. Ziehen Sie als nächstes ein Menü aus dem Bibliotheks Inspektor auf den Ansichts Controller in der Ansichts Hierarchie, und benennen Sie die drei Standardmenü Elemente Document, Text und Font um:Next drag a Menu from the Library Inspector onto the View Controller in the View Hierarchy and rename the three default menu items Document, Text and Font:

    Die erforderlichen Menü ElementeThe required menu items

  3. Ziehen Sie jetzt das Steuerelement aus der Eigenschaften Bezeichnung in das Menü:Now control-drag from the Property Label onto the Menu:

    Ziehen zum Erstellen einer TabelleDragging to create a segue

  4. Wählen Sie im Popup Dialogfeld die Option Menü:From the popup dialog, select Menu:

    ![Legen Sie den Typ "*" fest, indem Sie im Kontextmenü "Bezeichnung" das Menü aus den Outlets auswählen](menu-images/context05.png "Festlegen des Typs "Typ"")Setting the segue type by selecting menu from Outlets in the Label context menu.

  5. Legen Sie aus dem Identitäts Inspektor die Klasse des Ansichts Controllers auf "panelviewcontroller" fest:From the Identity Inspector, set the View Controller's class to "PanelViewController":

    ![Festlegen der Klasse "Klasse"](menu-images/context10.png "Festlegen der Klasse "Klasse"")Setting the segue class

  6. Wechseln Sie zurück zu Visual Studio für Mac synchronisieren, und kehren Sie dann zu Interface Builder zurück.Switch back to Visual Studio for Mac to sync, then return to Interface Builder.

  7. Wechseln Sie zum Assistenten-Editor , und wählen Sie die Datei panelviewcontroller. h aus.Switch to the Assistant Editor and select the PanelViewController.h file.

  8. Erstellen Sie eine Aktion für das Dokument Menü Element mit dem Namen propertyDocument :Create an action for the Document menu item called propertyDocument:

    Konfigurieren der Aktion namens propertydocument.Configuring the action named propertyDocument.

  9. Wiederholen Sie das Erstellen von Aktionen für die verbleibenden Menü Elemente:Repeat creating actions for the remaining menu items:

    Wiederholte Aktionen für die verbleibenden Menü Elemente.Repeating actions for the remaining menu items.

  10. Erstellen Sie schließlich ein Outlet für die Eigenschaften Bezeichnung mit dem Namen propertyLabel :Finally create an outlet for the Property Label called propertyLabel:

    Konfigurieren des OutletsConfiguring the outlet

  11. Speichern Sie die Änderungen, und kehren Sie zu Visual Studio für Mac zurück, um mit Xcode zu synchronisieren.Save your changes and return to Visual Studio for Mac to sync with Xcode.

Bearbeiten Sie die Datei PanelViewController.cs , und fügen Sie den folgenden Code hinzu:Edit the PanelViewController.cs file and add the following code:

partial void propertyDocument (Foundation.NSObject sender) {
    propertyLabel.StringValue = "Document";
}

partial void propertyFont (Foundation.NSObject sender) {
    propertyLabel.StringValue = "Font";
}

partial void propertyText (Foundation.NSObject sender) {
    propertyLabel.StringValue = "Text";
}

Wenn wir nun die Anwendung ausführen und mit der rechten Maustaste auf die Eigenschaften Bezeichnung im Panel klicken, wird unser benutzerdefiniertes Kontextmenü angezeigt.Now if we run the application and right-click on the property label in the panel, we'll see our custom contextual menu. Wenn Sie ein Element im Menü auswählen, ändert sich der Wert der Bezeichnung:If we select and item from the menu, the label's value will change:

Das Kontextmenü, das ausgeführt wirdThe contextual menu running

Im nächsten Abschnitt sehen wir uns das Erstellen von Status leisten Menüs an.Next let's look at creating status bar menus.

StatusBar-MenüsStatus bar menus

In den Menüs der Statusleiste wird eine Auflistung von Status Menü Elementen angezeigt, die eine Interaktion mit oder Feedback für den Benutzer bereitstellen, z. b. ein Menü oder ein Bild, das den Zustand einer Anwendung widerspiegeltStatus bar menus display a collection of status menu items that provide interaction with or feedback to the user, such as a menu or an image reflecting an application’s state. Das Menü Statusleiste einer Anwendung ist aktiviert und aktiv, selbst wenn die Anwendung im Hintergrund ausgeführt wird.An application's status bar menu is enabled and active even if the application is running in the background. Die systemweite Statusleiste befindet sich auf der rechten Seite der Anwendungsmenü Leiste und ist die einzige Statusleiste, die derzeit in macOS verfügbar ist.The system-wide status bar resides at the right side of the application menu bar and is the only Status Bar currently available in macOS.

Bearbeiten Sie die Datei AppDelegate.cs , und führen Sie die DidFinishLaunching Methode wie folgt aus:Let's edit our AppDelegate.cs file and make the DidFinishLaunching method look like the following:

public override void DidFinishLaunching (NSNotification notification)
{
    // Create a status bar menu
    NSStatusBar statusBar = NSStatusBar.SystemStatusBar;

    var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable);
    item.Title = "Text";
    item.HighlightMode = true;
    item.Menu = new NSMenu ("Text");

    var address = new NSMenuItem ("Address");
    address.Activated += (sender, e) => {
        PhraseAddress(address);
    };
    item.Menu.AddItem (address);

    var date = new NSMenuItem ("Date");
    date.Activated += (sender, e) => {
        PhraseDate(date);
    };
    item.Menu.AddItem (date);

    var greeting = new NSMenuItem ("Greeting");
    greeting.Activated += (sender, e) => {
        PhraseGreeting(greeting);
    };
    item.Menu.AddItem (greeting);

    var signature = new NSMenuItem ("Signature");
    signature.Activated += (sender, e) => {
        PhraseSignature(signature);
    };
    item.Menu.AddItem (signature);
}

NSStatusBar statusBar = NSStatusBar.SystemStatusBar; ermöglicht uns den Zugriff auf die systemweite Statusleiste.NSStatusBar statusBar = NSStatusBar.SystemStatusBar; gives us access to the system-wide status bar. var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable); erstellt ein neues Status leisten Element.var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable); creates a new status bar item. Von dort aus erstellen wir ein Menü und mehrere Menü Elemente und fügen das Menü an das soeben erstellte Status leisten Element an.From there we create a menu and a number of menu items and attach the menu to the status bar item we just created.

Wenn die Anwendung ausgeführt wird, wird das neue StatusBar-Element angezeigt.If we run the application, the new status bar item will be displayed. Wenn Sie im Menü ein Element auswählen, wird der Text in der Textansicht geändert:Selecting an item from the menu will change the text in the text view:

![Das Menü "Statusleiste" wird ausgeführt](menu-images/statusbar01.png "Das Menü "Statusleiste" wird ausgeführt")The status bar menu running

Sehen wir uns nun die Erstellung benutzerdefinierter Dock Menü Elemente an.Next, let's look at creating custom dock menu items.

Benutzerdefinierte Andock MenüsCustom dock menus

Das Menü Andocken wird für Ihre Macintosh-Anwendung angezeigt, wenn der Benutzer mit der rechten Maustaste klickt oder mit der Maus auf das Symbol der Anwendung im Dock klickt:The dock menu appears for you Mac application when the user right-clicks or control-clicks the application's icon in the dock:

Ein benutzerdefiniertes Andock MenüA custom dock menu

Erstellen Sie ein benutzerdefiniertes Andock Menü für die Anwendung, indem Sie die folgenden Schritte ausführen:Let's create a custom dock menu for our application by doing the following:

  1. Klicken Sie in Visual Studio für Mac mit der rechten Maustaste auf das Anwendungsprojekt, und wählen Sie neue Datei Hinzufügen > ... aus. Wählen Sie im Dialogfeld neue Datei die Option xamarin. Mac > leere Schnittstellen Definition aus, verwenden Sie "DockMenu" als Name , und klicken Sie auf die Schaltfläche " neu ", um die neue Datei " DockMenu. XIb " zu erstellenIn Visual Studio for Mac, right-click on the application's project and select Add > New File... From the new file dialog, select Xamarin.Mac > Empty Interface Definition, use "DockMenu" for the Name and click the New button to create the new DockMenu.xib file:

    Hinzufügen einer leeren Schnittstellen DefinitionAdding an empty interface definition

  2. Doppelklicken Sie im Lösungspad auf die Datei " DockMenu. XIb ", um Sie für die Bearbeitung in Xcode zu öffnen.In the Solution Pad, double-click the DockMenu.xib file to open it for editing in Xcode. Erstellen Sie ein neues Menü mit den folgenden Elementen : Address, Date, Gruß und Signature .Create a new Menu with the following items: Address, Date, Greeting, and Signature

    Gestalten der BenutzeroberflächeLaying out the UI

  3. Als nächstes verbinden wir unsere neuen Menü Elemente mit den vorhandenen Aktionen, die wir im Abschnitt hinzufügen, bearbeiten und Löschen von Menüs für das benutzerdefinierte Menü erstellt haben.Next, let's connect our new menu items to our existing actions that we created for our custom menu in the Adding, Editing and Deleting Menus section above. Wechseln Sie zum Verbindungs Inspektor , und wählen Sie den ersten Responder in der Schnittstellen Hierarchie aus.Switch to the Connection Inspector and select the First Responder in the Interface Hierarchy. Scrollen Sie nach unten, und suchen Sie die phraseAddress: Aktion.Scroll down and find the phraseAddress: action. Ziehen Sie eine Linie vom Kreis für diese Aktion in das Adress Menü Element:Drag a line from the circle on that action to the Address menu item:

    Ziehen Sie eine Linie zum Adress Menü Element.Dragging a line to the Address menu item.

  4. Wiederholen Sie diesen Vorgang für alle anderen Menü Elemente, die an die entsprechenden Aktionen angehängt werden:Repeat for all of the other menu items attaching them to their corresponding actions:

    Wiederholung für andere Menü Elemente, die an die entsprechenden Aktionen angehängt werden.Repeating for other menu items attaching them to their corresponding actions.

  5. Wählen Sie anschließend die Anwendung in der Schnittstellen Hierarchie aus.Next, select the Application in the Interface Hierarchy. Ziehen Sie im Verbindungs Inspektor eine Linie aus dem Kreis des dockMenu Outlets auf das soeben erstellte Menü:In the Connection Inspector, drag a line from the circle on the dockMenu outlet to the menu we just created:

    Ziehen Sie die Übertragung auf das Outlet.Dragging the wire up the outlet

  6. Speichern Sie die Änderungen, und wechseln Sie zurück zu Visual Studio für Mac, um mit Xcode zu synchronisieren.Save your changes and switch back to Visual Studio for Mac to sync with Xcode.

  7. Doppelklicken Sie auf die Info. plist -Datei, um Sie zur Bearbeitung zu öffnen:Double-click the Info.plist file to open it for editing:

    Bearbeiten der Info.plist-DateiEditing the Info.plist file

  8. Klicken Sie unten auf dem Bildschirm auf die Registerkarte Quelle :Click the Source tab at the bottom of the screen:

    Auswählen der Quell AnsichtSelecting the Source view

  9. Klicken Sie auf neuen Eintrag hinzufügen, klicken Sie auf die grüne Plus-Schaltfläche, legen Sie den Eigenschaftsnamen auf "appledockmenu" und den Wert auf "DockMenu" (der Name der neuen XIb-Datei ohne Erweiterung) fest:Click Add new entry, click the green plus button, set the property name to "AppleDockMenu" and the value to "DockMenu" (the name of our new .xib file without the extension):

    Hinzufügen des DockMenu-ElementsAdding the DockMenu item

Wenn wir nun die Anwendung ausführen und mit der rechten Maustaste auf das zugehörige Symbol im Dock klicken, werden die neuen Menü Elemente angezeigt:Now if we run our application and right-click on its icon in the Dock, our new menu items will be displayed:

Ein Beispiel für das Andock Menü, das ausgeführt wird.An example of the dock menu running

Wenn wir eines der benutzerdefinierten Elemente aus dem Menü auswählen, wird der Text in der Textansicht geändert.If we select one of the custom items from the menu, the text in our text view will be modified.

Popup Schaltfläche und pulldownlistenPop-up button and pull-down lists

Eine Popup Schaltfläche zeigt ein ausgewähltes Element an und zeigt eine Liste der Optionen an, die Sie auswählen können, wenn der Benutzer darauf klickt.A pop-up button displays a selected item and presents a list of options to select from when clicked by the user. Eine Pulldownliste ist ein Typ von Popup Schaltfläche, der in der Regel für die Auswahl von Befehlen verwendet wird, die für den Kontext der aktuellen Aufgabe spezifisch sind.A pull-down list is a type of pop-up button usually used for selecting commands specific to the context of the current task. Beides kann an beliebiger Stelle in einem Fenster angezeigt werden.Both can appear anywhere in a window.

Erstellen Sie eine benutzerdefinierte Popup Schaltfläche für die Anwendung, indem Sie die folgenden Schritte ausführen:Let's create a custom pop-up button for our application by doing the following:

  1. Bearbeiten Sie die Datei " Main. Storyboard " in Xcode, und ziehen Sie eine Popup Schaltfläche aus dem Bibliotheks Inspektor in das Panel Fenster, das im Abschnitt " Kontextmenüs " erstellt wurde:Edit the Main.storyboard file in Xcode and drag a Popup Button from the Library Inspector onto the Panel window we created in the Contextual Menus section:

    Hinzufügen einer Popup SchaltflächeAdding a popup button

  2. Fügen Sie ein neues Menü Element hinzu, und legen Sie die Titel der Elemente im Popup auf Folgendes fest: Address, Date, Gruß und Signature .Add a new menu item and set the titles of the Items in the Popup to: Address, Date, Greeting, and Signature

    Konfigurieren der Menü ElementeConfiguring the menu items

  3. Als nächstes verbinden wir unsere neuen Menü Elemente mit den vorhandenen Aktionen, die wir im Abschnitt hinzufügen, bearbeiten und Löschen von Menüs für das benutzerdefinierte Menü erstellt haben.Next, let's connect our new menu items to the existing actions that we created for our custom menu in the Adding, Editing and Deleting Menus section above. Wechseln Sie zum Verbindungs Inspektor , und wählen Sie den ersten Responder in der Schnittstellen Hierarchie aus.Switch to the Connection Inspector and select the First Responder in the Interface Hierarchy. Scrollen Sie nach unten, und suchen Sie die phraseAddress: Aktion.Scroll down and find the phraseAddress: action. Ziehen Sie eine Linie vom Kreis für diese Aktion in das Adress Menü Element:Drag a line from the circle on that action to the Address menu item:

    Ziehen, um eine Aktion zu übertragenDragging to wire up an action

  4. Wiederholen Sie diesen Vorgang für alle anderen Menü Elemente, die an die entsprechenden Aktionen angehängt werden:Repeat for all of the other menu items attaching them to their corresponding actions:

    Alle erforderlichen AktionenAll required actions

  5. Speichern Sie die Änderungen, und wechseln Sie zurück zu Visual Studio für Mac, um mit Xcode zu synchronisieren.Save your changes and switch back to Visual Studio for Mac to sync with Xcode.

Wenn wir nun die Anwendung ausführen und ein Element aus dem Popup auswählen, ändert sich der Text in der Textansicht:Now if we run our application and select an item from the popup, the text in our text view will change:

Ein Beispiel für die Ausführung des PopupsAn example of the popup running

Sie können pulldownlisten genau wie Popup Schaltflächen erstellen und mit diesen arbeiten.You can create and work with pull-down lists in the exact same way as pop-up buttons. Anstatt an eine vorhandene Aktion anzufügen, können Sie eigene benutzerdefinierte Aktionen wie im Kontextmenü des Abschnitts Kontextmenüs erstellen.Instead of attaching to existing action, you could create your own custom actions just like we did for our contextual menu in the Contextual Menus section.

ZusammenfassungSummary

In diesem Artikel wurde die Arbeit mit Menüs und Menü Elementen in einer xamarin. Mac-Anwendung ausführlich erläutert.This article has taken a detailed look at working with menus and menu items in a Xamarin.Mac application. Zuerst haben wir die Menüleiste der Anwendung untersucht. Anschließend haben wir uns mit dem Erstellen von Kontextmenüs beschäftigt. als nächstes haben wir Status leisten Menüs und benutzerdefinierte Andock Menüs überprüft.First we examined the application's menu bar, then we looked at creating contextual menus, next we examined status bar menus and custom dock menus. Schließlich haben wir Popup Menüs und pulldownlisten behandelt.Finally, we covered pop-up menus and pull-down Lists.