Общие сведения об окнах WPF

Пользователи взаимодействуют с автономными приложениями Windows Presentation Foundation (WPF) при помощи окон. Основным предназначением окна является размещение содержимого, которое отображает данные и позволяет пользователям взаимодействовать с ними. Автономные приложения WPF предоставляют свои собственные окна с помощью класса Window. В этом разделе перед рассмотрением основ создания и управления окнами в автономных приложениях описывается Window.

Примечание
Приложения WPF, реализуемые в обозревателе, включая XAML browser applications (XBAPs) и свободные страницы Extensible Application Markup Language (XAML), не предоставляют свои собственные окна.Вместо этого они размещаются в окнах, предоставляемых Windows Internet Explorer.См. раздел Общие сведения о приложениях браузера WPF XAML.

В этом разделе содержатся следующие подразделы.

• Класс "Окно"
• Реализация окна
• Настройка определения окна для MSBuild
• Время существования окна
• Расположение окон
• Размер окна
• Порядок приоритета свойств изменения размера
• Состояние окна
• Вид окна
• Вопросы безопасности
• Другие типы окон
• Связанные разделы

Класс "Окно"

На следующем рисунке показаны составные части окна.

Окно разделено на две области: неклиентскую и клиентскую область.

Неклиентская область окна реализована с помощью WPF и включает части окна, являющиеся общими для большинства окон, в том числе следующие:

• Граница.

• Заголовок окна.

• Значок.

• Кнопки "Свернуть", "Развернуть" и "Восстановить".

• Кнопка "Закрыть".

• Системное меню с элементами, которые позволяют пользователям сворачивать, разворачивать, восстанавливать, перемещать, изменять размер и закрывать окно.

Клиентская область окна является областью, входящей в неклиентскую область, и используется разработчиками для добавления содержимого конкретного приложения, такого как строки меню, панели инструментов и элементы управления.

В WPF окно инкапсулируется классом Window, предназначенным для выполнения следующих действий.

• Отображение окна.

• Настройка размера, положения и внешнего вида окна.

• Размещение содержимого конкретного приложения.

• Управление временем существования окна.

Реализация окна

Реализация типичного окна включает как вид, так и поведение, где вид определяет, как окно отображается для пользователей, а поведение определяет способ функционирования окна при взаимодействии пользователей с ним. В WPF можно реализовать внешний вид и поведение окна либо с помощью кода, либо с помощью разметки XAML.

Однако, как правило, внешний вид окна реализуется с помощью разметки XAML, а его поведение реализуется с помощью кода программной части, как показано в следующем примере.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarkupAndCodeBehindWindow">

  <!-- Client area (for content) -->

</Window>

Imports System.Windows ' Window

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

using System.Windows; // Window

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

Чтобы обеспечить взаимодействие файла разметки XAML и файла кода программной части, необходимо выполнить следующее:

• В разметке элемент Window должен включать атрибут x:Class. При построении приложения существование x:Class в файле разметки приводит к тому, что Microsoft build engine (MSBuild) создает класс partial, производный от Window с именем, которое определяется атрибутом x:Class. Для этого требуется добавить объявление пространства имен XML в схему XAML (xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"). Созданный класс partial реализует метод InitializeComponent, который вызывается для регистрации событий и задания свойств, реализованных в разметке.

• В коде программной части класс должен быть классом partial с тем же именем, которое определено атрибутом x:Class в разметке, и он должен быть производным от Window. Это позволяет связать файл кода программной части с классом partial, созданным для файла разметки при построении приложения (см. раздел Построение приложения WPF).

• В коде программной части класс Window должен реализовать конструктор, вызывающий метод InitializeComponent. Метод InitializeComponent реализуется классом partial, созданным файлом разметки, для регистрации событий и задания свойств, определенных в разметке.

Примечание
Когда в проект добавляется новый класс Window с помощью Microsoft Visual Studio, Window реализуется с помощью разметки и с помощью кода программной части и включает необходимую конфигурацию для создания связи между файлами разметки и файлами кода программной части.

При такой конфигурации можно сосредоточиться на определении внешнего вида окна в разметке XAML и реализации его поведения в коде программной реализации. В следующем примере показано окно с кнопкой, реализованное в разметке XAML, и обработчик событий Click кнопки, реализованный в коде программной части.

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

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

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.");
        }
    }
}

