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 Builder, jejich načítání ze scénářů a souborů. xib a práci s nimi prostřednictvím kódu programu.

při práci s C# a .net v aplikaci Xamarin. Mac máte přístup ke stejným Windowsům a panelům, které vývojář pracuje v Objective-C a Objective-C . protože se Xamarin. Mac integruje přímo s Xcode, můžete použít Interface Builder Xcode k vytváření a údržbě Windows a panelů (případně k jejich přímému vytvoření přímo v kódu C#).

na základě jeho účelu může aplikace Xamarin. Mac představovat jednu nebo více Windows na obrazovce pro správu a koordinaci informací, které zobrazuje a pracuje s. Hlavní funkce okna jsou:

1. K poskytnutí oblasti, ve které lze umístit a spravovat zobrazení a ovládací prvky.
2. Pro přijetí a reakci na události v reakci na interakci uživatele s klávesnicí a myší.

Windows lze použít v neaktivním stavu (například textový editor, který může mít otevřeno více dokumentů najednou) nebo modální (například dialogové okno exportu, které musí být ukončeno předtím, než může aplikace pokračovat).

Panely jsou speciálním druhem okna (podtřídou základní NSWindow třídy), která obvykle obsluhuje pomocnou funkci v aplikaci, jako jsou například okna nástrojů jako nástroje pro kontrolu formátu textu a výběr barvy systému.

v tomto článku se seznámíte se základy práce s Windows a panely v aplikaci Xamarin. Mac. Důrazně doporučujeme, abyste nejprve pracovali v článku Hello, Mac , konkrétně v částech Úvod k Xcode a Interface Builder a akcím a akcím , které se týkají klíčových konceptů a technik, které v tomto článku budeme používat.

Můžete se podívat i na část dokumentu s dalšími Exposing C# classes / methods to Objective-CExposing C# classes / methods to Objective-C a vysvětluje RegisterExport příkazy a používané k navýšení tříd jazyka C# do Objective-C objektů a prvků uživatelského rozhraní.

Úvod do Windows

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 applu má aplikace macOS pět hlavních typů Windows:

• Okno dokumentu – okno dokumentu obsahuje uživatelská data založená na souborech, jako je například tabulka nebo textový dokument.
• Okno aplikace – okno aplikace je hlavní okno aplikace, které není založené na dokumentu (například aplikace kalendáře na Macu).
• Panel – panel se nachází nad ostatními okny a poskytuje nástroje nebo ovládací prvky, se kterými uživatelé můžou pracovat, i 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ým obrázkem).
• Dialogové okno – zobrazí se dialogové okno v reakci na akci uživatele a obvykle poskytuje způsob, jakým můžou uživatelé tuto akci dokončit. Dialogové okno vyžaduje odpověď od uživatele předtím, než bude možné ho zavřít. (Viz práce s dialogovými dialogy)
• Výstrahy – výstraha je speciální typ dialogového okna, který se zobrazí při výskytu vážného problému (například chyba) nebo jako upozornění (například příprava k odstranění souboru). Vzhledem k tomu, že výstraha je dialog, vyžaduje také odpověď uživatele, aby mohla být zavřena. (Viz práce s výstrahami)

další informace najdete v části o Windows v tématu motivy návrhu macOSspolečnosti Apple.

Hlavní, klíčová a neaktivní okna

Windows v aplikaci Xamarin. Mac může vypadat a chovat se jinak, podle toho, jak uživatel aktuálně spolupracuje s nimi. Dokument nejpřednější nebo okno aplikace, které je aktuálně soustředěné na pozornost uživatele, se nazývá hlavní okno. Ve většině případů toto okno bude také okno klíče (okno, které aktuálně přijímá vstup uživatele). Nejedná se však vždy o tento případ, například výběr barvy by mohl být otevřen a musí se jednat o okno klíče, ve kterém uživatel pracuje, aby změnil stav položky v okně dokumentu (což je stále hlavní okno).

