Sdílet prostřednictvím

Přehled oken WPF

Uživatelé interagují s aplikacemi WPF (Windows Presentation Foundation) prostřednictvím oken. Primárním účelem okna je hostovat obsah, který vizualizuje data a umožňuje uživatelům pracovat s daty. Aplikace WPF poskytují svá vlastní okna prostřednictvím třídy Window. Tento článek představuje Window a následně se věnuje základům vytváření a správy oken v aplikacích.

Důležité

Tento článek používá kód XAML vygenerovaný z projektu C#. Pokud používáte Visual Basic, může XAML vypadat trochu jinak. Tyto rozdíly se obvykle vyskytují u hodnot atributů x:Class. Jazyk C# obsahuje kořenový obor názvů projektu, zatímco Visual Basic nikoli.

Šablony projektu pro jazyk C# vytvářejí typ App obsažený v souboru app.xaml. V jazyce Visual Basic má typ název Application a soubor má název Application.xaml.

Třída Window

Ve WPF je okno zapouzdřeno Window třídou, kterou používáte k provedení následujících kroků:

  • Zobrazení okna
  • Nakonfigurujte velikost, umístění a vzhled okna.
  • Hostování obsahu specifického pro aplikaci
  • Umožňuje spravovat dobu života okna.

Následující obrázek znázorňuje základní části okna:

Snímek obrazovky zobrazující části okna WPF

Okno je rozděleno do dvou oblastí: neklientská oblast a oblast klienta.

WPF implementuje neklientskou oblast okna, která zahrnuje části společné pro většinu oken, včetně následujících:

  • Záhlaví (1 až 5)
  • Ikona (1)
  • Název (2)
  • Tlačítka Minimalizovat (3), Maximalizovat (4) a Zavřít (5)
  • Systémová nabídka (6) s položkami nabídky Zobrazí se při kliknutí na ikonu (1)
  • Okraj (7)

Oblast klienta okna je oblast v oblasti, která není klientem okna, a používá ji vývojáři k přidání obsahu specifického pro aplikaci, jako jsou pruhy nabídek, panely nástrojů a ovládací prvky.

  • Klientská oblast (8)
  • Úchyt pro změnu velikosti (9) Tento ovládací prvek je přidán do klientské oblasti (8).

Implementace okna

Implementace typického okna zahrnuje vzhled i chování, přičemž vzhled definuje, jak okno vypadá pro uživatele, a chování definuje způsob, jakým okno funguje, když s ním uživatelé pracují. Ve WPF můžete implementovat vzhled a chování okna pomocí kódu nebo kódu XAML.

Obecně se ale vzhled okna implementuje pomocí kódu XAML a jeho chování se implementuje pomocí kódu na pozadí, jak je znázorněno v následujícím příkladu.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

</Window>

Následující kód je kód na pozadí pro XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }
    }
}

Public Class Window1

End Class

Pokud chcete povolit spolupráci XAML souboru s označovacím jazykem a souboru s kódem na pozadí, jsou požadovány následující věci:

  • V kódu musí prvek Window obsahovat atribut x:Class. Při sestavování aplikace způsobí existence atributu x:Class, že nástroj MSBuild (Microsoft Build Engine) vygeneruje třídu partial odvozenou od třídy Window s názvem, 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á partial třída implementuje InitializeComponent metodu, která je volána k registraci událostí a nastavení vlastností implementovaných v kódu.

  • V kódu na pozadí musí být třída partial třídou se stejným názvem, který je určen atributem x:Class ve značkovacím jazyce, a musí dědit z Window. To umožňuje přiřadit soubor s kódem na pozadí ke třídě partial, která je vygenerována pro soubor s XAML kódem při sestavování aplikace. Další informace naleznete v části Kompilace aplikace WPF.

  • V kódu na pozadí musí třída Window implementovat konstruktor, který volá metodu InitializeComponent. InitializeComponent je implementována vygenerovanou třídou partial souboru značkování pro registraci událostí a nastavení vlastností definovaných ve značkování.

Poznámka:

Když do svého projektu pomocí sady Visual Studio přidáte nový Window, Window se implementuje pomocí značky i kódu na pozadí a zahrnuje potřebnou konfiguraci k vytvoření asociace mezi značkou a soubory s kódem na pozadí, jak je popsáno zde.

