Przegląd Okna WPF

Użytkownicy korzystają z autonomicznych aplikacji programu Windows Presentation Foundation (WPF) za pośrednictwem systemu Windows. Głównym celem okna jest hostowanie zawartości, która wizualizuje dane i umożliwia użytkownikom interakcję z danymi. Autonomiczne aplikacje WPF udostępniają własne okna przy użyciu Window klasy . W tym temacie Window przedstawiono przed omówieniem podstaw tworzenia okien autonomicznych i zarządzania nimi.

Uwaga

Aplikacje WPF hostowane w przeglądarce, w tym aplikacje przeglądarki XAML (XBAPs) i luźne strony extensible Application Markup Language (XAML), nie udostępniają własnych okien. Zamiast tego są one hostowane w oknach udostępnianych przez program Windows Internet Explorer. Zobacz Omówienie aplikacji przeglądarki WPF XAML.

Klasa okna

Na poniższej ilustracji przedstawiono części składowe okna:

Okno jest podzielone na dwa obszary: obszar niekliencki i obszar klienta.

Obszar niekliencki okna jest implementowany przez platformę WPF i obejmuje części okna, które są wspólne dla większości okien, w tym następujące elementy:

• Obramowanie.

• Pasek tytułu.

• Ikona.

• Przyciski Minimalizuj, Maksymalizuj i Przywróć.

• Przycisk Zamknij.

• Menu System z elementami menu, które pozwalają użytkownikom zminimalizować, zmaksymalizować, przywrócić, przenieść, zmienić rozmiar i zamknąć okno.

Obszar klienta okna to obszar w obrębie obszaru nieklienckiego okna i jest używany przez deweloperów do dodawania zawartości specyficznej dla aplikacji, takiej jak paski menu, paski narzędzi i kontrolki.

W programie WPF okno jest hermetyzowane przez klasę Window używaną do wykonywania następujących czynności:

• Wyświetlanie okna.

• Konfigurowanie rozmiaru, położenia i wyglądu okna.

• Hostowanie zawartości specyficznej dla aplikacji.

• Zarządzanie okresem istnienia okna.

Implementowanie okna

Implementacja typowego okna składa się zarówno z wyglądu, jak i zachowania, w którym wygląd definiuje sposób, w jaki okno wygląda dla użytkowników i zachowanie definiuje sposób działania okna w miarę interakcji z nim przez użytkowników. Na platformie WPF można zaimplementować wygląd i zachowanie okna przy użyciu kodu lub znaczników XAML.

Jednak na ogół wygląd okna jest implementowany przy użyciu znaczników XAML, a jego zachowanie jest implementowane przy użyciu pliku codebehind, jak pokazano w poniższym przykładzie.

<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 umożliwić współdziałanie pliku znaczników XAML i pliku związanego z kodem, wymagane są następujące elementy:

• W znacznikach element Window musi zawierać atrybut x:Class. Gdy aplikacja jest kompilowana, istnienie x:Class w pliku znaczników powoduje, że aparat microsoft build engine (MSBuild) tworzy klasę partial , która pochodzi z Window i ma nazwę określoną przez x:Class atrybut . Wymaga to dodania deklaracji przestrzeni nazw XML dla schematu XAML ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). Wygenerowana klasa partial implementuje metodę InitializeComponent, która jest wywoływana w celu zarejestrowania zdarzeń i ustawienia właściwości implementowanych w znacznikach.

• W pliku codebehind klasa musi być klasą partial o tej samej nazwie, która jest określona przez atrybut x:Class w znacznikach, i musi pochodzić z klasy Window. Dzięki temu plik za kodem może być skojarzony z klasą partial , która jest generowana dla pliku znaczników podczas kompilowania aplikacji (zobacz Tworzenie aplikacji WPF).

• W pliku codebehind klasa Window musi zaimplementować konstruktora, który wywołuje metodę InitializeComponent. Metoda InitializeComponent jest implementowana przez wygenerowaną klasę partial pliku znaczników w celu rejestrowania zdarzeń i ustawiania właściwości zdefiniowanych w znacznikach.

Uwaga

Po dodaniu nowej klasy Window do projektu przy użyciu programu Visual Studio klasa Window jest implementowana przy użyciu zarówno znaczników, jak i pliku codebehind, oraz zawiera niezbędną konfigurację do utworzenia skojarzenia między znacznikami i plikami związanymi z kodem zgodnie z opisem w tym miejscu.

