Windows di Xamarin.Mac

Artikel ini membahas tentang bekerja dengan jendela dan panel dalam aplikasi Xamarin.Mac. Ini menjelaskan pembuatan jendela dan panel di Xcode dan Interface Builder, memuatnya dari papan cerita dan file .xib, dan bekerja dengannya secara terprogram.

Saat bekerja dengan C# dan .NET dalam aplikasi Xamarin.Mac, Anda memiliki akses ke Windows dan Panel yang sama dengan yang digunakan Objective-C pengembang dan Xcode . Karena Xamarin.Mac terintegrasi langsung dengan Xcode, Anda dapat menggunakan Penyusun Antarmuka Xcode untuk membuat dan memelihara Windows dan Panel Anda (atau secara opsional membuatnya langsung dalam kode C#).

Berdasarkan tujuannya, aplikasi Xamarin.Mac dapat menyajikan satu atau beberapa Windows di layar untuk mengelola dan mengoordinasikan informasi yang ditampilkan dan bekerja dengannya. Fungsi utama jendela adalah:

1. Untuk menyediakan area di mana Tampilan dan Kontrol dapat ditempatkan dan dikelola.
2. Untuk menerima dan menanggapi peristiwa sebagai respons terhadap interaksi pengguna dengan keyboard dan mouse.

Windows dapat digunakan dalam status Modeless (seperti editor teks yang dapat membuka beberapa dokumen sekaligus) atau Modal (seperti dialog Ekspor yang harus ditutup sebelum aplikasi dapat dilanjutkan).

Panel adalah jenis Jendela khusus (subkelas kelas dasar NSWindow ), yang biasanya melayani fungsi tambahan dalam aplikasi, seperti jendela utilitas seperti pemeriksa format Teks dan Pemilih Warna sistem.

Dalam artikel ini, kita akan membahas dasar-dasar bekerja dengan Windows dan Panel dalam aplikasi Xamarin.Mac. Sangat disarankan agar Anda bekerja melalui artikel Hello, Mac terlebih dahulu, khususnya bagian Pengenalan Xcode dan Penyusun Antarmuka dan Outlet dan Tindakan , karena mencakup konsep dan teknik utama yang akan kita gunakan dalam artikel ini.

Anda mungkin ingin melihat kelas / metode Exposing C# keObjective-Cbagian dari dokumen Xamarin.Mac Internals juga, ini menjelaskan Register perintah dan Export yang digunakan untuk menyambungkan kelas C# Anda ke Objective-C objek dan Elemen UI.

Pengantar jendela

Seperti yang dinyatakan di atas, Jendela menyediakan area di mana Tampilan dan Kontrol dapat ditempatkan dan dikelola dan merespons peristiwa berdasarkan interaksi pengguna (baik melalui keyboard atau mouse).

Menurut Apple, ada lima jenis utama Windows di App macOS:

• Jendela Dokumen - Jendela dokumen berisi data pengguna berbasis file seperti spreadsheet atau dokumen teks.
• Jendela Aplikasi - Jendela aplikasi adalah jendela utama aplikasi yang tidak berbasis dokumen (seperti app Kalender di Mac).
• Panel - Panel mengapung di atas jendela lain dan menyediakan alat atau kontrol yang dapat digunakan pengguna saat dokumen terbuka. Dalam beberapa kasus, panel dapat tembus (seperti saat bekerja dengan grafik besar).
• Dialog - Dialog muncul sebagai respons terhadap tindakan pengguna dan biasanya menyediakan cara pengguna dapat menyelesaikan tindakan. Dialog memerlukan respons dari pengguna sebelum dapat ditutup. (Lihat Bekerja dengan Dialog)
• Pemberitahuan - Pemberitahuan adalah jenis dialog khusus yang muncul ketika masalah serius terjadi (seperti kesalahan) atau sebagai peringatan (seperti bersiap menghapus file). Karena pemberitahuan adalah dialog, pemberitahuan juga memerlukan respons pengguna sebelum dapat ditutup. (Lihat Bekerja dengan Pemberitahuan)

Untuk informasi selengkapnya, lihat bagian Tentang Windows dari tema desain macOS Apple.

