Xamarin.Mac'te Windows

Bu makale, bir Xamarin.Mac uygulamasındaki pencereler ve panellerle çalışmayı kapsar. Xcode ve Interface Builder'da pencereler ve paneller oluşturmayı, bunları storyboard'lardan ve .xib dosyalarından yüklemeyi ve program aracılığıyla bu dosyalarla çalışmayı açıklar.

Bir Xamarin.Mac uygulamasında C# ve .NET ile çalışırken, ve Xcode'da çalışan bir geliştiricinin Windows panellere ve panellere Objective-C erişebilirsiniz. Objective-C Xamarin.Mac doğrudan Xcode ile tümleşik olduğundan, Windows ve Panellerinizi 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).

Amacına bağlı olarak, bir Xamarin.Mac uygulaması, Windows ve birlikte çalıştığını yönetmek ve koordine etmek için ekranda bir veya daha fazla uygulama sunabilirsiniz. Bir pencerenin asıl işlevleri:

1. Görünümler ve Denetimlerin yerleştirilil ve yönetile bir alan sağlamak için.
2. Hem klavye hem de fare ile kullanıcı etkileşimine yanıt olarak olayları kabul etmek ve yanıtlamak için.

Windows, Modeless (aynı anda birden çok belge açtıran bir metin düzenleyicisi gibi) veya Kalıcı (örneğin, uygulamanın devam etmek için önce açılması gereken bir Dışarı Aktar iletişim kutusu) kullanılabilir.

Paneller, genellikle Metin biçimi denetçileri ve sistem yöneticisi gibi yardımcı pencereler gibi bir uygulamada yardımcı bir işleve hizmet eden özel bir Pencere t NSWindow Renk Seçici.

Bu makalede, bir Xamarin.Mac uygulamasında Windows ve Panellerle çalışmayla ilgili temel bilgileri yer aeceğiz. Ö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 komutlarını da açıklayan bölümüne göz RegisterExportObjective-C atabilirsiniz.

Pencerelere giriş

Yukarıda belirtildiği gibi Pencere, Görünümler ve Denetimlerin yerleştirilebiliyor, yönetilebiliyor ve kullanıcı etkileşimine göre olaylara yanıt verebiliyor (klavye veya fare aracılığıyla) bir alan sağlar.

Apple'a göre, bir macOS uygulamasında Windows türü vardır:

• Belge Penceresi - Belge penceresi, elektronik tablo veya metin belgesi gibi dosya tabanlı kullanıcı verilerini içerir.
• Uygulama Penceresi - Uygulama penceresi, belge tabanlı olmayan bir uygulamanın ana penceresidir (Mac'te Takvim uygulaması gibi).
• Panel - Bir panel diğer pencerelerin üzerinde kayar ve kullanıcıların belgeler açıkken birlikte çalışabilirsiniz araçlar veya denetimler sağlar. Bazı durumlarda, bir panel saydam olabilir (örneğin, büyük grafiklerle çalışırken).
• İletişim kutusu - Bir kullanıcı eylemine yanıt olarak bir iletişim kutusu görünür ve genellikle kullanıcıların eylemi tamamlama yolları sağlar. İletişim kutusu kapatılamadan önce kullanıcıdan bir yanıt gerektirir. (Bkz. İletişim Kutularıyla Çalışma)
• Uyarılar - Uyarı, ciddi bir sorun oluştuğunda (hata gibi) veya uyarı olarak (bir dosyayı silene hazırlanma gibi) görüntülenen özel bir iletişim kutusu t'tir. Uyarı bir iletişim kutusu olduğundan kapatılamadan önce bir kullanıcı yanıtı gerektirir. (Bkz. Uyarılar ile Çalışma)

Daha fazla bilgi için Apple'ın macOS Windows temaları hakkında bölümüne bakın.

Ana, anahtar ve etkin olmayan pencereler

Windows bir Xamarin.Mac uygulamasındaki kullanıcılar, kullanıcının o anda bu uygulamayla nasıl etkileşim kurduğuna bağlı olarak farklı bir şekilde sınanır ve davranır. Kullanıcının dikkatini çeken en önemli Belge veya Uygulama Penceresi, Ana Pencere olarak da adlandırılan penceredir. Çoğu örnekte bu Pencere aynı zamanda Anahtar Penceresi (şu anda kullanıcı girişini kabul eden pencere) olur. Ancak bu her zaman böyle bir durum değildir; örneğin, Renk Seçici açık olabilir ve kullanıcının Belge Penceresi'nde bir öğenin durumunu değiştirmek için etkileşim kurduğu Anahtar penceresi olabilir (yine de Ana Pencere olabilir).

Ana ve Anahtar Windows (ayrı iseler) her zaman etkindir, Etkin olmayan Windows ön planda olmayan açık pencerelerdir. Örneğin, bir metin düzenleyici uygulamasında aynı anda birden fazla belge açık olabilir, yalnızca Ana Pencere etkin olur, diğerleri etkin değildir.

Daha fazla bilgi için Apple'ın macOS Windows temaları hakkında bölümüne bakın.

Adlandırma pencereleri

Pencere bir Başlık Çubuğu görüntülenebilir ve Başlık görüntülendiğinde genellikle uygulamanın adı, üzerinde çalışmakta olan belgenin adı veya pencerenin işlevi (Denetçi gibi) olur. Bazı uygulamalar, görüntü tarafından tanınabilir ve belgelerle çalışmayarak Başlık Çubuğu görüntülemez.

Apple aşağıdaki yönergeleri önerir:

• Ana, belge olmayan bir pencerenin başlığı için uygulama adını kullanın.
• Yeni bir belge penceresi olarak ad untitled girin. İlk yeni belge için Başlık'a bir sayı (örneğin, ) untitled 1 ekleyin. Kullanıcı ilk belgeyi kaydederek düzenlemeden önce başka bir yeni belge oluşturursa, bu untitled 2 pencereyi untitled 3 , vb. çağırabilirsiniz.

Daha fazla bilgi için Apple'ın macOSWindows adlandırma temaları bölümüne bakın.

Tam ekran pencereler

macOS'ta bir uygulamanın penceresi, içeriğiyle dikkat dağıtan ücretsiz etkileşim sağlamak için Uygulama Menü Çubuğu da dahil olmak üzere her şeyi gizler (imleci ekranın en üstüne doğru hareket ettirerek ortaya çıkar.

Apple aşağıdaki yönergeleri önerir:

• Bir pencerenin tam ekranla dolup dolu olmadığını belirler. Kısa etkileşimler (Hesaplayıcı gibi) sağlayan uygulamalar tam ekran modu sağlamaması gerekir.
• Tam ekran görevi gerektiriyorsa araç çubuğunu gösterir. Araç çubuğu genellikle tam ekran modundayken gizlenir.
• Tam ekran penceresinde kullanıcıların görevi tamamlaması için gereken tüm özelliklere sahip olması gerekir.
• Mümkünse, kullanıcı tam ekran penceresindeyken Bulıcı etkileşiminin önüne geçebilirsiniz.
• Odağı ana görevden kaydırmadan artırılmış ekran boşluğundan faydalanın.

Daha fazla bilgi için Apple'ın macOSWindows temalarının Tam Ekran Bilgileri bölümüne bakın.

Panel

Panel, etkin belgeyi veya seçimi etkileyen denetimleri ve seçenekleri içeren yardımcı bir penceredir (örneğin, sistem Renk Seçici):

Paneller Uygulamaya Özgü veya Systemwide olabilir. App-Specific Paneller, uygulamanın belge pencerelerinin üst kısmında kayar ve uygulama arka planda olduğunda kaybolur. Sistem genelindeki Paneller (Yazı Tipleri paneli gibi), uygulama ne olursa olsun tüm açık pencerelerin üzerinde kayan.

Apple aşağıdaki yönergeleri önerir:

• Genel olarak, standart bir panel kullanın, saydam paneller yalnızca yoğun grafik kullanımlı görevler için kullanılmalıdır.
• Kullanıcılara görevlerini doğrudan etkileyen önemli denetimlere veya bilgilere kolay erişim vermek için bir panel kullanmayı göz önünde bulundurabilirsiniz.
• Panelleri gereken şekilde gizle ve göster.
• Paneller her zaman başlık çubuğu içermeli.
• Paneller etkin bir simge durumuna küçült düğmesi içermemesi gerekir.

Müfettiş

Çoğu modern macOS uygulaması, Panel penceresi kullanmak yerine Ana Pencerenin parçası olan Denetçiler (aşağıda gösterilen Sayfalar uygulaması gibi) olarak etkin belgeyi veya seçimi etkileyen yardımcı denetimler ve seçenekler Windows:

Daha fazla bilgi için, Xamarin.Mac uygulamasında Denetçi Arabiriminin tam uygulaması için Apple'ın macOS tasarım temalarının Paneller bölümüne ve MacInspector örnek uygulamamıza bakın.

Xcode'da pencere oluşturma ve koruma

Yeni bir Xamarin.Mac Cocoa uygulaması sanız varsayılan olarak standart boş bir pencereyle karşınız olur. Bu pencereler projeye otomatik olarak .storyboard dahil edilen bir dosyada tanımlanır. Windows tasarımınızı düzenlemek için, Çözüm Gezginidosyasına çift tıklayın:

Bu, Xcode'un penceresinde pencere tasarımını Interface Builder:

Öznitelik Denetçisinde,pencerenizi tanımlamak ve kontrol etmek için kullanabileceğiniz çeşitli özellikler vardır:

• Başlık - Bu, pencerenin başlık çubuğuna görüntülenecek metindir.
• Otomatik kaydetme - Konumu ve ayarları otomatik olarak kaydedilirken pencereyi kimlikle ifade etmek için kullanılacak anahtardır.
• Başlık Çubuğu - Pencerede bir başlık çubuğu görüntülenir.
• Birleşik Başlık ve Araç Çubuğu - Pencere bir Araç Çubuğu içerirse, başlık çubuğunun bir parçası olması gerekir.
• Tam Boyutlu İçerik Görünümü - Pencerenin içerik alanına Başlık çubuğunun altında yer alan izin verir.
• Gölge - Pencerenin bir gölgesi var mı?
• Doku- Doku tabanlı pencereler, etkileri (vibrancy gibi) kullanabilir ve gövdelerinin herhangi bir yerine sürükleyerek taşıyabilir.
• Kapat - Pencerenin kapat düğmesi var mı?
• Simge durumuna küçült - Pencerede simge durumuna küçült düğmesi var mı?
• Yeniden boyutlandır - Pencerenin yeniden boyutlandırma denetimi var mı?
• Araç Çubuğu Düğmesi - Pencerede bir gizle/göster araç çubuğu düğmesi var mı?
• Geri yüklenebilir - Pencerenin konumu ve ayarları otomatik olarak kaydedilir ve geri yüklenir.
• Başlatma Sırasında Görünür - Dosya yüklendiğinde pencere otomatik olarak gösteriliyor mu?
• Devre Dışı Bırak'da Gizle - Uygulama arka plana girdiği zaman pencere gizlenir.
• Kapatılan Sürüm - Pencere kapatılan bellekten temiz mi?
• Her Zaman Araç İpucu Görüntüle - Araç ipucu sürekli görüntülenir.
• Görünümü döngüyü yeniden hesaplar -pencere çizilmeden önce görünüm sırası yeniden hesaplanır.
• Boşluk, Exposé ve geçiş -All, pencerenin Bu MacOS ortamlarında nasıl davranacağını tanımlar.
• Tam ekran -Bu pencerenin tam ekran moduna girip giremeyeceğini belirler.
• Animasyon -pencere için kullanılabilir animasyon türünü denetler.
• Görünüm -pencerenin görünümünü denetler. Şimdilik yalnızca bir görünüm, deniz mavisi olur.

daha fazla bilgi için bkz. Apple 'ın Windows ve nswindow belgelerine giriş .

Varsayılan boyut ve konum ayarlanıyor

Pencerenin ilk konumunu ayarlamak ve boyutunu denetlemek için Boyut denetçisinegeçin:

Buradan pencerenin başlangıç boyutunu ayarlayabilir, en düşük ve en büyük boyut verebilir, ekrandaki ilk konumu ayarlayabilir ve pencere çevresindeki kenarlıkları kontrol edebilirsiniz.

Özel ana pencere denetleyicisi ayarlama

UI öğelerini C# koduna sergilemek için, daha fazla işlem ve eylem oluşturabilmek üzere Xamarin. Mac uygulamasının özel bir pencere denetleyicisi kullanıyor olması gerekir.

Şunları yapın:

1. Uygulamanın film şeridini Xcode Interface Builder içinde açın.

2. Tasarım Yüzeyi öğesini seçin NSWindowController .

3. Kimlik denetçisi görünümüne geçin ve sınıf adıolarak girin:

   

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

5. WindowController.csProject, Mac için Visual Studio WindowController.cs bir dosya eklenir:

   

6. Film şeridini Xcode Interface Builder yeniden açın.

7. Dosya kullanıma sunulacaktır WindowController.h :

   

UI öğeleri ekleme

Bir pencerenin içeriğini tanımlamak için, kitaplık denetçisindeki denetimleri arabirim Düzenleyicisiüzerine sürükleyin. Denetimleri oluşturmak ve etkinleştirmek üzere Interface Builder kullanma hakkında daha fazla bilgi için bkz. Xcode ve Interface Builder belgelerine giriş .

Örnek olarak, kitaplık denetçisinden bir araç çubuğunu arabirim düzenleyicisindepencere üzerine sürükleyelim:

Sonra, bir metin görünümüne sürükleyin ve araç çubuğunun altındaki alanı dolduracak şekilde boyutlandırın:

Pencerenin boyutu değiştikçe metin görünümünün küçültülmesi ve büyümesi gerektiğinden, kısıtlama düzenleyicisine geçiş yapmanızı ve aşağıdaki kısıtlamaları ekleyelim:

Düzenleyicinin en üstündeki dört kırmızı ı-PM MS 'ye tıklayıp 4 kısıtlama Ekle' ye tıkladığınızda, metin görünümüne verilen X, Y koordinatlarına giriş ve pencere yeniden boyutlandırıldığından yatay ve dikey olarak büyütme ve küçültme olduğunu söylüyoruz.

Son olarak, metin görünümünü bir Çıkış kullanarak kodla kullanıma sunun (dosyayı seçtiğinizden emin olun ):

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

Dış ve eylemlerleçalışma hakkında daha fazla bilgi Için lütfen Çıkış ve eylem belgelerimize bakın.

Standart pencere iş akışı

Oluşturduğunuz ve Xamarin. Mac uygulamanızda birlikte çalıştığınız herhangi bir pencere için, bu işlem, yukarıda yaptığımız gibi temelde aynıdır:

1. Projenize otomatik olarak eklenen varsayılan olmayan yeni pencereler için projeye yeni bir pencere tanımı ekleyin. Bu, aşağıda ayrıntılı olarak ele alınacaktır.
2. Main.storyboardXcode 'un Interface Builder içinde düzenlenmek üzere pencere tasarımını açmak için dosyaya çift tıklayın.
3. Kullanıcı arabiriminin tasarımına yeni bir pencere sürükleyin ve segues 'yi kullanarak pencereyi ana pencereye bağlayın (daha fazla bilgi Için görsel taslak belgeleriyle Çalışımızınsegues bölümüne bakın).
4. Öznitelik denetçisinde ve Boyut denetçisindegerekli tüm pencere özelliklerini ayarlayın.
5. Arabiriminizi derlemek ve öznitelik denetçisindeyapılandırmak için gereken denetimleri sürükleyin.
6. Kullanıcı arabirimi öğelerinize yönelik yeniden boyutlandırmayı işlemek için Boyut denetçisini kullanın.
7. Pencere Kullanıcı arabirimi öğelerini, dış izin ve Eylemleraracılığıyla C# kodu olarak kullanıma sunun.
8. değişikliklerinizi kaydedin ve xcode ile eşitlemek için Mac için Visual Studio geri dönün.

Temel bir pencere oluşturduğumuz artık, bir Xamarin. Mac uygulamasının Windows ile çalışırken oluşturduğu tipik işlemlere bakacağız.

Varsayılan pencereyi görüntüleme

Varsayılan olarak, yeni bir Xamarin. Mac uygulaması başlatıldığında dosyada tanımlanan pencereyi otomatik olarak görüntüler MainWindow.xib :

Yukarıdaki pencerenin tasarımını değiştirdiğimiz için, artık varsayılan bir araç çubuğu ve metin görünümü denetimi içerir. Info.plistBu pencereyi görüntülemeden, dosyanın aşağıdaki bölümü sorumludur:

Ana arabirim açılan kutusu, ana uygulama kullanıcı arabirimi (Bu durumda) olarak kullanılacak görsel taslağı seçmek için kullanılır .

görüntülenen ana Windows (birincil görünümüyle birlikte) denetlemek için projeye otomatik olarak bir görünüm denetleyicisi eklenir. Bu, ViewController.cs dosyada tanımlanır ve kimlik denetçisialtında Interface Builder ViewController.cs iliştirilir:

Penceremiz için, ilk açılan bir başlığa sahip olmasını istiyoruz untitledViewWillAppear . böylece, içindeki yöntemi aşağıdakine benzer şekilde geçersiz kılabilirsiniz ViewController.cs :

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

    // Set Window Title
    this.View.Window.Title = "untitled";
}

