Udostępnij za pośrednictwem

Omówienie okien WPF

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

Ważne

W tym artykule jest używany kod XAML wygenerowany na podstawie projektu języka C#. Jeśli używasz języka Visual Basic, kod XAML może wyglądać nieco inaczej. Te różnice zwykle występują w wartościach atrybutu x:Class. Język C# uwzględnia przestrzeń nazw katalogu głównego projektu, a język Visual Basic nie.

Szablony projektów dla języka C# tworzą typ App zawarty w pliku app.xaml. W języku Visual Basic ten typ ma nazwę Application, a plik ma nazwę Application.xaml.

Klasa Window

W WPF okno jest hermetyzowane przez klasę Window, która służy do wykonywania następujących czynności:

  • Wyświetlanie okna.
  • Skonfiguruj rozmiar, położenie i wygląd okna.
  • Hostowanie zawartości specyficznej dla aplikacji.
  • Zarządzanie okresem istnienia okna.

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

Zrzut ekranu przedstawiający części okna WPF.

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

obszar niekliencki okna jest obsługiwany przez WPF i zawiera części okna, które są wspólne dla większości okien, w tym następujące:

  • Pasek tytułu (1–5).
  • Ikona (1).
  • Tytuł (2).
  • Przyciski Minimalizuj (3), Maksymalizuj (4) i Zamknij (5).
  • Menu systemowe (6) z elementami menu. Pojawia się po kliknięciu ikony (1).
  • Obramowanie (7).

Obszar kliencki okna jest obszarem w obrębie obszaru nieklienckiego okna i jest używany przez programistów do dodawania zawartości specyficznej dla aplikacji, takich jak paski menu, paski narzędzi i kontrolki.

  • Obszar klienta (8).
  • Uchwyt zmieniania rozmiaru (9). Jest to kontrolka dodawana do obszaru klienta (8).

Implementowanie okna

Implementacja typowego okna obejmuje zarówno wygląd, jak i zachowanie, przy czym wygląd definiuje wygląd okna widoczny dla użytkowników, a zachowanie definiuje sposób działania okna, gdy użytkownicy z niego korzystają. W WPF można zaimplementować wygląd i zachowanie okna przy użyciu kodu lub znaczników XAML.

Ogólnie jednak wygląd okna jest implementowany przy użyciu znaczników XAML, a jego zachowanie za pomocą code-behind, jak pokazano w poniższym przykładzie.

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

Poniższy kod to plik codebehind dla języka XAML.

using System.Windows;

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

Public Class Window1

End Class

Aby umożliwić współdziałanie pliku znaczników XAML i pliku z kodem, wymagane są następujące elementy:

  • W znacznikach element Window musi zawierać atrybut x:Class. Gdy aplikacja zostanie skompilowana, istnienie atrybutu x:Class spowoduje, że aparat kompilacji firmy Microsoft (MSBuild) wygeneruje klasę partial pochodzącą z klasy Window o nazwie określonej przez atrybut x:Class. 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 z kodem źródłowym klasa musi być klasą partial o tej samej nazwie, która jest określona przez atrybut x:Class w znacznikach i musi dziedziczyć po Window. Umożliwia to skojarzenie pliku związanego z kodem z klasą partial, która jest generowana dla pliku znaczników podczas kompilowania aplikacji. Aby uzyskać więcej informacji, zobacz Kompilowanie aplikacji WPF.

  • W części kodowej klasa Window musi zaimplementować konstruktor, który wywołuje metodę InitializeComponent. InitializeComponent jest implementowany przez wygenerowaną klasę partial pliku z kodem znaczników w celu rejestrowania zdarzeń i ustawiania właściwości zdefiniowanych w kodzie znaczników.

Uwaga / Notatka

Podczas dodawania nowego Window do projektu przy użyciu programu Visual Studio, Window jest implementowany przy użyciu znaczników i plików rozdzielonych kodem oraz zawiera niezbędną konfigurację do powiązania plików znaczników i plików z kodem, jak opisano tutaj.

Dzięki tej konfiguracji można skoncentrować się na zdefiniowaniu wyglądu okna w znaczniku XAML i zaimplementowaniu jego zachowania w kodzie. Poniższy przykład przedstawia okno z przyciskiem definiującym obsługę zdarzeń dla zdarzenia Click. Jest to implementowane w języku XAML, a procedura obsługi jest implementowana w pliku codebehind.

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

Poniższy kod to plik codebehind dla języka 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

Konfigurowanie okna dla programu MSBuild