Jendela utama, kunci, dan tidak aktif

Windows dalam aplikasi Xamarin.Mac dapat terlihat dan berulah secara berbeda berdasarkan bagaimana pengguna saat ini berinteraksi dengan mereka. Dokumen atau Jendela Aplikasi terdepan yang saat ini menjadi fokus perhatian pengguna disebut Jendela Utama. Dalam kebanyakan kasus, Jendela ini juga akan menjadi Jendela Kunci (jendela yang saat ini menerima input pengguna). Tetapi ini tidak selalu terjadi, misalnya, Pemilih Warna dapat terbuka dan menjadi jendela Kunci yang berinteraksi dengan pengguna untuk mengubah status item di Jendela Dokumen (yang masih akan menjadi Jendela Utama).

Windows Utama dan Kunci (jika terpisah) selalu aktif, Windows Tidak Aktif membuka jendela yang tidak ada di latar depan. Misalnya, aplikasi editor teks dapat memiliki lebih dari satu dokumen yang terbuka pada satu waktu, hanya Jendela Utama yang akan aktif, yang lain tidak aktif.

Untuk informasi selengkapnya, lihat bagian Tentang Windows dari tema desain macOS Apple.

Jendela penamaan

Jendela dapat menampilkan Bilah Judul dan saat Judul ditampilkan, biasanya nama aplikasi, nama dokumen yang sedang dikerjakan atau fungsi jendela (seperti Pemeriksa). Beberapa aplikasi tidak menampilkan Bilah Judul karena dapat dikenali oleh pandangan dan tidak berfungsi dengan dokumen.

Apple menyarankan panduan berikut:

• Gunakan nama aplikasi Anda untuk judul jendela utama non-dokumen.
• Beri nama jendela untitleddokumen baru . Untuk dokumen baru pertama, jangan tambahkan angka ke Judul (seperti untitled 1). Jika pengguna membuat dokumen baru lain sebelum menyimpan dan mengikat yang pertama, panggil jendela untitled 2tersebut , untitled 3, dll.

Untuk informasi selengkapnya, lihat bagian Penamaan Windows dari tema desain macOS Apple.

Jendela layar penuh

Di macOS, jendela aplikasi dapat membuka layar penuh yang menyembunyikan semuanya termasuk Bilah Menu Aplikasi (yang dapat diungkapkan dengan memindahkan kursor ke bagian atas layar) untuk memberikan interaksi bebas gangguan dengan kontennya.

Apple menyarankan panduan berikut:

• Tentukan apakah masuk akal bagi jendela untuk masuk layar penuh. Aplikasi yang menyediakan interaksi singkat (seperti Kalkulator) tidak boleh menyediakan mode layar penuh.
• Perlihatkan bilah alat jika tugas layar penuh memerlukannya. Biasanya toolbar disembunyikan saat dalam mode layar penuh.
• Jendela layar penuh harus memiliki semua fitur yang dibutuhkan pengguna untuk menyelesaikan tugas.
• Jika memungkinkan, hindari interaksi Finder saat pengguna berada di jendela layar penuh.
• Manfaatkan peningkatan ruang layar tanpa mengalihkan fokus dari tugas utama.

Untuk informasi selengkapnya, lihat bagian Windows Layar Penuh dari tema desain macOS Apple.

Panel

Panel adalah jendela tambahan yang berisi kontrol dan opsi yang memengaruhi dokumen atau pilihan aktif (seperti Pemilih Warna sistem):

Panel dapat berupa App-Specific atau Systemwide. Panel Khusus Aplikasi mengapung di bagian atas jendela dokumen aplikasi dan menghilang ketika aplikasi berada di latar belakang. Panel Systemwide (seperti panel Font ), mengapung di atas semua jendela terbuka apa pun aplikasinya.

Apple menyarankan panduan berikut:

• Secara umum, gunakan panel standar, panel transparan hanya boleh digunakan secara hemat dan untuk tugas intensif grafis.
• Pertimbangkan untuk menggunakan panel untuk memberi pengguna akses mudah ke kontrol atau informasi penting yang secara langsung memengaruhi tugas mereka.
• Sembunyikan dan tampilkan panel sesuai kebutuhan.
• Panel harus selalu menyertakan bilah judul.
• Panel tidak boleh menyertakan tombol minimalkan aktif.