S touto konfigurací se můžete zaměřit na definování vzhledu okna v kódu XAML a implementaci jeho chování v kódu. V následujícím příkladu je zobrazeno okno s tlačítkem, které definuje obslužnou rutinu události pro událost Click. To je implementováno v XAML a obslužná rutina je implementována v kódu na pozadí.

<Window x:Class="WindowsOverview.Window1"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
        xmlns:local="clr-namespace:WindowsOverview"
        >

    <!-- Client area containing the content of the window -->

    <Button Click="Button_Click">Click This Button</Button>

</Window>

Následující kód je kód na pozadí pro XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class Window1 : Window
    {
        public Window1()
        {
            InitializeComponent();
        }

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

Public Class Window1

    Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
        MessageBox.Show("Button was clicked.")
    End Sub

End Class

Konfigurace okna pro Microsoft Build Engine

Způsob implementace okna určuje způsob jeho konfigurace pro MSBuild (Microsoft Build Engine). Pro okno, které je definováno pomocí XAML značkování i kódu:

  • Soubory značek XAML jsou nakonfigurovány jako položky MSBuild Page.
  • Soubory za kódem jsou nakonfigurované jako položky nástroje MSBuild Compile.

Projekty sady .NET SDK automaticky importují správné Page a Compile položky za vás a nemusíte je deklarovat. Když je projekt nakonfigurován pro WPF, soubory s XAML kódem se automaticky importují jako položky Page a odpovídající soubor s kódem na pozadí se importuje jako Compile.

Projekty MSBuild neimportují automaticky typy. Musíte je deklarovat sami:

<Project>
    ...
    <Page Include="MarkupAndCodeBehindWindow.xaml" />
    <Compile Include=" MarkupAndCodeBehindWindow.xaml.cs" />
    ...
</Project>

Informace o sestavování aplikací WPF naleznete v části Kompilace aplikace WPF.

Doba života okna

Stejně jako každá jiná třída má i okno svou životnost, která začíná při vytvoření jeho první instance, po níž je otevřeno, aktivováno/deaktivováno a nakonec zavřeno.

Otevření okna

Pokud chcete otevřít okno, musíte nejprve vytvořit jeho instanci, což je vidět na následujícím příkladu:

using System.Windows;

namespace WindowsOverview
{
    public partial class App : Application
    {
        private void Application_Startup(object sender, StartupEventArgs e)
        {
            // Create the window
            Window1 window = new Window1();

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

Class Application

    Private Sub Application_Startup(sender As Object, e As StartupEventArgs)
        ' Create the window
        Dim window As New Window1

        ' Open the window
        window.Show()
    End Sub

End Class

V tomto příkladu je vytvořena instance Window1 při spuštění aplikace, k čemuž dojde při vyvolání události Startup. Další informace o spouštěcím okně najdete v tématu Jak získat nebo nastavit hlavní okno aplikace.

Při vytvoření instance okna je odkaz na něj automaticky přidán do seznamu oken, který je spravován objektem Application. První okno, jehož instance má být vytvořena, automaticky nastaví Application jako hlavní okno aplikace.

Okno se nakonec otevře voláním metody Show, jak je znázorněno na následujícím obrázku:

Okno WPF s jedním tlačítkem uvnitř s textem

Okno otevřené voláním Show je nemodální okno a aplikace nebrání uživatelům v interakci s jinými okny v aplikaci. Otevření okna pomocí ShowDialog otevře okno jako modální a zabrání interakci uživatele s konkrétním oknem. Další informace naleznete v tématu Přehled dialogových oken.

Při volání Show se před zobrazením okna provedou inicializační operace, aby se vytvořila infrastruktura, která mu umožní přijímat vstupy od uživatele. Při inicializaci okna se vyvolá událost SourceInitialized a zobrazí se okno.

Další informace najdete v tématu Jak otevřít okno nebo dialogové okno.

Spouštěcí okno

V předchozím příkladu byl pomocí události Startup spuštěn kód, který zobrazil úvodní okno aplikace. Místo toho můžete jako zkratku zadat cestu k souboru XAML v aplikaci pomocí StartupUri. Aplikace automaticky vytvoří a zobrazí okno určené touto vlastností.

<Application x:Class="WindowsOverview.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             xmlns:local="clr-namespace:WindowsOverview"
             StartupUri="ClippedWindow.xaml">
    <Application.Resources>
         
    </Application.Resources>
</Application>

Vlastnictví okna

Okno otevřené pomocí metody Show nemá implicitní relaci s oknem, které ho vytvořilo. Uživatelé mohou pracovat s oběma okny nezávisle na sobě, což znamená, že v obou oknech lze provádět následující činnosti:

  • Zakryjte ostatní (pokud některá z oken nemá vlastnost Topmost nastavenou na true).
  • Minimalizovat, maximalizovat a obnovit lze, aniž by to mělo vliv na ostatní.

Některá okna vyžadují relaci s oknem, které je otevře. Například aplikace integrovaného vývojového prostředí (IDE) může otevřít okna vlastností a okna nástrojů, jejichž typické chování je pokrytí okna, které je vytvoří. Kromě toho by se tato okna měla vždy zavřít, minimalizovat, maximalizovat a obnovit v souladu s oknem, které je vytvořilo. Takovou relaci lze vytvořit tak, že jedno okno bude vlastnit druhé, čehož se dosáhne nastavením vlastnosti Ownervlastněného okna s odkazem na okno vlastníka. To je znázorněno v následujícím příkladu.

private void Button_Click(object sender, RoutedEventArgs e)
{
    // Create a window and make the current window its owner
    var ownedWindow = new ChildWindow1();
    ownedWindow.Owner = this;
    ownedWindow.Show();
}

Private Sub Button_Click(sender As Object, e As RoutedEventArgs)
    ' Create a window and make the current window its owner
    Dim ownedWindow As New ChildWindow1
    ownedWindow.Owner = Me
    ownedWindow.Show()
End Sub

Po vytvoření vlastnictví:

  • Vlastní okno může odkazovat na okno vlastníka kontrolou hodnoty vlastnosti Owner.
  • Okno vlastníka může zjistit všechna okna, která vlastní, kontrolou hodnoty své vlastnosti OwnedWindows.

Aktivace okna

Když se okno poprvé otevře, stane se aktivním oknem. aktivní okno je okno, které aktuálně zaznamenává vstup uživatele, například stisknutí kláves a kliknutí myší. Když se okno aktivuje, vyvolá událost Activated.

Poznámka:

Při prvním otevření okna se události Loaded a ContentRendered vyvolá až po vyvolání události Activated. S ohledem na to lze okno efektivně považovat za otevřené, když je ContentRendered vyvolána.

Po aktivaci okna může uživatel aktivovat jiné okno ve stejné aplikaci nebo aktivovat jinou aplikaci. Když k tomu dojde, aktivní okno se deaktivuje a vyvolá Deactivated událost. Podobně když uživatel vybere aktuálně deaktivované okno, okno se znovu aktivuje a Activated se vyvolá.

Jedním z běžných důvodů, proč zpracovávat Activated a Deactivated, je povolit a zakázat funkce, které se dají spustit jenom v době, kdy je okno aktivní. Některá okna například zobrazují interaktivní obsah, který vyžaduje konstantní vstup uživatele nebo pozornost, včetně her a přehrávačů videa. Následující příklad je zjednodušený video přehrávač, který ukazuje, jak zpracovat Activated a Deactivated, tak aby se implementovalo toto chování.

<Window x:Class="WindowsOverview.CustomMediaPlayerWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Activated="Window_Activated"
        Deactivated="Window_Deactivated"
        Title="CustomMediaPlayerWindow" Height="450" Width="800">
    <Grid>
        <MediaElement x:Name="mediaElement" Stretch="Fill"
                      LoadedBehavior="Manual" Source="numbers.mp4" />
    </Grid>
</Window>

Následující kód je kód na pozadí pro XAML.

using System;
using System.Windows;

namespace WindowsOverview
{
    public partial class CustomMediaPlayerWindow : Window
    {
        public CustomMediaPlayerWindow() =>
            InitializeComponent();

        private void Window_Activated(object sender, EventArgs e)
        {
            // Continue playing media if window is activated
            mediaElement.Play();
        }

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

Public Class CustomMediaPlayerWindow
    Private Sub Window_Activated(sender As Object, e As EventArgs)
        ' Continue playing media if window Is activated
        mediaElement.Play()
    End Sub

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

Jiné typy aplikací můžou při deaktivaci okna dál 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. Takové aplikace často v době, kdy je hlavní okno deaktivováno, vykazují odlišné nebo dodatečné chování. V případě poštovního programu to může znamenat jak přidání nové položky pošty do složky doručené pošty, tak přidání ikony oznámení do oznamovací oblasti systému. Oznamovací ikona se musí zobrazit až tehdy, když okno pošty není aktivní, což se zjistí kontrolou vlastnosti IsActive.

Pokud se úloha na pozadí dokončí, okno může uživatele informovat naléhavěji voláním Activate metody. Pokud uživatel pracuje s jinou aplikací aktivovanou při zavolání Activate, tlačítko hlavního panelu okna bliká. Pokud však uživatel interaguje s aktuální aplikací, volání Activate přenese okno do popředí.

Poznámka:

Aktivaci rozsahu aplikace můžete zpracovat pomocí Application.Activated a Application.Deactivated událostí.

Zabránění aktivaci okna

Existují situace, kdy by se okna neměla při zobrazení aktivovat, například okna konverzace v aplikaci pro chat nebo okna oznámení v e-mailové aplikaci.

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

  • Okno se neaktivuje.
  • Není vyvolána událost Activated okna.
  • Aktuálně aktivované okno zůstane aktivní.

Okno se stane aktivním, jakmile ho uživatel aktivuje kliknutím na klientskou nebo neklientskou oblast. V tomto případě:

  • Okno je aktivováno.
  • Událost okna Activated je vyvolána.
  • Dříve aktivované okno se deaktivuje.
  • V reakci na akce uživatele jsou pak podle očekávání vyvolány události Deactivated a Activated okna.

Zavření okna

Život okna začíná docházet na konec, když ho uživatel zavře. Jakmile je okno zavřeno, nelze ho již znovu otevřít. Okno lze zavřít pomocí prvků v oblasti, která není klientem, včetně následujících:

  • Položka Zavřít nabídky systému .
  • Stisknutí kláves ALT + F4.
  • Stisknutí tlačítka Zavřít.
  • Stisknutí klávesy ESC, když je pro tlačítko v modálním okně nastavena vlastnost IsCancel na true.

Pro klientskou oblast můžete nastavit více mechanismů pro zavření okna, z nichž nejběžnější jsou následující:

  • Položka Ukončit v nabídce souboru , obvykle pro hlavní okna aplikací.
  • Položka Zavřít v nabídce Soubor, typicky v sekundárním okně aplikace.
  • Tlačítko Zrušit, obvykle na modálním dialogovém okně.
  • Tlačítko Zavřít, obvykle v nemodálním dialogovém okně.

Pokud chcete okno zavřít v reakci na některý z těchto vlastních mechanismů, musíte volat metodu Close. Následující příklad implementuje schopnost zavřít okno zvolením možnosti Ukončit z nabídky Soubor.

<Window x:Class="WindowsOverview.ClosingWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClosingWindow" Height="450" Width="800">
    <StackPanel>
        <Menu>
            <MenuItem Header="_File">
                <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
            </MenuItem>
        </Menu>
    </StackPanel>
</Window>

Následující kód je kód na pozadí pro XAML.

using System.Windows;

namespace WindowsOverview
{
    public partial class ClosingWindow : Window
    {
        public ClosingWindow() =>
            InitializeComponent();

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

Public Class ClosingWindow
    Private Sub fileExitMenuItem_Click(sender As Object, e As RoutedEventArgs)
        ' Close the current window
        Me.Close()
    End Sub
End Class

Poznámka:

Aplikaci je možné nakonfigurovat tak, aby se automaticky vypnula, když se zavře hlavní okno aplikace (viz MainWindow) nebo se zavře poslední okno. Další informace najdete v tématu ShutdownMode.

I když je možné okno explicitně uzavřít prostřednictvím mechanismů poskytovaných v jiných klientských a klientských oblastech, okno může být implicitně uzavřeno také v důsledku chování v jiných částech aplikace nebo Windows, včetně následujících:

Důležité

Okno nelze po zavření znovu otevřít.

Zrušení zavření okna

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

Closing je vyvolána před zavřením okna a poskytuje mechanismus, kterým lze zabránit uzavření okna. Jedním z běžných důvodů, proč zabránit zavření okna, je, že obsah okna obsahuje upravená data. V této situaci lze Closing událost zpracovat, aby se zjistilo, jestli jsou data zašpiněná, a pokud ano, požádejte uživatele, zda má pokračovat v zavření okna bez uložení dat nebo zrušení uzavření okna. Následující příklad ukazuje klíčové aspekty zpracování Closing.

<Window x:Class="WindowsOverview.DataWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="DataWindow" Height="450" Width="800"
        Closing="Window_Closing">
    <Grid>
        <TextBox x:Name="documentTextBox" TextChanged="documentTextBox_TextChanged" />
    </Grid>
</Window>

Následující kód je kód na pozadí pro XAML.

using System.Windows;
using System.Windows.Controls;

namespace WindowsOverview
{
    public partial class DataWindow : Window
    {
        private bool _isDataDirty;

        public DataWindow() =>
            InitializeComponent();

        private void documentTextBox_TextChanged(object sender, TextChangedEventArgs e) =>
            _isDataDirty = true;

        private void Window_Closing(object sender, System.ComponentModel.CancelEventArgs e)
        {
            // If data is dirty, prompt user and ask for a response
            if (_isDataDirty)
            {
                var result = MessageBox.Show("Document has changed. Close without saving?",
                                             "Question",
                                             MessageBoxButton.YesNo);

                // User doesn't want to close, cancel closure
                if (result == MessageBoxResult.No)
                    e.Cancel = true;
            }
        }
    }
}

Public Class DataWindow

    Private _isDataDirty As Boolean

    Private Sub documentTextBox_TextChanged(sender As Object, e As TextChangedEventArgs)
        _isDataDirty = True
    End Sub

    Private Sub Window_Closing(sender As Object, e As ComponentModel.CancelEventArgs)

        ' If data is dirty, prompt user and ask for a response
        If _isDataDirty Then
            Dim result = MessageBox.Show("Document has changed. Close without saving?",
                                         "Question",
                                         MessageBoxButton.YesNo)

            ' User doesn't want to close, cancel closure
            If result = MessageBoxResult.No Then
                e.Cancel = True
            End If
        End If

    End Sub
End Class

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

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

Události v průběhu doby života okna

Následující obrázek znázorňuje posloupnost hlavních událostí v době životnosti okna:

Diagram zobrazující události v průběhu doby života okna

Následující obrázek znázorňuje posloupnost hlavních událostí v době životnosti okna, které se zobrazuje bez aktivace (ShowActivated je nastavena na false před zobrazením okna):

Diagram zobrazující události v průběhu doby života okna bez aktivace

Umístění okna

Když je okno otevřené, má polohu v osách x a y vzhledem k ploše. Toto umístění lze určit kontrolou vlastností Left a Top. Nastavením těchto vlastností můžete změnit umístění okna.

Můžete také určit počáteční umístění Window při prvním zobrazení nastavením vlastnosti WindowStartupLocation s jednou z následujících hodnot výčtu WindowStartupLocation:

Pokud je spouštěcí umístění zadáno jako Manual a nejsou nastaveny vlastnosti Left a Top, Window požádá operační systém o umístění, ve kterém se má zobrazit.

Nejhornější okna a pořadí Z

Kromě umístění x a y má okno také umístění v rozměru z, které určuje jeho svislou polohu s ohledem na ostatní okna. 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 případě normálního pořadí Z je určeno tím, zda je okno právě aktivní, nebo ne. Ve výchozím nastavení se okno nachází v normálním z-pořadí vykreslování. Umístění okna v případě nejhornějšího pořadí Z je také určeno tím, zda je okno právě aktivní, nebo ne. Kromě toho jsou okna v nejvyšším z-řádu vždy umístěna nad okny v normálním z-řádu. Okno je umístěno do nejvyššího z-řádu nastavením jeho vlastnosti Topmost na true.

V rámci každého typu pořadí Z se aktuálně aktivní okno zobrazuje nad všemi ostatními okny ve stejném pořadí Z.

Velikost okna

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

MinWidth, Widtha MaxWidth a slouží ke správě rozsahu šířek, které může mít okno během své doby života.

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

Výška okna je spravována prostřednictvím vlastností MinHeight,Height a MaxHeight.

<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 určují určitý rozsah, je možné, aby šířka a výška okna s možností změny velikosti byla kdekoli v rámci určeného rozsahu pro příslušný rozměr. Chcete-li zjistit jeho aktuální šířku a výšku, zkontrolujte ActualWidth a ActualHeightv uvedeném pořadí.

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

Následující příklad ukazuje okno, které automaticky přizpůsobí jeho obsah svisle i vodorovně při prvním zobrazení.

<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 tak, aby určovala způsob, jakým se okno přizpůsobuje svému 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 velikostí

V podstatě se vlastnosti různých velikostí okna kombinují, aby definovaly rozsah šířky a výšky pro přizpůsobitelné okno. Pokud chcete zajistit zachování platného rozsahu, Window vyhodnotí hodnoty vlastností velikosti pomocí následujících pořadí priorit.

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čovat velikost okna při jeho maximalizaci, která se spravuje pomocí vlastnosti WindowState.

Stav okna

Během životnosti okna s možností změny velikosti může mít tři stavy: normální, minimalizované a maximalizované. Okno s normálním stavem je výchozím stavem okna. Okno s tímto stavem umožňuje uživateli okno přesouvat a měnit jeho velikost pomocí úchytu pro změnu velikosti nebo přetažením okraje (pokud je možné měnit jeho velikost).

Pokud má okno v minimalizovaném stavu nastavenu vlastnost ShowInTaskbar na hodnotu true, sbalí se na tlačítko na hlavním panelu, jinak se sbalí na nejmenší možnou velikost a přesune se do levého dolního rohu plochy. Žádný typ minimalizovaného okna nelze změnit pomocí ohraničení nebo úchytu pro změnu velikosti, i když minimalizované okno, které se nezobrazuje na hlavním panelu, lze přetáhnout po ploše.

Okno ve stavu maximalizovaném se rozšíří na maximální velikost, které může dosáhnout, což bude přesně tak velké, jak jeho vlastnosti MaxWidth, MaxHeighta SizeToContent dovolí. Stejně jako u minimalizovaného okna nelze ani u maximalizovaného okna měnit velikost pomocí úchytu pro změnu velikosti ani přetažením okraje.

Poznámka:

Hodnoty Top, Left, Widtha Height vlastností okna vždy představují hodnoty pro normální stav, i když je okno aktuálně maximalizované nebo minimalizované.

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

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

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

Obecně byste měli nastavit WindowState tak, aby nakonfigurovali počáteční stav okna. 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 změníte přidáním obsahu specifického pro okno, jako jsou tlačítka, popisky a textová pole. Pokud chcete nakonfigurovat oblast, která není klientem, Window poskytuje několik vlastností, mezi které patří Icon k nastavení ikony okna a Title nastavit její název.

Vzhled a chování ohraničení mimo klientskou oblast můžete také změnit tak, že nakonfigurujete režim změny velikosti okna, styl okna a to, jestli se zobrazí jako tlačítko na hlavním panelu plochy.

Režim změny velikosti

V závislosti na vlastnosti WindowStyle můžete ovlivnit, zda a jak budou uživatelé moci měnit velikost okna. Styl okna má vliv na následující nastavení:

  • Povolení nebo zakázání změny velikosti přetažením okraje okna myší.
  • Určuje, jestli se tlačítka Minimalizovat, Maximalizovat a Zavřít zobrazí v neklientské oblasti.
  • Určuje, jestli jsou povolena tlačítka Minimalizovat, Maximalizovat a Zavřít.

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

Stejně jako u WindowStylese režim změny velikosti okna pravděpodobně během jeho životnosti nezmění, což znamená, že ho pravděpodobně nastavíte z kódu XAML.

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

Všimněte si, že pomocí kontroly vlastnosti WindowState můžete zjistit, jestli je okno maximalizované, minimalizované nebo obnovené.

Styl okna

Hraniční čára viditelná z neklientské oblasti okna je vhodná pro většinu aplikací. Existují však okolnosti, kdy jsou potřeba různé typy ohraničení nebo nejsou vůbec potřeba žádné ohraničení v závislosti na typu okna.

Chcete-li kontrolovat, jaký typ ohraničení okno získá, vlastnost WindowStyle nastavte pomocí jedné z následujících hodnot výčtu WindowStyle.

Na následujícím obrázku je znázorněn výsledek použití stylu okna:

Snímek obrazovky, který ukazuje, jaký vliv má vlastnost WindowStyle na okno v rámci WPF

Všimněte si, že na obrázku výše není patrný žádný znatelný rozdíl mezi SingleBorderWindow a ThreeDBorderWindow. V systému Windows XP ovlivňovala vlastnost ThreeDBorderWindow způsob vykreslování okna přidáním 3D okraje do klientské oblasti. Od systému Windows 7 jsou rozdíly mezi oběma styly minimální.

WindowStyle můžete nastavit pomocí kódu nebo XAML kódu. Vzhledem k tomu, že je nepravděpodobné, že by se v průběhu doby života okna změnila, budete ji s největší pravděpodobností konfigurovat pomocí XAML kódu.

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

Neobdélníkový styl okna

Existují také situace, kdy styly okrajů, které vlastnost WindowStyle umožňuje mít, nejsou dostatečné. Můžete například chtít vytvořit aplikaci s neúúhledovým ohraničením, jako je microsoft Windows Media Player.

Podívejte se na příklad okna s řečovou bublinou, které vidíte na následujícím obrázku:

Snímek obrazovky okna WPF s oříznutou oblastí a vlastním tvarem

Tento typ okna lze vytvořit nastavením vlastnosti WindowStyle na Nonea využitím speciální podpory, kterou Window nabízí pro transparentnost.

<Window x:Class="WindowsOverview.ClippedWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="ClippedWindow" SizeToContent="WidthAndHeight"
        WindowStyle="None" AllowsTransparency="True" Background="Transparent">
    <Grid Margin="20">
        <Grid.RowDefinitions>
            <RowDefinition Height="*"/>
            <RowDefinition Height="20"/>
        </Grid.RowDefinitions>

        <Rectangle Stroke="#FF000000" RadiusX="10" RadiusY="10"/>
        <Path Fill="White" Stretch="Fill" Stroke="#FF000000" HorizontalAlignment="Left" Margin="15,-5.597,0,-0.003" Width="30" Grid.Row="1" Data="M22.166642,154.45381 L29.999666,187.66699 40.791059,154.54395"/>
        <Rectangle Fill="White" RadiusX="10" RadiusY="10" Margin="1"/>
        
        <TextBlock HorizontalAlignment="Left" VerticalAlignment="Center" FontSize="25" Text="Greetings!" TextWrapping="Wrap" Margin="5,5,50,5"/>
        <Button HorizontalAlignment="Right" VerticalAlignment="Top" Background="Transparent" BorderBrush="{x:Null}" Foreground="Red" Content="❌" FontSize="15" />

        <Grid.Effect>
            <DropShadowEffect BlurRadius="10" ShadowDepth="3" Color="LightBlue"/>
        </Grid.Effect>
    </Grid>
</Window>

Tato kombinace hodnot dává oknu pokyn k průhlednému vykreslení. V tomto stavu nelze použít ozdobná tlačítka okna, která nejsou v klientské oblasti, a musíte zadat vlastní.

Přítomnost hlavního panelu

Výchozí vzhled okna zahrnuje tlačítko na hlavním panelu. Některé typy oken nemají tlačítko na hlavním panelu, například okna zpráv, dialogová okna nebo okna s vlastností WindowStyle nastavenou na ToolWindow. Nastavením vlastnosti ShowInTaskbar, která má ve výchozím nastavení hodnotu true, můžete ovlivnit, jestli se tlačítko zobrazí na hlavním panelu okna.

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

Další typy oken

NavigationWindow je okno, které je určeno k zobrazení navigovatelného obsahu.

Dialogová okna jsou okna, která se často používají ke shromažďování informací od uživatele k dokončení funkce. Když chce například uživatel otevřít soubor, zobrazí aplikace dialogové okno Otevřít soubor, aby od uživatele získala název souboru. Další informace naleznete v tématu Přehled dialogových oken.

Viz také