Program aracılığıyla pencereyi kapatma

Bir Xamarin. Mac uygulamasındaki bir pencereyi program aracılığıyla kapatmak istediğiniz zaman, kullanıcının pencerenin Kapat düğmesine tıklamasından veya bir menü öğesinin kullanılmasına sahip olmanın bir zamanı olabilir. macOS, programlı bir şekilde kapatmak için iki farklı yol sağlar NSWindow : PerformClose ve Close .

Performckaybetme

PerformCloseBir öğesinin yöntemini çağırmak, düğmeyi kısa bir şekilde NSWindow vurgulayarak ve ardından pencereyi kapatarak pencerenin PerformClose düğmesine tıklayana kullanıcının benzetimini yapar.

Uygulama olayını uygularsa NSWindowWillClose pencere kapatılmadan önce bu oluşturulur. Olay döndürürse false , pencere kapanmaz. Pencerede bir kapatma düğmesi yoksa veya herhangi bir nedenle kapatılamaz, işletim sistemi uyarı sesini yayar.

Örnek:

MyWindow.PerformClose(this);

Örneği kapatmaya çalışır MyWindowNSWindow . Başarılı olduysa, pencere kapatılır, aksi takdirde uyarı sesi oluşturulur ve açık kalır.

Kapat

CloseBir öğesinin yöntemini çağırmak, NSWindow düğmeyi kısaca vurgulayarak pencerenin Close düğmesine tıklayarak kullanıcının benzetimini yapmaz.