Inspektur

Sebagian besar aplikasi macOS modern menyajikan kontrol dan opsi tambahan yang memengaruhi dokumen atau pilihan aktif sebagai Pemeriksa yang merupakan bagian dari Jendela Utama (seperti aplikasi Pages yang ditunjukkan di bawah), alih-alih menggunakan Panel Windows:

Untuk informasi selengkapnya, lihat bagian Panel tema desain macOS Apple.

Membuat dan memelihara jendela di Xcode

Saat Anda membuat aplikasi Xamarin.Mac Cocoa baru, Anda mendapatkan jendela kosong standar secara default. Jendela ini didefinisikan dalam file yang .storyboard secara otomatis disertakan dalam proyek. Untuk mengedit desain windows Anda, di Penjelajah Solusi, klik Main.storyboard dua kali file:

Ini akan membuka desain jendela di Penyusun Antarmuka Xcode:

Di Pemeriksa Atribut, ada beberapa properti yang dapat Anda gunakan untuk menentukan dan mengontrol jendela Anda:

• Judul - Ini adalah teks yang akan ditampilkan di bilah judul jendela.
• Simpan otomatis - Ini adalah kunci yang akan digunakan untuk ID jendela saat posisi dan pengaturan disimpan secara otomatis.
• Bilah Judul - Apakah jendela menampilkan bilah judul.
• Judul dan Toolbar Terpadu - Jika jendela menyertakan Toolbar, jika jendela tersebut merupakan bagian dari bilah judul.
• Tampilan Konten Berukuran Penuh - Memungkinkan area konten jendela berada di bawah bilah Judul.
• Shadow - Apakah jendela memiliki bayangan.
• Textured - Jendela bertekskus dapat menggunakan efek (seperti getaran) dan dapat dipindahkan dengan menyeret ke mana saja di tubuh mereka.
• Tutup - Apakah jendela memiliki tombol tutup.
• Minimalkan - Apakah jendela memiliki tombol minimalkan.
• Mengubah ukuran - Apakah jendela memiliki kontrol mengubah ukuran.
• Tombol Bilah Alat - Apakah jendela memiliki tombol sembunyikan/perlihatkan bilah alat.
• Dapat dipulihkan - Apakah posisi dan pengaturan jendela disimpan dan dipulihkan secara otomatis.
• Terlihat Saat Peluncuran - Apakah jendela secara otomatis ditampilkan saat .xib file dimuat.
• Sembunyikan Saat Dinonaktifkan - Apakah jendela tersembunyi saat aplikasi memasuki latar belakang.
• Rilis Saat Ditutup - Apakah jendela dihapus menyeluruh dari memori saat ditutup.
• Selalu Tampilkan TipsAlat - Apakah tipsalat terus ditampilkan.
• Menghitung Ulang Perulangan Tampilan - Apakah urutan tampilan dihitung ulang sebelum jendela digambar.
• Spasi, Exposé , dan Bersepeda - Semua menentukan bagaimana jendela bereaksi di lingkungan macOS tersebut.
• Layar Penuh - Menentukan apakah jendela ini dapat memasuki mode layar penuh.
• Animasi - Mengontrol jenis animasi yang tersedia untuk jendela.
• Penampilan - Mengontrol tampilan jendela. Untuk saat ini hanya ada satu penampilan, Aqua.

Lihat Dokumentasi Pengantar Windows dan NSWindow Apple untuk detail selengkapnya.

Mengatur ukuran dan lokasi default

Untuk mengatur posisi awal jendela Anda dan untuk mengontrol ukurannya, beralihlah ke Pemeriksa Ukuran:

Dari sini Anda dapat mengatur ukuran awal jendela, memberinya ukuran minimum dan maksimum, mengatur lokasi awal di layar dan mengontrol batas di sekitar jendela.

Mengatur pengontrol jendela utama kustom

Agar dapat membuat Outlet dan Tindakan untuk mengekspos elemen UI ke kode C#, aplikasi Xamarin.Mac harus menggunakan Pengontrol Jendela Kustom.