Sposób implementacji okna określa, jak jest ono skonfigurowane dla programu MSBuild. W przypadku okna zdefiniowanego przy użyciu zarówno znaczników XAML, jak i kodu zakulisowego:

  • Pliki znaczników XAML są konfigurowane jako elementy MSBuild Page.
  • Pliki zaplecza kodu są konfigurowane jako elementy MSBuild Compile.

Projekty .NET SDK automatycznie importują poprawne elementy Page i Compile, więc nie trzeba ich deklarować. Po skonfigurowaniu projektu dla platformy WPF pliki znaczników XAML są automatycznie importowane jako elementy Page, a odpowiedni plik związany z kodem jest importowany jako element Compile.

Projekty programu MSBuild nie będą automatycznie importować typów i należy je zadeklarować samodzielnie:

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

Aby uzyskać informacje na temat tworzenia aplikacji WPF, zobacz Kompilowanie aplikacji WPF.

Okres istnienia okna

Podobnie jak w przypadku każdej klasy okno ma okres istnienia, który rozpoczyna się, gdy po raz pierwszy zostanie utworzone jego wystąpienie, po czym jest ono otwierane, uaktywniane/dezaktywowane i ostatecznie zamykane.

Otwieranie okna

Aby otworzyć okno, należy najpierw utworzyć jego wystąpienie, co zostało pokazane w poniższym przykładzie:

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

W tym przykładzie dla klasy Window1 jest tworzone wystąpienie po uruchomieniu aplikacji, co następuje po wywołaniu zdarzenia Startup. Aby uzyskać więcej informacji na temat okna uruchamiania, zobacz Jak pobrać lub ustawić główne okno aplikacji.

Po utworzeniu wystąpienia okna odwołanie do niego jest automatycznie dodawane do listy okien zarządzanej przez obiekt Application. Pierwsze okno do utworzenia wystąpienia jest automatycznie ustawiane przez klasę Application jako główne okno aplikacji.

Okno jest ostatecznie otwierane przez wywołanie metody Show, jak pokazano na poniższej ilustracji:

Okno WPF z jednym przyciskiem wewnątrz z tekstem

Okno otwarte przez wywołanie metody Show to okno niemodalne, a aplikacja nie uniemożliwia użytkownikom interakcji z innymi oknami w aplikacji. Otwarcie okna przy użyciu metody ShowDialog powoduje otwarcie okna jako modalnego i ogranicza interakcję użytkownika do konkretnego okna. Aby uzyskać więcej informacji, zobacz omówienie okien dialogowych .

Po wywołaniu metody Show okno wykonuje inicjowanie zanim zostanie wyświetlone, aby ustanowić infrastrukturę, która umożliwia mu odbieranie danych wejściowych użytkownika. Po zainicjowaniu okna zostanie zgłoszone zdarzenie SourceInitialized i zostanie wyświetlone okno.

Aby uzyskać więcej informacji, zobacz Jak otworzyć okno lub okno dialogowe.

Okno uruchamiania

W poprzednim przykładzie użyto zdarzenia Startup do uruchomienia kodu, który powodował wyświetlenie początkowego okna aplikacji. Zamiast tego, w ramach skrótu, użyj interfejsu StartupUri, aby określić ścieżkę do pliku XAML w aplikacji. Aplikacja automatycznie tworzy i wyświetla okno określone przez tę właściwość.

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

Własność okna

Okno otwierane przy użyciu metody Show nie ma niejawnej relacji z oknem, które je utworzyło. Użytkownicy mogą korzystać z obu okien niezależnie od siebie, co oznacza, że każde z okien może wykonywać następujące operacje:

  • Zakryj drugą (chyba że jeden z okien ma właściwość Topmost ustawioną na wartość true).
  • Można zminimalizować, zmaksymalizować i przywrócić bez wpływu na drugą.

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, których typowe zachowanie polega na pokryciu okna, które je tworzy. Ponadto takie okna powinny być zawsze zamykane, minimalizowane, maksymalizowane i przywracane razem z oknem, które je utworzyło. Taką relację można ustanowić, sprawiając, że jedno okno jest właścicielem innego okna, co uzyskuje się przez ustawienie właściwości Owner okna należącego do z odwołaniem do okna właściciela . Jest to pokazane w poniższym przykładzie.

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

  • Okno należące do właściciela może odwoływać się do okna właściciela, sprawdzając wartość jej właściwości Owner.
  • Okno właścicielskie może odkryć wszystkie okna, które posiada, sprawdzając wartość swojej właściwości OwnedWindows.

Aktywacja okna

Po otwarciu okna po raz pierwszy staje się ono oknem aktywnym. aktywne okno to okno, które obecnie przechwytuje sygnały użytkownika, takie jak naciśnięcia klawiszy i kliknięcia myszy. Gdy okno stanie się aktywne, system generuje zdarzenie Activated.