Настройка определения окна для MSBuild

Реализация окна определяет его конфигурацию для MSBuild. Для окна, определенного как с помощью разметки XAML, так и с помощью кода программной части:

• Файлы разметки XAML настраиваются как элементы MSBuild Page.

• Файлы кода программной части настраиваются как элементы MSBuild Compile.

Это показано в следующем файле проекта MSBuild.

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

Сведения о построении приложений WPF см. в разделе Построение приложения WPF.

Время существования окна

Как и любой класс, окно имеет время существования, которое начинается с момента создания, после которого осуществляется его открытие, активация, деактивация и, в конечном счете, закрытие.

Этот подраздел состоит из следующих пунктов.

• Открытие окна
• Активация окна
• Закрытие окна
• События времени существования окна

Открытие окна

Чтобы открыть окно, сначала создайте его экземпляр, как показано в следующем примере.

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

Imports System.Windows

Namespace SDKSample
    Partial Public Class App
        Inherits Application
        Private Sub app_Startup(ByVal sender As Object, ByVal e As StartupEventArgs)
            ' Create a window
            Dim window As New MarkupAndCodeBehindWindow()

            ' Open a window
            window.Show()
        End Sub
    End Class
End Namespace

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

В этом примере при запуске приложения создается MarkupAndCodeBehindWindow, которое появляется при возникновении события Startup.

После создания окна ссылка на него автоматически добавляется в список окон, управление которым осуществляется объектом Application (см. Application.Windows). Кроме того, по умолчанию первый экземпляр окна устанавливается Application как главное окно приложения (см. Application.MainWindow).

Окончательное открытие окна осуществляется вызовом метода Show; результат показан на следующем рисунке.

Окно, открытое с помощью вызова Show, является безрежимным, что означает, что приложение работает в режиме, позволяющем пользователям активировать другие окна в том же приложении.

Примечание
ShowDialog вызывается для открытия модальных окон, таких как диалоговые окна.Дополнительные сведения см. в разделе Общие сведения о диалоговых окнах.

При вызове Show окно перед отображением выполняет инициализацию для установки инфраструктуры, позволяющей получать вводимые пользователем данные. После инициализации окна возникает событие SourceInitialized, и окно отображается.

Для быстрого запуска может быть установлен StartupUri, указывающий первое окно, которое открывается автоматически при запуске приложения.

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

При запуске приложения окно, заданное значением StartupUri, открывается безрежимно, а внутри приложения окно открывается с помощью вызова метода Show.

Владение окном

Окно, открытое с помощью метода Show, не имеет неявной связи с окном, которое его создало; пользователи могут взаимодействовать с одним окном независимо от другого, что означает, что любое из окон может выполнять следующее:

• Перекрывать другое (если свойство Topmost одного из окон установлено в true ).

• Сворачиваться, разворачиваться и восстанавливаться без влияния на другое окно.

Для некоторых окон требуется связь с окном, которое их открывает. Например, приложение Integrated Development Environment (IDE) может открыть окна свойств и окна инструментов, которые обычно перекрывают создавшее их окно. Кроме того, такие окна должны всегда закрываться, сворачиваться, разворачиваться и восстанавливаться вместе с окном, в котором они созданы. Такая связь может быть установлена путем задания одного окна как владельца другого, что достигается путем установки свойства Owner собственного окна в значение ссылки на окно владельца. Это показано в следующем примере.

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

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

После установки владельца:

• Собственное окно может ссылаться на окно владельца, путем проверки значения свойства Owner.

• Окно владельца может обнаруживать все окна, которыми оно владеет, путем проверки значения свойства OwnedWindows.

Предотвращение активации окна

В некоторых случаях не следует активировать отображаемые окна; примером таких окон являются окна беседы в приложениях, предназначенных для обмена сообщениями через Интернет, и окна уведомлений в приложениях электронной почты.