Dzięki tej konfiguracji można skupić się na zdefiniowaniu wyglądu okna w znacznikach XAML i zaimplementowaniu jego zachowania w pliku codebehind. W poniższym przykładzie pokazano okno z przyciskiem zaimplementowanym w znaczników XAML i procedurą obsługi zdarzeń dla zdarzenia przycisku Click zaimplementowanego w kodzie.

<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

Konfigurowanie definicji okna dla programu MSBuild

Sposób implementacji okna określa, jak jest on skonfigurowany dla programu MSBuild. W przypadku okna zdefiniowanego przy użyciu znaczników XAML i pliku codebehind:

• Pliki znaczników XAML są konfigurowane jako elementy Page programu MSBuild.

• Pliki związane z kodem są konfigurowane jako elementy Compile programu MSBuild.

Jest to pokazane w poniższym pliku projektu MSBuild.

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

Aby uzyskać informacje na temat kompilowania aplikacji WPF, zobacz Tworzenie aplikacji WPF.

Okres istnienia okna

Podobnie jak w przypadku każdej klasy, okno ma okres istnienia, który rozpoczyna się po pierwszym utworzeniu wystąpienia, po którym jest otwierany, aktywowany i dezaktywowany, i ostatecznie zamknięty.

Otwieranie okna

Aby otworzyć okno, należy najpierw utworzyć wystąpienie, które pokazano w poniższym przykładzie.

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

W tym przykładzie MarkupAndCodeBehindWindow wystąpienie obiektu jest tworzone po uruchomieniu aplikacji, co występuje po wystąpieniu Startup zdarzenia.

Po utworzeniu wystąpienia okna odwołanie do niego jest automatycznie dodawane do listy okien zarządzanych przez Application obiekt (zobacz Application.Windows). Ponadto pierwsze okno, które ma zostać utworzone, jest domyślnie ustawione Application jako główne okno aplikacji (zobacz Application.MainWindow).

Okno zostanie ostatecznie otwarte przez wywołanie Show metody . Wynik zostanie wyświetlony na poniższej ilustracji.

Okno otwierane przez wywołanie Show to okno bez moderowania, co oznacza, że aplikacja działa w trybie, który umożliwia użytkownikom aktywowanie innych okien w tej samej aplikacji.

Uwaga

ShowDialog jest wywoływana w celu otwierania okien, takich jak okna dialogowe modalnie. Aby uzyskać więcej informacji, zobacz Omówienie okien dialogowych.

Po Show wywołaniu okno wykonuje pracę inicjalizaliza przed wyświetleniem w celu ustanowienia infrastruktury, która umożliwia odbieranie danych wejściowych użytkownika. Po zainicjowaniu okna zostanie wywołane zdarzenie SourceInitialized i zostanie wyświetlone okno.

Jako skrót można ustawić, aby określić pierwsze okno, StartupUri które jest otwierane automatycznie po uruchomieniu aplikacji.

<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" />

Po uruchomieniu aplikacji okno określone przez wartość StartupUri jest otwierane trybowo; wewnętrznie okno jest otwierane przez wywołanie jego Show metody.

Własność okna

Okno otwierane przy użyciu Show metody nie ma niejawnej relacji z utworzonym oknem. Użytkownicy mogą korzystać z dowolnego okna niezależnie od drugiego, co oznacza, że jedno z okien może wykonać następujące czynności:

• Zakrywanie drugiego (chyba że jedno z okien ma dla właściwości Topmost ustawioną wartość true).

• Być minimalizowane, maksymalizowane i przywracane bez wywierania wpływu na drugie.

Niektóre okna wymagają relacji z oknem, które je otwiera. Na przykład aplikacja zintegrowanego środowiska projektowego (IDE) może otwierać okna właściwości i okna narzędzi, a ich typowym zachowaniem jest zakrywanie okna, które je utworzyło. Ponadto takie okna powinny zawsze być zamykane, minimalizowane, maksymalizowane i przywracane w połączeniu z oknem, które je utworzyło. Taką relację można ustanowić, przez uczynienie jednego okna właścicielem innego okna. Osiągane jest to przez ustawienie właściwości Owner okna posiadanego z odwołaniem do okna będącego właścicielem. Jest to pokazane w następującym przykładzie.