Lakukan:

1. Buka Storyboard aplikasi di Penyusun Antarmuka Xcode.

2. Pilih di NSWindowController Permukaan Desain.

3. Beralih ke tampilan Inspektur Identitas dan masukkan WindowController sebagai Nama Kelas:

   

4. Simpan perubahan Anda dan kembali ke Visual Studio untuk Mac untuk disinkronkan.

5. File WindowController.cs akan ditambahkan ke Proyek Anda di Penjelajah Solusi di Visual Studio untuk Mac:

   

6. Buka kembali Storyboard di Penyusun Antarmuka Xcode.

7. File WindowController.h akan tersedia untuk digunakan:

   

Menambahkan elemen UI

Untuk menentukan konten jendela, seret kontrol dari Pemeriksa Pustaka ke Editor Antarmuka. Silakan lihat dokumentasi Pengenalan Xcode dan Penyusun Antarmuka kami untuk informasi selengkapnya tentang menggunakan Pembangun Antarmuka untuk membuat dan mengaktifkan kontrol.

Sebagai contoh, mari kita seret Toolbar dari Pemeriksa Pustaka ke jendela di Editor Antarmuka:

Selanjutnya, seret dalam Tampilan Teks dan ukurannya untuk mengisi area di bawah toolbar:

Karena kita ingin Tampilan Teks menyusut dan bertambah saat ukuran jendela berubah, mari kita beralih ke Editor Batasan dan menambahkan batasan berikut:

Dengan mengeklik empat I-Beam Merah di bagian atas editor dan mengklik Tambahkan 4 Batasan, kami memberi tahu tampilan teks untuk menempel pada koordinat X,Y yang diberikan dan menumbuhkan atau menyusut secara horizontal dan vertikal saat jendela diubah ukurannya.

Terakhir, ekspos Tampilan Teks ke kode menggunakan Outlet (pastikan untuk memilih ViewController.h file):

Simpan perubahan Anda dan beralih kembali ke Visual Studio untuk Mac untuk disinkronkan dengan Xcode.

Untuk informasi selengkapnya tentang bekerja dengan Outlet dan Tindakan, silakan lihat dokumentasi Outlet dan Tindakan kami.

Alur kerja jendela standar

Untuk jendela apa pun yang Anda buat dan kerjakan di aplikasi Xamarin.Mac Anda, prosesnya pada dasarnya sama dengan apa yang baru saja kami lakukan di atas:

1. Untuk jendela baru yang bukan default yang ditambahkan secara otomatis ke proyek Anda, tambahkan definisi jendela baru ke proyek. Ini akan dibahas secara rinci di bawah ini.
2. Main.storyboard Klik dua kali file untuk membuka desain jendela untuk pengeditan di Penyusun Antarmuka Xcode.
3. Seret Jendela baru ke dalam desain Antarmuka Pengguna dan kaitkan jendela ke Jendela Utama menggunakan Segues (untuk informasi selengkapnya lihat bagian Segues dari dokumentasi Bekerja dengan Papan Cerita kami).
4. Atur properti jendela yang diperlukan di Pemeriksa Atribut dan Pemeriksa Ukuran.
5. Seret kontrol yang diperlukan untuk membangun antarmuka Anda dan konfigurasikan di Pemeriksa Atribut.
6. Gunakan Pemeriksa Ukuran untuk menangani perubahan ukuran untuk Elemen UI Anda.
7. Mengekspos elemen UI jendela ke kode C# melalui Outlet dan Tindakan.
8. Simpan perubahan Anda dan beralih kembali ke Visual Studio untuk Mac untuk disinkronkan dengan Xcode.

Sekarang setelah kita memiliki jendela dasar yang dibuat, kita akan melihat proses umum yang dilakukan aplikasi Xamarin.Mac saat bekerja dengan jendela.

Menampilkan jendela default

Secara default, aplikasi Xamarin.Mac baru akan secara otomatis menampilkan jendela yang ditentukan dalam MainWindow.xib file saat dimulai:

Karena kami memodifikasi desain jendela tersebut di atas, sekarang mencakup kontrol Toolbar dan Tampilan Teks default. Bagian berikut dalam Info.plist file bertanggung jawab untuk menampilkan jendela ini:

Dropdown Antarmuka Utama digunakan untuk memilih Storyboard yang akan digunakan sebagai UI aplikasi utama (dalam hal Main.storyboardini ).

Pengontrol Tampilan secara otomatis ditambahkan ke proyek untuk mengontrol Bahwa Windows Utama yang ditampilkan (bersama dengan Tampilan utamanya). Ini didefinisikan dalam ViewController.cs file dan dilampirkan ke Pemilik File di Penyusun Antarmuka di bawah Pemeriksa Identitas:

Untuk jendela kita, kita ingin memiliki judul untitled ketika pertama kali terbuka jadi mari kita ambil alih ViewWillAppear metode dalam ViewController.cs agar terlihat seperti berikut:

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

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

Catatan

Properti jendela Title diatur dalam ViewWillAppear metode alih-alih ViewDidLoad metode karena, sementara tampilan mungkin dimuat ke dalam memori, itu belum sepenuhnya dibuat. Title Mengakses properti dalam metode kami ViewDidLoad akan mendapatkan null pengecualian karena jendela belum dibangun dan dikabel ke properti belum.

Menutup jendela secara terprogram

Mungkin ada kalanya Anda ingin menutup jendela secara terprogram di aplikasi Xamarin.Mac, selain meminta pengguna mengklik tombol Tutup jendela atau menggunakan item menu. macOS menyediakan dua cara berbeda untuk menutup NSWindow secara terprogram: PerformClose dan Close.

PerformClose

Memanggil PerformClose metode simulasi NSWindow pengguna mengklik tombol Tutup jendela dengan menyoroti tombol sesaat lalu menutup jendela.

Jika aplikasi mengimplementasikan NSWindowperistiwa , WillClose itu akan dinaikkan sebelum jendela ditutup. Jika peristiwa mengembalikan false, maka jendela tidak akan ditutup. Jika jendela tidak memiliki tombol Tutup atau tidak dapat ditutup karena alasan apa pun, OS akan mengeluarkan suara pemberitahuan.

Contohnya:

MyWindow.PerformClose(this);

Akan mencoba menutup MyWindowNSWindow instans. Jika berhasil, jendela akan ditutup, jika tidak, suara pemberitahuan akan dipancarkan dan akan tetap terbuka.

Tutup

Memanggil Close metode dari NSWindow tidak mensimulasikan pengguna mengklik tombol Tutup jendela dengan sesaat menyoroti tombol, itu hanya menutup jendela.

Jendela tidak harus terlihat tertutup dan pemberitahuan NSWindowWillCloseNotification akan diposting ke Pusat Pemberitahuan default untuk jendela yang ditutup.

Metode ini Close berbeda dalam dua cara penting dari PerformClose metode :

1. Ini tidak mencoba untuk menaikkan WillClose peristiwa.
2. Ini tidak mensimulasikan pengguna mengklik tombol Tutup dengan menyoroti tombol sesaat.

Contohnya:

MyWindow.Close();

Akan menutup MyWindowNSWindow instans.

Konten windows yang dimodifikasi

Di macOS, Apple telah menyediakan cara untuk memberi tahu pengguna bahwa konten Jendela (NSWindow) telah dimodifikasi oleh pengguna dan perlu disimpan. Jika Jendela berisi konten yang dimodifikasi, titik hitam kecil akan ditampilkan di widget Tutup :

Jika pengguna mencoba menutup Jendela atau keluar dari Mac App saat ada perubahan yang tidak disimpan pada konten Jendela, Anda harus menyajikan Kotak Dialog atau Lembar Modal dan mengizinkan pengguna untuk menyimpan perubahan mereka terlebih dahulu:

Menandai jendela sebagai dimodifikasi

Untuk menandai Jendela sebagai memiliki konten yang dimodifikasi, gunakan kode berikut:

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

Dan setelah perubahan disimpan, hapus bendera yang dimodifikasi menggunakan:

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

Menyimpan perubahan sebelum menutup jendela