hlavní a klíčové Windows (pokud jsou oddělené) jsou vždy aktivní, neaktivní Windows jsou otevřená okna, která nejsou v popředí. Například v aplikaci textový editor může být otevřeno více dokumentů najednou, pouze hlavní okno by bylo aktivní, všichni ostatní budou neaktivní.

další informace najdete v části o Windows v tématu motivy návrhu macOSspolečnosti Apple.

Pojmenovávání Windows

Okno může zobrazit záhlaví a při zobrazení nadpisu je obvykle název aplikace, název dokumentu, na kterém pracujete, nebo funkce okna (například Inspector). Některé aplikace nezobrazují záhlaví, protože je rozpoznává a nefungují s dokumenty.

Společnost Apple navrhne následující pokyny:

• Název vaší aplikace použijte pro název hlavního okna bez dokumentu.
• Pojmenuje nové okno dokumentu untitled . U prvního nového dokumentu nepřipojujte k názvu číslo (například untitled 1 ). Pokud uživatel vytvoří další nový dokument před tím, než ho nejdřív uložíte a zavoláte, zavolejte toto okno untitled 2 , untitled 3 atd.

další informace najdete v části pojmenování Windows v motivech návrhu macOSspolečnosti Apple.

Okna na celé obrazovce

V macOS okno aplikace může přejít na celou obrazovku a Skrýt vše včetně panelu nabídek aplikace (který se dá zobrazit tak, že přesunete kurzor do horní části obrazovky) a zadáte bezchybnou interakci s obsahem.

Společnost Apple navrhuje následující pokyny:

• Určete, zda má okno smysl pro zobrazení celé obrazovky. Aplikace, které poskytují krátké interakce (například Kalkulačka), by neměly poskytovat režim zobrazení na celé obrazovce.
• Zobrazit panel nástrojů, pokud je to úloha na celé obrazovce vyžaduje. Panel nástrojů je typicky v režimu celé obrazovky skrytý.
• Okno na celé obrazovce by mělo mít všechny funkce, které uživatelé potřebují k dokončení této úlohy.
• Pokud je to možné, vyhněte se interakci Finder v době, kdy se uživatel nachází v okně na celé obrazovce.
• Využijte větší místo na obrazovce bez přesunu fokusu mimo hlavní úkol.

další informace najdete v části Windows na celé obrazovce v tématu motivy návrhu macOSspolečnosti Apple.

Zkušební

Panel je pomocné okno obsahující ovládací prvky a možnosti, které mají vliv na aktivní dokument nebo výběr (například na výběr systémové barvy):

Panely mohou být specifické pro aplikacenebo systém. App-Specific panely se nachází v horní části oken dokumentu aplikace a zmizí, když je aplikace na pozadí. Hlavní panely (například panel písma ) jsou plovoucí na všech otevřených oknech bez ohledu na aplikaci.

Společnost Apple navrhuje následující pokyny:

• Obecně platí, že použití standardního panelu by mělo být použito pouze k omezenému používání a pro graficky náročné úlohy.
• Zvažte použití panelu, který uživatelům poskytuje snadný přístup k důležitým ovládacím prvkům nebo informacím, které mají přímý vliv na jejich úkol.
• Skryjte a zobrazte panely podle potřeby.
• Panely by měly vždy obsahovat záhlaví.
• Panely by neměly zahrnovat aktivní tlačítko pro minimalizaci.

Kontroly

Většina moderních aplikací macOS prezentují pomocné ovládací prvky a možnosti, které mají vliv na aktivní dokument nebo výběr, jako kontrolory , které jsou součástí hlavního okna (jako je například aplikace stránky uvedená níže), namísto použití panelu Windows:

Další informace najdete v části panely v tématech pro návrh MacOS společnosti Apple a v naší ukázkové aplikaci MacInspector pro úplnou implementaci rozhraní Inspector v aplikaci Xamarin. Mac.

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

Když vytvoříte novou aplikaci Xamarin. Mac kakaa, ve výchozím nastavení se zobrazí standardní prázdné okno. Tato okna jsou definována v souboru, který je .storyboard automaticky zahrnutý v projektu. Chcete-li upravit návrh systému Windows, v Průzkumník řešenídvakrát klikněte na soubor:

Tím se otevře návrh okna Interface Builder Xcode:

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

• Title – jedná se o text, který se zobrazí v záhlaví okna.
• Automatické ukládání – jedná se o klíč , který se použije k ID okna, když se umístí a nastavení se automaticky uloží.
• Záhlaví – v okně se zobrazuje záhlaví.
• Sjednocený nadpis a panel nástrojů – Pokud okno obsahuje panel nástrojů, měl by být součástí záhlaví.
• Zobrazení obsahu v plném rozsahu – umožňuje, aby oblast obsahu okna byla pod záhlavím.
• Stín – okno má stín.
• Okna s texturou s texturou můžou používat efekty (například živost) a můžete je přesouvat přetažením kamkoli na své tělo.
• Zavřít – okno má tlačítko Zavřít.
• Minimalizovat – okno má tlačítko minimalizovat.
• Změnit velikost – okno má ovládací prvek pro změnu velikosti.
• Tlačítko panelu nástrojů – okno má tlačítko Skrýt/zobrazit na panelu nástrojů.
• Obnovitelné – umístění okna a nastavení se automaticky uloží a obnoví.
• Viditelné při spuštění – je okno automaticky zobrazené při načtení souboru.
• Skrýt při deaktivaci – je okno skryté, když aplikace vstoupí na pozadí.
• Vydaná verze po uzavření – je okno vyprázdněné z paměti, když je zavřené.
• Vždy zobrazovat popisy tlačítek – jsou popisy neustále zobrazeny.
• Přepočítá smyčku zobrazení – přepočítá pořadí zobrazení před vykreslením okna.
• Mezery,exposé a zamykací prostředí – vše definují, jak se okno v těchto prostředích macOS chová.
• Celá obrazovka – určuje, jestli toto okno může vstoupit do režimu zobrazení na celé obrazovce.
• Animace – řídí typ animace dostupné pro okno.
• Vzhled – řídí vzhled okna. Pro teď existuje jenom jeden vzhled, Akvamarínová.

Další podrobnosti najdete v dokumentaci společnosti Apple Windows a NSWindow.

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

Pokud chcete nastavit počáteční pozici okna a řídit jeho velikost, přepněte do inspektoru velikosti:

Tady můžete nastavit počáteční velikost okna, dejte mu minimální a maximální velikost, nastavit počáteční umístění na obrazovce a řídit ohraničení kolem okna.

Nastavení vlastního kontroleru hlavního okna

Aby bylo možné vytvářet výstupy a akce pro vystavení prvků uživatelského rozhraní kódu v jazyce C#, musí aplikace Xamarin.Mac používat vlastní kontroler oken.

Postupujte následovně:

1. Otevřete Storyboard aplikace v Xcode na Interface Builder.

2. V NSWindowController okně vyberte Návrhová plocha.

3. Přepněte do zobrazení Identity Inspector a jako Název třídy zadejte:

   

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

5. Soubor WindowController.cs se přidá do vašeho Project v WindowController.cs Visual Studio pro Mac:

   

6. Znovu otevřete Storyboard v Xcode Interface Builder.

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

   

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

Pokud chcete definovat obsah okna, přetáhněte ovládací prvky z inspektoru knihovny do editoru rozhraní. Další informace o vytváření a povolování ovládacích prvků najdete v Interface Builder úvodu do Xcode a Interface Builder o používání ovládacích prvků.

Jako příklad přetáhneme panel nástrojů z inspektoru knihovny do okna v Editoru rozhraní:

Potom přetáhněte zobrazení textu a jeho velikostí vyplňte oblast pod panelem nástrojů:

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

Když v horní části editoru kliknete na čtyři červené i-paprsky a kliknete na Add 4 Constraints(Přidat 4 omezení), řekneme zobrazení textu, aby se při změně velikosti okna drží na souřadnicích X,Y a zvětšoval nebo zmenšoval vodorovně a svisle.

Nakonec zobrazte zobrazení textu pro kód pomocí výstupu (nezapomeňte vybrat soubor ):