Bir pencerenin kapatılması için görünür olması gerekmez ve NSWindowWillCloseNotification Kapatılan pencere için varsayılan bildirim merkezine bir bildirim gönderilir.

CloseYöntemi yönteminden iki önemli şekilde farklılık gösterir PerformClose :

1. Olayı oluşturmaya çalışmaz WillClose .
2. Düğmeyi kısa bir şekilde vurgulayarak Kapat düğmesine tıklanarak kullanıcının benzetimini yapmaz.

Örnek:

MyWindow.Close();

Örneği kapatırdı MyWindowNSWindow .

Değiştirilen Windows içeriği

MacOS 'ta, Apple kullanıcıya bir pencere ( NSWindow ) içeriğinin Kullanıcı tarafından değiştirildiğini ve kaydedilmesi gerektiğini bildirmek için bir yol sağladı. Pencerede değiştirilen içerik varsa, küçük bir siyah nokta Kapanış pencere öğesinde görüntülenir:

Kullanıcı pencereyi kapatmayı denerse veya pencerenin içeriğinde kaydedilmemiş değişiklikler varken Mac uygulamasından çıkarsanız, bir Iletişim kutusu veya kalıcı bir sayfa sunmalı ve kullanıcının yaptığı değişiklikleri kaydetmesine izin vermeniz gerekir:

Pencereyi değiştirilmiş olarak işaretleme

Bir pencereyi değiştirilen içerik olarak işaretlemek için aşağıdaki kodu kullanın:

// Mark Window content as modified
Window.DocumentEdited = true;

Değişiklik kaydedildikten sonra, şunu kullanarak değiştirilen bayrağı temizleyin:

// Mark Window content as not modified
Window.DocumentEdited = false;

Pencereyi kapatmadan önce değişiklikler kaydediliyor

Kullanıcı bir pencereyi kapatan ve bu kullanıcıların değiştirilen içerikleri önceden kaydetmesine izin vermek için, bir alt sınıfı oluşturmanız NSWindowDelegate ve metodunu geçersiz kılmanız gerekir WindowShouldClose . Örnek:

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

namespace SourceWriter
{
    public class EditorWindowDelegate : NSWindowDelegate
    {
        #region Computed Properties
        public NSWindow Window { get; set;}
        #endregion

        #region constructors
        public EditorWindowDelegate (NSWindow window)
        {
            // Initialize
            this.Window = window;

        }
        #endregion

        #region Override Methods
        public override bool WindowShouldClose (Foundation.NSObject sender)
        {
            // is the window dirty?
            if (Window.DocumentEdited) {
                var alert = new NSAlert () {
                    AlertStyle = NSAlertStyle.Critical,
                    InformativeText = "Save changes to document before closing window?",
                    MessageText = "Save Document",
                };
                alert.AddButton ("Save");
                alert.AddButton ("Lose Changes");
                alert.AddButton ("Cancel");
                var result = alert.RunSheetModal (Window);

                // Take action based on result
                switch (result) {
                case 1000:
                    // Grab controller
                    var viewController = Window.ContentViewController as ViewController;

                    // Already saved?
                    if (Window.RepresentedUrl != null) {
                        var path = Window.RepresentedUrl.Path;

                        // Save changes to file
                        File.WriteAllText (path, viewController.Text);
                        return true;
                    } else {
                        var dlg = new NSSavePanel ();
                        dlg.Title = "Save Document";
                        dlg.BeginSheet (Window, (rslt) => {
                            // File selected?
                            if (rslt == 1) {
                                var path = dlg.Url.Path;
                                File.WriteAllText (path, viewController.Text);
                                Window.DocumentEdited = false;
                                viewController.View.Window.SetTitleWithRepresentedFilename (Path.GetFileName(path));
                                viewController.View.Window.RepresentedUrl = dlg.Url;
                                Window.Close();
                            }
                        });
                        return true;
                    }
                    return false;
                case 1001:
                    // Lose Changes
                    return true;
                case 1002:
                    // Cancel
                    return false;
                }
            }

            return true;
        }
        #endregion
    }
}

Bu temsilcinin bir örneğini pencereye eklemek için aşağıdaki kodu kullanın:

// Set delegate
Window.Delegate = new EditorWindowDelegate(Window);

Uygulamayı kapatmadan önce değişiklikler kaydediliyor

son olarak, Xamarin. Mac uygulamanız Windows değiştirilen içerik içerdiğinden ve kullanıcının çıkmadan önce değişiklikleri kaydetmesine izin vermeyi denetlemelidir. Bunu yapmak için AppDelegate.cs dosyanızı düzenleyin, yöntemi geçersiz kılın ApplicationShouldTerminate ve aşağıdaki gibi görünmesini sağlayın:

public override NSApplicationTerminateReply ApplicationShouldTerminate (NSApplication sender)
{
    // See if any window needs to be saved first
    foreach (NSWindow window in NSApplication.SharedApplication.Windows) {
        if (window.Delegate != null && !window.Delegate.WindowShouldClose (this)) {
            // Did the window terminate the close?
            return NSApplicationTerminateReply.Cancel;
        }
    }

    // Allow normal termination
    return NSApplicationTerminateReply.Now;
}

Birden çok pencere ile çalışma

Birçok belge tabanlı Mac uygulaması aynı anda birden çok belgeyi düzenleyebilir. Örneğin, bir metin düzenleyicisinde düzenleme için birden çok metin dosyası aynı anda açılabilir. Varsayılan olarak, yeni bir Xamarin. Mac uygulamasının, eyleme otomatik olarak kablolu Yeni bir öğe Içeren bir Dosya menüsü vardır .

Aşağıdaki kod bu yeni öğeyi etkinleştirir ve kullanıcının birden çok belgeyi tek seferde düzenlemek için ana pencerenin birden çok kopyasını açmasına olanak sağlar.

Dosyayı düzenleyin AppDelegate.cs ve aşağıdaki hesaplanan özelliği ekleyin:

public int UntitledWindowCount { get; set;} =1;

Kaydedilmemiş dosya sayısını izlemek için bunu kullanın, böylece kullanıcıya geri bildirim verebiliriz (yukarıda ele alındığı gibi Apple 'ın yönergelerine göre).

Sonra, aşağıdaki yöntemi ekleyin:

[Export ("newDocument:")]
void NewDocument (NSObject sender) {
    // Get new window
    var storyboard = NSStoryboard.FromName ("Main", null);
    var controller = storyboard.InstantiateControllerWithIdentifier ("MainWindow") as NSWindowController;

    // Display
    controller.ShowWindow(this);

    // Set the title
    controller.Window.Title = (++UntitledWindowCount == 1) ? "untitled" : string.Format ("untitled {0}", UntitledWindowCount);
}

Bu kod, pencere denetleyicimizin yeni bir sürümünü oluşturur, yeni pencereyi yükler, ana ve anahtar penceresi yapar ve başlık belirler. Uygulamamızı çalıştırdığımızda ve Dosya menüsünden Yeni ' yi seçtiğinizde yeni bir düzenleyici penceresi açılır ve görüntülenir:

Windows menüsünü açdığımızda, uygulamanın otomatik olarak izlenmesini ve açık Windows 'lerimizi işlemesini görebilirsiniz:

Xamarin. Mac uygulamasındaki menülerle çalışma hakkında daha fazla bilgi için lütfen menülerle çalıştımız belgelerine bakın.

Şu anda etkin pencereyi alma

Birden çok Windows (belge) açan bir Xamarin. Mac uygulamasında, geçerli, en üstteki pencereyi (anahtar penceresi) almanız gereken durumlar vardır. Aşağıdaki kod, anahtar penceresini döndürür:

var window = NSApplication.SharedApplication.KeyWindow;

Geçerli, anahtar penceresine erişmesi gereken herhangi bir sınıfta veya yöntemde çağrılabilir. Açık bir pencere yoksa, döndürülür null .

Tüm uygulama pencereleri 'ne erişme

Xamarin. Mac uygulamanızda Şu anda açık olan tüm Windows 'a erişmeniz gereken zamanlar olabilir. Örneğin, kullanıcının açmak istediği bir dosyanın bir çıkış penceresinde zaten açık olup olmadığını görmek için.

, NSApplication.SharedApplicationWindows Uygulamanızdaki tüm açık pencerelerin dizisini içeren bir özelliği tutar. Uygulamanın tüm geçerli pencerelerinin erişebilmesi için bu dizinin üzerinde yineleyebilirsiniz. Örnek:

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

Örnek kodda, her döndürülen pencereyi ViewController uygulamamızda özel sınıfa atadık ve özel bir Path özelliğin değerini kullanıcının açmak istediği bir dosyanın yoluyla test eteceğiz. Dosya zaten açıksa, bu pencereyi öne getiriyoruz.

Koddaki pencere boyutunu ayarlama

Uygulamanın kodda bir pencereyi yeniden boyutlandırması gereken zamanlar vardır. Bir pencereyi yeniden boyutlandırmak ve yeniden konumlandırmak için bu özelliği ayarlayın Frame . Bir pencerenin boyutunu ayarlarken, macOS 'un koordinat sistemi nedeniyle pencereyi aynı konumda tutmak için genellikle bu kaynağın kaynağını da ayarlamanız gerekir.

Sol üst köşenin (0, 0) gösterdiği iOS 'ın aksine macOS, ekranın sol alt köşesinin (0, 0) temsil ettiği bir matematik ve koordinat sistemi kullanır. İOS 'ta, doğru aşağı doğru hareket eden şekilde koordinatları artar. MacOS 'ta koordinatlar değerde yukarı doğru artar.

Aşağıdaki örnek kod bir pencereyi yeniden boyutlandırır:

nfloat y = 0;

// Calculate new origin
y = Frame.Y - (768 - Frame.Height);

// Resize and position window
CGRect frame = new CGRect (Frame.X, y, 1024, 768);
SetFrame (frame, true);

İzleme penceresi boyut değişiklikleri

Bir pencerenin Xamarin. Mac uygulamanızın içindeki boyutundaki değişiklikleri izlemeniz gereken zamanlar olabilir. Örneğin, içeriği yeni boyuta sığacak şekilde yeniden çizmek için.

Boyut değişikliklerini izlemek için, ilk olarak Xcode 'un Interface Builder pencere denetleyicisi için özel bir sınıf atadığınızdan emin olun. Örneğin, MasterWindowController aşağıdaki gibi:

Ardından, özel pencere denetleyicisi sınıfını düzenleyin ve DidResize canlı boyut değişikliklerinin bildirilmesi Için denetleyicinin penceresinde olayı izleyin. Örnek:

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

    Window.DidResize += (sender, e) => {
        // Do something as the window is being live resized
    };
}