// 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 ustanowieniu własności:

• Okno posiadane może odwoływać się do okna będącego jego właścicielem przez sprawdzenie wartości jego właściwości Owner.

• Okno będące właścicielem może odnajdować wszystkie okna, których jest właścicielem, przez sprawdzenie wartości jego właściwości OwnedWindows.

Zapobieganie aktywacji okien

Istnieją scenariusze, w których okna nie powinny być aktywowane po wyświetleniu, takie jak okna konwersacji aplikacji w stylu komunikatora internetowego lub okna powiadomień aplikacji poczty e-mail.

Jeśli aplikacja ma okno, które nie powinno być uaktywniane po jego wyświetleniu, można ustawić dla jej właściwości ShowActivated wartość false przed wywołaniem metody Show po raz pierwszy. W konsekwencji:

• Okno nie jest aktywowane.

• Zdarzenie okna nie jest wywoływane Activated .

• Obecnie uaktywnione okno pozostaje uaktywnione.

Okno zostanie uaktywnione, jednak dopiero gdy uaktywni je użytkownik przez kliknięcie obszaru klienta lub nieklienckiego. W takim przypadku:

• Okno jest uaktywnione.

• Zdarzenie okna Activated jest wywoływane.

• Okno uaktywnione wcześniej jest dezaktywowane.

• Zdarzenia i Activated okna Deactivated są następnie zgłaszane zgodnie z oczekiwaniami w odpowiedzi na akcje użytkownika.

Aktywacja okna

Po pierwszym otwarciu okna staje się ono aktywnym oknem (chyba że jest ono wyświetlane z ustawionym ShowActivated ustawieniem false). Okno aktywne to okno, które obecnie przechwytuje dane wejściowe użytkownika, takie jak naciśnięcia klawiszy i kliknięcia myszy. Gdy okno stanie się aktywne, wywołuje zdarzenie Activated.

Uwaga

Po pierwszym otwarciu okna zdarzenia Loaded i ContentRendered są wywoływane dopiero po wywołaniu zdarzenia Activated. Mając to na uwadze, okno może być uznawane za otwarte, gdy zostanie wywołane zdarzenie ContentRendered.

Gdy okno stanie się aktywne, użytkownik może aktywować inne okno w tej samej aplikacji lub aktywować inną aplikację. W takim przypadku obecnie aktywne okno zostanie zdezaktywowane i wywoła zdarzenie Deactivated. Podobnie, gdy użytkownik wybierze obecnie dezaktywowane okno, okno stanie się ponownie aktywne i zostanie wywołane zdarzenie Activated.

Jednym z typowych powodów obsługi zdarzeń Activated i Deactivated jest włączenie i wyłączenie funkcji, która może być uruchamiana tylko wtedy, gdy okno jest aktywne. Na przykład niektóre okna wyświetlają interaktywną zawartość, która wymaga stałego wprowadzania danych przez użytkownika lub jego uwagi, takie jak gry i odtwarzacze wideo. Poniższy przykład to uproszczony odtwarzacz wideo, który pokazuje, jak obsługiwać zdarzenia Activated i Deactivated w celu zaimplementowania tego zachowania.

<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

Inne typy aplikacji mogą nadal uruchamiać kod w tle po dezaktywacji okna. Na przykład klient poczty może kontynuować sondowanie serwera poczty, gdy użytkownik korzysta z innych aplikacji. Aplikacje takie jak te często zapewniają różne lub dodatkowe zachowanie podczas dezaktywowania okna głównego. W odniesieniu do programu poczty może to oznaczać zarówno dodanie nowego elementu poczty do skrzynki odbiorczej, jak i dodanie ikony powiadomienia do paska zadań systemowych. Ikona powiadomienia musi być wyświetlana tylko wtedy, gdy okno poczty nie jest aktywne, co można określić, sprawdzając IsActive właściwość.

Jeśli zadanie w tle zakończy się, okno może wysłać do użytkownika bardziej pilne powiadomienie przez wywołanie metody Activate. Jeśli użytkownik wchodzi w interakcję z inną aplikacją uaktywnioną po wywołaniu zdarzenia Activate, przycisk paska zadań okna miga. Jeśli użytkownik wchodzi w interakcję z bieżącą aplikacją, wywołanie Activate spowoduje przełączenie okna na pierwszy plan.