Uložte změny a přepněte zpět na Visual Studio pro Mac synchronizaci s Xcode.

Další informace o práci s výstupy a akcemi najdetev naší dokumentaci k výstupům a akcím.

Standardní pracovní postup okna

Pro každé okno, které vytvoříte a budete s ním pracovat v aplikaci Xamarin.Mac, je 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. Podrobněji to probíráme níže.
2. Dvojím kliknutím na soubor otevřete návrh okna pro úpravy v souboru Main.storyboard Interface Builder.
3. Přetáhněte nové okno do návrhu Uživatelské rozhraní a připojte okno do hlavního okna pomocí hosta (další informace najdete v části Host v naší dokumentaci Práce se scénáři).
4. V inspektoru atributů a v inspektoru velikosti nastavte všechny požadované vlastnosti okna.
5. Přetáhněte ovládací prvky potřebné k sestavení rozhraní a nakonfigurujte je v nástroji Attribute Inspector.
6. Ke zpracování velikosti prvků uživatelského rozhraní použijte Inspektor velikosti.
7. Prvky uživatelského rozhraní okna zpřístupňujete kódu jazyka C# prostřednictvím výstupů aakcí.
8. Uložte změny a přepněte zpět na Visual Studio pro Mac synchronizaci 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 Windows.

Zobrazení výchozího okna

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

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

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ě ).

Do projektu se automaticky přidá kontroler zobrazení, který řídí, Windows hlavní panel, který se zobrazí (spolu s jeho primárním zobrazením). Je definovaný v souboru a připojený k vlastníkovi souboru v ViewController.cs Interface Builder v rámci identity inspektoruViewController.cs :

U našeho okna chceme, aby měl při prvním otevření název , takže přepíšeme metodu v , aby untitledViewWillAppearViewController.cs vypadala takto:

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

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

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

Může se zobrazit, že chcete okno v aplikaci Xamarin.Mac zavřít programově, kromě toho, že uživatel klikne na tlačítko Zavřít okna nebo použije položku nabídky. MacOS nabízí dva různé způsoby, jak NSWindow programově zavřít: a PerformCloseClose .

ProvéstZavřít

Volání metody simuluje, že uživatel klikne na tlačítko Zavřít okna tím, že na chvíli zvýrazní tlačítko a pak PerformCloseNSWindow okno zavře. PerformClose

Pokud aplikace implementuje událost , bude vyvolána NSWindowWillClose před zavřením okna. Pokud událost vrátí false , okno se nezavře. Pokud okno nemá tlačítko Zavřít nebo ho z nějakého důvodu nelze zavřít, operační systém vysílá zvuk upozornění.

Například:

MyWindow.PerformClose(this);

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

Zavřít

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

Okno nemusí být viditelné, aby bylo možné ho zavřít, a oznámení se zavírá do výchozího Centra NSWindowWillCloseNotification oznámení.

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

1. Nepokoušuje se vyvolat WillClose událost.
2. Nesimulovat uživatele kliknutím na tlačítko Zavřít tím, že tlačítko na okamžik zvýrazní.

Například:

MyWindow.Close();

By zavřít MyWindowNSWindow instanci.

Úprava obsahu Windows

V systému macOS nabízí Apple způsob, jak informovat uživatele o tom, že uživatel změnil obsah okna ( ) a že je NSWindow potřeba ho uložit. Pokud okno obsahuje upravený obsah, zobrazí se ve widgetu Zavřít malá černá tečka:

Pokud se uživatel pokusí zavřít okno nebo ukončit aplikaci pro Mac v době, kdy dojde k neuloženou změně obsahu okna, měli byste zobrazit dialogové okno nebo modální list a povolit uživateli, aby změny nejprve ukládal:

Označení okna jako upraveného

Pokud chcete okno označit jako okno s upraveným obsahem, použijte následující kód:

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

A po uložení změny zrušte zaškrtnutí upravované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í mu předem uložit upravený obsah, budete muset vytvořit podtřídu třídy a přepsat NSWindowDelegate jeho WindowShouldClose metodu. Napří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
    }
}