Если в приложении имеется окно, которое не следует активировать при отображении, присвойте свойству ShowActivated этого окна значение false перед первым вызовом метода Show. Ниже перечислены результаты выполнения этих действий.

• Окно не активируется.

• Событие Activated этого окна не вызывается.

• Окно, активированное к настоящему моменту, остается активированным.

Тем не менее, окно будет активировано только тогда, когда пользователь щелкнет его в клиентской или иной области. В этом случае будут иметь место указанные ниже последствия.

• Окно активируется.

• Вызывается событие Activated этого окна.

• Ранее активированное окно деактивируется.

• В ответ на действия пользователя вызываются события Deactivated и Activated этого окна.

Активация окна

Когда окно открывается в первый раз, оно становится активным (за исключением случая, когда свойству ShowActivated этого окна присвоено значение false). Активное окно — это окно, которое в настоящее время перехватывает пользовательский ввод, например нажатие клавиш или щелчки мыши. Когда окно становится активным, оно вызывает событие Activated.

Примечание
При первом открытии окна события Loaded и ContentRendered вызываются после события Activated.С учетом этого окно может считаться открытым при возникновении события ContentRendered.

После того как окно становится активным, пользователь может активировать другое окно того же приложения или активировать другое приложение. При этом текущее активное окно становится неактивным и вызывается событие Deactivated. Аналогичным образом, когда пользователь выбирает неактивное в данный момент окно, оно снова становится активным и вызывается Activated.

Одной из распространенных причин для обработки Activated и Deactivated является включение и отключение функций, которые должны выполняться только в активном окне. Например, некоторые окна отображают интерактивное содержимое, которое требует постоянного ввода данных пользователем или внимания со стороны пользователя, например игры и видеопроигрыватели. В следующем примере показан упрощенный видеопроигрыватель, демонстрирующий обработку Activated и Deactivated для реализации этого поведения.

<Window
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://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>

Imports System ' EventArgs
Imports System.Windows ' Window

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

using System; // EventArgs
using System.Windows; // Window

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

Другие типы приложений при деактивации окна могут по-прежнему выполнять код в фоновом режиме. Например, почтовый клиент может продолжить опрашивать почтовый сервер, даже когда пользователь использует другое приложение. Такие приложения во время деактивации главного окна часто выполняют отличные или дополнительные действия. В почтовой программе это может означать как добавление нового элемента почты в почтовый ящик, так и добавление значка уведомлений в панель задач. Значок уведомлений требуется отображать, только если почтовое окно неактивно, что может быть определено с помощью проверки свойства IsActive.

Если фоновая задача завершается, то окну может потребоваться срочно сообщить об этом пользователю с помощью вызова метода Activate. Если пользователь взаимодействует с другим приложением, активированным после вызова метода Activate, то кнопка панели задач окна начинает мигать. Если пользователь взаимодействует с текущим приложением, то вызов Activate переместит окно на передний план.

Примечание
Можно обработать активацию области определения приложения с помощью событий Application.Activated и Application.Deactivated.

Закрытие окна

Время существования окна подходит к концу, когда пользователь закрывает его. Окно может быть закрыто с помощью следующих элементов неклиентской области:

• Пункт Закрыть меню Система.

• Нажатие комбинации клавиш ALT + F4.

• Нажатие кнопки Закрыть.

Можно указать дополнительные способы закрытия окна для клиентской области, к наиболее общим из которых относятся:

• Пункт Выход меню Файл (обычно для главных окон приложений).

• Пункт Закрыть меню Файл (обычно для дополнительного окна приложения).

• Кнопка Отмена (обычно для модального диалогового окна).

• Кнопка Закрыть (обычно для немодального диалогового окна).

Чтобы закрыть окно одним из этих пользовательских способов, необходимо вызвать метод Close. В следующем примере реализуется возможность закрытия окна с помощью выбора пункта Выход в меню Файл.

<Window 
    xmlns="https://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="https://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.WindowWithFileExit">

  <Menu>
    <MenuItem Header="_File">
      <MenuItem Header="E_xit" Click="fileExitMenuItem_Click" />
    </MenuItem>
  </Menu>

