Přehled WPF Windows

Uživatelé pracují se samostatnými aplikacemi WPF (Windows Presentation Foundation) prostřednictvím oken. Primárním účelem okna je zobrazovat obsah, který vizualizuje data a umožňuje uživatelům pracovat s daty. Samostatné aplikace WPF poskytují vlastní okna pomocí Window třídy. Toto téma představuje Window před pokrytím základů vytváření a správy oken v samostatných aplikacích.

The Window – třída

Na následujícím obrázku jsou znázorněny jednotlivé části okna:

Okno je rozděleno na dvě oblasti: neklientskou a klientskou.

Neklientská oblast okna je implementována prostřednictvím WPF a zahrnuje části okna, které jsou společné pro většinu oken, včetně následujících:

• Ohraničení.

• Záhlaví.

• Ikona.

• Tlačítka Minimalizovat, Maximalizovat a Obnovit

• Tlačítko Zavřít

• Systémová nabídka s položkami nabídek, které uživatelům umožňují minimalizovat, maximalizovat, obnovit, přesunout, změnit velikost a zavřít okno.

Klientská oblast okna je oblast v rámci neklientské oblasti okna a slouží vývojářům k přidávání obsahu specifického pro aplikaci, například řádků nabídek, panelů nástrojů a ovládacích prvků.

Ve WPF je okno zapouzdřeno třídou Window, která slouží k následujícím účelům:

• Zobrazení okna

• Konfigurace velikosti, umístění a vzhledu okna

• Hostování obsahu specifického pro aplikaci

• Správa doby života okna

Implementace okna

Implementace typického okna se skládá z vzhledu i chování, kdy vzhled definuje, jak okno vypadá uživatelům a chování , jak s ním uživatelé pracují. V rámci WPF můžete vzhled a chování okna implementovat pomocí kódu nebo XAML kódu.

Obecně však platí, že vzhled okna je implementován pomocí XAML kódu a jeho chování je implementováno pomocí kódu na pozadí, jak je znázorněno v následujícím příkladu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  
  <!-- Client area (for content) -->
  
</Window>

using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub
    End Class
End Namespace

Aby spolu soubor s XAML kódem a soubor s kódem mohly spolupracovat, je třeba následující:

• V souboru s XAML kódem musí element Window obsahovat atribut x:Class. Při sestavení aplikace, existence x:Class v souboru značek způsobí, že microsoft build engine (MSBuild) vytvoří partial třídu, která je odvozena a Window má název, který je určen atributem x:Class . To vyžaduje přidání deklarace oboru názvů XML pro schéma XAML ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Vygenerovaná třída partial implementuje metodu InitializeComponent, která se volá za účelem registrace událostí a nastavení vlastností implementovaných v rámci XAML kódu.

• V kódu na pozadí musí být třída partial třídou se stejným názvem, který je uveden v atributu x:Class v XAML kódu, a musí být odvozena od třídy Window. To umožňuje, aby se soubor kódu za kódem přidružoval ke partial třídě, která je vygenerována pro soubor revizí při vytváření aplikace (viz Sestavení aplikace WPF).

• V kódu na pozadí musí třída Window implementovat konstruktor, který volá metodu InitializeComponent. Metoda InitializeComponent je implementována třídou partial vygenerovanou ze souboru s XAML kódem pro registraci událostí a nastavení vlastností, které jsou definovány v souboru s XAML kódem.

Po nastavení této konfigurace se můžete zaměřit na definování vzhledu okna v XAML kódu a implementaci jeho chování v kódu na pozadí. Následující příklad ukazuje okno s tlačítkem, implementovaným v kódu XAML a obslužnou rutinou události události události Click , která je implementována v kódu za sebou.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">
  <!-- Client area (for content) -->
  <Button Click="button_Click">Click This Button</Button>
</Window>

using System.Windows;

namespace SDKSample
{
    public partial class MarkupAndCodeBehindWindow : Window
    {
        public MarkupAndCodeBehindWindow()
        {
            InitializeComponent();
        }