Pomocí následujícího kódu připojte instanci tohoto delegáta k oknu:

// 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 jejích Windows obsahuje upravený obsah, a umožnit uživateli uložit změny před ukončením. Chcete-li to provést, upravte AppDelegate.cs soubor, přepište metodu a ApplicationShouldTerminate zajistě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 aplikací systému Mac založených na dokumentech může upravovat více dokumentů současně. Textový editor například může mít otevřeno více textových souborů pro úpravy současně. Ve výchozím nastavení má nová aplikace Xamarin. Mac novou položku , která je automaticky zapojena do Akce.

Níže uvedený kód aktivuje tuto novou položku a umožní uživateli otevřít více kopií hlavního okna, aby bylo možné upravovat více dokumentů najednou.

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

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

Tuto možnost použijte ke sledování počtu neuložených souborů, abychom vám mohli poskytnout zpětnou vazbu uživateli (podle pokynů pro společnost 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, změní hlavní okno na hlavní a klíč a nastaví jeho název. Když teď naši aplikaci spustíte a v nabídce soubor vyberete Nový , otevře se nové okno editoru, které se otevře a zobrazí:

otevřete-li nabídku Windows , můžete vidět, že aplikace automaticky sleduje a zpracovává naše otevřená okna:

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

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

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

var window = NSApplication.SharedApplication.KeyWindow;

Může být volána v jakékoli třídě nebo metodě, která potřebuje přístup k aktuálnímu oknu klíče. Pokud není momentálně otevřené žádné okno, vrátí se null .

Přístup ke všem okenm aplikací

Můžou nastat situace, kdy potřebujete přístup ke všem Windows, které vaše aplikace Xamarin. Mac momentálně otevřela. Například, chcete-li zjistit, zda soubor, který chce uživatel otevřít, je již otevřen v ukončovacím okně.

NSApplication.SharedApplicationUdržuje Windows vlastnost, která obsahuje pole všech otevřených oken ve vaší aplikaci. Můžete iterovat přes toto pole pro přístup ke všem aktuálním oken aplikace. Napří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řetypování každého vráceného okna do vlastní ViewController třídy v naší aplikaci a testování hodnoty vlastní Path vlastnosti proti cestě souboru, který uživatel chce otevřít. Pokud je soubor už otevřený, přineseme toto okno do popředí.

Úprava velikosti okna v kódu

Existují situace, kdy aplikace potřebuje změnit velikost okna v kódu. Chcete-li změnit velikost okna a změnit jeho polohu, upravte jeho Frame vlastnost. Při úpravách velikosti okna je obvykle potřeba také upravit jeho původ, aby zůstalo okno ve stejném umístění, protože systém souřadnic macOS.

Na rozdíl od iOS, kde levý horní roh představuje (0, 0), macOS používá systém matematických souřadnic, ve kterém spodní levý roh obrazovky představuje (0, 0). V iOS se souřadnice při přesunu směrem dolů směrem k pravému místu zvyšují. V macOS se souřadnice nazvyšují směrem nahoru k pravému.

Následující příklad kódu mě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);

Změny velikosti okna monitorování

Může nastat situace, kdy potřebujete monitorovat změny velikosti okna v aplikaci Xamarin. Mac. Například pro překreslení obsahu tak, aby odpovídal nové velikosti.

Chcete-li monitorovat změny velikosti, nejprve zkontrolujte, zda jste přiřadili vlastní třídu pro řadič okna v Xcode Interface Builder. Například MasterWindowController v následujících případech:

Dále upravte třídu kontroleru vlastního okna a sledujte DidResize událost v okně kontroleru, abyste byli informováni o změnách živé velikosti. Například:

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

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

Volitelně můžete tuto událost použít pouze v případě, že DidEndLiveResize uživatel dokončil změnu velikosti okna. 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 reprezentovaného souboru okna