Uwaga

Aktywację w zakresie aplikacji można obsługiwać przy użyciu zdarzeń Application.Activated i Application.Deactivated.

Zamykanie okna

Okres życia okna zaczyna zbliżać się do końca po zamknięciu go przez użytkownika. Okno można zamknąć przy użyciu elementów w obszarze nieklienckim, takich jak poniższe:

• Element Zamknij menu System.

• Naciśnij klawisze ALT+F4.

• Naciśnięcie przycisku Zamknij.

Możesz udostępnić dodatkowe mechanizmy dla obszaru klienta, aby zamknąć okno, z których częściej są następujące:

• Element Zakończ w menu Plik, zwykle w przypadku głównych okien aplikacji.

• Element Zamknij w menu Plik, zwykle w pomocniczym oknie aplikacji.

• Przycisk Anuluj, zwykle w modalnym oknie dialogowym.

• Przycisk Zamknij, zwykle w niemodalnym oknie dialogowym.

Aby zamknąć okno w reakcji na jeden z tych mechanizmów niestandardowych, należy wywołać metodę Close. Poniższy przykład implementuje możliwość zamknięcia okna, wybierając polecenie Zakończ w menu Plik .

<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

Gdy okno zostanie zamknięte, wywołuje dwa zdarzenia: Closing i Closed.

Zdarzenie Closing jest wywoływane przed zamknięciem okna i zapewnia mechanizm, za pomocą którego można zapobiec zamknięciu okna. Jedną z typowych przyczyn zapobiegania zamykaniu okna jest to, że zawartość okna zawiera zmodyfikowane dane. W takiej sytuacji można obsłużyć zdarzenie Closing w celu ustalenia, czy dane są zanieczyszczone, a jeśli tak, do zapytania użytkownika, czy kontynuować zamykanie okna bez zapisywania danych, czy anulować zamknięcie okna. W poniższym przykładzie przedstawiono kluczowe aspekty obsługi zdarzenia 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

Do obsługi zdarzeń Closing jest przekazywany element CancelEventArgs implementujący właściwość BooleanCancel, dla której ustawiono wartość true, aby zapobiegać zamknięciu okna.

Jeśli Closing nie jest obsługiwana lub jest obsługiwana, ale nie jest anulowana, okno zostanie zamknięte. Tuż przed zamknięciem okna zostanie wywołane zdarzenie Closed. W tym momencie nie można zapobiec zamknięciu okna.

Uwaga

Aplikację można skonfigurować tak, aby była automatycznie zamykana po zamknięciu głównego okna aplikacji (zobacz MainWindow) lub zamknięciu ostatniego okna. Aby uzyskać szczegółowe informacje, zobacz ShutdownMode.

Chociaż okno można jawnie zamknąć za pomocą mechanizmów udostępnianych w obszarach klienta i nieklienckich, okno może również zostać niejawnie zamknięte w wyniku zachowania w innych częściach aplikacji lub systemu Windows, w tym następujących:

• Użytkownik wylogował się lub zamknął system Windows.

• Właściciel okna zostanie zamknięty (zobacz Owner).

• Zamknięto główne okno aplikacji i atrybut ShutdownMode ma wartość OnMainWindowClose.

• Wywołano metodę Shutdown.

Uwaga

Nie można ponownie otworzyć okna po jego zamknięciu.

Zdarzenia okresu istnienia okna

Poniższa ilustracja przedstawia sekwencję głównych zdarzeń w okresie istnienia okna:

Poniższa ilustracja przedstawia sekwencję głównych zdarzeń w okresie istnienia okna, które jest wyświetlane bez aktywacji (dla właściwości ShowActivated ustawiono wartość false przed wyświetleniem okna):

Lokalizacja okna

Gdy okno jest otwarte, ma lokalizację w wymiarach X i Y względem pulpitu. Tę lokalizację można ustalić, sprawdzając odpowiednio właściwości Left i Top. Możesz ustawić te właściwości, aby zmienić lokalizację okna.

