Xamarin.ios의 메뉴Menus in Xamarin.Mac

이 문서에서는 Xamarin.ios 응용 프로그램에서 메뉴를 사용 하는 방법을 설명 합니다. Xcode 및 Interface Builder에서 메뉴 및 메뉴 항목을 만들고 유지 관리 하 고 프로그래밍 방식으로 작업 하는 방법을 설명 합니다.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.

Xamarin.ios 응용 프로그램 C# 에서 및 .net을 사용 하는 경우 목표-C 및 Xcode에서 작업 하는 개발자와 동일한 cocoa 메뉴에 액세스할 수 있습니다.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. Xamarin.ios는 Xcode와 직접 통합 되므로 Xcode의 Interface Builder를 사용 하 여 메뉴 모음, 메뉴 및 메뉴 항목을 만들고 유지 관리할 수 있습니다 (또는 필요에 따라 코드에서 C# 직접 만들 수 있음).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).

메뉴는 Mac 응용 프로그램의 사용자 경험의 핵심 부분이 며 일반적으로 사용자 인터페이스의 다양 한 부분에 표시 됩니다.Menus are an integral part of a Mac application's user experience and commonly appear in various parts of the user interface:

  • 응용 프로그램의 메뉴 모음 -모든 Mac 응용 프로그램의 화면 맨 위에 표시 되는 주 메뉴입니다.The application's menu bar - This is the main menu that appears at the top of the screen for every Mac application.
  • 상황에 맞는 메뉴 -사용자가 창의 항목을 마우스 오른쪽 단추로 클릭 하거나 컨트롤을 클릭할 때 나타납니다.Contextual menus - These appear when the user right-clicks or control-clicks an item in a window.
  • 상태 표시줄 -화면 맨 위에 표시 되 고 (메뉴 모음 클록의 왼쪽), 항목이 추가 되 면 왼쪽으로 증가 하는 응용 프로그램 메뉴 모음의 오른쪽 끝에 있는 영역입니다.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.
  • 도킹 메뉴 -사용자가 응용 프로그램의 아이콘을 마우스 오른쪽 단추로 클릭 하거나 컨트롤을 클릭할 때 표시 되는 도킹의 각 응용 프로그램에 대 한 메뉴 또는 사용자가 아이콘을 마우스 왼쪽 단추로 클릭 하 고 마우스 단추를 누른 경우에 표시 되는 메뉴입니다.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.
  • 팝업 단추 및 드롭다운 목록 -팝업 단추는 선택한 항목을 표시 하 고 사용자가 클릭할 때 선택할 수 있는 옵션 목록을 표시 합니다.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. 풀 다운 목록은 일반적으로 현재 태스크의 컨텍스트와 관련 된 명령을 선택 하는 데 사용 되는 팝업 단추의 유형입니다.A pull-down list is a type of pop-up button usually used for selecting commands specific to the context of the current task. 둘 다 창의 어디에 나 나타날 수 있습니다.Both can appear anywhere in a window.

예제 메뉴An example menu

이 문서에서는 Xamarin.ios 응용 프로그램에서 Cocoa 메뉴 모음, 메뉴 및 메뉴 항목을 사용 하는 기본 사항을 설명 합니다.In this article, we'll cover the basics of working with Cocoa menu bars, menus, and menu items in a Xamarin.Mac application. Hello, Mac 문서를 먼저 사용 하는 것이 가장 좋습니다. 특히 Xcode 및 Interface Builder콘센트 및 작업 섹션을 소개 하 고,에서 사용할 주요 개념 및 기술을 설명 하 고 있습니다. 이 문서를 참조 하세요.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.

Xamarin.ios 내부 문서의 클래스/메서드를 대상으로 노출 C# -C 섹션을 살펴보고 C# 클래스를 연결 하는 데 사용 되는 RegisterExport 특성에 대해 설명 합니다. 목표-C 개체 및 UI 요소입니다.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.

응용 프로그램의 메뉴 모음The application's menu bar

Windows OS에서 실행 되는 응용 프로그램과 달리 모든 창에 자체 메뉴 모음이 연결 되어 있는 경우 macOS에서 실행 되는 모든 응용 프로그램에는 해당 응용 프로그램의 모든 창에 사용 되는 화면 위쪽에 실행 되는 단일 메뉴 모음이 있습니다.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:

메뉴 모음A menu bar

이 메뉴 모음의 항목은 지정 된 순간에 현재 컨텍스트 또는 응용 프로그램의 상태와 해당 사용자 인터페이스를 기반으로 활성화 되거나 비활성화 됩니다.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. 예를 들어 사용자가 텍스트 필드를 선택 하면 복사잘라내기와 같이 편집 메뉴의 항목이 활성화 됩니다.For example: if the user selects a text field, items on the Edit menu will be come enabled such as Copy and Cut.

Apple 및 기본적으로 모든 macOS 응용 프로그램은 응용 프로그램의 메뉴 모음에 표시 되는 표준 메뉴 및 메뉴 항목 집합을 포함 합니다.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 메뉴 -이 메뉴는 실행 중인 응용 프로그램에 관계 없이 항상 사용자가 사용할 수 있는 시스템 차원 항목에 대 한 액세스를 제공 합니다.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. 개발자는 이러한 항목을 수정할 수 없습니다.These items cannot be modified by the developer.
  • 앱 메뉴 -이 메뉴는 응용 프로그램의 이름을 굵게 표시 하 고 사용자가 현재 실행 중인 응용 프로그램을 식별 하는 데 도움이 됩니다.App menu - This menu displays the application's name in bold and helps the user identify what application is currently running. 응용 프로그램을 종료 하는 것과 같이 지정 된 문서 또는 프로세스가 아니라 전체적으로 응용 프로그램에 적용 되는 항목을 포함 합니다.It contains items that apply to the application as a whole and not a given document or process such as quitting the application.
  • 파일 메뉴 -응용 프로그램이 작동 하는 문서를 생성, 열기 또는 저장 하는 데 사용 되는 항목입니다.File menu - Items used to create, open, or save documents that your application works with. 응용 프로그램이 문서 기반이 아니면이 메뉴의 이름을 바꾸거나 제거할 수 있습니다.If your application is not document-based, this menu can be renamed or removed.
  • 편집 메뉴 -응용 프로그램의 사용자 인터페이스에서 요소를 편집 하거나 수정 하는 데 사용 되는 잘라내기, 복사붙여넣기 와 같은 명령을 보관 합니다.Edit menu - Holds commands such as Cut, Copy, and Paste which are used to edit or modify elements in the application's user interface.
  • 서식 메뉴 -응용 프로그램이 텍스트와 함께 작동 하는 경우이 메뉴에는 해당 텍스트의 서식을 조정 하는 명령이 포함 됩니다.Format menu - If the application works with text, this menu holds commands to adjust the formatting of that text.
  • 보기 메뉴 -응용 프로그램의 사용자 인터페이스에서 콘텐츠가 표시 되는 방법 (표시)에 영향을 주는 명령을 보유 합니다.View menu - Holds commands that affect how content is displayed (viewed) in the application's user interface.
  • 응용 프로그램 관련 메뉴 -응용 프로그램과 관련 된 모든 메뉴 (예: 웹 브라우저의 책갈피 메뉴)입니다.Application-specific menus - These are any menus that are specific to your application (such as a bookmarks menu for a web browser). 막대의 보기 창과 메뉴 사이에 표시 되어야 합니다.They should appear between the View and Window menus on the bar.
  • 창 메뉴 -응용 프로그램에서 windows를 사용 하기 위한 명령과 현재 열려 있는 창 목록을 포함 합니다.Window menu - Contains commands for working with windows in your application, as well as a list of current open windows.
  • 도움말 메뉴 -응용 프로그램이 화면 도움말을 제공 하는 경우 도움말 메뉴가 표시줄의 가장 오른쪽 메뉴 여야 합니다.Help menu - If your application provides onscreen help, the Help menu should be the right-most menu on the bar.