İsteğe bağlı olarak, DidEndLiveResize olayı yalnızca kullanıcının pencere boyutunu değiştirmeyi tamamladıktan sonra bildirim almak için kullanabilirsiniz. Örneğin:

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

        Window.DidEndLiveResize += (sender, e) => {
        // Do something after the user's finished resizing
        // the window
    };
}

Pencerenin başlığını ve temsil edilen dosyayı ayarlama

Belgeleri temsil eden Windows ile çalışırken, NSWindowDocumentEditedtrue kullanıcıya dosyanın değiştirildiğini ve kapatmadan önce kaydedilmesi gerektiğini belirten bir Işaret vermek için Kapat düğmesinde küçük bir nokta gösterecek şekilde ayarlanmış bir özelliğe sahiptir.

Şimdi, sitemizi düzenleyip ViewController.cs aşağıdaki değişiklikleri yapın:

public bool DocumentEdited {
    get { return View.Window.DocumentEdited; }
    set { View.Window.DocumentEdited = value; }
}
...

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

    // Set Window Title
    this.View.Window.Title = "untitled";

    View.Window.WillClose += (sender, e) => {
        // is the window dirty?
        if (DocumentEdited) {
            var alert = new NSAlert () {
                AlertStyle = NSAlertStyle.Critical,
                InformativeText = "We need to give the user the ability to save the document here...",
                MessageText = "Save Document",
            };
            alert.RunModal ();
        }
    };
}

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

    // Show when the document is edited
    DocumentEditor.TextDidChange += (sender, e) => {
        // Mark the document as dirty
        DocumentEdited = true;
    };

    // Overriding this delegate is required to monitor the TextDidChange event
    DocumentEditor.ShouldChangeTextInRanges += (NSTextView view, NSValue[] values, string[] replacements) => {
        return true;
    };

}

Ayrıca, WillClose penceredeki olayı izliyor ve özelliğin durumunu denetliyoruz DocumentEdited . Bu, true kullanıcıya değişiklikleri dosyaya kaydetme yeteneği vermemiz gerekir. Uygulamamızı çalıştırdığımızda ve bir metin girerken, nokta görüntülenir:

Pencereyi kapatmaya çalışırsanız, bir uyarı alırsınız:

Bir dosyadan belge yüklüyorsanız, yöntemini kullanarak pencerenin başlığını dosyanın adına ayarlayın window.SetTitleWithRepresentedFilename (Path.GetFileName(path)); ( path açılan dosyayı temsil eden bir dize olur). Ayrıca, yöntemini kullanarak dosyanın URL 'sini de ayarlayabilirsiniz window.RepresentedUrl = url; .

URL, işletim sistemi tarafından bilinen bir dosya türünü işaret ederken, simgesi başlık çubuğunda görüntülenir. Kullanıcı simgesine sağ tıklarsa, dosyanın yolu gösterilir.

Dosyayı düzenleyin AppDelegate.cs ve aşağıdaki yöntemi ekleyin:

[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) {
            var path = url.Path;

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

        }
    }
}

Uygulamamızı çalıştırdığımızda, Dosya menüsünden Aç... seçeneğini belirleyin, Aç iletişim kutusundan bir metin dosyası seçin ve açın:

Dosya görüntülenir ve başlık dosyanın simgesiyle ayarlanır:

Projeye yeni bir pencere ekleme

Ana belge penceresinden bir Xamarin. Mac uygulamasının, Kullanıcı için Tercihler veya Inspector paneli gibi diğer pencere türlerini görüntülemesi gerekebilir.

