Windows v Xamarin.Mac

Tento článek popisuje práci s okny a panely v aplikaci Xamarin.Mac. Popisuje vytváření oken a panelů v Xcode a Interface Builderu, načítání z scénářů a souborů .xib a práci s nimi prostřednictvím kódu programu.

Při práci s jazykem C# a .NET v aplikaci Xamarin.Mac máte přístup ke stejným systémům Windows a panelům, které vývojář pracuje v Objective-C Xcode. Vzhledem k tomu, že se Xamarin.Mac integruje přímo s Xcode, můžete pomocí Tvůrce rozhraní Xcode vytvářet a udržovat windows a panely (nebo je volitelně vytvářet přímo v kódu jazyka C#).

Na základě svého účelu může aplikace Xamarin.Mac prezentovat jeden nebo více oken na obrazovce pro správu a koordinaci informací, se kterými se zobrazuje a pracuje. Hlavní funkce okna jsou:

1. Chcete-li poskytnout oblast, ve které lze umístit a spravovat zobrazení a ovládací prvky.
2. Přijetí událostí a reakce na ně v reakci na interakci uživatele s klávesnicí i myší

Systém Windows lze použít v bezmodálním stavu (například textový editor, který může mít najednou otevřený více dokumentů) nebo modální (například dialogové okno exportu, které musí být zamítnuto před pokračováním aplikace).

Panely jsou speciální druh okna (podtřída základní NSWindow třídy), které obvykle obsluhují pomocnou funkci v aplikaci, například okna nástrojů, jako jsou kontroly formátu textu a systémová volba barev.

V tomto článku se budeme zabývat základy práce s Windows a panely v aplikaci Xamarin.Mac. Důrazně doporučujeme, abyste si nejprve prošli článek Hello, Mac , konkrétně úvod do Xcode a Tvůrce rozhraní a výstupy a akce , protože se zabývá klíčovými koncepty a technikami, které budeme používat v tomto článku.

Možná se také budete chtít podívat na oddíly v dokumentu Interní dokumenty Xamarin.Mac pro zveřejnění tříd a metodObjective-Cjazyka C#. Vysvětluje také, které Register příkazy a Export které se používají k připojení tříd jazyka C# k Objective-C objektům a prvkům uživatelského rozhraní.

Úvod do oken

Jak je uvedeno výše, okno poskytuje oblast, ve které lze umístit a spravovat zobrazení a ovládací prvky a reagovat na události na základě interakce uživatele (buď pomocí klávesnice nebo myši).

Podle Společnosti Apple existuje v aplikaci pro macOS pět hlavních typů Windows:

• Okno dokumentu – Okno dokumentu obsahuje uživatelská data založená na souborech, jako je tabulka nebo textový dokument.
• Okno aplikace – okno aplikace je hlavním oknem aplikace, která není založená na dokumentu (jako je aplikace Kalendář na Macu).
• Panel – Panel je plovoucí nad jinými okny a poskytuje nástroje nebo ovládací prvky, se kterými můžou uživatelé pracovat, když jsou dokumenty otevřené. V některých případech může být panel průsvitný (například při práci s velkými grafickými objekty).
• Dialogové okno – Dialogové okno se zobrazí v reakci na akci uživatele a obvykle poskytuje způsoby, jak můžou uživatelé akci dokončit. Dialogové okno vyžaduje odpověď od uživatele, než ho lze zavřít. (Viz Práce s dialogy)
• Výstrahy – výstraha je zvláštní typ dialogového okna, které se zobrazí, když dojde k závažnému problému (například k chybě) nebo jako upozornění (například příprava na odstranění souboru). Vzhledem k tomu, že výstraha je dialogové okno, vyžaduje také odpověď uživatele, aby bylo možné ji zavřít. (Viz Práce s upozorněními)

Další informace najdete v části O Windows motivů návrhu apple pro macOS.

Hlavní okna, klíč a neaktivní okna

Systém Windows v aplikaci Xamarin.Mac může vypadat a chovat odlišně podle toho, jak s nimi uživatel momentálně pracuje. Hlavním oknem uživatele se nazývá hlavní okno dokumentu nebo okna aplikace, které je aktuálně fokusem pozornosti uživatele. Ve většině případů bude toto okno také klíčové okno (okno, které aktuálně přijímá uživatelský vstup). Nejedná se ale vždy o případ, například může být otevřený výběr barvy a okno s klíčem, se kterým uživatel pracuje, aby změnil stav položky v okně dokumentu (což by stále bylo hlavní okno).