응용 프로그램 메뉴 모음과 표준 메뉴 및 메뉴 항목에 대 한 자세한 내용은 Apple의 휴먼 인터페이스 지침을 참조 하십시오.For more information about the application menu bar and standard menus and menu items, please see Apple's Human Interface Guidelines.

기본 응용 프로그램 메뉴 모음The default application menu bar

새 Xamarin.ios 프로젝트를 만들 때마다 macOS 응용 프로그램에 일반적으로 적용 되는 일반적인 항목을 포함 하는 표준 기본 응용 프로그램 메뉴 모음이 자동으로 표시 됩니다 (위 섹션에서 설명).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). 응용 프로그램의 기본 메뉴 모음은 Solution Pad의 프로젝트 아래에 있는 주 storyboard 파일 (앱 UI의 나머지 부분과 함께)에서 정의 됩니다.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:

![주 스토리 보드를 선택 합니다] . (menu-images/appmenu02.png "주 스토리 보드를 선택 합니다") .Select the main storyboard

주 storyboard 파일을 두 번 클릭 하 여 Xcode의 Interface Builder 편집을 위해 엽니다. 그러면 메뉴 편집기 인터페이스가 나타납니다.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:

Xcode에서 UI 편집Editing the UI in Xcode

여기에서 파일 메뉴의 열기 메뉴 항목 등의 항목을 클릭 하 고 특성 검사자에서 해당 속성을 편집 하거나 조정할 수 있습니다.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:

메뉴의 특성 편집Editing a menu's attributes

이 문서의 뒷부분에서 메뉴와 항목을 추가, 편집 및 삭제할 수 있습니다.We'll get into adding, editing, and deleting menus and items later in this article. 이제 기본적으로 사용할 수 있는 메뉴 및 메뉴 항목을 확인 하 고 미리 정의 된 콘센트 및 작업 집합을 통해 코드에 자동으로 노출 되는 방법에 대해 알아봅니다. 자세한 내용은 콘센트 및 작업 설명서를 참조 하세요.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).

예를 들어 열기 메뉴 항목에 대 한 openDocument: 연결 검사기 를 클릭 하면 작업에 자동으로 연결 되는 것을 볼 수 있습니다.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:

연결 된 작업 보기Viewing the attached action

인터페이스 계층 에서 첫 번째 응답자 를 선택 하 고 연결 검사기에서 아래로 스크롤하면 openDocument: 열기 메뉴 항목이 연결 된 작업의 정의 (몇 가지 및 인 응용 프로그램에 대 한 기타 기본 동작은 자동으로 컨트롤에 연결 되지 않습니다.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):

모든 연결 된 작업 보기Viewing all attached actions

이것이 중요 한 이유는 무엇 인가요?Why is this important? 다음 섹션에서는 이러한 자동 정의 작업이 다른 Cocoa 사용자 인터페이스 요소와 함께 작동 하 여 메뉴 항목을 자동으로 활성화 및 비활성화 하 고 항목에 대 한 기본 제공 기능을 제공 하는 방법을 확인 합니다.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.

나중에 이러한 기본 제공 작업을 사용 하 여 코드에서 항목을 활성화 및 비활성화 하 고, 선택 하는 경우 고유한 기능을 제공 합니다.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.

기본 제공 메뉴 기능Built-in menu functionality

UI 항목 또는 코드를 추가 하기 전에 새로 만든 Xamarin.ios 응용 프로그램을 실행 한 경우 일부 항목이 자동으로 자동으로 연결 되 고 사용 하도록 설정 된 것을 알 수 있습니다 (전체 기능이 자동으로 기본 제공 됨). 메뉴: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:

활성화 된 메뉴 항목An enabled menu item

잘라내기, 복사붙여넣기 와 같은 다른 메뉴 항목은 그렇지 않습니다.While other menu items, such as Cut, Copy, and Paste are not:

메뉴 항목 사용 안 함Disabled menu items

응용 프로그램을 중지 하 고 Solution Pad주 storyboard 파일을 두 번 클릭 하 여 Xcode의 Interface Builder에서 편집할 수 있도록 엽니다.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. 다음으로, 라이브러리텍스트 뷰인터페이스 편집기의 창 뷰 컨트롤러로 끌어 옵니다.Next, drag a Text View from the Library onto the window's view controller in the Interface Editor:

라이브러리에서 텍스트 뷰 선택Selecting a Text View from the Library

제약 조건 편집기 에서 창의 가장자리에 텍스트 뷰를 고정 하 고 편집기 맨 위에 있는 네 개의 빨간색 빔을 모두 클릭 하 고 4 개의 제약 조건 추가 단추를 클릭 하 여 창에서 확대 및 축소 되는 위치를 설정 합니다.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:

제약 조건 편집Editing the contraints

사용자 인터페이스 디자인에 대 한 변경 내용을 저장 하 고 Mac용 Visual Studio 다시 전환 하 여 변경 내용을 Xamarin.ios 프로젝트와 동기화 합니다.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. 이제 응용 프로그램을 시작 하 고 텍스트 뷰에 텍스트를 입력 하 고 선택한 다음 편집 메뉴를 엽니다.Now start the application, type some text into the text view, select it, and open the Edit menu:

![메뉴 항목이 자동으로 설정/해제 됩니다] . (menu-images/appmenu07.png "메뉴 항목이 자동으로 설정/해제 됩니다") .The menu items are automatically enabled/disabled

코드를 한 줄도 작성 하지 않고 잘라내기, 복사붙여넣기 항목을 자동으로 사용 하도록 설정 하 고 완벽 하 게 작동 하는 방법을 확인 합니다.Notice how the Cut, Copy, and Paste items are automatically enabled and fully functional, all without writing a single line of code.

여기에 무슨 일이 일어나고 있나요?What's going on here? 기본 제공 되는 기본 제공 작업 (위에서 설명한 대로)은 기본 메뉴 항목에 연결 되어 있습니다 (위에서 설명한 대로). macOS의 일부인 Cocoa 사용자 인터페이스 요소 대부분은 특정 작업 (예: copy:)에 대 한 후크를 제공 합니다.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:). 따라서 창에 추가 되 고 활성 및 선택 된 경우 해당 메뉴 항목이 나 해당 작업에 연결 된 항목이 자동으로 활성화 됩니다.So when they are added to a window, active, and selected, the corresponding menu item or items attached to that action are automatically enabled. 사용자가 해당 메뉴 항목을 선택 하면 UI 요소에 기본 제공 되는 기능을 개발자 개입 없이 모두 호출 하 고 실행 합니다.If the user selects that menu item, the functionality built into the UI element is called and executed, all without developer intervention.

메뉴 및 항목 사용 및 사용 안 함Enabling and disabling menus and items

기본적으로 사용자 이벤트가 발생할 때마다는 NSMenu 응용 프로그램의 컨텍스트를 기반으로 표시 되는 각 메뉴 및 메뉴 항목을 자동으로 사용 하거나 사용 하지 않도록 설정 합니다.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. 항목을 설정/해제 하는 방법에는 다음 세 가지가 있습니다.There are three ways to enable/disable an item:

  • 자동 메뉴 사용 -항목이 연결 된 작업에 응답 NSMenu 하는 적절 한 개체를 찾을 수 있는 경우 메뉴 항목이 활성화 됩니다.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. 예를 들어 위의 텍스트 뷰에는 copy: 동작에 대 한 기본 제공 후크가 있습니다.For example, the text view above that had a built-in hook to the copy: action.
  • 사용자 지정 작업 및 validateMenuItem: 창 또는 뷰 컨트롤러 사용자 지정 작업에 바인딩된 메뉴 항목의 경우 validateMenuItem: 작업을 추가 하 고 메뉴 항목을 수동으로 사용 하거나 사용 하지 않도록 설정할 수 있습니다.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.
  • 수동 메뉴 사용 -각 Enabled NSMenuItem 항목의 속성을 수동으로 설정 하 여 메뉴의 각 항목을 개별적으로 사용 하거나 사용 하지 않도록 설정할 수 있습니다.Manual menu enabling - You manually set the Enabled property of each NSMenuItem to enable or disable each item in a menu individually.

시스템을 선택 하려면 AutoEnablesItems NSMenu의 속성을 설정 합니다.To choose a system, set the AutoEnablesItems property of a NSMenu. true는 자동 (기본 동작) false 이며 수동입니다.true is automatic (the default behavior) and false is manual.

중요

수동 메뉴 사용을 사용 하도록 선택 하는 경우와 같은 NSTextViewappkit 클래스에 의해 제어 되는 메뉴 항목도 자동으로 업데이트 되지 않습니다.If you choose to use manual menu enabling, none of the menu items, even those controlled by AppKit classes like NSTextView, are updated automatically. 코드에서 모든 항목을 직접 사용 하거나 사용 하지 않도록 설정 하는 일을 담당 합니다.You will be responsible for enabling and disabling all items by hand in code.

ValidateMenuItem 사용Using validateMenuItem

위에서 설명한 것 처럼 창 또는 보기 컨트롤러 사용자 지정 작업에 바인딩된 모든 메뉴 항목에 대해 validateMenuItem: 작업을 추가 하 고 메뉴 항목을 수동으로 사용 하거나 사용 하지 않도록 설정할 수 있습니다.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.

다음 예제 Tag 에서는 속성을 사용 하 여에서 선택한 텍스트 NSTextView의 상태에 따라 동작에 validateMenuItem: 의해 활성화/비활성화 될 메뉴 항목의 형식을 결정 합니다.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. 속성 Tag 은 각 메뉴 항목에 대 한 Interface Builder에 설정 되어 있습니다.The Tag property has been set in Interface Builder for each menu item:

Tag 속성 설정Setting the Tag property

그리고 다음 코드를 뷰 컨트롤러에 추가 했습니다.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;
}

이 코드를 실행 하 고에서 NSTextView텍스트를 선택 하지 않은 경우 두 줄 바꿈 메뉴 항목이 사용 하지 않도록 설정 됩니다 (뷰 컨트롤러에서 작업에 연결 된 경우에도).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):

비활성화 된 항목 표시Showing disabled items

텍스트의 섹션을 선택 하 고 메뉴가 다시 열리면 두 줄 바꿈 메뉴 항목을 사용할 수 있습니다.If a section of text is selected and the menu reopened, the two wrap menu items will be available:

활성화 된 항목 표시Showing enabled items

코드에서 메뉴 항목 활성화 및 응답Enabling and responding to menu items in code

위에서 설명한 것 처럼 UI 디자인에 특정 Cocoa 사용자 인터페이스 요소 (예: 텍스트 필드)를 추가 하기만 하면 코드를 작성할 필요 없이 몇 가지 기본 메뉴 항목이 활성화 되 고 자동으로 작동 합니다.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. 다음으로, 사용자가 메뉴 항목을 C# 사용 하도록 설정 하 고 기능을 선택할 때 사용자 고유의 코드를 xamarin.ios 프로젝트에 추가 하 여 기능을 제공 하는 방법을 살펴보겠습니다.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.

예를 들어 사용자가 파일 메뉴에서 열기 항목을 사용 하 여 폴더를 선택할 수 있도록 하려는 경우를 가정해 보겠습니다.For example, let say we want the user to be able to use the Open item in the File menu to select a folder. 이는 응용 프로그램 전체 함수 이며 제공 창이 나 UI 요소로 제한 되지 않으므로 응용 프로그램 대리자에 게이를 처리 하는 코드를 추가 합니다.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.

Solution Pad에서 AppDelegate.CS 파일을 두 번 클릭 하 여 편집용으로 엽니다.In the Solution Pad, double-click the AppDelegate.CS file to open it for editing:

앱 대리자 선택Selecting the app delegate