Uwaga / Notatka

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

Gdy okno stanie się aktywne, użytkownik może aktywować inne okno w tej samej aplikacji lub aktywować inną aplikację. W takim przypadku aktualnie aktywne okno zostanie zdezaktywowane i zgłasza zdarzenie Deactivated. Podobnie gdy użytkownik wybierze aktualnie zdezaktywowane okno, zostanie ponownie aktywne i zostanie wyświetlone Activated.

Jedną z typowych przyczyn obsługi Activated i Deactivated jest włączenie i wyłączenie funkcji, które mogą być uruchamiane tylko wtedy, gdy okno jest aktywne. Na przykład niektóre okna wyświetlają interaktywną zawartość, która wymaga stałego wprowadzania lub uwagi użytkownika, w tym gier i odtwarzaczy wideo. Poniższy przykład to uproszczony odtwarzacz wideo, który pokazuje, jak obsługiwać Activated i Deactivated w celu zaimplementowania tego zachowania.

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

Poniższy kod to plik codebehind dla języka 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

Inne typy aplikacji mogą nadal uruchamiać kod w tle, gdy okno jest dezaktywowane. Na przykład klient poczty może kontynuować sondowanie serwera poczty, gdy użytkownik korzysta z innych aplikacji. Aplikacje takie jak te często udostępniają inne lub dodatkowe zachowanie, gdy okno główne jest dezaktywowane. W przypadku programu poczty może to oznaczać zarówno dodanie nowego elementu poczty do skrzynki odbiorczej, jak i dodanie ikony powiadomienia do zasobnika systemu. Ikona powiadomienia musi być wyświetlana tylko wtedy, gdy okno poczty nie jest aktywne, co jest ustalane przez sprawdzenie właściwości IsActive.

Jeśli zadanie w tle zostanie ukończone, okno może chcieć powiadomić użytkownika w trybie pilnym, wywołując metodę Activate. Jeśli użytkownik wchodzi w interakcję z inną aplikacją aktywowaną po wywołaniu Activate, przycisk paska zadań okna miga. Jeśli jednak użytkownik wchodzi w interakcję z bieżącą aplikacją, wywołanie zdarzenia Activate spowoduje przełączenie okna na pierwszy plan.

Uwaga / Notatka

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

Zapobieganie aktywacji okna

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

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

  • Okno nie jest uaktywnione.
  • Zdarzenie okna Activated nie jest wywoływane.
  • Aktualnie aktywowane okno pozostaje aktywowane.

Okno zostanie aktywowane, jednak zaraz po aktywowaniu go przez kliknięcie klienta lub obszaru innego niż klient. W tym przypadku:

  • Okno jest aktywowane.
  • Zdarzenie Activated okna zostaje zgłoszone.
  • Wcześniej aktywowane okno jest dezaktywowane.
  • Zdarzenia Deactivated i Activated okna są następnie wywoływane zgodnie z oczekiwaniami w reakcji na akcje użytkownika.

Zamykanie okna

Okres życia okna zaczyna zbliżać się do końca, gdy użytkownik go zamknie. Po zamknięciu okna nie można go ponownie otworzyć. Okno można zamknąć przy użyciu elementów w obszarze spoza klienta, w tym następujących:

  • Element Zamknij menu systemu .
  • Naciśnięcie klawiszy ALT + F4.
  • Naciśnij przycisk Zamknij.
  • Naciśnięcie klawisza ESC, gdy przycisk ma dla właściwości IsCancel ustawioną wartość true w oknie modalnym.

Możesz udostępnić więcej mechanizmów zamykania okna w obszarze klienta, z których najczęstsze są następujące:

  • Element Zakończ w menu pliku zazwyczaj dla głównych okien aplikacji.
  • Element Zamknij w menu pliku zazwyczaj w oknie aplikacji pomocniczej.
  • Przycisk Anuluj, zazwyczaj w modalnym oknie dialogowym.
  • Przycisk Zamknij, zazwyczaj w oknie dialogowym bez moderowania.

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

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

Poniższy kod to plik codebehind dla języka 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

Uwaga / Notatka

Aplikację można skonfigurować do automatycznego zamykania, gdy główne okno aplikacji zostanie zamknięte (zobacz MainWindow) lub ostatnie okno zostanie zamknięte. Aby uzyskać więcej informacji, zobacz ShutdownMode.