Hlavní a klíčové windows (pokud jsou samostatné) jsou vždy aktivní, Neaktivní windows jsou otevřená okna, která nejsou v popředí. Například aplikace textového editoru může mít současně otevřený více než jeden dokument, aktivní bude jenom hlavní okno, všechny ostatní budou neaktivní.

Další informace najdete v části O Windows motivů návrhu apple pro macOS.

Pojmenování oken

Okno může zobrazit záhlaví a když se zobrazí název, obvykle se jedná o název aplikace, název dokumentu, na kterém pracujete, nebo funkci okna (například Inspektor). Některé aplikace nezobrazují záhlaví, protože jsou rozpoznatelné podle dohledu a nefungují s dokumenty.

Apple navrhuje následující pokyny:

• Název aplikace použijte pro název hlavního okna, které není dokumentem.
• Pojmenujte nové okno untitleddokumentu . Pro první nový dokument nepřidávejte číslo k názvu (například untitled 1). Pokud uživatel vytvoří jiný nový dokument před uložením a pojmenovávat první, zavolejte toto okno untitled 2atd untitled 3.

Další informace najdete v části Pojmenování Windows motivů návrhu Apple pro macOS.

Okna na celé obrazovce

V systému macOS může okno aplikace jít na celou obrazovku skrýt vše včetně řádku nabídek aplikace (který může být odhalen přesunutím kurzoru na horní část obrazovky) a poskytnout tak rušivé volné interakce s obsahem.

Apple navrhuje následující pokyny:

• Určete, jestli má okno smysl přejít na celou obrazovku. Aplikace, které poskytují krátké interakce (jako je kalkulačka), by neměly poskytovat režim zobrazení na celé obrazovce.
• Pokud úkol na celé obrazovce vyžaduje, zobrazte panel nástrojů. Panel nástrojů je obvykle skrytý v režimu zobrazení na celé obrazovce.
• Okno na celé obrazovce by mělo obsahovat všechny funkce, které uživatelé potřebují k dokončení úkolu.
• Pokud je to možné, vyhněte se interakci Finderu, když je uživatel v okně na celé obrazovce.
• Využijte zvýšené místo na obrazovce bez posunu fokusu od hlavního úkolu.

Další informace najdete v části Windows na celé obrazovce motivů návrhu Apple pro macOS.

Panely

Panel je pomocné okno, které obsahuje ovládací prvky a možnosti, které ovlivňují aktivní dokument nebo výběr (například výběr barvy systému):

Panely můžou být specifické pro aplikaci nebo pro celou aplikaci. Panely specifické pro aplikace jsou plovoucí nad horní částí oken dokumentů aplikace a zmizí, když je aplikace na pozadí. Panely pro celou organizaci (například panel Písma ) jsou plovoucí nad všemi otevřenými okny bez ohledu na aplikaci.

Apple navrhuje následující pokyny:

• Obecně platí, že používejte standardní panel, průhledné panely by měly být použity jen střídmě a pro graficky náročné úlohy.
• Zvažte použití panelu, který uživatelům umožňuje snadný přístup k důležitým ovládacím prvkům nebo informacím, které přímo ovlivňují jejich úlohu.
• Podle potřeby skryjte a zobrazte panely.
• Panely by měly vždy obsahovat záhlaví.
• Panely by neměly obsahovat aktivní tlačítko pro minimalizaci.

Inspektorů

Většina moderních aplikací pro macOS prezentuje pomocné ovládací prvky a možnosti, které ovlivňují aktivní dokument nebo výběr jako inspektory, které jsou součástí hlavního okna (například aplikace Pages zobrazená níže), a ne pomocí oken panelu:

Další informace najdete v části Panely motivů návrhu macOS společnosti Apple a ukázkové aplikace MacInspector pro úplnou implementaci rozhraní inspektoru v aplikaci Xamarin.Mac.

Vytváření a údržba oken v Xcode

Když vytvoříte novou aplikaci Xamarin.Mac Cocoa, ve výchozím nastavení se zobrazí standardní prázdné okno. Tato okna jsou definována .storyboard v souboru, který je automaticky zahrnutý v projektu. Pokud chcete upravit návrh oken, poklikejte v Průzkumník řešení na Main.storyboard soubor:

Otevře se návrh okna v Tvůrci rozhraní Xcode:

V inspektoru atributů existuje několik vlastností, které můžete použít k definování a řízení okna:

• Název – Jedná se o text, který se zobrazí v záhlaví okna.
• Automatické ukládání – Toto je klíč , který se použije k ID okna, když je umístění a nastavení automaticky uloženo.
• Záhlaví – Zobrazuje se v okně záhlaví.
• Sjednocený název a panel nástrojů – pokud okno obsahuje panel nástrojů, měl by být součástí záhlaví.
• Zobrazení obsahu s plnou velikostí – Umožňuje, aby oblast obsahu okna byla pod záhlavím.
• Stín - Má okno stín.
• Texturovaná - texturová okna mohou používat efekty (například vibrace) a lze je přesouvat přetažením kamkoli do těla.
• Zavřít – Má okno tlačítko zavřít.
• Minimalizovat – má okno tlačítko minimalizovat.
• Změna velikosti – Má okno ovládací prvek pro změnu velikosti.
• Tlačítko panelu nástrojů – má okno tlačítko panelu nástrojů skrýt nebo zobrazit.
• Obnovitelné – je umístění a nastavení okna automaticky uloženo a obnoveno.
• Viditelné při spuštění – je okno automaticky zobrazeno při .xib načtení souboru.
• Skrýt při deaktivaci – je okno skryté, když aplikace přejde na pozadí.
• Uvolnění při zavření – je okno vyprázdněno z paměti při zavření.
• Vždy zobrazovat popisy – jsou popisy tlačítek neustále zobrazeny.
• Přepočítá smyčku zobrazení – přepočítá pořadí zobrazení před vykresleným oknem.
• Prostory, exposé a cyklistika – Všechny definují, jak se okno chová v prostředích macOS.
• Celá obrazovka – určuje, jestli toto okno může vstoupit do režimu celé obrazovky.
• Animace – určuje typ animace dostupné pro okno.
• Vzhled – řídí vzhled okna. Prozatím existuje jen jeden vzhled, Aqua.

Další podrobnosti najdete v dokumentaci k systému Windows a NSWindow společnosti Apple.

Nastavení výchozí velikosti a umístění

Pokud chcete nastavit počáteční umístění okna a nastavit jeho velikost, přepněte na Kontrolu velikosti:

Odsud můžete nastavit počáteční velikost okna, dát jí minimální a maximální velikost, nastavit počáteční umístění na obrazovce a ovládat ohraničení kolem okna.

Nastavení vlastního hlavního kontroleru oken

Aby bylo možné vytvářet výstupy a akce, které zpřístupňují prvky uživatelského rozhraní kódu jazyka C#, aplikace Xamarin.Mac bude muset používat vlastní kontroler oken.

Postupujte následovně:

1. Otevřete scénář aplikace v Tvůrci rozhraní Xcode.

2. NSWindowController Vyberte návrhovou plochu.

3. Přepněte do zobrazení Kontroly identit a zadejte WindowController jako název třídy:

   

4. Uložte změny a vraťte se do Visual Studio pro Mac k synchronizaci.

5. Soubor WindowController.cs se přidá do projektu v Průzkumník řešení v Visual Studio pro Mac:

   

6. Znovu otevřete storyboard v Tvůrci rozhraní Xcode.

7. Soubor WindowController.h bude k dispozici pro použití:

   

Přidání prvků uživatelského rozhraní

Chcete-li definovat obsah okna, přetáhněte ovládací prvky z nástroje Library Inspector do editoru rozhraní. Další informace o použití Tvůrce rozhraní k vytváření a povolování ovládacích prvků najdete v naší dokumentaci Úvod do Xcode a Interface Builderu .

Například přetáhneme panel nástrojů z inspektoru knihovny do okna editoru rozhraní:

V dalším kroku přetáhněte zobrazení textu a na jeho velikost vyplňte oblast pod panelem nástrojů:

Vzhledem k tomu, že chceme, aby se při změně velikosti okna zmenšovalo a zvětšovalo zobrazení textu, přepněte do Editoru omezení a přidejte následující omezení:

Když kliknete na čtyři červené paprsky V v horní části editoru a klikneme na Přidat 4 omezení, řekneme textovému zobrazení, aby se při změně velikosti okna přichytálo k zadaným souřadnicím X,Y a zmenšoval nebo zmenšil vodorovně a svisle.

