Xamarin.Mac'te menüler

Bu makale, bir Xamarin.Mac uygulamasında menülerle çalışmayı kapsar. Xcode'da menüler ve menü öğelerini oluşturma ve bakımını Interface Builder ve program aracılığıyla bu öğelerle çalışmayı açıklar.

Bir Xamarin.Mac uygulamasında C# ve .NET ile çalışırken, bir geliştiricinin ve Xcode'un çalıştığı Cocoa menülerine Objective-C erişebilirsiniz. Xamarin.Mac doğrudan Xcode ile tümleşik olduğundan, menü çubuklarınızı, menülerinizi ve menü öğelerinizi oluşturmak ve korumak için Xcode'un Interface Builder'sini kullanabilirsiniz (veya isteğe bağlı olarak bunları doğrudan C# kodunda oluşturabilirsiniz).

Menüler, Mac uygulamasının kullanıcı deneyiminin ayrılmaz bir parçasıdır ve genellikle kullanıcı arabiriminin çeşitli kısımlarında görünür:

• Uygulamanın menü çubuğu - Bu, her Mac uygulaması için ekranın üst kısmında görünen ana menü.
• Bağlam menüleri - Bunlar, kullanıcı bir pencere içinde bir öğeye sağ tıkladığında veya tıkladığında görünür.
• Durum çubuğu - Bu, uygulama menü çubuğunun en sağ tarafında, ekranın üst kısmında (menü çubuğu saatinin sol tarafında) görünen ve öğeler eklendikçe sola doğru büyüyen alandır.
• Dock menüsü - Kullanıcı uygulama simgesine sağ tıkladığında veya denetim tıkladığında ya da kullanıcı simgeye sol tıkladığında ve fare düğmesini aşağıda tutarsa, dock'ta görüntülenen her uygulamanın menüsü.
• Açılır düğme ve aşağı açılan listeler - Açılan düğme seçili bir öğeyi görüntüler ve kullanıcı tarafından tıkıldığında seçilecek seçeneklerin bir listesini sunar. Aşağı açılan liste, genellikle geçerli görevin bağlamına özgü komutları seçmek için kullanılan bir açılır düğme tuşuna tuşuna basın. Her ikisi de bir pencerede herhangi bir yerde görünebilir.

Bu makalede bir Xamarin.Mac uygulamasında Cocoa menü çubukları, menüleri ve menü öğeleriyle çalışmayla ilgili temel bilgileri burada bulabilirsiniz. Öncelikle Hello, Mac makalesi, özellikle de Xcode'a giriş ve Interface Builder ve Çıkışlar ve Eylemler bölümlerine bakarak bu makalede kullanacaklarımız temel kavramları ve teknikleri gözden geçirin.

Exposing C# classes / methods to Objective-CExposing C# classes / methods to Objective-C belgesinin C# sınıflarınızı nesnelere ve kullanıcı arabirimi öğelerine kablolamak için kullanılan ve özniteliklerini de açıklayan bölümüne göz RegisterExportObjective-C atabilirsiniz.

Uygulamanın menü çubuğu

Her pencerenin kendi menü çubuğunun bağlı olduğu Windows işletim sistemi üzerinde çalışan uygulamalardan farklı olarak, macOS üzerinde çalışan her uygulamanın, bu uygulamanın her penceresi için kullanılan ekranın üst kısmında çalışan tek bir menü çubuğu vardır:

Bu menü çubuğundaki öğeler, herhangi bir anda uygulamanın geçerli bağlamına veya durumuna ve kullanıcı arabirimine bağlı olarak etkinleştirilir veya devre dışı bırakılır. Örneğin, kullanıcı bir metin alanı seçerse Düzenle menüsündeki Kopyala ve Kes gibi öğeler etkinleştirilir.

Apple'a göre ve varsayılan olarak, tüm macOS uygulamalarında uygulamanın menü çubuğunda görünen menüler ve menü öğeleri standart bir kümeye sahiptir:

• Apple menüsü - Bu menü, çalışan uygulama ne olursa olsun, kullanıcıya her zaman kullanılabilen sistem genelindeki öğelere erişim sağlar. Bu öğeler geliştirici tarafından değiştirilemez.
• Uygulama menüsü - Bu menü uygulamanın adını kalın olarak görüntüler ve kullanıcının o anda hangi uygulamanın çalıştırlı olduğunu belirlemeye yardımcı olur. Uygulamanın tamamı için geçerli olan öğeleri içerir ve uygulamayı bırakma gibi bir belgeyi veya işlemi içerir.
• Dosya menüsü - Uygulamanıza yönelik belgeleri oluşturmak, açmak veya kaydetmek için kullanılan öğeler. Uygulamanız belge tabanlı değilse bu menü yeniden adlandırılabilir veya kaldırılabilir.
• Düzenle menüsü - Uygulamanın kullanıcı arabirimindeöğeleridüzenlemek veya değiştirmek için kullanılan Kes, Kopyala ve Yapıştır gibi komutları tutar.
• Biçim menüsü - Uygulama metinle birlikte çalışıyorsa bu menü, metnin biçimlendirmesini ayarlamak için komutları içerir.
• Görünüm menüsü - İçeriğin uygulamanın kullanıcı arabiriminde nasıl görüntülendiğinden (görüntülendiğinden) etkileyebilecek komutları tutar.
• Uygulamaya özgü menüler - Bunlar uygulamanıza özgü menülerdir (web tarayıcısı için yer işaretleri menüsü gibi). Bunlar, çubukta Görünüm vePencere menüleri arasında görünseler.
• Pencere menüsü - Uygulamanıza windows ile çalışmak için komutların yanı sıra geçerli açık pencerelerin listesini içerir.
• Yardım menüsü - Uygulamanıza ekran yardımı sağ ise, Yardım menüsü çubukta en sağ menü olması gerekir.

Uygulama menü çubuğu, standart menüler ve menü öğeleri hakkında daha fazla bilgi için lütfen Apple İnsan Arabirimi Yönergeleri'ne bakın.

Varsayılan uygulama menü çubuğu

Yeni bir Xamarin.Mac projesi ekleyebilirsiniz. Bir macOS uygulamasının normalde sahip olduğu tipik öğeleri (yukarıdaki bölümde ele alınmıştır) olan standart, varsayılan uygulama menü çubuğunu otomatik olarak alırsınız. Uygulamanın varsayılan menü çubuğu, proje altındaki Main.storyboard dosyasında (uygulama kullanıcı arabiriminin geri kalanıyla birlikte) Çözüm Bölmesi:

Main.storyboard dosyasına çift tıklar ve Xcode'un Interface Builder için dosyayı açarsanız menü düzenleyicisi arabirimi açılır:

Buradan Dosya menüsündeki Menü öğesini aç gibi öğelere tıklar ve Öznitelik Denetçisi'nin özelliklerini düzenleyebilir veya ayarlayabiliriz:

Bu makalenin devamlarında menüleri ve öğeleri ekleme, düzenleme ve silme işlemiyle ilgili bilgi aacağız. Şimdilik yalnızca varsayılan olarak hangi menülerin ve menü öğelerinin kullanılabilir olduğunu ve önceden tanımlanmış bir dizi çıkış ve eylem aracılığıyla koda nasıl otomatik olarak açık olduğunu görmek için (daha fazla bilgi için Çıkışlar ve Eylemler belgelerimize bakın).

Örneğin, Aç menü öğesi için Bağlantı Denetçisi'ne tıklarsanız otomatik olarak eyleme bağlı olduğunu görebiliriz:

Arabirim Hiyerarşisinde İlk Yanıtlayan'ı seçer ve Bağlantı Denetçisi'ne inin aşağı kaydırarak menü öğesini aç öğesinin ekli olduğu eylemin tanımını (denetimlere otomatik olarak bağlı olan ve denetimlere otomatik olarak bağlanmadan uygulamanın diğer birkaç varsayılan eylemiyle birlikte) göreceğiz:

Bu neden önemlidir? Sonraki bölümde, menü öğelerini otomatik olarak etkinleştirmek ve devre dışı bırakmak ve öğeler için yerleşik işlevsellik sağlamak için otomatik olarak tanımlanan bu eylemlerin diğer Cocoa kullanıcı arabirimi öğeleriyle nasıl çalışılır göreceğiz.

Daha sonra bu yerleşik eylemleri kullanarak koddaki öğeleri etkinleştirecek, devre dışı bırakacağız ve seçildiğinde kendi işlevlerimizi sağlayacağız.

Yerleşik menü işlevi

Kullanıcı arabirimi öğeleri veya kod eklemeden önce yeni oluşturulan bir Xamarin.Mac uygulamasını çalıştırdıysanız, uygulama menüsündeki Çık öğesi gibi bazı öğelerin sizin için otomatik olarak kablolu ve etkin olduğunu (tam işlevsellik otomatik olarak yerleşik olarak) fark edersiniz:

Kes, Kopyala ve Yapıştır gibi diğermenü öğeleri şu şekilde değildir:

dışı menü

Uygulamayı durduracak ve Xcode'un çalışma Çözüm Bölmesi için ana dosyada Main.storyboard dosyasına çift Interface Builder. Ardından, Kitaplık'tan bir Metin Görünümü'ni Arabirim Düzenleyicisi'nde pencerenin görünüm denetleyicisine sürükleyin:

Kısıtlama Düzenleyicisi'nde metin görünümünü pencerenin kenarlarına sabitlenin ve düzenleyicinin üst kısmında yer alan dört kırmızı I-tuşuna ve 4 Kısıtlama Ekle düğmesine tıklayarak pencereyle birlikte pencereyle birlikte büyüyecek ve küçülecek şekilde ayarlayabilirsiniz:

Değişikliklerinizi kullanıcı arabirimi tasarımına kaydedin ve değişiklikleri Xamarin.Mac Mac için Visual Studio eşitlemek için kullanıcı arabirimine geri geçiş yapın. Şimdi uygulamayı başlatarak metin görünümüne metin yazın, seçin ve Düzenle menüsünü açın:

Tek bir kod satırıyazmadanKes, Kopyala ve Yapıştır öğelerinin otomatik olarak etkinleştirildiğinden ve tamamen işlevsel olduğunu fark edersiniz.

Burada neler oluyor? MacOS'un parçası olan Cocoa kullanıcı arabirimi öğelerinin çoğu, varsayılan menü öğelerine bağlı olarak gelen yerleşik önceden tanım eylemlerini unutmayın (örneğin, copy: ). Bu nedenle, etkin ve seçili bir pencereye eklendiklerinde, ilgili menü öğesi veya bu eyleme eklenen öğeler otomatik olarak etkinleştirilir. Kullanıcı bu menü öğesini seçerse, kullanıcı arabirimi öğesinde yerleşik olan işlevler çağrılır ve yürütülür; bunların hepsi geliştirici müdahalesi olmadan olur.

Menüleri ve öğeleri etkinleştirme ve devre dışı bırakma

Varsayılan olarak, bir kullanıcı olayı her oluştuğunda, uygulamanın bağlamına bağlı olarak her görünür menüyü ve menü öğesini otomatik olarak NSMenu etkinleştirebilir ve devre dışı bırakacaktır. Bir öğeyi etkinleştirmenin/devre dışı bırakmanın üç yolu vardır:

• Otomatik menü etkinleştirme - Öğenin kablolu olarak bağlı olduğu eyleme yanıt veren uygun bir nesne bulabilirse bir menü öğesi etkinleştirilir. Örneğin, yukarıdaki metin görünümü eyleme yerleşik bir kancaya copy: sahiptir.
• Özel eylemler ve validateMenuItem: - Pencereye bağlı herhangi bir menü öğesi veya denetleyici özel eylemlerini görüntülemek için eylemiekleyebilir ve menü öğelerini el ile etkinleştirebilir veya devre dışı ekleyebilirsiniz.
• El ile menü etkinleştirme - Bir menüyü tek tek etkinleştirmek veya devre dışı bırakmak için her bir NSMenuItem öğenin özelliğini el ile ayarlarsınız.

Bir sistem seçmek için bir AutoEnablesItems özelliğini NSMenu ayarlayın. true otomatiktir (varsayılan davranış) ve false el iledir.

validateMenuItem kullanma

Yukarıda belirtildiği gibi, Bir Pencere veya Görünüm Denetleyicisi Özel Eylemine bağlı herhangi bir menü öğesi için eylemi ekleyebilir ve menü öğelerini el ile etkinleştirebilir veya devre dışı ekleyebilirsiniz.

Aşağıdaki örnekte özelliği, bir içinde seçili metnin durumuna bağlı olarak eylem tarafından etkinleştirilecek/devre dışı bırakılacak menü öğesinin türüne TagvalidateMenuItem: karar vermek için NSTextView kullanılacaktır. özelliği, Tag her menü Interface Builder için şu şekilde ayarlanmıştır:

Görünüm Denetleyicisi'ne aşağıdaki kod da eklendi:

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

Bu kod çalıştırılmıştır ve içinde metin seçilmemişse, iki sarmala menü öğesi devre dışı bırakılır (görünüm denetleyicisinde eylemlere kablolu NSTextView olsalar bile):

Devre dışı bırakılmış öğeleri

Metnin bir bölümü seçilirse ve menü yeniden açılırsa, iki sarmala menü öğesi kullanılabilir:

Koddaki menü öğelerini etkinleştirme ve yanıt verme

Yukarıda da görülen gibi, kullanıcı arabirimi tasarımımıza (metin alanı gibi) belirli Cocoa kullanıcı arabirimi öğeleri ekleniyorsa, varsayılan menü öğelerinin birkaçı kod yazmak zorunda kalmadan otomatik olarak etkinleştirilir ve çalışır. Şimdi bir menü öğesini etkinleştirmek ve kullanıcı bunu seçerken işlevsellik sağlamak için Xamarin.Mac projemize kendi C# kodumuz eklemeye bakalım.

Örneğin, kullanıcının Dosya menüsündeki Aç öğesini kullanarak bir klasör seçmesine izin vermemiz gerekir. Bunun uygulama genelinde bir işlev olması ve belirli bir pencere veya kullanıcı arabirimi öğesiyle sınırlı olmadığınız için, bunu işlemek için kodu uygulama temsilcimize ekleyebilirsiniz.