DidFinishLaunching 메서드 아래에 다음 코드를 추가 합니다.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 ();
    }
}

이제 응용 프로그램을 실행 하 고 파일 메뉴를 엽니다.Let's run the application now and open the File menu:

파일 메뉴The File menu

이제 열기 메뉴 항목이 활성화 된 것을 확인할 수 있습니다.Notice that the Open menu item is now enabled. 이를 선택 하면 열기 대화 상자가 표시 됩니다.If we select it, the open dialog will be displayed:

열기 대화 상자An open dialog

열기 단추를 클릭 하면 다음과 같은 경고 메시지가 표시 됩니다.If we click the Open button, our alert message will be displayed:

예제 대화 상자 메시지An example dialog message

여기 [Export ("openDocument:")]에서 키 줄은 AppDelegate void OpenDialog (NSObject sender) NSMenu 에게작업에응답하는openDocument: 메서드가 있음을 나타냅니다.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. 위에서 기억할 경우 기본적으로 Interface Builder에서 열기 메뉴 항목이 자동으로이 작업에 연결 됩니다.If you'll remember from above, the Open menu item is automatically wired-up to this action by default in Interface Builder:

연결 된 작업 보기Viewing the attached actions

다음으로, 자체 메뉴, 메뉴 항목 및 작업을 만들고 코드에서이에 대해 응답 하는 방법을 살펴보겠습니다.Next let's look at creating our own menu, menu items, and actions and responding to them in code.

최근 항목 열기 메뉴 작업Working with the open recent menu

기본적으로 파일 메뉴에는 사용자가 앱을 사용 하 여 연 마지막 몇 개의 파일을 추적 하는 최근 열기 항목이 포함 되어 있습니다.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. NSDocument 기반 xamarin.ios 앱을 만드는 경우이 메뉴는 자동으로 처리 됩니다.If you are creating a NSDocument based Xamarin.Mac app, this menu will be handled for you automatically. 다른 형식의 Xamarin.ios 앱의 경우에는이 메뉴 항목을 수동으로 관리 하 고 응답할 책임이 있습니다.For any other type of Xamarin.Mac app, you will be responsible for managing and responding to this menu item manually.

최근 항목 열기 메뉴를 수동으로 처리 하려면 다음을 사용 하 여 새 파일이 열리거나 저장 되었음을 먼저 알려 주어 야 합니다.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);

앱에서을 사용 NSDocuments하지 않는 경우에도를 SharedDocumentController NSDocumentController 사용 하 여의 NoteNewRecentDocumentURL 메서드에 파일의 위치를 포함 하 NSUrl 는를 전송 하 여 최근 열기 메뉴를 유지 관리 합니다.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.

그런 다음 사용자가 OpenFile 최근 항목 열기 메뉴에서 선택한 파일을 열도록 앱 대리자의 메서드를 재정의 해야 합니다.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. 예를 들어: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;
    }
}

파일 true 을 열 수 있으면를 반환 하 고, false 그렇지 않으면를 반환 하 고, 파일을 열 수 없는 사용자에 게 기본 제공 경고를 표시 합니다.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.

최근 항목 열기 메뉴에서 반환 된 파일 이름과 경로에 공백이 포함 될 수 있으므로을 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. 다음 코드를 사용 하 여이 작업을 수행 합니다.We do that with the following code:

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

마지막으로, 파일을 NSUrl 가리키는를 만들고 앱 대리자의 도우미 메서드를 사용 하 여 새 창을 열고 파일을 로드 합니다.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);

모든 항목을 함께 끌어 AppDelegate.cs 파일의 구현 예를 살펴보겠습니다.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
    }
}

앱의 요구 사항에 따라 사용자가 동시에 두 개 이상의 창에서 동일한 파일을 열지 않으려고 할 수 있습니다.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 our example app, if the user chooses a file that is already open (either from the Open Recent or Open.. 메뉴 항목)에서 파일을 포함 하는 창을 맨 앞으로 가져옵니다.menu items), the window that contains the file is brought to the front.

이를 위해 도우미 메서드에서 다음 코드를 사용 했습니다.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;
    }
}

ViewController 해당Path 속성에 파일의 경로를 포함 하도록 클래스를 디자인 했습니다.We designed our ViewController class to hold the path to the file in its Path property. 이제 앱에서 현재 열려 있는 모든 창을 반복 합니다.Next, we loop through all currently open windows in the app. 파일이 windows 중 하나에서 이미 열려 있는 경우 다음을 사용 하 여 다른 모든 창의 맨 앞으로 가져옵니다.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);

일치 항목을 찾을 수 없는 경우 파일이 로드 된 새 창이 열리고 최근 열기 메뉴에 파일이 표시 됩니다.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);

사용자 지정 창 작업 작업Working with custom window actions

표준 메뉴 항목으로 연결 되는 기본 제공 첫 번째 응답자 작업과 마찬가지로 새 사용자 지정 작업을 만들고 Interface Builder의 메뉴 항목에 연결할 수 있습니다.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.

먼저 앱의 창 컨트롤러 중 하나에 대 한 사용자 지정 작업을 정의 합니다.First, define a custom action on one of your app's window controllers. 예를 들어:For example:

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

다음으로 Solution Pad 에서 앱의 스토리 보드 파일을 두 번 클릭 하 여 Xcode의 Interface Builder에서 편집할 수 있도록 엽니다.Next, double-click the app's storyboard file in the Solution Pad to open it for editing in Xcode's Interface Builder. 응용 프로그램 장면아래에서 첫 번째 응답자 를 선택 하 고 특성 검사자로 전환 합니다.Select the First Responder under the Application Scene, then switch to the Attributes Inspector:

특성 검사자The Attributes Inspector

특성 검사자 의 맨 아래에 있는 단추를클릭하여새사용자지정작업을추가합니다.+Click the + button at the bottom of the Attributes Inspector to add a new custom action:

새 작업 추가Adding a new action

창 컨트롤러에서 만든 사용자 지정 작업과 동일한 이름을 지정 합니다.Give it the same name as the custom action that you created on your window controller:

작업 이름 편집Editing the action name

컨트롤을 클릭 하 고 메뉴 항목에서 응용 프로그램 장면의 첫 번째 응답자 로 끕니다.Control-click and drag from a menu item to the First Responder under the Application Scene. 팝업 목록에서 방금 만든 새 작업 (defineKeyword: 이 예제에서는)을 선택 합니다.From the popup list, select the new action you just created (defineKeyword: in this example):

작업 연결Attaching an action