Nakonec zpřístupňte textové zobrazení kódu pomocí výstupu(nezapomeňte vybrat ViewController.h soubor):

Uložte změny a přepněte zpátky na Visual Studio pro Mac, aby se synchronizovaly s Xcode.

Další informace o práci s výstupy a akcemi naleznete v naší dokumentaci k výstupu a akci .

Pracovní postup standardního okna

Pro každé okno, se kterým vytvoříte a pracujete v aplikaci Xamarin.Mac, je tento proces v podstatě stejný jako to, co jsme právě provedli výše:

1. Pro nová okna, která nejsou automaticky přidána do projektu, přidejte do projektu novou definici okna. Podrobnosti najdete níže.
2. Poklikáním na Main.storyboard soubor otevřete návrh okna pro úpravy v Tvůrci rozhraní Xcode.
3. Přetáhněte nové okno do návrhu uživatelského rozhraní a připojte okno do hlavního okna pomocí segues (další informace najdete v části Segues v naší dokumentaci Práce se scénáři).
4. Nastavte všechny požadované vlastnosti okna v inspektoruatributů a inspektoru velikostí.
5. Přetáhněte ovládací prvky potřebné k sestavení rozhraní a jejich konfiguraci v inspektoru atributů.
6. Pomocí inspektoru velikostí můžete zpracovat změnu velikosti prvků uživatelského rozhraní.
7. Zpřístupnění prvků uživatelského rozhraní okna pro kód jazyka C# prostřednictvím výstupů a akcí
8. Uložte změny a přepněte zpátky na Visual Studio pro Mac, aby se synchronizovaly s Xcode.

Když teď máme vytvořené základní okno, podíváme se na typické procesy, které aplikace Xamarin.Mac dělá při práci s Okny.

Zobrazení výchozího okna

Ve výchozím nastavení nová aplikace Xamarin.Mac automaticky zobrazí okno definované v MainWindow.xib souboru při spuštění:

Vzhledem k tomu, že jsme upravili návrh výše uvedeného okna, obsahuje teď výchozí panel nástrojů a ovládací prvek Zobrazení textu. Následující část souboru Info.plist odpovídá za zobrazení tohoto okna:

Rozevírací seznam Hlavní rozhraní slouží k výběru scénáře, který se použije jako hlavní uživatelské rozhraní aplikace (v tomto případě Main.storyboard).

Do projektu se automaticky přidá kontroler zobrazení, který určuje, že se zobrazí hlavní okna (spolu s jeho primárním zobrazením). Je definován v ViewController.cs souboru a připojen k vlastníku souboru v Tvůrci rozhraní v rámci kontroly identity:

V našem okně bychom chtěli, aby měla název untitled , kdy se poprvé otevře, abychom metodu ViewWillAppear přepsali ViewController.cs tak, aby vypadala takto:

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

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

Poznámka:

Vlastnost okna Title je nastavena v ViewWillAppear metodě namísto ViewDidLoad metody, protože zatímco zobrazení může být načteno do paměti, ještě není plně vytvořena instance. Title Přístup k vlastnosti v ViewDidLoad metodě získáme null výjimku, protože okno ještě nebylo sestaveno a drátově připojeno k vlastnosti.

Zavírání okna prostřednictvím kódu programu

Někdy můžete chtít okno v aplikaci Xamarin.Mac programově zavřít, kromě toho, že uživatel klikne na tlačítko Zavřít nebo použije položku nabídky. macOS nabízí dva různé způsoby, jak programově zavřít NSWindow : PerformClose a Close.

PerformClose

PerformClose Volání metody NSWindow simuluje uživatele, který kliká na tlačítko Zavřít okna, a to tak, že tlačítko zvýrazníte a pak okno zavřete.

Pokud aplikace implementuje NSWindowudálost ' WillClose s, bude vyvolána před zavřeným oknem. Pokud se událost vrátí false, okno se nezavře. Pokud okno nemá tlačítko Zavřít nebo nelze z nějakého důvodu zavřít, operační systém vygeneruje zvuk výstrahy.

Příklad:

MyWindow.PerformClose(this);

Pokusí se instanci zavřít MyWindowNSWindow . Pokud bylo okno úspěšné, zavře se okno, jinak se vygeneruje zvuk upozornění a zůstane otevřený.