Dosyanın Çözüm Bölmesidosyasına çift tıklar ve dosyayı düzenlemek için açın:

Aşağıdaki kodu yönteminin altına DidFinishLaunching ekleyin:

[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 ();
    }
}

Şimdi uygulamayı çalıştırarak Dosya menüsünü açabilirsiniz:

Menü öğesini aç seçeneğinin etkin olduğunu fark edin. Bunu seçerse, aç iletişim kutusu görüntülenir:

Aç düğmesine tıklarsanız uyarı iletimiz görüntülenir:

Örnek bir iletişim kutusu

Buradaki temel satır, [Export ("openDocument:")]NSMenu[Export ("openDocument:")] eyleme yanıt veren void OpenDialog (NSObject sender) bir yöntemi olduğunu openDocument: söyler. Yukarıdan hatırlayacak olursanız Aç menü öğesi, aşağıdaki ayarlarda varsayılan olarak bu eyleme Interface Builder:

Şimdi kendi menümz, menü öğelerimiz ve eylemlerimizi oluşturmaya ve kodda bunları yanıtlaya göz atacağız.

Son aç menüsüyle çalışma

Varsayılan olarak, Dosya menüsünde kullanıcının uygulamanıza açtığı son birkaç dosyayı takip etmek için Bir Son Aç öğesi vardır. Tabanlı bir NSDocument Xamarin.Mac uygulaması oluşturuyorsanız, bu menü sizin için otomatik olarak işlenir. Diğer herhangi bir Xamarin.Mac uygulaması türü için bu menü öğesini el ile yönetmek ve yanıt verme sorumluluğu size ve ardından gelecektir.

Son Aç menüsünü el ile işlemek için, önce aşağıdakini kullanarak yeni bir dosyanın aç olduğunu veya kayded olduğunu bildirmeniz gerekir:

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

Uygulamanız kullanmasa da, dosyasının konumunu yöntemine göndererek Son Kullanılanları Aç menüsünü korumak için yine NSDocumentsNSDocumentController de NSDocumentsNSUrlNoteNewRecentDocumentURLSharedDocumentController kullanırsiniz.

Ardından, kullanıcının Son Aç menüsünden seçerek herhangi bir dosyayı açmak OpenFile için uygulama temsilcisinin yöntemini geçersiz OpenFile gerekir. Örnek:

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

Dosya açılabilirse geri dön, yoksa geri dön ve kullanıcıya dosyanın açılamadı olarak true gösterilen yerleşik bir uyarı false görüntülenir.

Dosya adı ve Son Aç menüsünden döndürülen yol bir boşluk içerebilir, oluşturmadan önce bu karakterden düzgün bir şekilde kaçış karakteri gerekir, yoksa bir hata alırsınız. Bunu aşağıdaki kodla yapacağız:

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

Son olarak, dosyayı temsil edecek bir oluşturuz ve uygulama temsilcisinde bir yardımcı yöntem kullanarak yeni bir pencere açıp dosyayı NSUrl içine yükleyebilirsiniz:

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

Her şeyi bir araya çekmek için AppDelegate.cs dosyasındaki örnek bir uygulamaya göz atalım:

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

Uygulama gereksinimlerine bağlı olarak, kullanıcının aynı dosyayı aynı anda birden fazla pencerede açması istemeyebilirsiniz. Örnek uygulamamızda, kullanıcı zaten açık olan bir dosyayı seçerse (Son Aç veya Aç menü öğelerinden), dosyayı içeren pencere öne getiri.

Bunu gerçekleştirmek için yardımcı yöntemimizde aşağıdaki kodu kullandık:

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

ViewControllerSınıfımızı, özelliğinde dosyanın yolunu tutmak için Path tasarladık. Ardından uygulamada açık olan tüm pencerelerde döngüye geçebilirsiniz. Dosya zaten pencerelerden biri açıksa, aşağıdakiler kullanılarak diğer tüm pencerelerin önüne getirebilirsiniz:

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

Eşleşme bulunamazsa, dosyanın yükleniyor olduğu yeni bir pencere açılır ve dosya Son Aç menüsünde gösterilir:

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

Özel pencere eylemleriyle çalışma

Standart menü öğelerine önceden kablolu olarak gelen yerleşik İlk Yanıtlayan eylemleri gibi, yeni, özel eylemler oluşturabilir ve bunları yeni menü öğelerine Interface Builder.

İlk olarak, uygulama pencere denetleyicilerinden biri üzerinde özel bir eylem tanımlayın. Örnek:

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

Ardından, Xcode'un çalışma Çözüm Bölmesi düzenlemek için açmak için uygulamanın Interface Builder. Uygulama Sahnesi'nin altında İlk Yanıtlayan'ıseçin ve ardından Öznitelikler Denetçisi'ne geçiş:

Yeni + bir özel eylem eklemek için + altındaki düğmesine tıklayın:

Pencere denetleyiciniz üzerinde oluşturduğunuz özel eylemle aynı adı girin:

Bir menü öğesinden Uygulama Sahnesi'nin altındaki İlk Yanıtlayan'a denetim tıklama ve sürükleme. Açılan listeden yeni oluşturduğunuz eylemi seçin defineKeyword: (bu örnekte):

Değişiklikleri storyboard'a kaydedin ve değişiklikleri eşitlemek Mac için Visual Studio panoya geri dön. Uygulamayı çalıştırdıysanız, özel eylemi bağdan çıkardıktan sonra menü öğesi otomatik olarak etkinleştirilir/devre dışı bırakılır (eylemin açık olduğu pencereye bağlı olarak) ve menü öğesinin seçildiğinde eylem devre dışı bırakılır:

Menüleri ekleme, düzenleme ve silme

Önceki bölümlerde de olduğu gibi bir Xamarin.Mac uygulaması, belirli kullanıcı arabirimi denetimlerinin otomatik olarak etkinleştirilen ve yanıt veren önceden ayarlanmış sayıda varsayılan menü ve menü öğesiyle birlikte gelir. Ayrıca uygulamamıza bu varsayılan öğeleri de etkinleştirecek ve bunlara yanıt veren kodun nasıl ekli olduğunu gördük.

Bu bölümde ihtiyacımız olan menü öğelerini kaldırmayı, menüleri yeniden düzenlemeyi ve yeni menüler, menü öğeleri ve eylemler eklemeyi göz atacak.

Düzenleme için açmak için dosyanın içinde Main.storyboardÇözüm Bölmesi çift tıklayın:

Belirli Xamarin.Mac uygulamamız için varsayılan Görünüm menüsünü kullanmayacak, bu nedenle uygulamayı kaldıracak. Arabirim Hiyerarşisi'ninana menü çubuğunun bir parçası olan Görünüm menü öğesini seçin:

menü öğesini

Menüyü silmek için Sil veya geri al tuşuna basın. Bundan sonra Biçim menüsündeki tüm öğeleri kullanmayacak ve alt menülerin altından çıkaracaklarımız öğeleri taşımak istiyorum. Arabirim Hiyerarşisi'ne aşağıdaki menü öğelerini seçin:

çok öğe

Üst Menü altındaki öğeleri şu anda olduğu alt menüden sürükleyin:

Men niz şimdi şöyle görünür:

Şimdi Biçim menüsünün altından Metin alt menüsünü sürükleyip Biçim ve Pencere menüleri arasındaki ana menü çubuğunaek olarak bu menüyü ekseriz:

Biçim menüsünün altına geri dönüp Yazı tipi alt menü öğesini silebilirsiniz. Ardından Biçim menüsünü seçin ve "Font" olarak yeniden adlandırabilirsiniz:

Şimdi, seçili olduğunda metin görünümündeki metne otomatik olarak eklenecek ön tanımlama tümceciklerinin özel bir menüsünü oluşturabilirsiniz. Kitaplık Denetçisi'nin en altındaki arama kutusuna "menu" yazın. Bu, tüm menü kullanıcı arabirimi öğelerini bulma ve bu öğelerle çalışma kolaylaştıracaktır:

Şimdi menüyü oluşturmak için şunları yapacağız:

1. Kitaplık Denetçisi'ninMenü Öğesini Metin ve Pencere menüleri arasındaki menüçubuğuna sürükleyin:

   

2. Öğeyi "Tümcecikler" olarak yeniden adlandır:

   

3. Ardından Kitaplık Denetçisi'ne bir Menü sürükleyin:

   

4. Yeni oluşturduğum Menü Öğesi'nin üzerine Menü'yü bırakın ve adını "Tümcecikler" olarak değiştirebilirsiniz:

   

5. Şimdi üç varsayılan Menü Öğesini "Adres", "Tarih" ve "Selamlama" olarak yeniden adlandırabilirsiniz:

   

6. Şimdi Kitaplık Denetçisi'ne bir Menü Öğesisürükleyip bunu "İmza" olarak çağırarak dördüncü bir Menü Öğesi ek o zaman:

   

7. Değişiklikleri menü çubuğuna kaydedin.

Şimdi yeni menü öğelerimizin C# koduna açık olacak şekilde bir dizi özel eylem oluşturabilirsiniz. Xcode'da Yardımcı görünümüne geçelim:

Şimdi şunları gerçekleştirin:

1. Adres menü öğesindenAppDelegate.h dosyasına control-drag komutuyla sürükleyin.

2. Bağlantı türünü Eylem olarak değiştirme:

   

3. Yeni eylemi oluşturmak için "phraseAddress" Bağlan düğmesine basın:

   

4. Tarih, tebrikve imza menü öğeleri için yukarıdaki adımları yineleyin:

   Tamamlanan eylemler

5. Değişiklikleri menü çubuğuna kaydedin.