Możesz również określić początkową lokalizację obiektu Window po jego wyświetleniu po raz pierwszy, ustawiając dla właściwości WindowStartupLocation jedną z następujących wartości wyliczenia WindowStartupLocation:

• CenterOwner (domyślne)

• CenterScreen

• Manual

Jeśli lokalizacja uruchamiania jest określona jako Manual, a Left właściwości i Top nie zostały ustawione, Window zostanie wyświetlony monit systemu Windows o wyświetlenie lokalizacji.

Najważniejsze okna i kolejność Z

Oprócz lokalizacji w wymiarach X i Y okno ma również lokalizację w wymiarze Z, który określa jego położenie pionowe w odniesieniu do innych okien. Jest to nazywane porządkiem osi Z okna i istnieją jego dwa typy: normalny i najwyżej w hierarchii. Lokalizacja okna w normalnym porządku z jest określana przez to, czy jest obecnie aktywny, czy nie. Domyślnie okno znajduje się w normalnym porządku osi Z. Lokalizacja okna w najbardziej najwyższej kolejności z jest również określana przez to, czy jest obecnie aktywny, czy nie. Ponadto okna w najwyższym w hierarchii porządku osi Z są zawsze umieszczone nad oknami w normalnym porządku wzdłuż osi Z. Okno jest umieszczane w najwyższym w hierarchii porządku osi Z po ustawieniu dla jego właściwości Topmost wartości true.

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

W każdej kolejności z aktualnie aktywne okno jest wyświetlane powyżej wszystkich innych okien w tej samej kolejności z.

Rozmiar okna

Oprócz lokalizacji na pulpicie okno ma rozmiar, który jest określany przez kilka właściwości, w tym różne właściwości szerokości i wysokości oraz SizeToContent.

MinWidth, Widthi MaxWidth są używane do zarządzania zakresem szerokości, które okno może mieć w okresie jego istnienia i są skonfigurowane, jak pokazano w poniższym przykładzie.

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

Wysokość okna jest zarządzana przez MinHeightwartości , Heighti MaxHeighti są skonfigurowane, jak pokazano w poniższym przykładzie.

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

Ponieważ poszczególne wartości szerokości i wysokości określają zakres, istnieje możliwość, że szerokość i wysokość okna z możliwością zmiany rozmiaru mogą znajdować się w dowolnym miejscu w określonym zakresie dla odpowiedniego wymiaru. Aby wykryć bieżącą szerokość i wysokość, sprawdź odpowiednio właściwości ActualWidth i ActualHeight.

Jeśli chcesz, aby szerokość i wysokość okna miały rozmiar pasujący do rozmiaru zawartości okna, możesz użyć właściwości SizeToContent, która ma następujące wartości:

• Manual. Brak efektu (wartość domyślna).

• Width. Dopasuj do szerokości zawartości, co ma taki sam efekt jak ustawienie zarówno właściwości MinWidth, jak i MaxWidth na szerokość zawartości.

• Height. Dopasuj do wysokości zawartości, co ma taki sam efekt jak ustawienie zarówno właściwości MinHeight, jak i MaxHeight na wysokość zawartości.

• WidthAndHeight. Dopasuj do szerokości i wysokości zawartości, co ma taki sam efekt jak ustawienie zarówno właściwości MinHeight, jak i MaxHeight na wysokość zawartości, oraz ustawienie zarówno właściwości MinWidth, jak i MaxWidth na szerokość zawartości.

W poniższym przykładzie pokazano okno, które automatycznie dopasowuje rozmiar do zawartości, zarówno w pionie, jak i w poziomie, gdy jest wyświetlane po raz pierwszy.

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

W poniższym przykładzie pokazano, jak ustawić właściwość SizeToContent w kodzie, aby określić sposób zmieniania rozmiaru okna w celu dopasowania go do jego zawartości.

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

Kolejność pierwszeństwa dla właściwości ustalania rozmiaru

Zasadniczo różne właściwości rozmiarów okna łączą się w celu zdefiniowania zakresu szerokości i wysokości dla okna, którego rozmiar można zmieniać. Aby zapewnić utrzymanie prawidłowego zakresu, obiekt Window oblicza wartości właściwości rozmiaru przy użyciu następujących kolejności pierwszeństwa.

W przypadku właściwości wysokości:

1. FrameworkElement.MinHeight

2. FrameworkElement.MaxHeight