스토리 보드에 대 한 변경 내용을 저장 하 고 Mac용 Visual Studio로 돌아가서 변경 내용을 동기화 합니다.Save the changes to the storyboard and return to Visual Studio for Mac to sync the changes. 앱을 실행 하는 경우 사용자 지정 작업을 연결한 메뉴 항목이 자동으로 사용/사용 안 함으로 설정 되 고 (작업이 열리는 창에 따라) 메뉴 항목을 선택 하면 작업이 실행 됩니다.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:

새 작업 테스트Testing the new action

메뉴 추가, 편집 및 삭제Adding, editing, and deleting menus

이전 섹션에서 볼 수 있듯이 Xamarin.ios 응용 프로그램에는 특정 UI 컨트롤에서 자동으로 활성화 하 고 응답 하는 기본 메뉴 및 메뉴 항목의 미리 설정 된 수와 함께 제공 됩니다.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. 또한 이러한 기본 항목을 사용 하 고 응답할 수 있도록 응용 프로그램에 코드를 추가 하는 방법도 살펴보았습니다.We have also seen how to add code to our application that will also enable and respond to these default items.

이 섹션에서는 필요 하지 않은 메뉴 항목을 제거 하 고, 메뉴를 다시 구성 하 고, 새 메뉴, 메뉴 항목 및 동작을 추가 하는 방법을 살펴봅니다.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.

Solution Pad 에서 주 storyboard 파일을 두 번 클릭 하 여 편집용으로 엽니다.Double-click the Main.storyboard file in the Solution Pad to open it for editing:

Xcode에서 UI 편집Editing the UI in Xcode

특정 Xamarin.ios 응용 프로그램의 경우 기본 보기 메뉴를 사용 하지 않으므로 제거 하겠습니다.For our specific Xamarin.Mac application we are not going to be using the default View menu so we are going to remove it. 인터페이스 계층 구조 에서 주 메뉴 모음의 일부인 보기 메뉴 항목을 선택 합니다.In the Interface Hierarchy select the View menu item that is a part of the main menu bar:

보기 메뉴 항목 선택Selecting the View menu item

메뉴를 삭제 하려면 delete 또는 백스페이스 키를 누릅니다.Press delete or backspace to delete the menu. 다음으로는 서식 메뉴의 모든 항목을 사용 하지 않고 하위 메뉴 아래에서 사용할 항목을 이동 하려고 합니다.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. 인터페이스 계층 구조 에서 다음 메뉴 항목을 선택 합니다.In the Interface Hierarchy select the following menu items:

여러 항목 강조 표시Highlighting multiple items

부모 메뉴 의 항목을 현재 있는 하위 메뉴에서 끌어 옵니다.Drag the items under the parent Menu from the sub-menu where they currently are:

메뉴 항목을 부모 메뉴에 끌기Dragging menu items to the parent menu

이제 메뉴가 다음과 같이 표시 됩니다.Your menu should now look like:

새 위치의 항목The items in the new location

그런 다음 서식 메뉴에서 텍스트 하위 메뉴를 바깥쪽으로 끌어와 메뉴의 주 메뉴 모음에 놓습니다.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:

텍스트 메뉴The Text menu

서식 메뉴로 돌아가서 글꼴 하위 메뉴 항목을 삭제 하겠습니다.Let's go back under the Format menu and delete the Font sub-menu item. 그런 다음 서식 메뉴를 선택 하 고 이름을 "Font"로 바꿉니다.Next, select the Format menu and rename it "Font":

글꼴 메뉴The Font menu

다음에는 텍스트 보기를 선택할 때 텍스트 보기의 텍스트에 자동으로 추가 되는 미리 정의 된 구의 사용자 지정 메뉴를 만들어 보겠습니다.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. 라이브러리 검사자 의 아래쪽에 있는 검색 상자에 "메뉴"를 입력 합니다.In the search box at the bottom on the Library Inspector type in "menu." 이를 통해 모든 메뉴 UI 요소를 쉽게 찾고 작업할 수 있습니다.This will make it easier to find and work with all of the menu UI elements:

라이브러리 검사기The Library Inspector

이제 다음을 수행 하 여 메뉴를 만듭니다.Now let's do the following to create our menu:

  1. 메뉴 항목라이브러리 검사기 에서 텍스트 창과 메뉴 사이에 있는 메뉴 모음으로 끌어 옵니다.Drag a Menu Item from the Library Inspector onto the menu bar between the Text and Window menus:

    라이브러리에서 새 메뉴 항목 선택Selecting a new menu item in the Library

  2. "문구" 항목의 이름을 바꿉니다.Rename the item "Phrases":

    메뉴 이름 설정Setting the menu name

  3. 다음으로 라이브러리 검사기에서 메뉴 를 끌어 옵니다.Next drag a Menu from the Library Inspector:

    라이브러리에서 메뉴 선택Selecting a menu from the Library

  4. 방금 만든 새 메뉴 항목 의 드롭다운 메뉴 를 클릭 하 고 이름을 "문구"로 변경 합니다.Drop then Menu on the new Menu Item we just created and change its name to "Phrases":

    메뉴 이름 편집Editing the menu name

  5. 이제 세 가지 기본 메뉴 항목인 "Address", "Date" 및 "인사말이"로 이름을 바꿉니다.Now let's rename the three default Menu Items "Address", "Date," and "Greeting":

    구 메뉴The Phrases menu

  6. 라이브러리 검사기 에서 메뉴 항목 을 끌어서 "Signature"를 호출 하 여 네 번째 메뉴 항목 을 추가 해 보겠습니다.Let's add a fourth Menu Item by dragging a Menu Item from the Library Inspector and calling it "Signature":

    메뉴 항목 이름 편집Editing the menu item name

  7. 메뉴 모음에 변경 내용을 저장 합니다.Save the changes to the menu bar.

이제 새 메뉴 항목이 코드에 C# 노출 되도록 일련의 사용자 지정 작업을 만들어 보겠습니다.Now let's create a set of custom actions so that our new menu items are exposed to C# code. Xcode let에서 보조자 보기로 전환 합니다.In Xcode let's switch to the Assistant view:

필요한 작업 만들기Creating the required actions

다음 작업을 수행해 보겠습니다.Let's do the following:

  1. 주소 메뉴 항목에서 AppDelegate 파일로 컨트롤을 끕니다.Control-drag from the Address menu item to the AppDelegate.h file.

  2. 연결 유형을 작업으로 전환 합니다.Switch the Connection type to Action:

    작업 유형 선택Selecting the action type

  3. "PhraseAddress"의 이름을 입력 하 고 연결 단추를 클릭 하 여 새 작업을 만듭니다.Enter a Name of "phraseAddress" and press the Connect button to create the new action:

    작업 구성Configuring the action

  4. 날짜, 인사말서명 메뉴 항목에 대해 위의 단계를 반복 합니다.Repeat the above steps for the Date, Greeting, and Signature menu items:

    완료 된 작업The completed actions

  5. 메뉴 모음에 변경 내용을 저장 합니다.Save the changes to the menu bar.