</Window>

Imports System.Windows ' window, RoutedEventArgs

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

using System.Windows; // window, RoutedEventArgs

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

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

При закрытии окно вызывает два события: Closing и Closed.

Closing вызывается перед закрытием окна и предоставляет механизм, с помощью которого закрытие окна может быть прервано. Одной из основных причин для предотвращения закрытия окна является изменение данных в содержимом окна. В этом случае событие Closing может быть обработано, чтобы определить, являются ли данные "грязными", и, если это так, спросить у пользователя, следует ли отменить закрытие окна или закрыть его без сохранения данных. В следующем примере показаны ключевые аспекты обработки Closing.

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


...


        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

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

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


...


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

Обработчику событий Closing передается CancelEventArgs, который реализует свойство Boolean Cancel, устанавливаемое в true для предотвращения закрытия окна.

Если Closing не обрабатывается или обрабатывается, но не было отменено, то окно будет закрыто. Перед фактическим закрытием окна вызывается Closed. В этом случае закрытие окна предотвратить нельзя.

Примечание
Приложение может быть настроено на завершение работы автоматически, либо когда закрывается главное окно приложения (см. MainWindow), либо когда закрывается последнее окно.Дополнительные сведения см. в разделе ShutdownMode.

Хотя окно может быть закрыто явным образом с помощью механизмов, предоставленных в клиентской и неклиентской областях, окно может быть закрыто неявно в результате поведения других элементов приложения или Windows, к которым относятся следующие:

• Пользователь выходит из системы или завершает работу Windows.

• Владелец окна закрывается (см. Owner).

• Закрывается главное окно приложения, а ShutdownMode устанавливается в OnMainWindowClose.

• Вызывается метод Shutdown.

Примечание
Окно не может быть открыто повторно после его закрытия.

События времени существования окна

На следующем рисунке показана последовательность основных событий времени существования окна.

На приведенном ниже рисунке показана последовательность основных событий во время существования окна, которое отображается без активации (перед отображением окна свойству ShowActivated присваивается значение false).

Расположение окон

Пока окно открыто, для него задано положение и размеры по осям X и Y относительно рабочего стола. Это расположение можно определить путем проверки свойств Left и Top соответственно. Можно задать эти свойства для изменения расположения окна.

Также можно задать начальное расположение Window при его первом появлении с помощью свойства WindowStartupLocation и одного из следующих значений перечисления WindowStartupLocation:

• Manual (по умолчанию)

• CenterScreen

• CenterOwner

Если начальное расположение указано как Manual, а свойства Left и Top не были установлены, то Window запросит Windows для определения места появления.

Окна переднего плана и Z-порядок

Помимо координат X и Y окно также имеет координату по оси Z, которая определяет его вертикальную позицию относительно других окон. Это явление называется Z-порядком окна. Их существует два типа: обычный Z-порядок и верхний Z-порядок. Расположение окна в обычном Z-порядке определяется его активностью. По умолчанию окно находится в нормальном Z-порядке. Расположение окна в верхнем Z-порядке также определяется его активностью. Кроме того, окна в верхнем z-порядке всегда расположены над окнами обычного Z-порядка. Окно можно расположить в верхнем Z-порядке, установив для его свойства Topmost значение true.

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


...


</Window>

Внутри каждого z-порядка текущее активное окно появляется поверх всех остальных окон одного Z-порядка.

Размер окна

Помимо расположения на рабочем столе окно имеет размер, определяемый несколькими свойствами, включая различные свойства ширины, высоты и SizeToContent.

MinWidth, Width и MaxWidth используются для управления диапазоном ширины, которую может иметь окно во время существования, и настроены, как показано в следующем примере.

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


...


</Window>

Высота окна управляется MinHeight, Height и MaxHeight, которые настраиваются, как показано в следующем примере.

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


...


</Window>

Поскольку различные значения высоты и ширины определяют диапазон, существует возможность устанавливать ширину и высоту изменяемого в размерах окна в любое значение в пределах указанного диапазона для соответствующего измерения. Чтобы определить текущую ширину и высоту, проверьте ActualWidth и ActualHeight соответственно.

