Visão geral do WPF Windows

Os usuários interagem com aplicativos autônomos do Windows Presentation Foundation (WPF) por meio do Windows. O objetivo principal de uma janela é hospedar conteúdo que visualize dados e permita que os usuários interajam com dados. Aplicativos WPF autônomos fornecem suas próprias janelas usando a classe Window. Este tópico apresenta Window antes de abordar os fundamentos da criação e gerenciamento de janelas em aplicativos autônomos.

A classe Window

A figura a seguir ilustra as partes constituintes de uma janela:

Uma janela é dividida em duas áreas: a área não cliente e a área cliente.

A área não cliente de uma janela é implementada pelo WPF e inclui as partes de uma janela que são comuns à maioria das janelas, incluindo o seguinte:

• Uma fronteira.

• Uma barra de título.

• Um ícone.

• Botões Minimizar, Maximizar e Restaurar.

• Um botão Fechar.

• Um menu Sistema com itens de menu que permitem aos usuários minimizar, maximizar, restaurar, mover, redimensionar e fechar uma janela.

A área do cliente de uma janela é a área dentro da área não cliente de uma janela e é usada pelos desenvolvedores para adicionar conteúdo específico do aplicativo, como barras de menus, barras de ferramentas e controles.

No WPF, uma janela é encapsulada pela classe Window que você usa para fazer o seguinte:

• Exiba uma janela.

• Configure o tamanho, a posição e a aparência de uma janela.

• Hospede conteúdo específico do aplicativo.

• Gerencie o tempo de vida de uma janela.

Implementando uma janela

A implementação de uma janela típica compreende aparência e comportamento, onde aparência define como uma janela parece para os usuários e comportamento define a maneira como uma janela funciona como os usuários interagem com ela. No WPF, você pode implementar a aparência e o comportamento de uma janela usando código ou marcação XAML.

Em geral, no entanto, a aparência de uma janela é implementada usando marcação XAML e seu comportamento é implementado usando code-behind, conforme mostrado no exemplo a seguir.

<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

Para permitir que um arquivo de marcação XAML e um arquivo code-behind trabalhem juntos, é necessário o seguinte:

• Na marcação, o elemento Window deve incluir o atributo x:Class. Quando o aplicativo é criado, a existência de x:Class no arquivo de marcação faz com que o mecanismo de compilação da Microsoft (MSBuild) crie uma classe partial que deriva de Window e tem o nome especificado pelo atributo x:Class. Isso requer a adição de uma declaração de namespace XML para o esquema XAML ( xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" ). A classe partial gerada implementa o método InitializeComponent, que é chamado para registrar os eventos e definir as propriedades que são implementadas na marcação.

• Em code-behind, a classe deve ser uma classe partial com o mesmo nome especificado pelo atributo x:Class na marcação e deve derivar de Window. Isso permite que o arquivo code-behind seja associado à classe partial que é gerada para o arquivo de marcação quando o aplicativo é criado (consulte Criando um aplicativo WPF).

• No arquivo de code-behind, a classe Window deve implementar um construtor que chama o método InitializeComponent. InitializeComponent é implementado pela classe partial gerada do arquivo de marcação para registrar eventos e definir propriedades definidas na marcação.

Com esta configuração em vigor, pode-se concentrar em definir a aparência da janela na marcação XAML e implementar o seu comportamento no código subjacente. O exemplo a seguir mostra uma janela com um botão, implementado na marcação XAML, e um manipulador de eventos para o evento Click do botão, implementado no code-behind.

<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

Configurando uma definição de janela para MSBuild

Como você implementa sua janela determina como ela é configurada para MSBuild. Para uma janela definida usando marcação XAML e código subjacente:

• Os arquivos de marcação XAML são configurados como itens Page do MSBuild.

• Os ficheiros code-behind são configurados como itens Compile do MSBuild.

Isso é mostrado no seguinte arquivo de projeto MSBuild.

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

Para obter informações sobre como criar aplicativos WPF, consulte Criando um aplicativo WPF.

Tempo de vida da janela

Como em qualquer classe, uma janela tem um tempo de vida que começa quando é instanciada pela primeira vez, após o qual é aberta, ativada e desativada e, eventualmente, fechada.

Abrir uma janela

Para abrir uma janela, primeiro crie uma instância dela, o que é demonstrado no exemplo a seguir.

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

Neste exemplo, o MarkupAndCodeBehindWindow é instanciado quando o aplicativo é iniciado, o que ocorre quando o evento Startup é gerado.

Quando uma janela é instanciada, uma referência a ela é adicionada automaticamente a uma lista de janelas gerenciadas pelo objeto Application (consulte Application.Windows). Além disso, a primeira janela a ser instanciada é, por padrão, definida por Application como a janela principal do aplicativo (consulte Application.MainWindow).

A janela é finalmente aberta chamando o método Show; O resultado é mostrado na figura a seguir.

Uma janela que é aberta chamando Show é uma janela sem modal, o que significa que a aplicação opera num modo que permite aos utilizadores ativar outras janelas na mesma aplicação.

Quando Show é chamado, uma janela executa o trabalho de inicialização antes de ser mostrada para estabelecer uma infraestrutura que permita receber entrada do usuário. Quando a janela é inicializada, o evento SourceInitialized é gerado e a janela é mostrada.

Como atalho, StartupUri pode ser definido para especificar a primeira janela que é aberta automaticamente quando um aplicativo é iniciado.

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

Quando o aplicativo é iniciado, a janela especificada pelo valor de StartupUri é aberta de forma não modal; internamente, a janela é aberta chamando seu método Show.

Propriedade da janela

Uma janela que é aberta usando o método Show não tem uma relação implícita com a janela que a criou; Os usuários podem interagir com qualquer janela independentemente da outra, o que significa que qualquer janela pode fazer o seguinte:

• Cubra a outra (a menos que uma das janelas tenha sua propriedade Topmost definida como true).

• Podem ser minimizados, maximizados e restaurados sem afectar os outros.

Algumas janelas requerem uma relação com a janela que as abre. Por exemplo, um aplicativo IDE (Ambiente de Desenvolvimento Integrado) pode abrir janelas de propriedades e janelas de ferramentas cujo comportamento típico é cobrir a janela que as cria. Além disso, estas janelas devem sempre fechar, minimizar, maximizar e restaurar em simultâneo com a janela que as criou. Tal relação pode ser estabelecida fazendo com que uma janela se torne subordinada a outra, e é alcançada definindo a propriedade Owner da janela subordinada com uma referência à janela principal . Isso é mostrado no exemplo a seguir.

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

Após a propriedade ser estabelecida:

• A janela de propriedade pode fazer referência à janela do proprietário inspecionando o valor de sua propriedade Owner.

• A janela do proprietário pode descobrir todas as janelas que possui, inspecionando o valor de sua propriedade OwnedWindows.

Impedindo a ativação da janela

Há cenários em que as janelas não devem ser ativadas quando mostradas, como janelas de conversa de um aplicativo estilo mensageiro da Internet ou janelas de notificação de um aplicativo de email.

Se seu aplicativo tiver uma janela que não deve ser ativada quando mostrada, você pode definir sua propriedade ShowActivated como false antes de chamar o método Show pela primeira vez. Consequentemente:

• A janela não está ativada.

• O evento Activated da janela não é ativado.

• A janela atualmente ativada permanece ativada.

A janela será ativada assim que o utilizador a ativar, clicando na área do cliente ou na área não cliente. Neste caso:

• A janela está ativada.

• O evento de Activated da janela é levantado.

• A janela ativada anteriormente é desativada.

• Os eventos Deactivated e Activated da janela são subsequentemente gerados, conforme esperado, em resposta às ações do usuário.

Ativação da janela

Quando uma janela é aberta pela primeira vez, ela se torna a janela ativa (a menos que seja mostrada com ShowActivated definida como false). A janela ativa é a janela que está a receber a entrada do utilizador no momento, como toques no teclado e cliques do rato. Quando uma janela se torna ativa, ela gera o evento Activated.

Depois que uma janela se torna ativa, um usuário pode ativar outra janela no mesmo aplicativo ou ativar outro aplicativo. Quando isso acontece, a janela atualmente ativa é desativada e gera o evento Deactivated. Da mesma forma, quando o usuário seleciona uma janela atualmente desativada, a janela fica ativa novamente e Activated é gerada.

Uma razão comum para lidar com Activated e Deactivated é habilitar e desabilitar a funcionalidade que só pode ser executada quando uma janela está ativa. Por exemplo, algumas janelas exibem conteúdo interativo que requer entrada ou atenção constante do usuário, incluindo jogos e players de vídeo. O exemplo a seguir é um leitor de vídeo simplificado que demonstra como lidar com Activated e Deactivated para implementar esse comportamento.

<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

Outros tipos de aplicativos ainda podem executar código em segundo plano quando uma janela é desativada. Por exemplo, um cliente de email pode continuar sondando o servidor de email enquanto o usuário está usando outros aplicativos. Aplicativos como esses geralmente fornecem um comportamento diferente ou adicional enquanto a janela principal está desativada. Com relação ao programa de email, isso pode significar adicionar o novo item de email à caixa de entrada e adicionar um ícone de notificação à bandeja do sistema. Um ícone de notificação só precisa ser exibido quando a janela de email não estiver ativa, o que pode ser determinado inspecionando a propriedade IsActive.

Se uma tarefa em segundo plano for concluída, uma janela pode querer notificar o utilizador com mais urgência ao chamar o método Activate. Se o usuário estiver interagindo com outro aplicativo ativado quando Activate é chamado, o botão da barra de tarefas da janela pisca. Se um usuário estiver interagindo com o aplicativo atual, chamar Activate trará a janela para o primeiro plano.

Fechar uma janela

A vida útil de uma janela começa a chegar ao fim quando um usuário a fecha. Uma janela pode ser fechada usando elementos na área não cliente, incluindo o seguinte:

• O Fechar item do menu Sistema .

• Pressionando ALT+F4.

• Pressionando o botão Fechar.

Você pode fornecer mecanismos adicionais para a área do cliente para fechar uma janela, os mais comuns dos quais incluem o seguinte:

• Um item Sair no menu Arquivo , normalmente para as janelas principais do aplicativo.

• Um Fechar item no menu Arquivo , normalmente em uma janela secundária do aplicativo.

• Um botão Cancelar, normalmente numa caixa de diálogo modal.

• Um botão Fechar, normalmente numa caixa de diálogo não modal.

Para fechar uma janela em resposta a um desses mecanismos personalizados, você precisa chamar o método Close. O exemplo a seguir implementa a capacidade de fechar uma janela escolhendo o Exit no menu File.

<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

Quando uma janela se fecha, ela gera dois eventos: Closing e Closed.

Closing é levantado antes de a janela fechar, e fornece um mecanismo pelo qual o fechamento da janela pode ser evitado. Uma razão comum para evitar o fechamento da janela é se o conteúdo da janela contiver dados modificados. Nessa situação, o evento Closing pode ser manipulado para determinar se os dados estão sujos e, em caso afirmativo, para perguntar ao usuário se deve continuar fechando a janela sem salvar os dados ou cancelar o fechamento da janela. O exemplo seguinte mostra os principais aspetos do tratamento 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

O manipulador de eventos Closing recebe um CancelEventArgs, que implementa a propriedade BooleanCancel que você define para true para impedir que uma janela seja fechada.

Se Closing não for manipulado, ou for manipulado mas não cancelado, a janela será fechada. Pouco antes de uma janela realmente fechar, o sinal Closed é acionado. Neste ponto, uma janela não pode ser impedida de fechar.

Embora uma janela possa ser explicitamente fechada por meio de mecanismos fornecidos nas áreas não-cliente e cliente, uma janela também pode ser implicitamente fechada como resultado do comportamento em outras partes do aplicativo ou do Windows, incluindo o seguinte:

• Um utilizador termina a sessão ou desliga o Windows.

• Uma janela é fechada pelo proprietário (consulte Owner).

• A janela principal do aplicativo está fechada e ShutdownMode é OnMainWindowClose.

• Shutdown é chamado.

Eventos de Ciclo de Vida da Janela

A ilustração a seguir mostra a sequência dos principais eventos no tempo de vida de uma janela:

A ilustração a seguir mostra a sequência dos eventos principais no tempo de vida de uma janela que é mostrada sem ativação (ShowActivated é definida como false antes da janela ser mostrada):

Localização da janela

Enquanto uma janela está aberta, ela tem um local nas dimensões x e y em relação à área de trabalho. Esse local pode ser determinado inspecionando as propriedades Left e Top, respectivamente. Você pode definir essas propriedades para alterar o local da janela.

Você também pode especificar o local inicial de um Window quando ele aparece pela primeira vez definindo a propriedade WindowStartupLocation com um dos seguintes valores de enumeração WindowStartupLocation:

• CenterOwner (padrão)

• CenterScreen

• Manual

Se o local de inicialização for especificado como Manuale as propriedades Left e Top não tiverem sido definidas, Window solicitará ao Windows que escolha um local para aparecer.

Topmost Windows e Z-Order

Além de ter uma localização x e y, uma janela também tem uma localização na dimensão z, que determina a sua posição vertical em relação a outras janelas. Isso é conhecido como ordem z da janela, e há dois tipos: ordem z normal e ordem z superior. A localização de uma janela no de ordem z normal é determinada pelo facto de a janela estar atualmente ativa ou não. Por padrão, uma janela está localizada na ordem z normal. A localização de uma janela no de ordem z mais alta também é determinada pelo fato de ela estar ativa ou não. Além disso, as janelas na ordem z mais alta estão sempre localizadas acima das janelas na ordem z normal. Uma janela é posicionada na camada superior da ordem z ao definir a sua propriedade Topmost como true.

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

Dentro de cada ordem z, a janela atualmente ativa aparece acima de todas as outras janelas na mesma ordem z.

Tamanho da janela

Além de ter uma localização no ambiente de trabalho, uma janela tem um tamanho determinado por várias propriedades, incluindo as de largura e altura e SizeToContent.

MinWidth, Widthe MaxWidth são usados para gerenciar o intervalo de larguras que uma janela pode ter durante sua vida útil e são configurados conforme mostrado no exemplo a seguir.

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

A altura da janela é gerenciada por MinHeight, Heighte MaxHeighte são configuradas conforme mostrado no exemplo a seguir.

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

Como os vários valores de largura e altura especificam um intervalo, é possível que a largura e a altura de uma janela redimensionável estejam em qualquer lugar dentro do intervalo especificado para a respetiva dimensão. Para detetar sua largura e altura atuais, inspecione ActualWidth e ActualHeight, respectivamente.

Se pretender que a largura e a altura da janela tenham um tamanho adequado ao tamanho do conteúdo da janela, pode utilizar a propriedade SizeToContent, que tem os seguintes valores:

• Manual. Sem efeito (padrão).

• Width. Ajustar à largura do conteúdo, o que tem o mesmo efeito que definir tanto MinWidth como MaxWidth para a largura do conteúdo.

• Height. Ajuste à altura do conteúdo, que tem o mesmo efeito que definir MinHeight e MaxHeight para a altura do conteúdo.

• WidthAndHeight. Ajuste à largura e altura do conteúdo, o que tem o mesmo efeito que definir MinHeight e MaxHeight para a altura do conteúdo e definir MinWidth e MaxWidth para a largura do conteúdo.

O exemplo a seguir mostra uma janela que é dimensionada automaticamente para ajustar seu conteúdo, tanto vertical quanto horizontalmente, quando mostrada pela primeira vez.

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

O exemplo a seguir mostra como definir a propriedade SizeToContent no código para especificar como uma janela é redimensionada para se ajustar ao seu conteúdo.

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

Ordem de precedência para propriedades de dimensionamento

Essencialmente, as propriedades de vários tamanhos de uma janela combinam-se para definir o intervalo de largura e altura para uma janela redimensionável. Para garantir que um intervalo válido seja mantido, o Window avalia os valores das propriedades de tamanho usando as seguintes ordens de precedência.

Relativamente às Propriedades de Altura:

1. FrameworkElement.MinHeight

2. FrameworkElement.MaxHeight

3. SizeToContent.Height/SizeToContent.WidthAndHeight

4. FrameworkElement.Height

Para propriedades de largura:

1. FrameworkElement.MinWidth

2. FrameworkElement.MaxWidth

3. SizeToContent.Width/SizeToContent.WidthAndHeight

4. FrameworkElement.Width

A ordem de precedência também pode determinar o tamanho de uma janela quando ela é maximizada, que é gerenciada com a propriedade WindowState.

Estado da janela

Durante a vida útil de uma janela redimensionável, ela pode ter três estados: normal, minimizado e maximizado. Uma janela com um estado normal é o estado padrão de uma janela. Uma janela com esse estado permite que um usuário a mova e redimensione usando uma pega de redimensionamento ou a borda, se for redimensionável.

Uma janela com um estado de minimizado colapsa para o botão da barra de tarefas se estiver definido como ; caso contrário, ele colapsa para o menor tamanho possível e se desloca para o canto inferior esquerdo da área de trabalho. Nenhum dos tipos de janela minimizada pode ser redimensionada usando uma borda ou uma pega de redimensionamento, embora uma janela minimizada que não seja mostrada na barra de tarefas possa ser arrastada pela área de trabalho.

Uma janela com um estado maximizado expande-se para o tamanho máximo que pode ser, que só será tão grande quanto as suas propriedades MaxWidth, MaxHeighte SizeToContent ditarem. Como uma janela minimizada, uma janela maximizada não pode ser redimensionada usando um controlador de redimensionamento ou arrastando a borda.

O estado de uma janela pode ser configurado definindo sua propriedade WindowState, que pode ter um dos seguintes valores de enumeração WindowState:

• Normal (padrão)

• Maximized

• Minimized

O exemplo a seguir mostra como criar uma janela que é mostrada como maximizada quando ela é aberta.

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

Em geral, você deve definir WindowState para configurar o estado inicial de uma janela. Depois que uma janela redimensionável é mostrada, os usuários podem pressionar os botões minimizar, maximizar e restaurar na barra de título da janela para alterar o estado da janela.

Aparência da janela

Você altera a aparência da área do cliente de uma janela adicionando conteúdo específico da janela a ela, como botões, rótulos e caixas de texto. Para configurar a área não-cliente, Window fornece várias propriedades, que incluem Icon para definir o ícone de uma janela e Title para definir seu título.

Você também pode alterar a aparência e o comportamento da borda da área não cliente configurando o modo de redimensionamento de uma janela, o estilo da janela e se ela aparece como um botão na barra de tarefas da área de trabalho.

Modo de redimensionamento

Dependendo da propriedade WindowStyle, você pode controlar como (e se) os usuários podem redimensionar a janela. A escolha do estilo da janela afeta se um usuário pode redimensionar a janela arrastando sua borda com o mouse, se os botões Minimizar, Maximizare Redimensionaraparecem na área não cliente e, se aparecerem, se estão habilitados.

Você pode configurar como uma janela é redimensionada definindo sua propriedade ResizeMode, que pode ser um dos seguintes valores de enumeração ResizeMode:

• NoResize

• CanMinimize

• CanResize (padrão)

• CanResizeWithGrip

Assim como no WindowStyle, é improvável que o modo de redimensionamento de uma janela mude durante sua vida útil, o que significa que você provavelmente a definirá a partir da marcação XAML.

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

Observe que você pode detetar se uma janela é maximizada, minimizada ou restaurada inspecionando a propriedade WindowState.

Estilo da janela

A borda exposta da área não cliente de uma janela é adequada para a maioria das aplicações. No entanto, existem circunstâncias em que são necessários diferentes tipos de fronteiras, ou em que não são necessárias quaisquer fronteiras, dependendo do tipo de janela.

Para controlar que tipo de borda uma janela obtém, defina sua propriedade WindowStyle com um dos seguintes valores da enumeração WindowStyle:

• None

• SingleBorderWindow (padrão)

• ThreeDBorderWindow

• ToolWindow

O efeito desses estilos de janela é ilustrado na figura a seguir:

Você pode definir WindowStyle usando marcação ou código XAML; como é improvável que ela seja alterada durante o tempo de vida de uma janela, você provavelmente a configurará usando marcação XAML.

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

Estilo de janela não retangular

Há também situações em que os estilos de bordas que o WindowStyle lhe permite ter não são suficientes. Por exemplo, você pode querer criar um aplicativo com uma borda não retangular, como o Microsoft Windows Media Player usa.

Por exemplo, considere a janela de balão de fala mostrada na figura a seguir:

Esse tipo de janela pode ser criado definindo a propriedade WindowStyle como Nonee usando suporte especial que Window tem para transparência.

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

Essa combinação de valores instrui a janela a renderizar completamente transparente. Nesse estado, os elementos da área não cliente da janela (os botões Fechar, Minimizar, Maximizar, Restaurar, entre outros) não podem ser usados. Consequentemente, terás de fornecer o teu próprio.

Presença na Barra de Tarefas

A aparência padrão de uma janela inclui um botão da barra de tarefas, como o mostrado na figura a seguir:

Alguns tipos de janelas não têm um botão da barra de tarefas, como caixas de mensagem e caixas de diálogo (consulte Visão geral das caixas de diálogo). Você pode controlar se o botão da barra de tarefas de uma janela é mostrado definindo a propriedade ShowInTaskbar (true por padrão).

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

Considerações de segurança

Window requer UnmanagedCode permissão de segurança para ser instanciada. Para aplicativos instalados e iniciados a partir da máquina local, isso se enquadra no conjunto de permissões concedidas ao aplicativo.

No entanto, isso está fora do conjunto de permissões concedidas a aplicativos que são iniciados a partir da Internet ou zona de intranet local usando ClickOnce. Consequentemente, os usuários receberão um aviso de segurança do ClickOnce e precisarão elevar o conjunto de permissões para o aplicativo para confiança total.

Além disso, XBAPs não podem mostrar janelas ou caixas de diálogo por padrão. Para uma Discussão sobre Considerações de Segurança de Aplicações Independentes, consulte Estratégia de Segurança do WPF - Segurança da Plataforma.

Outros tipos de janelas

NavigationWindow é uma janela projetada para hospedar conteúdo navegável. Para obter mais informações, consulte Visão geral da navegação).

As caixas de diálogo são janelas que geralmente são usadas para coletar informações de um usuário para concluir uma função. Por exemplo, quando um usuário deseja abrir um arquivo, a caixa de diálogo Abrir arquivo geralmente é exibida por um aplicativo para obter o nome do arquivo do usuário. Para obter mais informações, consulte a Visão Geral das Caixas de Diálogo .

Ver também

• Window
• MessageBox
• NavigationWindow
• Application
• Visão geral das caixas de diálogo
• Criando um aplicativo WPF