다음으로 코드에서 콘텐츠를 조정할 수 있도록 텍스트 보기에 대 한 유출를 만들어야 합니다.Next we need to create an outlet for our text view so that we can adjust its content from code. 길잡이 편집기 에서 documentText viewcontroller .h 파일을 선택 하 고 라는 새 콘센트를 만듭니다.Select the ViewController.h file in the Assistant Editor and create a new outlet called documentText:

콘센트 만들기Creating an outlet

Xcode에서 변경 내용을 동기화 하는 Mac용 Visual Studio로 돌아갑니다.Return to Visual Studio for Mac to sync the changes from Xcode. 그런 다음 ViewController.cs 파일을 편집 하 여 다음과 같이 만듭니다.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
    }
}

그러면 ViewController 클래스 외부에서 텍스트 뷰의 텍스트가 노출 되 고 창이 포커스를 얻거나 잃을 때 앱 대리자에 게 알립니다.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. 이제 AppDelegate.cs 파일을 편집 하 여 다음과 같이 만듭니다.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
    }
}

여기서는 Interface Builder에서 정의한 AppDelegate 작업과 콘센트를 사용할 수 있도록 partial 클래스를 만들었습니다.Here we've made the AppDelegate a partial class so that we can use the actions and outlets that we defined in Interface Builder. 또한 현재 포커스가 있는 textEditor 창을 추적 하기 위해를 노출 합니다.We also expose a textEditor to track which window is currently in focus.

다음 메서드는 사용자 지정 메뉴 및 메뉴 항목을 처리 하는 데 사용 됩니다.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";
}

이제 응용 프로그램을 실행 하는 경우 메뉴의 모든 항목이 활성화 되 고 선택 시 텍스트 보기에 문구 제공이 추가 됩니다.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:

실행 중인 앱의 예An example of the app running

이제 응용 프로그램 메뉴 모음을 사용 하 여 작업 하는 기본 사항을 만들었으므로 사용자 지정 상황에 맞는 메뉴를 만드는 방법을 살펴보겠습니다.Now that we have the basics of working with the application menu bar down, let's look at creating a custom contextual menu.

코드에서 메뉴 만들기Creating menus from code

Xcode의 Interface Builder를 사용 하 여 메뉴 및 메뉴 항목을 만드는 것 외에도 Xamarin.ios 앱에서 메뉴, 하위 메뉴 또는 메뉴 항목을 코드에서 생성, 수정 또는 제거 해야 하는 경우가 있을 수 있습니다.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.

다음 예제에서는 동적으로 생성 되는 메뉴 항목 및 하위 메뉴에 대 한 정보를 포함 하는 클래스를 만듭니다.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
    }
}

메뉴 및 항목 추가Adding menus and items

이 클래스를 정의 하면 다음 루틴은 개체의 LanguageFormatCommand컬렉션을 구문 분석 하 고, 전달 된 기존 메뉴 (Interface Builder에서 만들어짐)의 맨 아래에 추가 하 여 새 메뉴 및 메뉴 항목을 재귀적으로 빌드합니다.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);
    }
}

LanguageFormatCommandTitle 속성이 있는 개체의 경우이 루틴은 메뉴 섹션 사이에 구분 기호 메뉴 항목 (얇은 회색 선)을 만듭니다.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;

제목이 제공 되 면 해당 제목이 있는 새 메뉴 항목이 생성 됩니다.If a title is provided, a new menu item with that title is created:

menuItem = new NSMenuItem (command.Title);

개체에 LanguageFormatCommand 자식 LanguageFormatCommand 개체가 포함 되어 있으면 하위 AssembleMenu 메뉴가 만들어지고 메서드를 재귀적으로 호출 하 여 해당 메뉴를 빌드합니다.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);

하위 메뉴가 없는 새 메뉴 항목의 경우 사용자가 선택 하는 메뉴 항목을 처리 하는 코드가 추가 됩니다.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
    ...
};

메뉴 만들기 테스트Testing the menu creation

위의 모든 코드를 만든 다음 개체의 LanguageFormatCommand 컬렉션을 만든 경우 다음을 수행 합니다.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)"));

이 컬렉션을 AssembleMenu 함수에 전달 하면 ( 서식 메뉴가 기본으로 설정 됨) 다음과 같은 동적 메뉴 및 메뉴 항목이 생성 됩니다.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:

실행 중인 응용 프로그램의 새 메뉴 항목The new menu items in the running app

메뉴 및 항목 제거Removing menus and items

앱의 사용자 인터페이스에서 메뉴 또는 메뉴 항목을 제거 해야 하는 경우 제거할 항목의 0부터 시작 RemoveItemAt 하는 인덱스 NSMenu 를 지정 하 여 클래스의 메서드를 간단히 사용할 수 있습니다.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.

예를 들어 위의 루틴에서 만든 메뉴 및 메뉴 항목을 제거 하기 위해 다음 코드를 사용할 수 있습니다.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);
    }
}

위의 코드의 경우 처음 네 개의 메뉴 항목이 앱에서 사용할 수 있는 Xcode의 Interface Builder 및 aways에 생성 되므로 동적으로 제거 되지 않습니다.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.

상황에 맞는 메뉴Contextual menus

사용자가 창의 항목을 마우스 오른쪽 단추로 클릭 하거나 컨트롤을 클릭 하면 상황에 맞는 메뉴가 나타납니다.Contextual menus appear when the user right-clicks or control-clicks an item in a window. 기본적으로 macOS에 내장 된 여러 UI 요소에는 텍스트 뷰와 같은 상황별 메뉴가 이미 연결 되어 있습니다.By default, several of the UI elements built into macOS already have contextual menus attached to them (such as the text view). 그러나 창에 추가한 UI 요소에 대 한 사용자 지정 상황에 맞는 메뉴를 만들려는 경우가 있을 수 있습니다.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.

Xcode에서 기본 storyboard 파일을 편집 하 고 창을 디자인에 추가 하 고, Identity Inspector에서 해당 클래스 를 "NSPanel"로 설정 하 고, 메뉴에 새 보조자 항목을 추가 하 고, 새 항목에 연결 해 보겠습니다. Show Segue를 사용 하는 창: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:

Segue 형식 설정Setting the segue type