        void button_Click(object sender, RoutedEventArgs e)
        {
            MessageBox.Show("Button was clicked.");
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class MarkupAndCodeBehindWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub button_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            MessageBox.Show("Button was clicked.")
        End Sub
    End Class
End Namespace

Konfigurace definice okna pro NÁSTROJ MSBuild

Způsob implementace okna určuje, jak je nakonfigurovaný pro nástroj MSBuild. Pro okno definované jak pomocí XAML kódu, tak pomocí kódu na pozadí:

• Soubory s XAML kódem jsou konfigurovány jako položky Page platformy MSBuild.

• Soubory s kódem na pozadí jsou konfigurovány jako položky Compile platformy MSBuild.

To je vidět v následujícím souboru projektu MSBuild.

<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ... >  
    ...  
    <Page Include="MarkupAndCodeBehindWindow.xaml" />  
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />  
    ...  
</Project>  

Informace o vytváření aplikací WPF naleznete v tématu Sestavení aplikace WPF.

Životnost okna

Stejně jako u jakékoli třídy má okno životnost, která začíná při prvním vytvoření instance, po kterém se otevře, aktivuje a deaktivuje a nakonec zavře.

Otevření okna

Pokud chcete otevřít okno, nejprve vytvoříte jeho instanci, což je znázorněno v následujícím příkladu.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    Startup="app_Startup">
</Application>

using System.Windows;
namespace SDKSample
{
    public partial class App : Application
    {
        void app_Startup(object sender, StartupEventArgs e)
        {
            // Create a window
            MarkupAndCodeBehindWindow window = new MarkupAndCodeBehindWindow();

            // Open a window
            window.Show();
        }
    }
}

V tomto příkladu se MarkupAndCodeBehindWindow vytvoří instance při spuštění aplikace, která nastane při Startup vyvolání události.

Když se vytvoří instance okna, automaticky se na něj přidá odkaz do seznamu oken spravovaných objektem Application (viz Application.Windows). Kromě toho první okno, které se má vytvořit instance, je ve výchozím nastavení nastaveno Application jako hlavní okno aplikace (viz Application.MainWindow).

Okno se nakonec otevře voláním Show metody. Výsledek se zobrazí na následujícím obrázku.

Okno otevřené voláním Show je bezmodální okno, což znamená, že aplikace funguje v režimu, který uživatelům umožňuje aktivovat jiná okna ve stejné aplikaci.

Když Show je volána, okno provádí inicializaci dříve, než se zobrazí vytvoření infrastruktury, která umožňuje přijímat uživatelský vstup. Při inicializaci okna je vyvolána událost SourceInitialized a okno je zobrazeno.

Jako zástupce můžete nastavit, StartupUri aby se při spuštění aplikace automaticky otevíralo první okno.

<Application
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.App"
    StartupUri="PlainWindow.xaml" />

Když se aplikace spustí, okno určené hodnotou StartupUri je otevřeno bez režimu; interně se okno otevře voláním jeho Show metody.

Vlastnictví okna

Okno otevřené pomocí Show metody nemá implicitní vztah s oknem, které ho vytvořilo. Uživatelé můžou interagovat s oběma okny nezávisle na druhém okně, což znamená, že některé okno může provést následující akce:

• Zakrýt druhé okno (pokud není u jednoho z oken nastavena vlastnost Topmost na true).

• Minimalizovat, maximalizovat a obnovit okno, aniž by to mělo vliv na druhé okno.

Některá okna vyžadují relaci s oknem, které je otevírá. Například aplikace integrovaného vývojového prostředí (IDE) může otevírat okna vlastností a nástrojů, jejichž typickým chováním je zakrytí okna, ze kterého byla tato nová okna vytvořena. Kromě toho by se taková okna měla vždy zavírat, minimalizovat, maximalizovat a obnovovat podle okna, ze kterého byla vytvořena. Takovou relaci lze vytvořit tak, že jedno okno bude vlastnit druhé, čehož se dosáhne nastavením vlastnosti Owner vlastněného okna s odkazem na okno vlastníka. To je ukázáno v následujícím příkladu.

// Create a window and make this window its owner
Window ownedWindow = new Window();
ownedWindow.Owner = this;
ownedWindow.Show();

' Create a window and make this window its owner
Dim ownedWindow As New Window()
ownedWindow.Owner = Me
ownedWindow.Show()

Po vytvoření vlastnictví:

• Vlastněné okno může odkazovat na okno vlastníka kontrolou hodnoty jeho vlastnosti Owner.

• Okno vlastníka může zjistit všechna okna, která vlastní, zkontrolováním hodnoty své vlastnosti. OwnedWindows.

Zabránění aktivaci okna

Existují scénáře, kdy by se okna neměla aktivovat, když se zobrazí, například okna konverzace v aplikaci typu Internet messenger nebo okna oznámení e-mailové aplikace.

Pokud má vaše aplikace okno, které by se nemělo při zobrazení aktivovat, můžete před prvním voláním metody Show nastavit jeho vlastnost ShowActivated na false. V důsledku toho:

• Okno není aktivováno.

• Událost okna Activated není vyvolána.

• Aktuálně aktivované okno zůstane aktivované.

Okno se však aktivuje, jakmile ho uživatel aktivuje kliknutím do klientské nebo neklientské oblasti. V tomto případě:

• Okno se aktivuje.

• Je vyvolána událost Activated okna.

• Dříve aktivované okno se deaktivuje.

• Události a Activated události okna Deactivated se následně v reakci na akce uživatelů vyvolají podle očekávání.

Aktivace okna

Když je okno poprvé otevřené, stane se aktivním oknem (pokud není zobrazeno s nastaveným ShowActivated nastavením false). Aktivní okno je okno, které aktuálně zaznamenává vstupy uživatele, například stisknutí kláves a kliknutí myší. Když se okno aktivuje, vyvolá událost Activated.

Po aktivování okna může uživatel aktivovat jiné okno ve stejné aplikaci nebo aktivovat jinou aplikaci. Jakmile k tomu dojde, aktuálně aktivní okno se deaktivuje a vyvolá událost Deactivated. Stejně tak když uživatel vybere aktuálně deaktivované okno, stane se toto okno opět aktivním a je vyvolána událost Activated.

Jedním z častých důvodů pro zpracování událostí Activated a Deactivated je povolení a zakázání funkce, která může být spuštěna pouze tehdy, když je okno aktivní. Některá okna například zobrazují interaktivní obsah, který vyžaduje neustálý vstup nebo pozornost uživatele, včetně her a přehrávačů videa. Následující příklad je zjednodušený přehrávač videa, který vám ukáže, jak události Activated a Deactivated zpracovávat a jak toto chování implementovat.

<Window
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.CustomMediaPlayerWindow"
    Activated="window_Activated"
    Deactivated="window_Deactivated">

    <!-- Media Player -->
    <MediaElement 
      Name="mediaElement" 
      Stretch="Fill" 
      LoadedBehavior="Manual" 
      Source="numbers.wmv" />

</Window>

using System;
using System.Windows;

namespace SDKSample
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow()
        {
            InitializeComponent();
        }

        void window_Activated(object sender, EventArgs e)
        {
            // Recommence playing media if window is activated
            this.mediaElement.Play();
        }

        void window_Deactivated(object sender, EventArgs e)
        {
            // Pause playing if media is being played and window is deactivated
            this.mediaElement.Pause();
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class CustomMediaPlayerWindow
        Inherits Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub window_Activated(ByVal sender As Object, ByVal e As EventArgs)
            ' Recommence playing media if window is activated
            Me.mediaElement.Play()
        End Sub

        Private Sub window_Deactivated(ByVal sender As Object, ByVal e As EventArgs)
            ' Pause playing if media is being played and window is deactivated
            Me.mediaElement.Pause()
        End Sub
    End Class
End Namespace

Po deaktivaci okna mohou jiné typy aplikací stále spouštět kód na pozadí. Poštovní klient může například pokračovat v dotazování poštovního serveru, zatímco uživatel používá jiné aplikace. Aplikace, jako jsou tyto, často poskytují jiné nebo další chování při deaktivaci hlavního okna. Pokud jde o poštovní program, může to znamenat přidání nové položky pošty do složky Doručená pošta a přidání ikony oznámení do hlavního panelu systému. Ikona oznámení se musí zobrazit jenom v případě, že okno pošty není aktivní, což je možné určit kontrolou IsActive vlastnosti.

Pokud se dokončí úloha na pozadí, okno může chtít uživatele upozornit naléhavěji voláním metody Activate. Pokud uživatel interaguje s jinou aplikací aktivovanou při volání metody Activate, začne blikat tlačítko okna na hlavním panelu. Pokud uživatel pracuje s aktuální aplikací, volání Activate přenese okno do popředí.

Zavření okna

Při zavření okna uživatelem začíná jeho životnost končit. Okno lze zavřít pomocí prvků v neklientské oblasti, včetně následujících:

• Položka Zavřít systémové nabídky.

• Stiskněte kombinaci kláves ALT+F4.

• Stisknutí tlačítka Zavřít.

Do klientské oblasti můžete poskytnout další mechanismy pro zavření okna, což je běžnější:

• Položka Ukončit v nabídce Soubor, obvykle pro hlavní okna aplikace.

• Položka Zavřít v nabídce Soubor, obvykle v sekundárním okně aplikace.

• Tlačítko Zrušit, obvykle v modálním dialogovém okně.

• Tlačítko Zavřít, obvykle v nemodálním dialogovém okně.

Pokud chcete zavřít okno v reakci na některý z těchto vlastních mechanismů, musíte volat metodu Close. Následující příklad implementuje možnost zavřít okno výběrem Exit v nabídce Soubor .

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.WindowWithFileExit">
  
  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>
  
</Window>

using System.Windows;

namespace SDKSample
{
    public partial class WindowWithFileExit : System.Windows.Window
    {
        public WindowWithFileExit()
        {
            InitializeComponent();
        }

        void fileExitMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Close this window
            this.Close();
        }
    }
}

Imports System.Windows

Namespace SDKSample
    Partial Public Class WindowWithFileExit
        Inherits System.Windows.Window
        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub fileExitMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
            ' Close this window
            Me.Close()
        End Sub
    End Class
End Namespace

Když se okno zavře, vyvolá dvě události: Closing a Closed.

Closing se vyvolá před zavřením okna a poskytuje mechanismus, kterým lze zavření okna zabránit. Jedním z častých důvodů, proč byste mohli chtít zabránit zavření okna, je případ, kdy jsou v obsahu okna upravená data. V takovém případě lze událost Closing zpracovat tak, aby se zjistilo, zda se jedná o neuložená data, a pokud ano, aby se uživateli zobrazil dotaz, zda se má pokračovat v zavírání okna bez uložení dat, nebo zda se má zavírání okna zrušit. V následujícím příkladu jsou popsány klíčové aspekty zpracování události Closing.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // window

namespace CSharp
{
    public partial class DataWindow : Window
    {
        // Is data dirty
        bool isDataDirty = false;

        public DataWindow()
        {
            InitializeComponent();
        }

        void documentTextBox_TextChanged(object sender, EventArgs e)
        {
            this.isDataDirty = true;
        }

        void DataWindow_Closing(object sender, CancelEventArgs e)
        {
            MessageBox.Show("Closing called");

            // If data is dirty, notify user and ask for a response
            if (this.isDataDirty)
            {
                string msg = "Data is dirty. Close without saving?";
                MessageBoxResult result =
                  MessageBox.Show(
                    msg,
                    "Data App",
                    MessageBoxButton.YesNo,
                    MessageBoxImage.Warning);
                if (result == MessageBoxResult.No)
                {
                    // If user doesn't want to close, cancel closure
                    e.Cancel = true;
                }
            }
        }
    }
}

Imports System ' EventArgs
Imports System.ComponentModel ' CancelEventArgs
Imports System.Windows ' window

Namespace VisualBasic
    Partial Public Class DataWindow
        Inherits Window
        ' Is data dirty
        Private isDataDirty As Boolean = False

        Public Sub New()
            InitializeComponent()
        End Sub

        Private Sub documentTextBox_TextChanged(ByVal sender As Object, ByVal e As EventArgs)
            Me.isDataDirty = True
        End Sub

        Private Sub DataWindow_Closing(ByVal sender As Object, ByVal e As CancelEventArgs)
            MessageBox.Show("Closing called")

            ' If data is dirty, notify user and ask for a response
            If Me.isDataDirty Then
                Dim msg As String = "Data is dirty. Close without saving?"
                Dim result As MessageBoxResult = MessageBox.Show(msg, "Data App", MessageBoxButton.YesNo, MessageBoxImage.Warning)
                If result = MessageBoxResult.No Then
                    ' If user doesn't want to close, cancel closure
                    e.Cancel = True
                End If
            End If
        End Sub
    End Class
End Namespace

Obslužné rutině události Closing je předán parametr CancelEventArgs implementující vlastnost BooleanCancel, kterou jste nastavili na true, aby se zabránilo zavření okna.

Pokud Closing se nezpracuje nebo se zpracuje, ale nezruší se, okno se zavře. Těsně před samotným zavření okna je vyvolána událost Closed. V tomto okamžiku nelze zabránit zavření okna.

Okno lze sice explicitně zavřít pomocí mechanismů dostupných v klientské a neklientské oblasti, lze ho však zavřít i implicitně v důsledku chování v jiných částech aplikace nebo systému Windows, včetně následujících případů:

• Uživatel se odhlásí nebo vypne systém Windows.

• Vlastník okna se zavře (viz).Owner

• Zavře se hlavní okno aplikace ShutdownMode a je OnMainWindowClose.

• Volá se Shutdown.

Události doby života okna

Následující obrázek znázorňuje posloupnost hlavních událostí v průběhu doby života okna:

Následující obrázek znázorňuje posloupnost hlavních událostí v průběhu doby života okna, které se zobrazuje bez aktivace (ShowActivated je před zobrazením okna nastaveno na false):

Umístění okna

Když je okno otevřené, má své umístění definované rozměry X a Y vzhledem k ploše. Toto umístění lze určit kontrolou vlastností Left a Top. Tyto vlastnosti můžete nastavit tak, aby se změnilo umístění okna.

Můžete také zadat počáteční umístění, když se Window poprvé zobrazí, nastavením vlastnosti WindowStartupLocation na jednu z následujících hodnot výčtu WindowStartupLocation:

• CenterOwner (výchozí)

• CenterScreen

• Manual

Pokud je spouštěcí umístění zadáno jako Manuala Left vlastnosti nebyly Top nastaveny, vyzve systém Windows, Window aby se zobrazilo umístění.

Nejobsáhlé windows a pořadí Z

Kromě pozice X a Y má okno také pozici v rozměru Z, která určuje jeho vertikální pozici vůči ostatním oknům. To se označuje jako pořadí Z okna a existují dva typy: normální pořadí Z a nejhornější pořadí Z. Umístění okna v normálním pořadí vykreslování je určeno, jestli je aktuálně aktivní nebo ne. Ve výchozím nastavení má okno normální pořadí Z. Umístění okna v nejvyšší objednávce z je také určeno, jestli je aktuálně aktivní nebo ne. Kromě toho jsou okna v případě nejhornějšího pořadí Z vždy umístěna nad okny v normálním pořadí Z. Okno se nachází v nejhornějším pořadí Z na základě nastavení jeho vlastnosti Topmost na true.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    Topmost="True">
</Window>

V každém pořadí vykreslování se aktuálně aktivní okno zobrazí nad všemi ostatními okny ve stejném pořadí vykreslování.

Velikost okna

Kromě umístění na ploše má okno velikost, která je určena několika vlastnostmi, včetně různých vlastností šířky a výšky a SizeToContent.

MinWidth, Widtha MaxWidth slouží ke správě rozsahu šířek, které okno může mít během své životnosti, a jsou nakonfigurované, jak je znázorněno v následujícím příkladu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinWidth="300" Width="400" MaxWidth="500">
</Window>

Výška okna se spravuje pomocí MinHeighta HeightMaxHeighta konfigurují se tak, jak je znázorněno v následujícím příkladu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    MinHeight="300" Height="400" MaxHeight="500">
</Window>

Vzhledem k tomu, že různé hodnoty šířky a výšky každé určují rozsah, je možné, aby šířka a výška okna s možností změny velikosti byla kdekoli v zadaném rozsahu pro příslušnou dimenzi. Chcete-li zjistit aktuální šířku a výšku, zkontrolujte vlastnosti ActualWidth a ActualHeight v uvedeném pořadí.

Pokud chcete, aby šířka a výška okna měly velikost odpovídající velikosti obsahu okna, můžete použít vlastnost SizeToContent, která má následující hodnoty:

• Manual. Nemá žádný vliv (výchozí nastavení).

• Width. Přizpůsobení šířce obsahu, což má stejný vliv jako nastavení jak vlastnosti MinWidth, tak vlastnosti MaxWidth na šířku obsahu.

• Height. Přizpůsobení výšce obsahu, což má stejný vliv jako nastavení jak vlastnosti MinHeight, tak vlastnosti MaxHeight na výšku obsahu.

• WidthAndHeight. Přizpůsobení šířce a výšce obsahu, což má stejný vliv jako nastavení jak vlastnosti MinHeight, tak vlastnosti MaxHeight na výšku obsahu a nastavení jak vlastnosti MinWidth, tak vlastnosti MaxWidth na šířku obsahu.

Následující příklad ukazuje okno, jehož velikost se při prvním zobrazení automaticky přizpůsobí jeho obsahu, a to jak svisle, tak vodorovně.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    SizeToContent="WidthAndHeight">
</Window>

Následující příklad ukazuje, jak nastavit vlastnost SizeToContent v kódu, aby se určilo, jak se velikost okna přizpůsobí jeho obsahu.

// Manually alter window height and width
this.SizeToContent = SizeToContent.Manual;

// Automatically resize width relative to content
this.SizeToContent = SizeToContent.Width;

// Automatically resize height relative to content
this.SizeToContent = SizeToContent.Height;

// Automatically resize height and width relative to content
this.SizeToContent = SizeToContent.WidthAndHeight;

' Manually alter window height and width
Me.SizeToContent = SizeToContent.Manual

' Automatically resize width relative to content
Me.SizeToContent = SizeToContent.Width

' Automatically resize height relative to content
Me.SizeToContent = SizeToContent.Height

' Automatically resize height and width relative to content
Me.SizeToContent = SizeToContent.WidthAndHeight

Pořadí priorit pro vlastnosti velikosti

Různé vlastnosti velikosti okna v principu definují rozsah šířky a výšky okna, jehož velikost lze měnit. Aby bylo zajištěno zachování platného rozsahu, Window vyhodnocuje hodnoty vlastností velikosti podle následujícího pořadí priority.

Pro vlastnosti výšky:

1. FrameworkElement.MinHeight

2. FrameworkElement.MaxHeight

3. SizeToContent.Height/SizeToContent.WidthAndHeight

4. FrameworkElement.Height

Pro vlastnosti šířky:

1. FrameworkElement.MinWidth

2. FrameworkElement.MaxWidth

3. SizeToContent.Width/SizeToContent.WidthAndHeight

4. FrameworkElement.Width

Pořadí priorit může také určit velikost okna při maximalizaci, která se spravuje pomocí WindowState vlastnosti.

Stav okna

Okno, jehož velikost lze měnit, může mít v průběhu své doby života tři stavy: normální, minimalizované a maximalizované. Výchozím stavem okna je okno s normálním stavem. Okno s tímto stavem umožňuje uživateli přesunout ho a změnit jeho velikost pomocí úchytu pro změnu velikosti nebo ohraničení, pokud je možné změnit velikost.

Okno s minimalizovaným stavem se sbalí na tlačítko hlavního panelu, pokud ShowInTaskbar je nastavené na true; v opačném případě se sbalí na nejmenší možnou velikost, může být a přemísťuje se do levého dolního rohu plochy. Velikost žádného z typů minimalizovaných oken nelze měnit přetažením okraje ani úchytu pro změnu velikosti, přestože lze minimalizované okno, které se nezobrazuje na hlavním panelu, přetahovat po ploše.

Okno s maximalizovaným stavem se rozšíří na maximální možnou velikost, která bude pouze tak velká, jak určují hodnoty jeho vlastností MaxWidth, MaxHeight a SizeToContent. Stejně jako minimalizované okno nelze změnit velikost maximalizovaného okna přetažením úchytu nebo přetažením ohraničení.

Stav okna lze konfigurovat nastavením jeho vlastnosti WindowState, která může mít jednu z následujících hodnot výčtu WindowState:

• Normal (výchozí)

• Maximized

• Minimized

Následující příklad ukazuje, jak vytvořit okno, které se po otevření zobrazí jako maximalizované.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowState="Maximized">
</Window>

Obecně byste měli nakonfigurovat počáteční stav okna nastavením vlastnosti WindowState. Po zobrazení okna s možností změny velikosti mohou uživatelé změnit stav okna stisknutím tlačítek Minimalizovat, Maximalizovat a Obnovit v záhlaví okna.

Vzhled okna

Vzhled klientské oblasti okna můžete změnit přidáním obsahu specifického pro dané okno, například tlačítek, popisků a textových polí. Pokud chcete nakonfigurovat neklientskou oblast, Window nabízí několik vlastností, jako je Icon pro nastavení ikony okna a Title pro nastavení jeho názvu.

Vzhled a chování okraje neklientské oblasti můžete změnit také nakonfigurováním režimu změny velikosti okna, stylu okna a toho, jestli se zobrazí jako tlačítko na hlavním panelu plochy.

Režim změny velikosti

V závislosti na WindowStyle vlastnosti můžete určit, jak (a jestli) uživatelé můžou změnit velikost okna. Volba stylu okna má vliv na to, jestli uživatel může změnit velikost okna přetažením jeho ohraničení myší, jestli se tlačítka Minimalizovat, Maximalizovat a Změnit velikost zobrazí v oblasti, která není klientská, a pokud se zobrazí, jestli jsou povolená.

Způsob změny velikosti okna můžete nakonfigurovat nastavením jeho vlastnosti ResizeMode, která může mít jednu z následujících hodnot výčtu ResizeMode:

• NoResize

• CanMinimize

• CanResize (výchozí)

• CanResizeWithGrip

Stejně jako v případě WindowStyle se ani režim změny velikosti okna v průběhu doby jeho života pravděpodobně nezmění, což znamená, že ho s největší pravděpodobností nastavíte pomocí XAML kódu.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ResizeMode="CanResizeWithGrip">
</Window>

To, zda je okno maximalizované, minimalizované nebo obnovené, můžete zjistit kontrolou vlastnosti WindowState.

Styl okna

Okraj, který je zobrazen z neklientské oblasti okna, je vhodný pro většinu aplikací. V závislosti na typu okna jsou však za určitých okolností zapotřebí různé typy okrajů nebo nejsou zapotřebí žádné.

Pokud chcete určit, jaký typ okraje bude okno mít, nastavíte pro jeho vlastnost WindowStyle jednu z následujících hodnot výčtu WindowStyle:

• None

• SingleBorderWindow (výchozí)

• ThreeDBorderWindow

• ToolWindow

Efekt těchto stylů oken je znázorněn na následujícím obrázku:

Můžete nastavit WindowStyle buď kód XAML, nebo kód, protože se pravděpodobně během životnosti okna nezmění, pravděpodobně ho nakonfigurujete pomocí značek XAML.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="ToolWindow">
</Window>

Styl okna bez obdélníku

Existují také situace, kdy styly ohraničení, které WindowStyle vám umožní, nejsou dostatečné. Můžete například chtít vytvořit aplikaci s neobdélníkovým okrajem, jaký používá například přehrávač Microsoft Windows Media Player.

Představte si například okno bublin řeči zobrazené na následujícím obrázku:

Tento typ okna lze vytvořit nastavením vlastnosti WindowStyle na None a použitím speciální podpory, kterou má Window pro průhlednost.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    WindowStyle="None"
    AllowsTransparency="True"
    Background="Transparent">
</Window>

Tato kombinace hodnot dává okně pokyn, aby se vykresloval zcela průhledně. V tomto stavu nelze použít doplňky oblasti bez klienta okna (nabídka Zavřít, minimalizovat, maximalizovat a obnovit tlačítka atd.). V důsledku toho musíte zadat vlastní.

Stav hlavního panelu

Výchozí vzhled okna obsahuje tlačítko hlavního panelu, podobně jako na následujícím obrázku:

Některé typy oken nemají tlačítko hlavního panelu, například pole zpráv a dialogová okna (viz Přehled dialogových oken). Nastavením vlastnostitrue (ve výchozím nastavení) můžete určit, jestli se tlačítko hlavního panelu pro okno zobrazujeShowInTaskbar.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    ShowInTaskbar="False">
</Window>

Aspekty zabezpečení

Window vyžaduje UnmanagedCode vytvoření instance oprávnění zabezpečení. U aplikací nainstalovaných na místním počítači a jejich spuštění spadá do sady oprávnění udělených aplikaci.

To však spadá mimo sadu oprávnění udělených aplikacím spuštěným z zóny Internetu nebo místního intranetu pomocí Technologie ClickOnce. Uživatelé proto obdrží upozornění zabezpečení ClickOnce a budou muset zvýšit oprávnění nastavená pro aplikaci na úplný vztah důvěryhodnosti.

Kromě toho XBAPs ve výchozím nastavení nemůžou zobrazovat okna ani dialogová okna. Diskuzi o aspektech zabezpečení samostatných aplikací najdete v tématu Strategie zabezpečení WPF – Zabezpečení platformy.

Další typy windows

NavigationWindow je okno, které je určeno k hostování obsahu s možností navigace. Další informace najdete v tématu Přehled navigace).

Dialogová okna jsou okna, která se často používají ke shromažďování informací od uživatele za účelem provedení určité funkce. Například když chce uživatel otevřít soubor, zobrazí se obvykle dialogové okno Otevřít soubor aplikací, aby získala název souboru od uživatele. Další informace naleznete v tématu Přehled dialogových oken.

Viz také

• Window
• MessageBox
• NavigationWindow
• Application
• Přehled dialogových oken
• Sestavení aplikace WPF