Untuk mengawasi pengguna menutup Jendela dan memungkinkan mereka menyimpan konten yang dimodifikasi sebelumnya, Anda harus membuat subkelas NSWindowDelegate dan mengambil alih metodenya WindowShouldClose . Contohnya:

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

Gunakan kode berikut untuk melampirkan instans delegasi ini ke jendela:

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

Menyimpan perubahan sebelum menutup aplikasi

Terakhir, Aplikasi Xamarin.Mac Anda harus memeriksa untuk melihat apakah salah satu Windows-nya berisi konten yang dimodifikasi dan memungkinkan pengguna untuk menyimpan perubahan sebelum berhenti. Untuk melakukan ini, edit file Anda AppDelegate.cs , ambil alih ApplicationShouldTerminate metode dan buat terlihat seperti berikut ini:

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

Bekerja dengan beberapa jendela

Sebagian besar aplikasi Mac berbasis dokumen dapat mengedit beberapa dokumen secara bersamaan. Misalnya, editor teks dapat membuka beberapa file teks untuk diedit secara bersamaan. Secara default, aplikasi Xamarin.Mac baru memiliki menu File dengan item Baru yang secara otomatis terhubung ke newDocument:Tindakan.

Kode di bawah ini akan mengaktifkan item baru ini dan memungkinkan pengguna membuka beberapa salinan Jendela Utama untuk mengedit beberapa dokumen sekaligus.

AppDelegate.cs Edit file dan tambahkan properti komputasi berikut:

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

Gunakan ini untuk melacak jumlah file yang belum disimpan sehingga kami dapat memberikan umpan balik kepada pengguna (sesuai pedoman Apple seperti yang dibahas di atas).

Selanjutnya, tambahkan metode berikut:

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

Kode ini membuat versi baru Pengontrol Jendela kami, memuat Jendela baru, menjadikannya Jendela Utama dan Kunci, dan mengaturnya judul. Sekarang jika kita menjalankan aplikasi kita, dan pilih Baru dari menu File jendela editor baru akan dibuka dan ditampilkan:

Jika kita membuka menu Windows , Anda dapat melihat aplikasi secara otomatis melacak dan menangani jendela terbuka kami:

Untuk informasi selengkapnya tentang bekerja dengan Menu dalam aplikasi Xamarin.Mac, silakan lihat dokumentasi Bekerja dengan Menu kami.

Mendapatkan jendela yang saat ini aktif

Dalam aplikasi Xamarin.Mac yang dapat membuka beberapa jendela (dokumen), ada kalanya Anda harus mendapatkan jendela paling atas saat ini (jendela kunci). Kode berikut akan mengembalikan jendela kunci:

var window = NSApplication.SharedApplication.KeyWindow;

Ini dapat dipanggil di kelas atau metode apa pun yang perlu mengakses jendela kunci saat ini. Jika tidak ada jendela yang saat ini terbuka, jendela akan mengembalikan null.

Mengakses semua jendela aplikasi

Mungkin ada kalanya Anda perlu mengakses semua jendela yang saat ini dibuka oleh aplikasi Xamarin.Mac Anda. Misalnya, untuk melihat apakah file yang ingin dibuka pengguna sudah terbuka di jendela keluar.

mempertahankan NSApplication.SharedApplicationWindows properti yang berisi array semua jendela yang terbuka di aplikasi Anda. Anda dapat melakukan iterasi melalui array ini untuk mengakses semua jendela aplikasi saat ini. Contohnya:

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

Dalam contoh kode, kami mentransmisikan setiap jendela yang dikembalikan ke kelas kustom ViewController di aplikasi kami dan menguji nilai properti kustom Path terhadap jalur file yang ingin dibuka pengguna. Jika file sudah terbuka, kita membawa jendela itu ke depan.

Menyesuaikan ukuran jendela dalam kode

Ada kalanya aplikasi perlu mengubah ukuran jendela dalam kode. Untuk mengubah ukuran dan memposisikan ulang jendela, Anda menyesuaikan propertinya Frame . Saat menyesuaikan ukuran jendela, Anda biasanya juga perlu menyesuaikan asalnya, untuk menjaga jendela di lokasi yang sama karena sistem koordinat macOS.