3. SizeToContent.Height/SizeToContent.WidthAndHeight

4. FrameworkElement.Height

W przypadku właściwości szerokości:

1. FrameworkElement.MinWidth

2. FrameworkElement.MaxWidth

3. SizeToContent.Width/SizeToContent.WidthAndHeight

4. FrameworkElement.Width

Kolejność pierwszeństwa może również określać rozmiar okna, gdy jest zmaksymalizowany, który jest zarządzany za WindowState pomocą właściwości .

Stan okna

W okresie istnienia okno z możliwością zmiany rozmiaru może mieć trzy stany: normalne, zminimalizowane i zmaksymalizowane. Okno w stanie normalnym to domyślny stan okna. Okno o tym stanie umożliwia użytkownikowi przenoszenie i zmienianie jego rozmiaru przy użyciu uchwytu zmiany rozmiaru lub obramowania, jeśli jest możliwe do zmiany rozmiaru.

Okno z zminimalizowanym stanem zwija się do przycisku paska zadań, jeśli ShowInTaskbar jest ustawione truena ; w przeciwnym razie zwija się do najmniejszego możliwego rozmiaru może być i przenosi się do lewego dolnego rogu pulpitu. Nie można zmienić rozmiaru okna zminimalizowanego przy użyciu obramowania ani uchwytu zmiany rozmiaru, chociaż zminimalizowane okno, które nie jest wyświetlane na pasku zadań, można przeciągać po pulpicie.

Okno w stanie zmaksymalizowanym jest rozszerzone do maksymalnego rozmiaru, jaki może przyjąć, czyli będzie mieć maksymalnie takie rozmiary, na które zezwalają jego właściwości MaxWidth, MaxHeight i SizeToContent. Podobnie jak w przypadku zminimalizowanego okna, zmaksymalizowane okno nie może być zmieniane przy użyciu uchwytu zmiany rozmiaru ani przeciągania obramowania.

Uwaga

Wartości właściwości Top, Left, Width i Height okna zawsze reprezentują wartości stanu normalnego, nawet jeśli okno jest obecnie zmaksymalizowane lub zminimalizowane.

Stan okna można skonfigurować, ustawiając jego właściwość WindowState, która może mieć jedną z następujących wartości wyliczenia WindowState:

• Normal (domyślne)

• Maximized

• Minimized

W poniższym przykładzie pokazano, jak utworzyć okno, które po otwarciu jest wyświetlane jako zmaksymalizowane.

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

Na ogół należy ustawić właściwość WindowState w celu skonfigurowania początkowego stanu okna. Gdy zostanie wyświetlone okno z możliwością zmiany rozmiaru, użytkownicy mogą naciskać przyciski minimalizuj, maksymalizuj i przywróć na pasku tytułu okna, aby zmienić stan okna.

Wygląd okna

Wygląd obszaru klienta okna można zmienić, dodając do niego zawartość specyficzną dla okna, taką jak przyciski, etykiety i pola tekstowe. W celu skonfigurowania obszaru nieklienckiego klasa Window udostępnia kilka właściwości, które obejmują Icon do ustawiania ikony okna i Title do ustawiania jego tytułu.

Możesz również zmienić wygląd i zachowanie obramowania obszaru nieklienckiego, konfigurując tryb zmiany rozmiaru okna, styl okna i to, czy jest ono wyświetlane jako przycisk na pasku zadań pulpitu.

Tryb zmiany rozmiaru

W zależności WindowStyle od właściwości można kontrolować, jak (i jeśli) użytkownicy mogą zmieniać rozmiar okna. Wybór stylu okna ma wpływ na to, czy użytkownik może zmienić rozmiar okna, przeciągając obramowanie myszą, czy przyciski Minimalizuj, Maksymalizuj i Zmień rozmiar są wyświetlane w obszarze niekliencką, a jeśli tak się stanie, czy są włączone.

Możesz skonfigurować sposób zmieniania rozmiaru okna, ustawiając jego właściwość ResizeMode, która może być jedną z następujących wartości wyliczenia ResizeMode:

• NoResize

• CanMinimize

• CanResize (domyślne)

• CanResizeWithGrip

