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 C# a .NET v aplikaci Xamarin.Mac máte přístup ke stejným Windows a panelům, ve kterých vývojář pracuje Objective-C a Xcode dělá. Vzhledem k tomu, že Xamarin.Mac se 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 na obrazovce jeden nebo více Windows pro správu a koordinaci informací, se kterými se zobrazují a pracují. 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ší

Windows lze použít v režimu bez režimu (například v textovém editoru, který může mít otevřeno více dokumentů najednou) nebo modální (například dialogové okno exportu, které je nutné zavřít, než aplikace může pokračovat).

Panely jsou speciální druh okna (podtřídy základní NSWindow třídy), které obvykle obsluhují pomocné funkce v aplikaci, jako jsou okna nástrojů, jako jsou kontroly formátu textu a výběr barvy systému.

Editing a window in Xcode

V tomto článku se podíváme na základy práce s Windows a panely v aplikaci Xamarin.Mac. Důrazně doporučujeme nejprve projít si článek Hello, Mac , konkrétně úvod do Xcode a Interface Builder aOutlets and Actions oddíly, protože se zabývá klíčovými koncepty a technikami, které budeme používat v tomto článku.

Můžete se také podívat na třídy / metody pro zveřejnění kódu jazyka C# v Objective-C části dokumentu Interní dokumenty Xamarin.Mac , vysvětluje Register a Export příkazy používané k převodu tříd jazyka C# na Objective-C objekty a prvky 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 pět hlavních typů Windows v aplikaci macOS:

  • 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 (například aplikace Kalendář na Macu).
  • Panel – 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é. V některých případech může být panel průsvitný (například při práci s velkou grafikou).
  • Dialogové okno – Dialogové okno se zobrazí v reakci na akci uživatele a obvykle poskytuje způsob, jak uživatelé mohou 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 speciální 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 Windowsmotivů návrhu apple pro macOS.

Hlavní, klíč a neaktivní okna

Windows v aplikaci Xamarin.Mac může vypadat a chovat odlišně podle toho, jak s nimi uživatel právě pracuje. Nejdůležitějším oknem dokumentu nebo aplikace, které je aktuálně zaměřeno na pozornost uživatele, se nazývá hlavní okno. Ve většině případů bude toto okno také klíčové okno (okno, které aktuálně přijímá uživatelský vstup). Ale to není vždy případ, například výběr barvy může být otevřený a může to být okno klíče, 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í. Aplikace textového editoru může mít například otevřený více než jeden dokument najednou, pouze hlavní okno bude aktivní, všechny ostatní budou neaktivní.

Další informace najdete v části o Windowsmotivů 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é pohledem a nefungují s dokumenty.

Apple navrhuje následující pokyny:

  • Název aplikace použijte pro název hlavního okna bez dokumentu.
  • 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ává první, zavolejte toto okno untitled 2atd untitled 3.

Další informace najdete v části Pojmenování Windowsmotivů návrhu apple pro macOS.

Okna na celé obrazovce

V systému macOS může okno aplikace skrýt vše, co zahrnuje řádek nabídek aplikace (který se dá odhalit přesunutím kurzoru na horní část obrazovky) a zajistit rušivé volné interakce s jeho obsahem.

Apple navrhuje následující pokyny:

  • Určete, jestli má okno smysl pro přechod na celou obrazovku. Aplikace, které poskytují stručné interakce (například kalkulačku), by neměly poskytovat režim celé obrazovky.
  • Zobrazení panelu nástrojů, pokud to úloha na celé obrazovce vyžaduje. Panel nástrojů je obvykle skrytý v režimu celé obrazovky.
  • Okno na celé obrazovce by mělo mít 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é obrazovcemotivů návrhu macOS společnosti Apple.

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

A color panel

Panely můžou být specifické pro aplikace nebo pro celou systém. App-Specific panely plují nad horní část oken dokumentů aplikace a zmizí, když je aplikace na pozadí. Panely pro celou celou systém (například panel Písma ) jsou plovoucí na všech otevřených oknech 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 pouze 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í svůj úkol.
  • Podle potřeby skryjte a zobrazte panely.
  • Panely by měly vždy obsahovat záhlaví.
  • Panely by neměly obsahovat aktivní tlačítko minimalizace.

Inspektorů

Většina moderních aplikací pro macOS představuje 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 Stránky zobrazená níže), místo použití panelu Windows:

An example inspector

Další informace najdete v části Panely motivůnávrhu apple pro macOS 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í získáte standardní prázdné okno. Tato okna jsou definována .storyboard v souboru automaticky zahrnuté v projektu. Pokud chcete upravit návrh oken, poklikejte v Průzkumník řešení na Main.storyboard soubor:

Selecting the main storyboard

Tím se otevře návrh okna v Tvůrci rozhraní Xcode:

Editing the UI in 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ž se automaticky uloží umístění a nastavení.
  • Záhlaví – Zobrazuje okno 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á - texturovaná okna můžou používat efekty (například vibrace) a lze je přesouvat přetažením kamkoli na tělo.
  • 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 pozice okna a nastavení automaticky uložena a obnovena.
  • Visible At Launch – zobrazuje se automaticky okno při .xib načtení souboru.
  • Skrýt při deaktivaci – je okno skryté, když aplikace přejde na pozadí.
  • Release When Closed - Is the window purged from memory when it is closed.
  • Vždy zobrazované popisy – jsou popisy tlačítek neustále zobrazeny.
  • Přepočítá zobrazení Loop – je pořadí zobrazení přepočítáno před vykresleným oknem.
  • Prostory, exposé a cyklistika – Všechny definují, jak se okno chová v těchto 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 – určuje vzhled okna. Prozatím existuje jen jeden vzhled, Aqua.

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

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

Pokud chcete nastavit počáteční pozici okna a nastavit její velikost, přepněte na kontrolu velikosti:

The default size and location

Odsud můžete nastavit počáteční velikost okna, dát 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 hlavního kontroleru oken

Aby bylo možné vytvářet zásuvky a akce pro zveřejnění prvků uživatelského rozhraní kódu jazyka C#, bude aplikace Xamarin.Mac muset používat vlastní kontroler oken.

Postupujte následovně:

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

  2. NSWindowController Vyberte v návrhovém povrchu tlačítko.

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

    Setting the class name

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

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

    Selecting the windows controller

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

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

    Editing the WindowController.h file

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 povolení ovládacích prvků pomocí Tvůrce rozhraní najdete v naší dokumentaci k Xcode a Tvůrci rozhraní .

Jako příklad přetáhněte panel nástrojů z inspektoru knihovny do okna v editoru rozhraní:

Selecting a Toolbar from the Library

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

Adding a Text View

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

Editing constraints

Když kliknete na čtyři červené paprsky v horní části editoru a kliknete na Přidat 4 omezení, řekneme textovému zobrazení, aby se při změně velikosti okna vylepšoval nebo zmenšoval vodorovně a svisle.

Nakonec zpřístupňte textové zobrazení kódu pomocí zásuvky (nezapomeňte vybrat ViewController.h soubor):

Configuring an outlet

Uložte změny a vraťte se na Visual Studio pro Mac, abyste se mohli synchronizovat s Xcode.

Další informace o práci s zásuvkami a akcemi najdete v naší dokumentaci k zásuvkám a akcím .

Pracovní postup standardního okna

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

  1. Pro nová okna, která nejsou automaticky přidána do projektu, přidejte do projektu novou definici okna. Podrobněji se o tom budeme zabývat 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 naší dokumentace k práci s scénářem ).
  4. Nastavte všechny požadované vlastnosti okna v inspektoru atributů a nástrojiSize Inspector.
  5. Přetáhněte ovládací prvky potřebné k sestavení rozhraní a jejich konfiguraci v inspektoru atributů.
  6. Pomocí kontroly velikosti můžete zpracovat změnu velikosti prvků uživatelského rozhraní.
  7. Zpřístupnění prvků uživatelského rozhraní okna kódu jazyka C# prostřednictvím zásuvek a akcí
  8. Uložte změny a vraťte se na Visual Studio pro Mac, abyste se mohli synchronizovat s Xcode.

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

Zobrazení výchozího okna

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

An example window running

Vzhledem k tomu, že jsme změnili návrh výše uvedeného okna, teď obsahuje výchozí ovládací prvek Panel nástrojů a zobrazení textu . Následující část souboru Info.plist je zodpovědná za zobrazení tohoto okna:

Editing Info.plist

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

Kontroler zobrazení se automaticky přidá do projektu, který řídí zobrazenou hlavní Windows (spolu s primárním zobrazením). Je definován v ViewController.cs souboru a připojený k vlastníkovi souboru v Tvůrci rozhraní v nástroji Identity Inspector:

Setting the file's owner

Pro naše okno bychom chtěli, aby měl názevuntitled, kdy se poprvé otevře, abychom metodu ViewController.cs přepsali ViewWillAppear 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ě místo ViewDidLoad metody, protože zatímco zobrazení může být načteno do paměti, ještě není plně vytvořena instance. Přístup k Title vlastnosti v ViewDidLoad metodě získáme null výjimku, protože okno ještě není vytvořené a drátové připojení k vlastnosti.

Programové zavření okna

Může se stát, že budete chtít okno v aplikaci Xamarin.Mac programově zavřít, jinak než uživatel klikne na tlačítko Zavřít okno 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ý klikne na tlačítko Zavřít okna, a to tak, že tlačítko zvýrazníte a pak zavřete okno.

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 upozornění.

Příklad:

MyWindow.PerformClose(this);

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

Zavřít

Close Voláním metody objektu NSWindow není simulován uživatel, který klikne na tlačítko Zavřít okna, a to tak, že tlačítko zvýrazníte, jednoduše zavře okno.

Okno nemusí být viditelné, aby bylo 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 událost vyvolat WillClose .
  2. Nenapodobuje uživatele, který klikne na tlačítko Zavřít , a to tak, že tlačítko zvýrazníte.

Příklad:

MyWindow.Close();

Zavřete MyWindowNSWindow instanci.

Upravený obsah windows

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

A window with the modified marker

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

A save sheet being shown when the window is closed

Označení okna podle změny

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, aby uživatel zavřel okno a umožnil jim uložit upravený obsah předem, budete muset vytvořit podtřídu a přepsat jeho WindowShouldClose metoduNSWindowDelegate. 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
    }
}

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

// 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 obsahovat upravený obsah a umožnit uživateli uložit změny před ukončením. Uděláte to tak, že upravíte soubor, přepíšete AppDelegate.cs metodu ApplicationShouldTerminate a bude vypadat 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 více okny

Většina dokumentových aplikací pro Mac může současně upravovat více dokumentů. Textový editor může mít například otevřený více textových souborů pro úpravy najednou. Ve výchozím nastavení má nová aplikace Xamarin.Mac nabídku Soubor s novou položkou automaticky připojenou k newDocument: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 upravil více dokumentů.

AppDelegate.cs Upravte soubor a přidejte následující počí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í jeho 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:

A new untitled window was added

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

The windows menu

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í okno nejvyšší úrovně (okno klíče). Následující kód vrátí okno klíče:

var window = NSApplication.SharedApplication.KeyWindow;

Může se volat v libovolné třídě nebo metodě, které potřebují 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 aplikací

Může se stát, že budete potřebovat přístup ke všem okům, 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. Toto pole můžete iterovat, abyste získali přístup ke všem aktuálním oknám 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 testování hodnoty vlastní Path vlastnosti na cestu k souboru, který chce uživatel otevřít. Pokud je soubor již otevřený, přeneseme 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 okno zůstalo ve stejném umístění kvůli souřadnicovým systémům macOS.

Na rozdíl od iOS, kde levý horní roh představuje (0,0), macOS používá matematický souřadnicový systém, kde levý dolní roh obrazovky představuje (0,0). V iOSu se souřadnice zvyšují, když se posunete směrem dolů 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é

Když upravíte velikost a umístění oken v kódu, musíte se ujistit, že respektujete minimální a maximální velikosti, které jste nastavili v Tvůrci rozhraní. Nebude to automaticky dodrženo a vy budete moct okno zvětšit nebo zmenšit, než jsou tyto limity.

Monitorování změn velikosti okna

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:

The Identity Inspector

Dále upravte vlastní třídu kontroleru oken a sledujte DidResize událost v okně kontroleru, aby byla informována o změnách živé velikosti. 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, abyste byli DidEndLiveResize upozorněni jenom po dokončení změny 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 okna a reprezentovaných souborů

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 indikoval, že soubor byl změněn a měl by být uložen před zavřením.

Pojďme soubor upravit ViewController.cs a udělat 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é monitorujeme 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 v souboru. Pokud spustíme naši aplikaci a zadáme nějaký text, zobrazí se tečka:

A changed window

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

Displaying a save dialog

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 je to řetězec představující soubor, který se otevírá). Kromě toho můžete pomocí metody nastavit adresu URL souboru window.RepresentedUrl = url; .

Pokud adresa URL odkazuje na typ souboru známého 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:

An open dialog box

Zobrazí se soubor a název se nastaví ikonou souboru:

The contents of a file loaded

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 inspektorů.

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

  1. V Průzkumník řešení poklikejte na Main.storyboard soubor a otevřete ho pro úpravy v Tvůrci rozhraní Xcode.

  2. Přetáhněte nový ovladač okna z knihovny a přesuňte ho na návrhovou plochu:

    Selecting a new Window Controller in the Library

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

    Setting the storyboard ID

  4. Návrh rozhraní:

    Designing the UI

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

    Creating a segue

  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:

A sample preferences menu

Práce s panely

Jak je uvedeno na začátku tohoto článku, 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é.

Stejně jako jakýkoli jiný typ okna, se kterým vytváříte a pracujete v aplikaci Xamarin.Mac, je 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 Inspektoru atributů a Inspektoru velikosti.
  4. Přetáhněte ovládací prvky potřebné k sestavení rozhraní a konfiguraci v Inspektoru atributů.
  5. Pomocí Inspektoru velikosti 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 pro synchronizaci s Xcode.

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

The Attribute Inspector

  • 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 klíčové okno.
  • Modální režim dokumentu – Pokud je dokument modální, panel bude plovávat pouze nad okny aplikace, jinak se nad všemi plováky.

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

  1. V Průzkumník řešení klikněte pravým tlačítkem na Project a vyberte AddNew>File....

  2. V dialogovém okně Nový soubor vyberte okno Xamarin.MacCocoa>s řadičem:

    Adding a new window controller

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

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

    Editing the panel

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

    Deleting the existing window

  6. Připojte panel k souboruOwnerwindowOutlet - - :

    Dragging to wire up the panel

  7. Přepněte na Nástroj Identity Inspector a nastavte třídu panelu na DocumentPanel:

    Setting the panel's class

  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:

The panel in a running app

Důležité

Panel Windows 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 .

Souhrn

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#.