Zavřít

Close Volání metody NSWindow nesimuluje uživatele, který kliká na tlačítko Zavřít okno tím, že tlačítko momentálně zvýrazní, jednoduše zavře okno.

Okno nemusí být viditelné pro zavření a NSWindowWillCloseNotification oznámení se publikuje do výchozího centra oznámení pro zavřené okno.

Metoda Close se liší dvěma důležitými způsoby od PerformClose metody:

1. Nepokouší se vyvolat WillClose událost.
2. Nenapodobuje uživatele, který kliká na tlačítko Zavřít , a to tak, že tlačítko zvýrazní.

Příklad:

MyWindow.Close();

Zavření MyWindowNSWindow instance.

Upravený obsah windows

V systému macOS společnost Apple poskytla uživateli způsob, jak uživatele informovat, že obsah okna (NSWindow) byl upraven uživatelem a je třeba ho uložit. Pokud okno obsahuje upravený obsah, zobrazí se v widgetu Zavřít malý černý tečka:

Pokud se uživatel pokusí okno zavřít nebo ukončit aplikaci pro Mac, když dojde k neuložené změně obsahu okna, měli byste nejdřív prezentovat dialogové okno nebo modální list a povolit uživateli uložit změny:

Označení okna jako upraveného

Pokud chcete okno označit jako změněný obsah, použijte následující kód:

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

Po uložení změny zrušte zaškrtnutí upraveného příznaku pomocí:

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

Uložení změn před zavřením okna

Pokud chcete sledovat, jak uživatel zavře okno a umožní jim uložit upravený obsah předem, budete muset vytvořit podtřídu NSWindowDelegate a přepsat jeho WindowShouldClose metodu. Příklad:

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

K připojení instance tohoto delegáta do okna použijte následující kód:

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

Uložení změn před zavřením aplikace

Nakonec by vaše aplikace Xamarin.Mac měla zkontrolovat, jestli některá z jeho windows obsahuje upravený obsah, a umožnit uživateli, aby změny před ukončením uložil. Uděláte to tak, že upravíte soubor, přepíšete AppDelegate.cs metodu ApplicationShouldTerminate a nastavíte, aby vypadal takto:

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

Práce s několika okny

Většina dokumentových aplikací pro Mac může upravovat více dokumentů najednou. Textový editor může mít například několik textových souborů otevřených pro úpravy najednou. Ve výchozím nastavení má nová aplikace Xamarin.Mac nabídku Soubor s novou položkou automaticky připojenou newDocument:k akci.

Následující kód aktivuje tuto novou položku a umožní uživateli otevřít více kopií hlavního okna, aby najednou upravoval více dokumentů.

AppDelegate.cs Upravte soubor a přidejte následující vypočítanou vlastnost:

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

Pomocí tohoto postupu můžete sledovat počet neuložených souborů, abychom mohli uživateli poskytnout zpětnou vazbu (podle pokynů společnosti Apple, jak je popsáno výše).

Dále přidejte následující metodu:

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

Tento kód vytvoří novou verzi našeho kontroleru oken, načte nové okno, nastaví ho jako hlavní a klíčové okno a nastaví název. Když teď spustíme naši aplikaci a v nabídce Soubor vybereme Nový, otevře se a zobrazí se nové okno editoru:

Pokud otevřete nabídku Windows , uvidíte, že aplikace automaticky sleduje a zpracovává otevřená okna:

Další informace o práci s nabídkami v aplikaci Xamarin.Mac najdete v naší dokumentaci k práci s nabídkami .

Získání aktuálně aktivního okna

V aplikaci Xamarin.Mac, která může otevřít více oken (dokumentů), existují časy, kdy budete muset získat aktuální horní okno (okno klíče). Následující kód vrátí okno klíče:

var window = NSApplication.SharedApplication.KeyWindow;

Lze ji volat v libovolné třídě nebo metodě, která potřebuje přístup k aktuálnímu okně klíče. Pokud není aktuálně otevřené žádné okno, vrátí nullse .

Přístup ke všem okny aplikace

Může se stát, že potřebujete získat přístup ke všem okny, která má vaše aplikace Xamarin.Mac aktuálně otevřenou. Pokud chcete například zjistit, jestli je soubor, který chce uživatel otevřít, už otevřený v zavřeném okně.