Yeni bir pencere eklemek için aşağıdakileri yapın:

1. Çözüm Gezgini, dosyayı xcode 'un Interface Builder düzenlenmek üzere açmak için çift tıklayın.

2. Kitaplıktan yeni bir pencere denetleyicisi sürükleyip Tasarım yüzeyibırakın:

   

3. Kimlik denetçisinde, film şeridi kimliğiiçin girin:

   

4. Arabiriminizi tasarlama:

   

5. Uygulama menüsünü () açın MacWindows , MacWindowsControl-Click seçin ve yeni pencereye sürükleyin:

   

6. Açılır menüden göster ' i seçin.

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

Kodu çalıştırdık ve uygulama menüsündetercihleri... seçeneğini belirlerseniz pencere görüntülenir:

Panolarla çalışma

Bu makalenin başlangıcında belirtildiği gibi, panel diğer pencerelerin üstünde kayar ve belgeler açıkken kullanıcıların birlikte çalışacağı Araçlar veya denetimler sağlar.

Xamarin. Mac uygulamanızda oluşturduğunuz ve birlikte çalıştığınız diğer tüm pencere türleri gibi işlemler temelde aynıdır:

1. Projeye yeni bir pencere tanımı ekleyin.
2. .xibXcode 'un Interface Builder içinde düzenlenmek üzere pencere tasarımını açmak için dosyaya çift tıklayın.
3. Öznitelik denetçisinde ve Boyut denetçisindegerekli tüm pencere özelliklerini ayarlayın.
4. Arabiriminizi derlemek ve öznitelik denetçisindeyapılandırmak için gereken denetimleri sürükleyin.
5. Kullanıcı arabirimi öğelerinize yönelik yeniden boyutlandırmayı işlemek için Boyut denetçisini kullanın.
6. Pencere Kullanıcı arabirimi öğelerini, dış izin ve Eylemleraracılığıyla C# kodu olarak kullanıma sunun.
7. değişikliklerinizi kaydedin ve xcode ile eşitlemek için Mac için Visual Studio geri dönün.

Öznitelik denetçisinde, panellere özgü aşağıdaki seçeneklere sahipsiniz:

• Stil -bölmenin stilini ayarlamanıza izin ver: normal panel (Standart bir pencere gibi), yardımcı program paneli (daha küçük bir başlık çubuğuna sahiptir), HUD paneli (yarı saydam ve başlık çubuğu arka planın bir parçası olur).
• Etkinleştirilmeyen -panelin temel pencere haline geldiğini belirler.
• Belge kalıcı -belge kalıcı ise, panel yalnızca uygulamanın pencerelerinin üzerine kayar, aksi durumda tümü üzerine gelir.

Yeni bir panel eklemek için aşağıdakileri yapın:

1. Çözüm Gezgini, Project sağ tıklayıp yeni dosya ekle...seçeneğini belirleyin.

2. Yeni dosya iletişim kutusunda denetleyici ile Xamarin. MacCocoa penceresiniseçin:

   

3. DocumentPanelDocumentPanel Için girin ve Yeni düğmesine tıklayın.

4. DocumentPanel.xibInterface Builder ' de düzenlenmek üzere açmak için dosyaya çift tıklayın:

   

5. Var olan pencereyi silin ve arabirim düzenleyicidekikitaplık denetçisinden bir paneli sürükleyin:

   

6. Panelin dosyanın sahibipencereprizinekadar kanca:

   

7. Kimlik denetçisi ' ne geçin ve bölmenin sınıfını şu şekilde ayarlayın :

   

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

9. Dosyayı düzenleyin DocumentPanel.cs ve sınıf tanımını aşağıdaki şekilde değiştirin:

   public partial class DocumentPanel : NSPanel

10. Dosyadaki değişiklikleri kaydedin.

Dosyayı düzenleyin AppDelegate.cs ve DidFinishLaunching yöntemin aşağıdaki gibi görünmesini sağlayın:

public override void DidFinishLaunching (NSNotification notification)
{
        // Display panel
    var panel = new DocumentPanelController ();
    panel.Window.MakeKeyAndOrderFront (this);
}

Uygulamamızı çalıştırdığımızda, panel görüntülenir:

Özet

bu makale, Xamarin. Mac uygulamasındaki Windows ve panellerle çalışma hakkında ayrıntılı bir bakış gerçekleştirmiştir. Windows ve panellerinin farklı türlerini ve kullanımlarını, xcode Interface Builder ' de Windows ve panelleri oluşturma ve sürdürme ve C# kodundaki Windows ve panellerle çalışma hakkında daha fazla kod sunuyoruz.

İlgili bağlantılar

• MacWindows (örnek)
• MacInspector (örnek)
• Hello, Mac
• Menülerle çalışma
• macOS tasarım temaları (Apple)
• Windows, paneller ve ekranlar (Apple)