Tidak seperti iOS di mana sudut kiri atas mewakili (0,0), macOS menggunakan sistem koordinat matematika di mana sudut kiri bawah layar mewakili (0,0). Di iOS, koordinat meningkat saat Anda bergerak ke bawah ke kanan. Di macOS, koordinat meningkat nilainya ke atas ke kanan.

Contoh kode berikut mengubah ukuran jendela:

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

Penting

Saat menyesuaikan ukuran dan lokasi windows dalam kode, Anda perlu memastikan Anda menghormati ukuran minimum dan maksimum yang telah Anda tetapkan di Penyusun Antarmuka. Ini tidak akan secara otomatis dihormati dan Anda akan dapat membuat jendela lebih besar atau lebih kecil dari batas ini.

Memantau perubahan ukuran jendela

Mungkin ada kalanya Anda perlu memantau perubahan ukuran Jendela di dalam aplikasi Xamarin.Mac Anda. Misalnya, untuk menggambar ulang konten agar sesuai dengan ukuran baru.

Untuk memantau perubahan ukuran, pertama-tama pastikan Anda telah menetapkan kelas kustom untuk Pengontrol Jendela di Penyusun Antarmuka Xcode. Misalnya, MasterWindowController dalam hal berikut:

Selanjutnya, edit kelas Pengontrol Jendela kustom dan pantau DidResize peristiwa di Jendela Pengontrol untuk diberi tahu tentang perubahan ukuran langsung. Contohnya:

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

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

Secara opsional, Anda dapat menggunakan DidEndLiveResize peristiwa untuk hanya diberi tahu setelah pengguna selesai mengubah ukuran Jendela. Misalnya:

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

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

Mengatur judul jendela dan file yang diwakili

Saat bekerja dengan jendela yang mewakili dokumen, NSWindow memiliki DocumentEdited properti yang jika diatur untuk true menampilkan titik kecil di Tombol Tutup untuk memberi pengguna indikasi bahwa file telah dimodifikasi dan harus disimpan sebelum ditutup.

Mari kita edit file kita ViewController.cs dan buat perubahan berikut:

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

}

Kami juga memantau WillClose peristiwa di jendela dan memeriksa status DocumentEdited properti. Jika kita true perlu memberi pengguna kemampuan untuk menyimpan perubahan ke file. Jika kita menjalankan aplikasi dan memasukkan beberapa teks, titik akan ditampilkan:

Jika Anda mencoba menutup jendela, Anda akan mendapatkan pemberitahuan:

Jika Anda memuat dokumen dari file, atur judul jendela ke nama file menggunakan window.SetTitleWithRepresentedFilename (Path.GetFileName(path)); metode (mengingat bahwa adalah string yang mewakili file yang path sedang dibuka). Selain itu, Anda dapat mengatur URL file menggunakan window.RepresentedUrl = url; metode .

Jika URL menunjuk ke jenis file yang diketahui oleh OS, ikonnya akan ditampilkan di bilah judul. Jika pengguna mengklik kanan ikon, jalur ke file akan ditampilkan.

AppDelegate.cs Edit file dan tambahkan metode berikut:

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

        }
    }
}

Sekarang jika kita menjalankan aplikasi kita, pilih Buka... dari menu File , pilih file teks dari kotak Dialog Buka dan buka:

File akan ditampilkan dan judul akan diatur dengan ikon file:

Menambahkan jendela baru ke proyek

Selain jendela dokumen utama, aplikasi Xamarin.Mac mungkin perlu menampilkan jenis jendela lain kepada pengguna, seperti Preferensi atau Panel Pemeriksa.

Untuk menambahkan jendela baru, lakukan hal berikut:

1. Di Penjelajah Solusi, klik Main.storyboard dua kali file untuk membukanya untuk diedit di Penyusun Antarmuka Xcode.

2. Seret Pengontrol Jendela baru dari Pustaka dan letakkan di Permukaan Desain:

   

3. Di Pemeriksa Identitas, masukkan PreferencesWindow untuk ID Storyboard:

   

4. Desain antarmuka Anda:

   