Если необходимо, чтобы ширина и высота окна имели размер, соответствующий содержимому окна, то можно использовать свойство SizeToContent, которое имеет следующие значения:

• Manual. Не оказывает влияние (по умолчанию).

• Width. Растяжение окна по ширине содержимого имеет тот же эффект, что и установка MinWidth и MaxWidth по ширине содержимого.

• Height. Растяжение окна по высоте содержимого имеет тот же эффект, что и установка MinHeight и MaxHeight по высоте содержимого.

• WidthAndHeight. Растяжение окна по ширине и высоте содержимого имеет тот же эффект, что и установка MinHeight и MaxHeight по высоте содержимого, а MinWidth и MaxWidth по ширине содержимого.

В следующем коде показано окно, которое при первом отображении автоматически изменяет свои размеры по размеру содержимого, причем как по вертикали, так и по горизонтали.

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


...


</Window>

Порядок приоритета свойств изменения размера

По существу, различные свойства изменения размера окна объединяются для определения диапазона ширины и высоты для изменяемого в размерах окна. Чтобы гарантировать сохранение допустимого диапазона, Window вычисляет значения свойств размера, используя следующие приоритеты.

Для свойств высоты:

1. FrameworkElement.MinHeight >

2. FrameworkElement.MaxHeight >

3. SizeToContent.Height/SizeToContent.WidthAndHeight >

4. FrameworkElement.Height

Для свойств ширины:

1. FrameworkElement.MinWidth >

2. FrameworkElement.MaxWidth >

3. SizeToContent.Width/SizeToContent.WidthAndHeight >

4. FrameworkElement.Width

Порядок приоритета может также определять размер развернутого окна, что управляется с помощью свойства WindowState.

Состояние окна

Во время существования изменяемое в размерах окно может находиться в трех состояниях: обычном, свернутом и развернутом. Обычное состояние является состоянием окна по умолчанию. Если окно находится в этом состоянии, пользователь может перемещать его и изменять его размеры с помощью захвата для изменения размера или перетаскивания границы, если окно изменяется в размерах.

Окно в свернутом состоянии сворачивается в кнопку на панели задач, если ShowInTaskbar имеет значение true. В противном случае оно сворачивается до наименьшего допустимого размера и размещается в левом нижнем углу рабочего стола. Ни один тип свернутого окна не может быть изменен в размерах с помощью границ или захвата, хотя свернутое окно, которое не отображается на панели задач, можно перетаскивать по всему рабочему столу.

Окно в развернутом состоянии расширяется до максимально допустимого размера, который определяется свойствами MaxWidth,MaxHeight и SizeToContent. Как и свернутое окно, развернутое окно не может быть изменено в размерах с помощью захвата для изменения размера или перетаскиванием границ.

Примечание
Значения свойств окна Top, Left, Width и Height всегда представляют значения для нормального состояния, даже когда окно развернуто на весь экран или свернуто.

Состояние окна можно настроить путем установки его свойства WindowState, которое может иметь одно из следующих значений перечисления WindowState:

• Normal (по умолчанию)

• Maximized

• Minimized

В следующем примере показано создание окна, которое при открытии отображается развернутым.

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


...


</Window>

В общем случае следует задать WindowState для настройки начального состояния окна. После отображения изменяемого в размерах окна пользователи могут нажимать кнопки свертывания, развертывания и восстановления в строке заголовка для изменения состояния окна.

Вид окна

Можно изменить внешний вид клиентской области окна с помощью добавления характерного для окна содержимого, такого как кнопки, метки и текстовые поля. Для настройки неклиентской области Window предоставляет несколько свойств, включающих Icon для задания значка окна и Title для задания его заголовка.

Также можно изменить вид и поведение границы неклиентской области, настраивая режим изменения размера окна, стиль окна и будет ли оно отображается в виде кнопки на панели задач рабочего стола.

Этот подраздел состоит из следующих пунктов.

• Режим изменения размера
• Стиль окна
• Наличие панели задач

Режим изменения размера