Chociaż można jawnie zamknąć okno za pomocą mechanizmów dostępnych w obszarach nieklienta i klienta, okno może być również niejawnie zamknięte w wyniku zachowania w innych częściach aplikacji lub systemu Windows, w tym następujące elementy:

Ważne

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

Anulowanie zamknięcia okna

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

Closing jest podniesiona przed zamknięciem okna i zapewnia mechanizm, za pomocą którego można zapobiec zamykaniu 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, należy zapytać użytkownika, czy kontynuować zamykanie okna bez zapisywania danych lub anulowania zamknięcia okna. Poniższy przykład przedstawia kluczowe aspekty obsługi 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>

Poniższy kod to plik codebehind dla języka 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

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

Jeśli zdarzenie Closing nie jest obsługiwane lub jest obsługiwane, ale nie zostało anulowane, okno zostanie zamknięte. Tuż przed zamknięciem okna zostanie podniesiona Closed. W tym momencie nie można uniemożliwić zamknięcia okna.

Zdarzenia okresu istnienia okna

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

Diagram przedstawiający zdarzenia w okresie istnienia okna.

Poniższa ilustracja przedstawia sekwencję zdarzeń głównych w okresie istnienia okna wyświetlanego bez aktywacji (ShowActivated jest ustawiona na false przed wyświetleniem okna):

Diagram przedstawiający zdarzenia w okresie istnienia okna bez aktywacji.

Lokalizacja okna

Gdy okno jest otwarte, ma lokalizację w wymiarach x i y względem pulpitu. Tę lokalizację można określić, sprawdzając odpowiednio właściwości Left i Top. Ustaw te właściwości, aby zmienić lokalizację okna.

Możesz również określić początkową lokalizację Window, gdy pojawi się po raz pierwszy, ustawiając właściwość WindowStartupLocation przy użyciu jednej z następujących wartości wyliczenia WindowStartupLocation:

Jeśli lokalizacja uruchamiania jest określona jako Manual, a właściwości Left i Top nie zostały ustawione, obiekt Window zapyta system operacyjny o lokalizację, w której ma zostać wyświetlony.

Okna najwyżej w hierarchii i porządek osi Z

Oprócz lokalizacji 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 osi Z zależy od tego, czy jest ono obecnie aktywne, czy nie. Domyślnie okno jest umieszczone w normalnym porządku Z. Lokalizacja okna w najwyższym w hierarchii porządku osi Z także zależy od tego, czy jest ono obecnie aktywne, czy nie. Ponadto okna w najwyższej kolejności z są zawsze umieszczone nad oknami w normalnej kolejności z. Okno jest umieszczone najwyżej w porządku Z, ustawiając jego właściwość Topmost na wartość true.

W każdym typie hierarchii porządku osi Z obecnie aktywne okno jest wyświetlane powyżej wszystkich innych okien w tym samym porządku osi Z.

Rozmiar okna

Poza lokalizacją na pulpicie, okno ma rozmiar określany przez kilka właściwości, w tym różne właściwości szerokości i wysokości oraz SizeToContent.

Właściwości MinWidth, Width i MaxWidth są używane do zarządzania zakresem szerokości, które okno może mieć w swoim okresie istnienia.

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

Wysokość okna jest zarządzana przez właściwości MinHeight, Height i MaxHeight.

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

Ponieważ różne wartości szerokości i wysokości określają zakres, można określić szerokość i wysokość okna z możliwością zmiany rozmiaru w dowolnym miejscu w określonym zakresie dla odpowiedniego wymiaru. Aby wykryć bieżącą szerokość i wysokość, sprawdź odpowiednio 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:

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

<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ć, jak zmienia się rozmiar okna w celu dopasowania jej do 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 określania rozmiaru

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

właściwości dotyczące wysokości:

  1. FrameworkElement.MinHeight
  2. FrameworkElement.MaxHeight
  3. SizeToContent.Height / SizeToContent.WidthAndHeight
  4. FrameworkElement.Height

dla 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 ono zmaksymalizowane. Do zarządzania tym służy właściwość WindowState.

Stan okna

W okresie istnienia okna z możliwością zmiany rozmiaru może mieć trzy stany: normalny, zminimalizowany i zmaksymalizowany. Okno z normalnym stanem jest domyślnym stanem okna. Okno o tym stanie umożliwia użytkownikowi przenoszenie i zmienianie jego rozmiaru za pomocą uchwytu zmiany rozmiaru lub obramowania, jeśli zmiana rozmiaru jest możliwa.