Windows Udržuje NSApplication.SharedApplication vlastnost, která obsahuje pole všech otevřených oken v aplikaci. V tomto poli můžete iterovat, abyste získali přístup ke všem aktuálním oknem aplikace. Příklad:

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

V ukázkovém kódu přetypujeme každé vrácené okno do vlastní ViewController třídy v naší aplikaci a otestujeme hodnotu vlastní Path vlastnosti na cestu k souboru, který chce uživatel otevřít. Pokud je soubor již otevřený, přinášíme toto okno na přední straně.

Úprava velikosti okna v kódu

Existují časy, kdy aplikace potřebuje změnit velikost okna v kódu. Pokud chcete změnit velikost a umístění okna, upravte jeho Frame vlastnost. Při úpravě velikosti okna je obvykle potřeba upravit jeho původ, aby bylo okno ve stejném umístění kvůli souřadnicovém systému macOS.

Na rozdíl od iOSu, kde levý horní roh představuje (0,0), používá macOS matematický souřadnicový systém, kde levý dolní roh obrazovky představuje (0,0). V iOSu se souřadnice zvětší, když se posunete směrem dolů směrem doprava. V systému macOS se souřadnice zvětšují směrem nahoru doprava.

Následující příklad kódu změní velikost okna:

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

Důležité

Při úpravě velikosti a umístění oken v kódu musíte zajistit, abyste respektovali minimální a maximální velikosti, které jste nastavili v Tvůrci rozhraní. Nebude to automaticky respektováno a budete moci okno zvětšit nebo zmenšit, než jsou tyto limity.

Změny velikosti okna monitorování

V aplikaci Xamarin.Mac možná budete muset monitorovat změny velikosti okna. Pokud chcete například překreslit obsah tak, aby odpovídal nové velikosti.

Pokud chcete monitorovat změny velikosti, nejprve se ujistěte, že jste přiřadili vlastní třídu kontroleru oken v Tvůrci rozhraní Xcode. Například MasterWindowController v následujícím příkladu:

Dále upravte vlastní třídu Kontroleru oken a monitorujte DidResize událost v okně kontroleru, aby se dostávala oznámení o změnách velikosti v reálném provozu. Příklad:

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

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

Volitelně můžete událost použít DidEndLiveResize , aby byla upozorněna pouze po dokončení změny velikosti okna uživatelem. Příklad:

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

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

Nastavení názvu a reprezentního souboru okna

Při práci s okny, která představují dokumenty, má DocumentEdited vlastnost, NSWindow která pokud je nastavena na true zobrazení malé tečky v tlačítku Zavřít, aby uživatel oznámil, že soubor byl změněn a měl by být uložen před zavřením.

Pojďme soubor ViewController.cs upravit a provést následující změny:

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

}

Také sledujeme WillClose událost v okně a kontrolujeme stav DocumentEdited vlastnosti. Pokud je true potřeba dát uživateli možnost uložit změny souboru. Pokud spustíme naši aplikaci a zadáme nějaký text, zobrazí se tečka:

Pokud se pokusíte okno zavřít, zobrazí se upozornění:

Pokud načítáte dokument ze souboru, nastavte název okna na název souboru pomocí window.SetTitleWithRepresentedFilename (Path.GetFileName(path)); metody (vzhledem k tomu, že path se jedná o řetězec představující soubor, který se otevírá). Kromě toho můžete nastavit adresu URL souboru pomocí window.RepresentedUrl = url; metody.

Pokud adresa URL odkazuje na typ souboru známý operačním systémem, jeho ikona se zobrazí v záhlaví. Pokud uživatel klikne pravým tlačítkem myši na ikonu, zobrazí se cesta k souboru.

AppDelegate.cs Upravte soubor a přidejte následující metodu:

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

        }
    }
}

Když teď spustíme naši aplikaci, v nabídce Soubor vyberte Otevřít... vyberte textový soubor z dialogového okna Otevřít a otevřete ho:

Soubor se zobrazí a název se nastaví ikonou souboru:

Přidání nového okna do projektu

Kromě hlavního okna dokumentu může aplikace Xamarin.Mac potřebovat uživateli zobrazit jiné typy oken, jako jsou předvolby nebo panely inspektoru.

Pokud chcete přidat nové okno, postupujte takto:

1. V Průzkumník řešení poklikáním Main.storyboard otevřete soubor pro úpravy v Tvůrci rozhraní Xcode.