С помощью значений свойства WindowStyle можно управлять способами изменения размера окна пользователями (если это разрешено). Выбор стиля окна влияет на то, может ли пользователь изменять размеры окна путем перетаскивания его границы с помощью мыши, отображаются ли кнопки Свернуть, Развернуть и Изменить размер в неклиентской области и доступны ли они, если они отображаются.

Можно настроить изменение размера окна путем установки его свойства ResizeMode, которое может принимать одно из следующих значений перечисления ResizeMode:

• NoResize

• CanMinimize

• CanResize (по умолчанию)

• CanResizeWithGrip

Как и в случае с WindowStyle, режим изменения размера окна нежелательно менять во время существования. Это означает, что лучше всего задать его из разметки XAML.

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


...


</Window>

Обратите внимание, что можно обнаружить, развернуто, свернуто или восстановлено окно, с помощью просмотра свойства WindowState.

Стиль окна

Граница, предоставляемая из неклиентской области окна, может использоваться в большинстве приложений. Однако существуют ситуации, когда в зависимости от типа окна требуются различные типы границ, или границы не требуются вовсе.

Для управления типом границы окна, установите его свойство WindowStyle с помощью одного из следующих значений перечисления WindowStyle:

• None

• SingleBorderWindow (по умолчанию)

• ThreeDBorderWindow

• ToolWindow

Воздействие этих оконных стилей показано на следующем рисунке.

Можно задать WindowStyle XAML, используя либо разметку, либо код. Поскольку его вряд ли можно изменить во время существования окна, то лучше всего задать его из разметки XAML.

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


...


</Window>

Непрямоугольный стиль окна

Существуют также ситуации, когда недостаточно стилей границ, предоставляемых WindowStyle. Например, возможно, потребуется создать приложение с непрямоугольной границей, подобно той, которую использует Microsoft Windows Media Player.

Например, рассмотрим окно типа "Облачко", показанное на следующем рисунке.

Этот тип окна можно создать, задав свойству WindowStyle значение None, и с помощью специальной поддержки прозрачности Window.

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


...


</Window>

Это сочетание значений приводит к тому, что окно отображается полностью прозрачным. В этом состоянии нельзя использовать элементы оформления неклиентской области окна (меню "Закрыть", кнопки "Свернуть", "Развернуть" и "Восстановить" и т. д.). Следовательно, необходимо предоставить свои собственные.

Наличие панели задач

По умолчанию вид окна включает кнопку панели задач, как показано на следующем рисунке.

Некоторые типы окон не имеют кнопки панели задач, например окна сообщений и диалоговые окна (см. Общие сведения о диалоговых окнах). Можно управлять отображением кнопки панели задач окна с помощью свойства ShowInTaskbar (по умолчанию true).

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


...


</Window>

Вопросы безопасности

Window требует создания разрешения безопасности UnmanagedCode. Для приложений, установленных и запускаемых с локального компьютера, они включены в набор разрешений, которые предоставляются приложению.

Однако для приложений, запускаемых из Интернета или локальной интрасети с помощью ClickOnce, они не попадут в этот набор разрешений. Следовательно, пользователи будут получать предупреждение безопасности ClickOnce и необходимо расширить набор разрешений приложения до полного доверия.

Кроме того, по умолчанию XBAPs не может отображать окна или диалоговые окна. Вопросы безопасности в автономных приложениях рассматриваются в разделе Стратегия безопасности WPF — безопасность платформы.

Другие типы окон

NavigationWindow представляет собой окно, предназначенное для предоставления навигации по содержимому. Дополнительные сведения см. в разделе Общие сведения о переходах.

Диалоговые окна являются окнами, которые часто используются для сбора сведений от пользователя, необходимых для выполнения функции. Например, когда пользователь хочет открыть файл, то обычно приложение отображает диалоговое окно Открытие файла для получения имени файла от пользователя. Дополнительные сведения см. в разделе Общие сведения о диалоговых окнах.

См. также

Ссылки

Window

MessageBox

NavigationWindow

Application

Основные понятия

Общие сведения о диалоговых окнах

Построение приложения WPF