5. Buka Menu Aplikasi (MacWindows), pilih Preferensi..., Klik Kontrol dan seret ke jendela baru:

   

6. Pilih Perlihatkan dari menu popup.

7. Simpan perubahan Anda dan kembali ke Visual Studio untuk Mac untuk disinkronkan dengan Xcode.

Jika kita menjalankan kode dan memilih Preferensi... dari Menu Aplikasi, jendela akan ditampilkan:

Bekerja dengan panel

Seperti yang dinyatakan pada awal artikel ini, panel mengapung di atas jendela lain dan menyediakan alat atau kontrol yang dapat digunakan pengguna saat dokumen terbuka.

Sama seperti jenis jendela lain yang Anda buat dan kerjakan di aplikasi Xamarin.Mac Anda, prosesnya pada dasarnya sama:

1. Tambahkan definisi jendela baru ke proyek.
2. .xib Klik dua kali file untuk membuka desain jendela untuk pengeditan di Penyusun Antarmuka Xcode.
3. Atur properti jendela yang diperlukan di Pemeriksa Atribut dan Pemeriksa Ukuran.
4. Seret kontrol yang diperlukan untuk membangun antarmuka Anda dan konfigurasikan di Pemeriksa Atribut.
5. Gunakan Pemeriksa Ukuran untuk menangani perubahan ukuran untuk Elemen UI Anda.
6. Mengekspos elemen UI jendela ke kode C# melalui Outlet dan Tindakan.
7. Simpan perubahan Anda dan beralih kembali ke Visual Studio untuk Mac untuk disinkronkan dengan Xcode.

Di Pemeriksa Atribut, Anda memiliki opsi berikut khusus untuk Panel:

• Gaya - Memungkinkan Anda menyesuaikan gaya panel dari: Panel Reguler (terlihat seperti jendela standar), Panel Utilitas (memiliki bilah Judul yang lebih kecil), Panel HUD (tembus cahaya dan bilah judul adalah bagian dari latar belakang).
• Non Aktivasi - Menentukan di panel menjadi jendela kunci.
• Modal Dokumen - Jika Modal Dokumen, panel hanya akan mengapung di atas jendela aplikasi, jika tidak, itu mengapung di atas segalanya.

Untuk menambahkan Panel baru, lakukan hal berikut:

1. Di Penjelajah Solusi, klik kanan Proyek dan pilih Tambahkan>File Baru....

2. Dalam kotak dialog File Baru, pilih Jendela Kakao Xamarin.Mac>dengan Pengontrol:

   

3. Masukkan DocumentPanel untuk Nama dan klik tombol Baru .

4. DocumentPanel.xib Klik dua kali file untuk membukanya untuk pengeditan di Penyusun Antarmuka:

   

5. Hapus Jendela yang ada dan seret Panel dari Pemeriksa Pustaka di Editor Antarmuka:

   

6. Kaitkan panel ke Outlet jendela - Pemilik - File:

   

7. Beralih ke Inspektur Identitas dan atur kelas Panel ke DocumentPanel:

   

8. Simpan perubahan Anda dan kembali ke Visual Studio untuk Mac untuk disinkronkan dengan Xcode.

9. DocumentPanel.cs Edit file dan ubah definisi kelas menjadi yang berikut ini:

   public partial class DocumentPanel : NSPanel

10. Simpan perubahan pada file.

AppDelegate.cs Edit file dan buat DidFinishLaunching metode terlihat seperti berikut ini:

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

Jika kita menjalankan aplikasi kita, panel akan ditampilkan:

Penting

Panel Windows tidak digunakan lagi oleh Apple dan harus diganti dengan Antarmuka Pemeriksa.

Ringkasan

Artikel ini telah melihat secara rinci tentang bekerja dengan Windows dan Panel dalam aplikasi Xamarin.Mac. Kami melihat berbagai jenis dan penggunaan Windows dan Panel, cara membuat dan memelihara Windows dan Panel di Penyusun Antarmuka Xcode dan cara bekerja dengan Windows dan Panel dalam kode C#.

Tautan terkait

• Halo, Mac
• Bekerja dengan Menu
• Tema desain macOS (Apple)
• Windows, Panel, dan Layar (Apple)