다음 작업을 수행해 보겠습니다.Let's do the following:

  1. 라이브러리 검사기 에서 패널 창으로 레이블을 끌어 오고 텍스트를 "Property"로 설정 합니다.Drag a Label from the Library Inspector onto the Panel window and set its text to "Property":

    레이블 값 편집Editing the label's value

  2. 그런 다음 라이브러리 검사기 에서 뷰 계층의 뷰 컨트롤러로 메뉴 를 끌고 세 개의 기본 메뉴 항목 문서, 텍스트글꼴의 이름을 바꿉니다.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:

    ![필수 메뉴 항목] 입니다. (menu-images/context02.png "필수 메뉴 항목") 입니다.The required menu items

  3. 이제 속성 레이블에서 메뉴로 컨트롤을 끕니다.Now control-drag from the Property Label onto the Menu:

    드래그 하 여 segue 만들기Dragging to create a segue

  4. 팝업 대화 상자에서 메뉴를 선택 합니다.From the popup dialog, select Menu:

    Segue 형식 설정Setting the segue type

  5. Id 검사자에서 뷰 컨트롤러의 클래스를 "PanelViewController"로 설정 합니다.From the Identity Inspector, set the View Controller's class to "PanelViewController":

    Segue 클래스 설정Setting the segue class

  6. Mac용 Visual Studio으로 다시 전환 하 여 동기화 한 다음 Interface Builder로 돌아갑니다.Switch back to Visual Studio for Mac to sync, then return to Interface Builder.

  7. 길잡이 편집기 로 전환 하 고 PanelViewController 파일을 선택 합니다.Switch to the Assistant Editor and select the PanelViewController.h file.

  8. 이라는propertyDocument 문서 메뉴 항목에 대 한 작업을 만듭니다.Create an action for the Document menu item called propertyDocument:

    작업 구성Configuring the action

  9. 나머지 메뉴 항목에 대 한 작업 만들기를 반복 합니다.Repeat creating actions for the remaining menu items:

    필요한 작업The required actions

  10. 마지막으로 라는 propertyLabel 속성 레이블에 대 한 콘센트를 만듭니다.Finally create an outlet for the Property Label called propertyLabel:

    콘센트 구성Configuring the outlet

  11. 변경 내용을 저장 하 고 Xcode와 동기화 할 Mac용 Visual Studio로 돌아갑니다.Save your changes and return to Visual Studio for Mac to sync with Xcode.

PanelViewController.cs 파일을 편집 하 고 다음 코드를 추가 합니다.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";
}

이제 응용 프로그램을 실행 하 고 패널에서 속성 레이블을 마우스 오른쪽 단추로 클릭 하면 사용자 지정 상황에 맞는 메뉴가 표시 됩니다.Now if we run the application and right-click on the property label in the panel, we'll see our custom contextual menu. 메뉴에서 및 항목을 선택 하면 레이블의 값이 다음과 같이 변경 됩니다.If we select and item from the menu, the label's value will change:

실행 상황에 맞는 메뉴The contextual menu running

다음으로 상태 표시줄 메뉴 만들기를 살펴보겠습니다.Next let's look at creating status bar menus.

상태 표시줄 메뉴Status bar menus

상태 표시줄 메뉴는 응용 프로그램의 상태를 반영 하는 이미지 또는 메뉴와 같은 사용자 의견을 제공 하는 상태 메뉴 항목의 컬렉션을 표시 합니다.Status 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. 응용 프로그램의 상태 표시줄 메뉴는 응용 프로그램이 백그라운드에서 실행 되는 경우에도 활성화 되 고 활성화 됩니다.An application's status bar menu is enabled and active even if the application is running in the background. 시스템 수준 상태 표시줄은 응용 프로그램 메뉴 모음의 오른쪽에 있으며, 현재 macOS에서 사용할 수 있는 유일한 상태 표시줄입니다.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.

AppDelegate.cs 파일을 편집 하 고 메서드를 DidFinishLaunching 다음과 같이 만듭니다.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;시스템 차원의 상태 표시줄에 대 한 액세스를 제공 합니다.NSStatusBar statusBar = NSStatusBar.SystemStatusBar; gives us access to the system-wide status bar. var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable);새 상태 표시줄 항목을 만듭니다.var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable); creates a new status bar item. 여기에서 메뉴 및 메뉴 항목을 몇 개 만들고 방금 만든 상태 표시줄 항목에 메뉴를 연결 합니다.From there we create a menu and a number of menu items and attach the menu to the status bar item we just created.

응용 프로그램을 실행 하면 새 상태 표시줄 항목이 표시 됩니다.If we run the application, the new status bar item will be displayed. 메뉴에서 항목을 선택 하면 텍스트 보기의 텍스트가 변경 됩니다.Selecting an item from the menu will change the text in the text view:

상태 표시줄 메뉴 실행 중The status bar menu running

다음으로 사용자 지정 도크 메뉴 항목을 만드는 방법을 살펴보겠습니다.Next, let's look at creating custom dock menu items.

사용자 지정 고정 메뉴Custom dock menus

사용자가 도크의 응용 프로그램 아이콘을 마우스 오른쪽 단추로 클릭 하거나 컨트롤을 클릭 하면 Mac 응용 프로그램에 대 한 도킹 메뉴가 나타납니다.The dock menu appears for you Mac application when the user right-clicks or control-clicks the application's icon in the dock:

사용자 지정 도크 메뉴A custom dock menu