Když pracujete se systémem Windows, který představuje dokumenty, NSWindow má DocumentEdited vlastnost, která je nastavena na true zobrazení malé tečky v tlačítku zavřít, aby uživateli bylo jasné, že soubor byl upraven a měl by být uložen před zavřením.

Pojďme upravit náš ViewController.cs soubor 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;
    };

}

Sledujeme také WillClose událost v okně a kontrolujeme stav této DocumentEdited Vlastnosti. Pokud je true potřeba, aby uživatel měl možnost Uložit změny do souboru. Pokud spustíme naši aplikaci a zadáte 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 ( path je-li řetězec představující otevíraný soubor). 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, zobrazí se jeho ikona v záhlaví. Pokud uživatel klikne pravým tlačítkem myši na ikonu, zobrazí se cesta k souboru.

Upravte AppDelegate.cs 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;

        }
    }
}

Teď, když spouštíme naši aplikaci, vyberte otevřít... v nabídce soubor , v dialogovém okně otevřít vyberte textový soubor a otevřete ho:

Soubor se zobrazí a název se nastaví pomocí ikony souboru:

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

Kromě hlavního okna dokumentu může aplikace Xamarin. Mac vyžadovat zobrazení dalších typů oken uživateli, jako jsou předvolby nebo panely inspektora.

Chcete-li přidat nové okno, postupujte následovně:

1. V Průzkumník řešenídvakrát klikněte na soubor a otevřete ho pro úpravy v Interface Builder Xcode.

2. Přetáhněte nový řadič okna z knihovny a přetáhněte ho na návrhová plocha:

   

3. V inspektoru identityzadejte pro ID scénáře:

   

4. Navrhněte své rozhraní:

   

5. Otevřete nabídku aplikace ( MacWindows ), vyberte MacWindows, Control-Click a přetáhněte je do nového okna:

   

6. V místní nabídce vyberte možnost Zobrazit .

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

Pokud kód spouštíme a v nabídce aplikacevyberete Předvolby... , zobrazí se okno:

Práce s panely

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

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

1. Přidejte do projektu novou definici okna.
2. Dvojím kliknutím na .xib soubor otevřete návrh okna pro úpravy v Interface Builder Xcode.
3. Nastavte všechny požadované vlastnosti okna v inspektoru atributů a v inspektoru velikosti.
4. Přetáhněte v ovládacích prvcích požadovaných k sestavení rozhraní a nakonfigurujte je v inspektoru atributů.
5. Použijte inspektora velikosti pro zpracování změny velikosti prvků uživatelského rozhraní.
6. Zpřístupňujte prvky uživatelského rozhraní okna pro kód C# prostřednictvím výstupů a akcí.
7. uložte své změny a přepněte zpět na Visual Studio pro Mac a synchronizujte se s Xcode.

V inspektoru atributůmáte následující možnosti, které jsou 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í).
• Neaktivace – určuje, že se v panelu zobrazí okno klíče.
• Dokument modální – Pokud se jedná o modální dokument, panel bude plovoucí jenom nad okny aplikace, jinak bude float nad rámec všech.

Chcete-li přidat nový panel, postupujte následovně:

1. v Průzkumník řešeníklikněte pravým tlačítkem na Project a vyberte přidatnový soubor....

2. V dialogovém okně Nový soubor vyberte Xamarin. Mackakaové box s řadičem:

   

3. Jako DocumentPanel Název zadejte DocumentPanel klikněte na tlačítko Nový.

4. Poklikejte na DocumentPanel.xib soubor a otevřete ho pro úpravy v Interface Builder:

   

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íksouboru:

   

7. Přepněte do inspektoru identit a nastavte třídu Panelu na :

   

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

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

   public partial class DocumentPanel : NSPanel

10. Uložte změny souboru.

Upravte AppDelegate.cs soubor a DidFinishLaunching zajistěte, aby metoda vypadala takto:

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

Pokud aplikaci spustíme, zobrazí se panel:

Souhrn

Tento článek se podrobně podíval na práci s Windows panely 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 Interface Builder Xcode a jak pracovat s panely 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 macOS (Apple)
• Windows, panely a obrazovky (Apple)