Bundan sonra, içeriğini koddan ayarlayabilmemiz için metin görünümümüzü bir priz oluşturmamız gerekiyor. Yardımcı düzenleyici 'de ViewController. h dosyasını seçin ve adlı yeni bir priz oluşturun :

çıkışı oluşturma

değişiklikleri xcode 'dan eşitlemek için Mac için Visual Studio geri dönün. Daha sonra ViewController. cs dosyasını düzenleyin ve aşağıdaki gibi görünmesini sağlayın:

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

Bu, metin görünümümüzün metnini sınıf dışında kullanıma sunar ViewController ve pencere, odağı aldığında veya kaybettiğinde uygulama temsilcisine bildirir. Şimdi Appdelegate. cs dosyasını düzenleyin ve aşağıdaki gibi görünmesini sağlayın:

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

Burada, AppDelegate Interface Builder tanımladığımız eylemleri ve aykırı seçenekleri kullanabilmemiz için kısmi bir sınıf yaptık. Ayrıca textEditor , hangi pencerenin odaklanmakta olduğunu izlemek için bir de kullanıma sunuldu.

Aşağıdaki yöntemler özel menü ve menü öğelerimizi işlemek için kullanılır:

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

Uygulamamızı çalıştırdığımızda, ifade menüsündeki tüm öğeler etkin olur ve seçildiğinde, metin görünümüne ver ifadesi eklenir:

Uygulamanın örneğini çalıştıran uygulamanın bir

Artık uygulama menü çubuğu ile çalışmanın temelleri olduğuna göre, özel bağlamsal menü oluşturma konusuna bakalım.

Koddan menüler oluşturma

Xcode 'un Interface Builder menü ve menü öğeleri oluşturmaya ek olarak, bir Xamarin. Mac uygulamasının koddan bir menü, alt menü ya da menü öğesi oluşturması, değiştirmesi veya kaldırılması gerektiği zamanlar olabilir.

Aşağıdaki örnekte, ile dinamik olarak oluşturulacak menü öğeleri ve alt menüler hakkındaki bilgileri tutmak için bir sınıf oluşturulur:

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

Menü ve öğe ekleme

Bu sınıf tanımlı olarak, aşağıdaki yordam bir LanguageFormatCommand nesne koleksiyonunu ayrıştırarak yeni menüleri ve menü öğelerini yinelemeli olarak oluşturur (Interface Builder oluşturulan) mevcut menünün sonuna ekleyerek özyinelemeli olarak yeni menüler ve menü öğeleri oluşturur:

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

LanguageFormatCommandBoş bir özelliği olan herhangi bir nesne için Title , bu yordam menü bölümleri arasında bir LanguageFormatCommand (ince gri çizgi) oluşturur:

menuItem = NSMenuItem.SeparatorItem;

Bir başlık sağlanmışsa, bu başlığa sahip yeni bir menü öğesi oluşturulur:

menuItem = new NSMenuItem (command.Title);

LanguageFormatCommandNesne alt LanguageFormatCommand nesneler içeriyorsa, bir alt menü oluşturulur ve AssembleMenu Bu menüyü oluşturmak için yöntem yinelemeli olarak çağırılır:

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

Alt menüleri olmayan yeni bir menü öğesi için, Kullanıcı tarafından seçilen menü öğesini işlemek üzere kod eklenir:

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

Menü oluşturmayı test etme

Yukarıdaki tüm kod varsa, aşağıdaki LanguageFormatCommand nesne koleksiyonu oluşturulduysa:

// 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)"));

Bu koleksiyon AssembleMenu işleve geçirilir (taban olarak ayarlanan AssembleMenu menüsüyle), aşağıdaki dinamik menüler ve menü öğeleri oluşturulur:

Çalışan ,

Menüleri ve öğeleri kaldırma

Uygulamanın kullanıcı arabiriminden herhangi bir menü veya menü öğesini kaldırmanız gerekirse, RemoveItemAtNSMenu kaldırılacak öğenin sıfır tabanlı dizinini vererek sınıfının yöntemini kullanabilirsiniz.

Örneğin, yukarıdaki yordam tarafından oluşturulan menüleri ve menü öğelerini kaldırmak için aşağıdaki kodu kullanabilirsiniz:

public void UnpopulateFormattingMenu(NSMenu menu) {

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

Yukarıdaki kod söz konusu olduğunda, ilk dört menü öğesi, Xcode 'un Interface Builder, uygulamada kullanılabilir ve bu nedenle dinamik olarak kaldırılmamaları halinde oluşturulur.

Bağlamsal menüler

Bağlamsal menüler, Kullanıcı sağ tıkladığı veya bir penceredeki bir öğeyi Control-tıkladığı zaman görünür. Varsayılan olarak, macOS 'ta yerleşik olarak bulunan Kullanıcı arabirimi öğelerinden birkaçı zaten bunlara eklenmiş bağlam menülerine sahiptir (örneğin, metin görünümü). Ancak, bir pencereye eklediğimiz bir UI öğesi için kendi özel bağlamsal menülerinizi oluşturmak istediğimizden zaman zaman olabilir.

Ayrıca, Xcode 'Da ana. görsel taslak dosyanızı düzenleyelim ve tasarımımız bir pencere penceresi ekleyecek, kimlik denetçisindekendi sınıfını "nspanel" olarak ayarlayalım, pencere menüsüne yeni bir yardımcı öğe ekleyecek ve bunu gösterile yeni pencereye iliştirelim:

Şunları yapalim:

1. Kitaplık denetçisinden bir etiketipanel penceresine sürükleyin ve metnini "Property" olarak ayarlayın:

   Etiketin değerini düzenleniyor

2. Sonra, kitaplık denetçisindeki bir menüyü görünüm hiyerarşisinde görünüm denetleyicisine sürükleyin ve üç varsayılan menü öğesi belge, metin ve yazı tipiniyeniden adlandırın:

   Gerekli

3. Şimdi Control- Property etiketindenMenuüzerine sürükleyin:

   Bir g/y bir aşağı sürükleme

4. Açılan iletişim kutusundan menü' yi seçin:

   

5. Kimlik denetçisinde, görünüm denetleyicisinin sınıfını "PanelViewController" olarak ayarlayın:

   SEG

6. eşitlemek için Mac için Visual Studio geri dönün, sonra Interface Builder geri döndürün.

7. Yardımcı düzenleyiciye geçin ve panelviewcontroller. h dosyasını seçin.

8. Şu adlı belge menü öğesi için bir eylem oluşturun :

   

9. Kalan menü öğeleri için eylem oluşturmayı yineleyin:

   

10. Son olarak, çağrılan özellik etiketi için bir çıkış oluşturun :

    yapılandırma

11. değişikliklerinizi kaydedin ve xcode ile eşitlemek için Mac için Visual Studio geri dönün.

Panelviewcontroller. cs dosyasını düzenleyin ve aşağıdaki kodu ekleyin:

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

Uygulamayı çalıştırdığımızda ve paneldeki Özellik etiketine sağ tıkladıktan sonra özel bağlamsal menümüzü görüyoruz. Menüden ve öğesini seçmemiz durumunda etiketin değeri değişecektir:

Şimdi durum çubuğu menülerini oluşturmaya bakalım.

Durum çubuğu Menüleri

Durum çubuğu menüleri, bir menü ya da bir uygulamanın durumunu yansıtan bir görüntü gibi kullanıcı ile etkileşim sağlayan durum menüsü öğelerinin bir koleksiyonunu görüntüler. Uygulamanın arka planda çalışıyor olsa bile, uygulamanın durum çubuğu menüsü etkinleştirilir ve etkin olur. Sistem genelindeki durum çubuğu, uygulama menü çubuğunun sağ tarafında bulunur ve macOS 'ta Şu anda kullanılabilen tek durum çubuğudur.

Appdelegate. cs dosyanızı düzenleyelim ve yöntemin aşağıdaki gibi görünmesini sağlayın:

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; sistem genelindeki durum çubuğuna erişim elde etmenizi sağlar. var item = statusBar.CreateStatusItem (NSStatusItemLength.Variable); Yeni bir durum çubuğu öğesi oluşturur. Buradan bir menü ve birkaç menü öğesi oluşturur ve menüyü yeni oluşturduğumuz durum çubuğu öğesine ekler.

Uygulamayı çalıştırdığımızda yeni durum çubuğu öğesi görüntülenecektir. Menüden bir öğenin seçilmesi, metin görünümündeki metni değiştirecek:

çalıştıran durum

Ardından, özel Dock menü öğeleri oluşturmaya bakalım.

Özel yerleştirme Menüleri

Kullanıcı sağ tıkladığı veya denetimin Dock 'ta uygulamanın simgesine tıkladığı zaman, Mac uygulaması için dock menüsü görünür:

Özel Dock menüsü

Aşağıdaki işlemleri gerçekleştirerek uygulamamız için özel bir yuva menüsü oluşturalım:

1. Mac için Visual Studio, uygulamanın projesine sağ tıklayın ve yeni dosya ekle... seçeneğini belirleyin. Yeni dosya iletişim kutusunda Xamarin. Macboş arabirim tanımı' nı seçin, ad için "DockMenu" kullanın ve yeni bir DockMenu. XIB dosyası oluşturmak için Yeni düğmesine tıklayın:

   Boş bir arabirim tanımı

2. Çözüm bölmesi, DockMenu. XIB dosyasına çift tıklayarak Xcode 'da düzenlenmek üzere açın. Şu öğelerle yeni bir menü oluşturun: Adres, Tarih, tebrikve imza

   Kullanıcı arabiriminidüzenleme

3. Daha sonra, yeni menü öğelerimizi, Yukarıdaki menü ekleme, Düzenle ve silme bölümünde yer alan özel menümüzde oluşturduğumuz mevcut eylemlerimize bağlayalim. Bağlantı denetçisi ' ne geçin ve arabirim hiyerarşisindekiilk Yanıtlayıcıyı seçin. Aşağı kaydırın ve eylemi bulun phraseAddress: . Bu eylemde bulunan çemberden bir çizgiyi Adres menü öğesine sürükleyin:

   

4. Bunları karşılık gelen eylemlere ekleyerek diğer menü öğelerinin tümü için yineleyin:

   

5. Sonra, arabirim hiyerarşisindekiuygulamayı seçin. Bağlantı denetçisinde, çıkış üzerindeki çemberden bir çizgiyi Yeni oluşturduğumuz menüye sürükleyin:

   altına çıkışı sürükleme

6. değişikliklerinizi kaydedin ve xcode ile eşitlemek için Mac için Visual Studio geri dönün.

7. Info. plist dosyasına çift tıklayarak dosyayı düzenlenmek üzere açın:

   İnfo. plist dosyasını düzenleyen Info.

8. Ekranın altındaki kaynak sekmesine tıklayın:

   Kaynak görünümünü

9. Yeni giriş Ekle' ye tıklayın, yeşil artı düğmesine tıklayın, özellik adını "AppleDockMenu" olarak ve değeri "DockMenu" olarak ayarlayın (uzantısı olmadan yeni. XIB dosyası adı):

   DockMenu öğesiniekleme

Uygulamamızı çalıştırdığımızda ve Dock 'ta simgesine sağ tıkladığınızda yeni menü öğelerimiz görüntülenir:

Dock menüsünün

Menüden özel öğelerden birini seçmemiz durumunda metin görünümümüzde bulunan metin değiştirilecek.

Açılır düğme ve aşağı açılan listeler

Bir açılır düğme seçili bir öğeyi görüntüler ve Kullanıcı tarafından tıklandığı sırada seçilecek seçeneklerin bir listesini gösterir. Bir aşağı açılan liste, genellikle geçerli görevin bağlamına özgü komutları seçmek için kullanılan bir açılır düğme türüdür. Her ikisi de pencerenin herhangi bir yerinde görünebilir.

Aşağıdaki işlemleri gerçekleştirerek uygulamamız için özel bir açılır düğme oluşturalım:

1. Xcode 'da ana. Storyboard dosyasını düzenleyin ve kitaplık denetçisinden bir açılan düğmeyi , bağlamsal menüler bölümünde oluşturduğumuz panel penceresi üzerine sürükleyin:

   Açılır menü ekleme

2. Yeni bir menü öğesi ekleyin ve açılan menüdeki öğelerin başlıklarını şu şekilde ayarlayın: Adres, Tarih, tebrikve imza

   Menü menü öğelerini yapılandırma

3. Daha sonra, yeni menü öğelerimizi, Yukarıdaki menü ekleme, Düzenle ve silme bölümünde yer alan özel menümüzde oluşturduğumuzu var olan eylemlere bağlayalim. Bağlantı denetçisi ' ne geçin ve arabirim hiyerarşisindekiilk Yanıtlayıcıyı seçin. Aşağı kaydırın ve eylemi bulun phraseAddress: . Bu eylemde bulunan çemberden bir çizgiyi Adres menü öğesine sürükleyin:

   Bir eylemi bağlamak için bir eylem bırakmak

4. Bunları karşılık gelen eylemlere ekleyerek diğer menü öğelerinin tümü için yineleyin:

   Tüm

5. değişikliklerinizi kaydedin ve xcode ile eşitlemek için Mac için Visual Studio geri dönün.

Uygulamamızı çalıştırdığımızda ve açılan listeden bir öğe seçtiğinizde, metin görünümümüzdeki metin değişecektir:

Açılan pencere çalıştıran örneği

Açılır düğmeleriyle tam olarak aynı şekilde, çekme listeleri oluşturup bunlarla çalışabilirsiniz. Var olan eyleme eklemek yerine, kendi özel eylemlerinizi, bağlamsal menüler bölümünde bağlam menümüzde olduğu gibi oluşturabilirsiniz.

Özet

Bu makale, Xamarin. Mac uygulamasındaki menüler ve menü öğeleriyle çalışma konusunda ayrıntılı bir bakış gerçekleştirmiştir. İlk olarak uygulamanın menü çubuğunu inceledik, sonra da durum çubuğu menülerini ve özel yerleştirme menülerini inceledik. Son olarak, açılır menüler ve aşağı açılan listeler kapsandık.

İlişkili Bağlantılar

• MacMenus (örnek)
• Hello, Mac
• İnsan arabirimi yönergeleri-menüler
• Uygulama menülerine ve açılır listelere giriş