Podobnie jak w przypadku elementu WindowStylemało prawdopodobna jest modyfikacja trybu zmiany rozmiaru okna w okresie jego istnienia, co oznacza, że najprawdopodobniej będzie on ustawiany na podstawie znaczników XAML.

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

Pamiętaj, że możesz wykryć, czy okno jest zmaksymalizowane, zminimalizowane lub przywrócone, sprawdzając właściwość WindowState.

Styl okna

Obramowanie uwidocznione z obszaru nieklienckiego okna jest odpowiednie dla większości aplikacji. Istnieją jednak okoliczności, w których potrzebne są różne typy obramowań lub w ogóle nie są potrzebne żadne obramowania, w zależności od typu okna.

Aby kontrolować typ obramowania nadawany oknu, należy ustawić jego właściwość WindowStyle przy użyciu jednej z następujących wartości wyliczenia WindowStyle:

• None

• SingleBorderWindow (domyślne)

• ThreeDBorderWindow

• ToolWindow

Efekt tych stylów okna przedstawiono na poniższej ilustracji:

Można ustawić WindowStyle przy użyciu znaczników XAML lub kodu; ponieważ jest mało prawdopodobne, aby zmienić się w okresie istnienia okna, najprawdopodobniej skonfigurujesz go przy użyciu znaczników XAML.

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

Styl okna nie prostokątnego

Istnieją również sytuacje, w których style obramowania, które WindowStyle pozwalają nie być wystarczające. Możesz na przykład utworzyć aplikację z obramowaniem nieprostokątnym, takie jak używane przez odtwarzacz Microsoft Windows Media Player.

Rozważmy na przykład okno bąbelka mowy pokazane na poniższej ilustracji:

Ten typ okna można utworzyć, ustawiając dla właściwości WindowStyle wartość None, i używając specjalnej obsługi, którą ma obiekt Window dla przezroczystości.

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

Ta kombinacja wartości nakazuje, aby okno było renderowane całkowicie przezroczyste. W tym stanie nie można użyć przycisków Minimalizuj, Maksymalizuj i Przywróć nie można używać okien innych niż klient (menu Zamknij, Minimalizuj, Maksymalizuj i Przywróć). W związku z tym musisz podać własne.

Obecność paska zadań

Domyślny wygląd okna zawiera przycisk paska zadań, taki jak pokazany na poniższym rysunku:

Niektóre typy okien nie mają przycisku paska zadań, takiego jak okna komunikatów i okna dialogowe (zobacz Przegląd okien dialogowych). Możesz kontrolować, czy przycisk paska zadań dla okna jest wyświetlany, ustawiając ShowInTaskbar właściwość (true domyślnie).

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

Zagadnienia związane z zabezpieczeniami

Window wymaga UnmanagedCode utworzenia wystąpienia uprawnień zabezpieczeń. W przypadku aplikacji zainstalowanych i uruchomionych z komputera lokalnego należy do zestawu uprawnień przyznanych aplikacji.

Jednak wykracza to poza zestaw uprawnień przyznanych aplikacjom uruchamianym z Internetu lub lokalnej strefy intranetowej przy użyciu technologii ClickOnce. W związku z tym użytkownicy otrzymają ostrzeżenie o zabezpieczeniach technologii ClickOnce i będą musieli podnieść poziom uprawnień ustawiony dla aplikacji w celu pełnego zaufania.

Ponadto XBAPs nie może domyślnie wyświetlać okien ani okien dialogowych. Aby zapoznać się z omówieniem zagadnień dotyczących zabezpieczeń aplikacji autonomicznych, zobacz Strategia zabezpieczeń platformy WPF.

Inne typy systemu Windows

NavigationWindow jest oknem przeznaczonym do hostowania zawartości z możliwością nawigacji. Aby uzyskać więcej informacji, zobacz Omówienie nawigacji).

Okna dialogowe to okna, które są często używane do zbierania informacji od użytkownika w celu ukończenia funkcji. Na przykład gdy użytkownik chce otworzyć plik, okno dialogowe Otwieranie pliku jest zwykle wyświetlane przez aplikację w celu pobrania nazwy pliku od użytkownika. Aby uzyskać więcej informacji, zobacz Omówienie okien dialogowych.

Zobacz też

• Window
• MessageBox
• NavigationWindow
• Application
• Okna dialogowe — omówienie
• Kompilowanie aplikacji WPF