Okno w stanie zminimalizowanym jest zwijane do przycisku paska zadań, jeśli dla właściwości ShowInTaskbar ustawiono wartość true. W przeciwnym razie jest zwijane do najmniejszego możliwego rozmiaru, a następnie przenoszone do lewego dolnego rogu pulpitu. Żaden typ zminimalizowanego okna nie może być zmieniany przy użyciu obramowania lub uchwytu zmiany rozmiaru, chociaż zminimalizowane okno, które nie jest wyświetlane na pasku zadań, można przeciągnąć wokół pulpitu.

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 okna zminimalizowanego, nie można zmieniać rozmiaru okna zmaksymalizowanego przy użyciu uchwytu zmiany rozmiaru ani przez przeciąganie obramowania.

Uwaga / Notatka

Wartości właściwości Top, Left, Widthi 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:

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

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

Ogólnie rzecz biorąc, należy ustawić WindowState, aby skonfigurować początkowy stan 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. Aby skonfigurować obszar niestandardowy, Window udostępnia kilka właściwości, w tym Icon do ustawiania ikony okna i Title do ustawiania jego tytułu.

Można również zmienić wygląd i zachowanie obramowania obszaru innego niż klient, konfigurując tryb zmiany rozmiaru okna, styl okna i czy jest wyświetlany jako przycisk na pasku zadań pulpitu.

Tryb zmiany rozmiaru

W zależności od właściwości WindowStyle możesz kontrolować, czy i jak użytkownicy mogą zmieniać rozmiar okna. Styl okna wpływa na następujące aspekty:

  • Zezwalanie na zmianę rozmiaru lub nie zezwalanie na nią przez przeciąganie obramowania okna myszą.
  • Czy przyciski Minimalizuj, Maksymalizuj i Zamknij są wyświetlane w obszarze nieklienckim.
  • Czy są włączone przyciski Minimalizuj, Maksymalizuj i Zamknij.

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

Podobnie jak w przypadku WindowStyletryb zmiany rozmiaru okna raczej nie ulegnie zmianie w czasie jego użytkowania, co oznacza, że najprawdopodobniej ustawisz go ze znaczników XAML.

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

Należy pamiętać, że można 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 rodzaje obramowań lub w ogóle nie są potrzebne żadne obramowania, w zależności od typu okna.

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

Efekt zastosowania stylu okna przedstawiono na poniższej ilustracji:

Zrzut ekranu pokazujący, jak właściwość WindowStyle wpływa na okno na platformie WPF.

Zwróć uwagę, że powyższy obraz nie pokazuje zauważalnej różnicy między właściwościami SingleBorderWindow i ThreeDBorderWindow. W systemie Windows XP właściwość ThreeDBorderWindow miała wpływ na sposób rysowania okna przez dodanie obramowania 3D do obszaru klienta. Począwszy od systemu Windows 7, różnice między dwoma stylami są minimalne.

Można ustawić właściwość WindowStyle przy użyciu znaczników XAML lub kodu. Ponieważ jest mało prawdopodobne, że ulegnie to zmianie w okresie istnienia okna, najprawdopodobniej skonfigurujesz to przy użyciu znaczników XAML.

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

Styl okna nieprostokątnego

Istnieją również sytuacje, gdy style obramowania, na które zezwala obiekt WindowStyle, są niewystarczające. Na przykład możesz utworzyć aplikację z obramowaniem nie prostokątnym, na przykład używanym przez program Microsoft Windows Media Player.

Rozważmy na przykład okno dymka mowy pokazane na poniższej ilustracji:

Zrzut ekranu przedstawiający okno WPF z obciętym obszarem i kształtem niestandardowym.

Ten typ okna można utworzyć, ustawiając właściwość WindowStyle na Nonei używając specjalnej obsługi, którą Window ma w zakresie przejrzystości.

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

Ta kombinacja wartości powoduje, że okno będzie renderowane jako przezroczyste. W tym stanie nie można używać przycisków zakończenia obszaru nieklienckiego okna i należy udostępnić własne.

Obecność na pasku zadań

Domyślny wygląd okna obejmuje przycisk paska zadań. Niektóre typy okien nie mają przycisku paska zadań, takie jak okna komunikatów, okna dialogowe lub okna, dla których dla właściwości WindowStyle ustawiono wartość ToolWindow. Możesz kontrolować, czy przycisk paska zadań dla okna jest wyświetlany, ustawiając właściwość ShowInTaskbar, która domyślnie ma wartość true.

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

Inne typy okien

NavigationWindow jest oknem przeznaczonym do hostowania zawartości z możliwością 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, przez aplikację jest wyświetlane okno dialogowe Otwieranie pliku w celu uzyskania nazwy pliku od użytkownika. Aby uzyskać więcej informacji, zobacz omówienie okien dialogowych .

Zobacz także