다음을 수행 하 여 응용 프로그램에 대 한 사용자 지정 도크 메뉴를 만들어 보겠습니다.Let's create a custom dock menu for our application by doing the following:

  1. Mac용 Visual Studio에서 응용 프로그램의 프로젝트를 마우스 오른쪽 단추로 클릭 하 고새 파일 추가 > ...를 선택 합니다. 새 파일 대화 상자에서 xamarin.ios > 빈 인터페이스 정의를 선택 하 고 이름 에 "DockMenu"를 사용 하 고 새로 만들기 단추를 클릭 하 여 새 DockMenu 파일을 만듭니다.In 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:

    빈 인터페이스 정의 추가Adding an empty interface definition

  2. Solution Pad에서 xib 파일을 두 번 클릭 하 여 Xcode에서 편집할 수 있도록 엽니다.In the Solution Pad, double-click the DockMenu.xib file to open it for editing in Xcode. 다음 항목을 사용 하 여 새 메뉴 를 만듭니다. 주소, 날짜, 인사말서명Create a new Menu with the following items: Address, Date, Greeting, and Signature

    UI 레이아웃Laying out the UI

  3. 다음으로, 위의 메뉴 추가, 편집 및 삭제 섹션에서 사용자 지정 메뉴에 대해 만든 기존 작업에 새 메뉴 항목을 연결 하겠습니다.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. 연결 검사자 로 전환 하 고 인터페이스 계층에서 첫 번째 응답자 를 선택 합니다.Switch to the Connection Inspector and select the First Responder in the Interface Hierarchy. 아래로 스크롤하여 작업을 phraseAddress: 찾습니다.Scroll down and find the phraseAddress: action. 해당 작업의 원에서 주소 메뉴 항목으로 선을 끌어 옵니다.Drag a line from the circle on that action to the Address menu item:

    ![끌어서 작업] 연결 (menu-images/dock04.png "끌어서 작업") 연결Dragging to wire up an action

  4. 해당 작업에 연결 하는 다른 모든 메뉴 항목에 대해이 작업을 반복 합니다.Repeat for all of the other menu items attaching them to their corresponding actions:

    필요한 작업The required actions

  5. 다음으로 인터페이스 계층 구조에서 응용 프로그램 을 선택 합니다.Next, select the Application in the Interface Hierarchy. 연결 검사기에서 dockMenu 콘센트의 원에서 방금 만든 메뉴로 선을 끌어 옵니다.In the Connection Inspector, drag a line from the circle on the dockMenu outlet to the menu we just created:

    연결 ![을 콘센트 위로 끌기] 연결 (menu-images/dock06.png "을 콘센트 위로 끌기")Dragging the wire up the outlet

  6. 변경 내용을 저장 하 고 다시 Mac용 Visual Studio로 전환 하 여 Xcode와 동기화 합니다.Save your changes and switch back to Visual Studio for Mac to sync with Xcode.

  7. Info.plist 파일을 두 번 클릭 하 여 편집용으로 엽니다.Double-click the Info.plist file to open it for editing:

    Info.plist 파일 편집Editing the Info.plist file

  8. 화면 맨 아래에 있는 원본 탭을 클릭 합니다.Click the Source tab at the bottom of the screen:

    원본 뷰 선택Selecting the Source view

  9. 새 항목 추가를 클릭 하 고, 녹색 더하기 단추를 클릭 하 고, 속성 이름을 "AppleDockMenu"로 설정 하 고, 값을 "DockMenu" (확장명이 없는 xib 파일의 이름)로 설정 합니다.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):

    DockMenu 항목 추가Adding the DockMenu item

이제 응용 프로그램을 실행 하 고 도크에서 해당 아이콘을 마우스 오른쪽 단추로 클릭 하면 새 메뉴 항목이 표시 됩니다.Now if we run our application and right-click on its icon in the Dock, our new menu items will be displayed:

실행 되는 도킹 메뉴의 예An example of the dock menu running

메뉴에서 사용자 지정 항목 중 하나를 선택 하면 텍스트 뷰의 텍스트가 수정 됩니다.If we select one of the custom items from the menu, the text in our text view will be modified.

팝업 단추 및 풀 다운 목록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. 풀 다운 목록은 일반적으로 현재 태스크의 컨텍스트와 관련 된 명령을 선택 하는 데 사용 되는 팝업 단추의 유형입니다.A pull-down list is a type of pop-up button usually used for selecting commands specific to the context of the current task. 둘 다 창의 어디에 나 나타날 수 있습니다.Both can appear anywhere in a window.

다음을 수행 하 여 응용 프로그램에 대 한 사용자 지정 팝업 단추를 만들어 보겠습니다.Let's create a custom pop-up button for our application by doing the following:

  1. Xcode에서 기본 storyboard 파일을 편집 하 고 라이브러리 검사자팝업 단추상황에 맞는 메뉴 섹션에서 만든 패널 창으로 끌어 놓습니다.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:

    팝업 단추 추가Adding a popup button

  2. 새 메뉴 항목을 추가 하 고 팝업에서 항목의 제목을로 설정 합니다. 주소, 날짜, 인사말서명Add a new menu item and set the titles of the Items in the Popup to: Address, Date, Greeting, and Signature

    메뉴 항목 구성Configuring the menu items

  3. 다음으로, 위의 메뉴 추가, 편집 및 삭제 섹션에서 사용자 지정 메뉴에 대해 만든 기존 작업에 새 메뉴 항목을 연결 하겠습니다.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. 연결 검사자 로 전환 하 고 인터페이스 계층에서 첫 번째 응답자 를 선택 합니다.Switch to the Connection Inspector and select the First Responder in the Interface Hierarchy. 아래로 스크롤하여 작업을 phraseAddress: 찾습니다.Scroll down and find the phraseAddress: action. 해당 작업의 원에서 주소 메뉴 항목으로 선을 끌어 옵니다.Drag a line from the circle on that action to the Address menu item:

    ![끌어서 작업] 연결 (menu-images/popup03.png "끌어서 작업") 연결Dragging to wire up an action

  4. 해당 작업에 연결 하는 다른 모든 메뉴 항목에 대해이 작업을 반복 합니다.Repeat for all of the other menu items attaching them to their corresponding actions:

    필요한 모든 작업All required actions

  5. 변경 내용을 저장 하 고 다시 Mac용 Visual Studio로 전환 하 여 Xcode와 동기화 합니다.Save your changes and switch back to Visual Studio for Mac to sync with Xcode.

이제 응용 프로그램을 실행 하 고 팝업에서 항목을 선택 하면 텍스트 뷰의 텍스트가 변경 됩니다.Now if we run our application and select an item from the popup, the text in our text view will change:

실행 중인 팝업의 예An example of the popup running

팝업 단추와 정확히 같은 방식으로 풀 다운 목록을 만들고 작업할 수 있습니다.You can create and work with pull-down lists in the exact same way as pop-up buttons. 기존 작업에 연결 하는 대신 상황별 메뉴 섹션의 상황에 맞는 메뉴에 대 한 것 처럼 사용자 고유의 사용자 지정 작업을 만들 수 있습니다.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.

요약Summary

이 문서에서는 Xamarin.ios 응용 프로그램에서 메뉴 및 메뉴 항목을 사용 하는 방법에 대해 자세히 살펴봅니다.This article has taken a detailed look at working with menus and menu items in a Xamarin.Mac application. 먼저 응용 프로그램의 메뉴 모음을 검사 한 다음 상황에 맞는 메뉴 및 사용자 지정 도킹 메뉴를 검사 한 다음 상황에 맞는 메뉴를 살펴보았습니다.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. 마지막으로 팝업 메뉴와 풀 다운 목록에 대해 살펴보았습니다.Finally, we covered pop-up menus and pull-down Lists.