2. Přetáhněte nový kontroler okna z knihovny a umístěte ho na návrhovou plochu:

   

3. V nástroji Identity Inspector zadejte PreferencesWindow ID scénáře:

   

4. Navrhněte rozhraní:

   

5. Otevřete nabídku aplikace (MacWindows), vyberte Předvolby..., Stiskněte stisknutou klávesu Control a přetáhněte ho do nového okna:

   

6. V místní nabídce vyberte Zobrazit .

7. Uložte změny a vraťte se do Visual Studio pro Mac pro synchronizaci s Xcode.

Pokud kód spustíme a v nabídce Aplikace vybereme předvolby... zobrazí se okno:

Práce s panely

Jak je uvedeno na začátku tohoto článku, panel se nachází nad jinými okny a poskytuje nástroje nebo ovládací prvky, se kterými můžou uživatelé pracovat, když jsou dokumenty otevřené.

Stejně jako jakýkoli jiný typ okna, se kterým vytváříte a pracujete v aplikaci Xamarin.Mac, je tento proces v podstatě stejný:

1. Přidejte do projektu novou definici okna.
2. Poklikáním na .xib soubor otevřete návrh okna pro úpravy v Tvůrci rozhraní Xcode.
3. Nastavte všechny požadované vlastnosti okna v inspektoruatributů a inspektoru velikostí.
4. Přetáhněte ovládací prvky potřebné k sestavení rozhraní a jejich konfiguraci v inspektoru atributů.
5. Pomocí inspektoru velikostí můžete zpracovat změnu velikosti prvků uživatelského rozhraní.
6. Zpřístupnění prvků uživatelského rozhraní okna pro kód jazyka C# prostřednictvím výstupů a akcí
7. Uložte změny a přepněte zpátky na Visual Studio pro Mac, aby se synchronizovaly s Xcode.

V inspektoru atributů máte následující možnosti specifické pro panely:

• Styl – Umožňuje upravit styl panelu z: Běžný panel (vypadá jako standardní okno), Panel nástrojů (má menší záhlaví), PANEL HUD (je průsvitný a záhlaví je součástí pozadí).
• Neaktivování – Určuje na panelu okno klíče.
• Document Modal – Pokud document Modal, panel bude plovoucí pouze nad okny aplikace, jinak se nad všemi plovoucí.

Pokud chcete přidat nový panel, postupujte takto:

1. V Průzkumník řešení klikněte pravým tlačítkem na Projekt a vyberte Přidat>nový soubor....

2. V dialogovém okně Nový soubor vyberte okno Xamarin.Mac>Cocoa s kontrolerem:

   

3. Zadejte DocumentPanel název a klikněte na tlačítko Nový.

4. Poklikáním otevřete DocumentPanel.xib soubor pro úpravy v Tvůrci rozhraní:

   

5. Odstraňte existující okno a přetáhněte panel z inspektoru knihovny v editoru rozhraní:

   

6. Připojte panel k výstupu okna - Vlastník - souboru:

   

7. Přepněte do nástroje Identity Inspector a nastavte třídu panelu na DocumentPanel:

   

8. Uložte změny a vraťte se do Visual Studio pro Mac pro synchronizaci s Xcode.

9. DocumentPanel.cs Upravte soubor a změňte definici třídy na následující:

   public partial class DocumentPanel : NSPanel

10. Uložte změny souboru.

AppDelegate.cs Upravte soubor a udělejte metodu DidFinishLaunching takto:

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

Pokud spustíme naši aplikaci, zobrazí se panel:

Důležité

Systém Windows panelu byl společností Apple zastaralý a měl by být nahrazen rozhraními inspektoru. Úplný příklad vytvoření inspektoru v aplikaci Xamarin.Mac najdete v ukázkové aplikaci MacInspector.

Shrnutí

Tento článek se podrobně podíval na práci s Windows a panely v aplikaci Xamarin.Mac. Viděli jsme různé typy a použití windows a panelů, jak vytvářet a udržovat Windows a panely v Tvůrci rozhraní Xcode a jak pracovat s Windows a panely v kódu jazyka C#.

Související odkazy

• MacWindows (ukázka)
• MacInspector (ukázka)
• Hello, Mac
• Práce s nabídkami
• Motivy návrhu pro macOS (Apple)
• Windows, panely a obrazovky (Apple)