Share via

Visão geral do WPF do Windows

  • Artigo

Os usuários interagem com aplicativos autônomos do Windows Presentation Foundation (WPF) pelo Windows. O objetivo principal de uma janela é para hospedar conteúdo que visualiza dados e permite que os usuários interajam com dados. Standalone WPF aplicativos fornecem suas próprias janelas usando o Window classe. Este tópico apresenta Window antes de abranger os fundamentos da criação e gerenciamento de janelas de aplicativos autônomos.

ObservaçãoObservação:

Hospedado no navegador WPF aplicativos, incluindo aplicativos de navegador XAML (XBAPs) e flexível Extensible Application Markup Language (XAML) páginas, não fornecem suas próprias janelas. Em vez disso, eles são hospedados em janelas fornecidas pelo Windows Internet Explorer. Consulte Visão geral sobre Windows Presentation Foundation XAML Browser Applications.

Este tópico contém as seguintes seções.

  • A classe Window
  • Implementando uma janela
  • Configurando uma definição de janela para MSBuild
  • Tempo de vida de janela
  • Local da Janela
  • Tamanho da Janela
  • Ordem de precedência para propriedades de dimensionamento
  • Estado da Janela
  • Aparência da Janela
  • Considerações sobre segurança
  • Outros tipos de Windows
  • Tópicos relacionados

A classe Window

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

Elementos de janela

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

A non-client area de uma janela é implementado por WPF e inclui as partes de uma janela que são comuns a maioria das janelas, incluindo o seguinte:

  • Uma borda.

  • Um barra de título.

  • Um ícone.

  • Botões de Minimizar, Maximizar e Restaurar.

  • Um botão Fechar.

  • Um menu de sistema com itens de menu que permitem que os usuários minimizar, maximizar, restauração, mover, redimensionar e fechar uma janela.

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

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

  • Exibe uma janela.

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

  • Conteúdo específico de aplicativo Host.

  • Gerencie o tempo de vida de uma janela.

Implementando uma janela

A implementação de uma janela típica compreende tanto aparência e comportamento, onde appearance define como uma janela aparece para os usuários e Appearance a maneira como uma janela funções como usuários interagir com ele. Em WPF,você pode implementar a aparência e 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 código por trás, como mostrado no exemplo a seguir.

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

using System.Windows; // Window

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

Para ativar um arquivo de marcação XAML e arquivo de código de apoio para funcionar juntos, o seguinte é necessário:

  • Na marcação, o elemento Window precisa incluir o atributo x:Class. Quando o aplicativo é construído, a existência do x:Class no arquivo de marcação causa o Mecanismo de compilação Microsoft (MSBuild) a criar uma classe partial que deriva de Window e possui o nome que é especificado pelo atributo x:Class. Isto requer a adição de uma declaração de namespace XML no esquema XAML (xmlns:x="https://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.

  • Nos arquivo de lógica, a classe precisa ser uma classe partial com o mesmo nome que o especificado pelo atributo x:Class na marcação, e precisa derivar de Window. Isto permite ao arquivo de lógica estar associado à classe partial que é gerada para o arquivo de marcação quando o aplicativo é construído (veja Building a WPF Application (WPF)).

  • No code-behind, o Window a classe deve implementar um construtor que chama o InitializeComponent método. InitializeComponent é implementada pela marcação da gerado o arquivo partial classe de registro de eventos e conjunto as propriedades definidas na marcação.

ObservaçãoObservação:

Quando você adiciona um novo Window para seu projeto, usando Microsoft Visual Studio, o Window é implementada usando marcação e code-behind e inclui a configuração necessária para criar a associação entre sistema autônomo arquivos code-behind e de marcação, conforme descrito aqui.

Com essa configuração no lugar, você pode focalizar na definição da aparência da janela na marcação XAML e implementar seu comportamento no código de apoio. O exemplo a seguir mostra uma janela com um botão, implementada na marcação XAML, e um manipulador de eventos para o evento do botão Click, implementado no código de apoio.

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

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

Configurando uma definição de janela para MSBuild

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

  • Arquivos de marcação XAML são configurados como itens MSBuild Page.

  • Arquivos de código de apoio são configurados como itens MSBuild Compile.

Isso é mostrado no seguinte arquivo de projeto do MSBuild.

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

Para obter informações sobre criação de aplicativos WPF, consulte Building a WPF Application (WPF).

Tempo de vida de janela

Como com qualquer classe, uma janela tem uma vida útil que começa quando ela é instanciada pela primeira vez, após a qual ela é aberta, ativada e desativada e eventualmente fechada.

Esta seção contém as seguintes subseções.

  • Abrindo uma janela
  • Ativação de Janela
  • Fechando uma janela
  • Eventos de Tempo de Vida da Janela

Abrindo uma janela

Para abrir uma janela, você primeiro cria uma instância dela, que é demonstrada no exemplo a seguir.

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

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

Nesse exemplo, a MarkupAndCodeBehindWindow é instanciada quando o aplicativo for iniciado, que ocorre quando o evento Startup é gerado.

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

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

Uma janela aberta chamando Window.Show

Uma janela que é aberta, chamando Show é uma janela sem janela restrita, o que significa que o aplicativo opera em um modo que permite aos usuários ativar outras janelas no mesmo aplicativo.

ObservaçãoObservação:

ShowDialog é chamado para abrir janelas, como caixas de diálogo modalmente. Consulte Dialog Boxes Overview para obter mais informações.

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

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

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

Quando o aplicativo for iniciado, a janela especificada pelo valor de StartupUri é aberta em modo sem restrição; internamente, a janela é aberta, chamando o 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 de outra, o que significa que qualquer janela pode fazer o seguinte:

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

  • Ser minimizada, maximizada, e restaurada sem afetar as outras.

Algumas janelas requerem uma relação com a janela que as abriu. Por exemplo, um aplicativo Ambiente de Desenvolvimento Integrado (IDE) pode abrir janelas de propriedade e janelas de ferramenta cujo comportamento típico é para cobrir a janela que as criou. Além disso, essas janelas devem sempre fechar, minimizar, maximizar e restaurar em conjunto com a janela em que as criou. Tal relação pode ser estabelecida por fazer com que uma janela own a outra, e é obtido definindo a propriedade Owner da owned window com uma referência à owner window. Isto é mostrado no exemplo a seguir.

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

Depois que a propriedade é estabelecida:

  • A janela propriedade pode fazer referência a janela sua proprietária inspecionando o valor de sua propriedade Owner.

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

Impedindo a ativação de janela

Há situações em que windows devem ser ativadas não quando mostrado sistema autônomo janelas de conversa de um aplicativo de 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 mostrado, você pode conjunto seus ShowActivated propriedade para false antes de ligar o Show método pela primeira vez. sistema autônomo conseqüência:

  • A janela não está ativada.

  • Activated evento não é aumentado.

  • Janela ativada no momento permanece ativada.

Será da janela tornam-se ativado, no entanto, sistema autônomo logo sistema autônomo o o usuário ativa clicando a área de cliente ou que não é destinada aos clientes. Nesse caso:

  • A janela é ativada.

  • Activated evento é gerado.

  • A janela ativada anteriormente é desativada.

  • Deactivated e Activated eventos são disparados subseqüentemente sistema autônomo esperado na resposta às ações do usuário.

Para obter um exemplo que demonstra como mostrar uma janela sem ativá-lo, consulte Mostrar uma janela sem ativar exemplo.

Ativação de Janela

Quando uma janela for aberta pela primeira vez, torna a janela ativo (a menos que ele é mostrado com ShowActivated conjunto para false). A active window é a janela que está atualmente capturando entrada do usuário, tal como os pressionamentos de tecla e cliques do mouse. Quando uma janela fica ativa, ela gera o evento Activated.

ObservaçãoObservação:

Quando uma janela é primeiro aberto, o Loaded e ContentRendered eventos são disparados somente após o Activated evento é gerado. Com isso em mente, uma janela pode efetivamente ser considerada aberta quando ContentRendered é gerado.

Após uma janela se tornar ativa, um usuário pode ativar outra janela no mesmo aplicativo, ou ativar outro aplicativo. Quando isso acontece, a janela atualmente ativa se torna desativa e gera o evento Deactivated. Da mesma forma, quando o usuário seleciona uma janela desativada no momento, a janela ficará ativa novamente e Activated é gerado.

Um motivo comum para manipular Activated e Deactivated é ativar e desativar funcionalidades que podem apenas executar quando uma janela está ativa. Por exemplo, algumas janelas exibem conteúdo interativo que requer constante entrada ou atenção do usuário, incluindo jogos e tocadores de vídeo. O exemplo a seguir é um tocador de vídeo simplificado que demonstra como manipular Activated e Deactivated para implementar esse comportamento.

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

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();
        }
    }
}
ObservaçãoObservação:

Consulte Janela ativação e desativação de exemplo Para obter um exemplo completo.

Outros tipos de aplicativos ainda podem executar códigos em segundo plano quando uma janela é desativada. Por exemplo, um cliente de email pode continuar pesquisando o servidor de email enquanto o usuário estiver usando outros aplicativos. Aplicativos como esses geralmente fornecem comportamentos diferentes ou adicionais enquanto a janela principal é desativada. Com relação ao programa de email, isso pode significar ambos adicionando o novo item de email para a Caixa de Entrada e adicionando um ícone de notificação para a bandeja do sistema. Um ícone de notificação só precisa ser exibido quando a janela de email não está ativa, que pode ser determinada verificando a propriedade IsActive.

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

ObservaçãoObservação:

Você pode manipular a ativação de escopo de aplicativo usando o Application.Activated e Application.Deactivated eventos.

Fechando uma janela

A vida de uma janela inicia vindo ao final quando um usuário a fecha. Uma janela pode ser fechada usando elementos na área não cliente, incluindo o seguinte:

  • O item Close do menu System.

  • Pressionando ALT+F4.

  • Pressionar o botão Close.

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

  • Um item Exit no menu File, geralmente para janelas do aplicativo principal.

  • Um item Close no menu File, normalmente em uma janela do aplicativo secundário.

  • Um botão Cancel,geralmente em uma caixa de diálogo em modo de janela restrita.

  • Um botão Close, normalmente em uma caixa de diálogo em modo de janela não restrita.

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

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

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

Quando uma janela é fechada, ele lança dois eventos: Closing e Closed.

Closing é gerado antes da janela fechar, e ele 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 contém dados modificados. Nesta situação, o evento Closing pode ser tratado para determinar se os dados estão impróprios e, em caso afirmativo, perguntar ao usuário se continua o fechamento da janela sem salvar os dados ou cancela o fechamento da janela. O exemplo a seguir mostra os principais aspectos 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;


...


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

Ao manipulador de eventos Closing é passado um CancelEventArgs, que implementa a propriedade Boolean Cancel que você define como true para impedir que uma janela seja fechada.

Se Closing não é tratado, ou é tratado mas não cancelado, a janela será fechada. Pouco antes de uma janela realmente fechar, Closed é gerado. Neste ponto, uma janela não pode ser impedida de fechamento.

ObservaçãoObservação:

Um aplicativo pode ser configurado para ser desligado automaticamente quando fecha janela principal do aplicativo (consulte a MainWindow) ou a última janela será fechada. Para obter detalhes, consulte:ShutdownMode.

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

ObservaçãoObservação:

Uma janela não pode ser reaberta depois que ela for fechada.

Eventos de Tempo de Vida da Janela

A ilustração a seguir mostra a sequência de eventos principais na vida útil de uma janela.

Tempo de vida de janela

A ilustração a seguir mostra a sequência de eventos principais na tempo de vida de uma janela que é mostrada sem ativação (ShowActivated é definido como false antes da janela é mostrada).

Tempo de vida de janela (Window.ShowActivated = False)

Local da Janela

Embora uma janela estiver aberta, ela tem um local em que x e y dimensões em relação a á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 é inicialmente exibido, definindo a propriedade WindowStartupLocation com um dos seguintes valores de enumeração WindowStartupLocation:

Se o local de inicialização é especificado como Manual e as propriedades Left e Top não foram definidas, Window solicitará ao Windows um local a ser exibido.

Janela Superior e Ordem Z

Além de ter uma localização x e y , uma janela também possui uma localização na dimensão z, que determina sua posição vertical em relação às outras janelas. Isso é conhecido sistema autônomo ordem-z da janela, e há dois tipos: ordem-z normal e ordem z superior. A localização de uma janela na normal z-order é determinada pelo fato de se ela está ativa no momento ou não. Por padrão, uma janela está localizada na ordem z normal. A localização de uma janela na topmost z-order também é determinada pelo fato de se ela está ativa no momento ou não. Além disso, janelas na ordem z superior sempre estão localizadas acima das janelas na ordem z normal. Uma janela está localizada na ordem z superior definindo sua propriedade Topmost como true.

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


...


</Window>

Em cada ordem z, a janela ativa no momento aparece acima de todas as outras janelas na mesma ordem z.

Tamanho da Janela

Além de ter um local na área de trabalho, uma janela tem um tamanho que é determinado por várias propriedades, incluindo as diversas propriedades de largura e altura e SizeToContent.

MinWidth, Width, e MaxWidth são usados para gerenciar o intervalo de largura que uma janela pode ter durante seu ciclo de vida e são configurados como mostrado no exemplo o seguir.

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


...


</Window>

A altura da janela é gerenciada pelo MinHeight, Height e MaxHeight e são configurados como mostrado no exemplo o seguir.

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


...


</Window>

Como altura cada um dos vários valores de largura e altura especificam um intervalo, é possível para a largura e altura de uma janela redimensionável estar em qualquer lugar dentro do intervalo especificado para a dimensão respectiva. Para detectar sua altura e largura atual, inspecione ActualWidth e ActualHeight, respectivamente.

Se você gostaria que a largura e altura da sua janela para seja de um tamanho que se ajusta ao tamanho do conteúdo da janela, você pode utilizar a propriedade SizeToContent, que possui os seguintes valores:

  • Manual. Nenhum efeito (padrão).

  • Width. ajuste à largura do conteúdo, que tem o mesmo efeito que configuração ambas MinWidth e MaxWidth e a largura do conteúdo.

  • Height. ajuste à altura de conteúdo, que tem o mesmo efeito que definir ambos sistema autônomo MinHeight e MaxHeight à altura do conteúdo.

  • WidthAndHeight. ajuste ao conteúdo de largura e altura, que tem o mesmo efeito que definir ambos sistema autônomo MinHeight e MaxHeight a altura do conteúdo e configuração de ambas sistema autônomo MinWidth e MaxWidth e a largura do conteúdo.

O código a seguir mostra uma janela que dimensiona automaticamente para caber seu conteúdo, tanto vertical e horizontalmente, quando mostrada inicialmente.

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


...


</Window>

Ordem de precedência para propriedades de dimensionamento

Essencialmente, as várias propriedades de tamanhos de uma janela são combinadas para definir o intervalo de largura e altura de uma janela redimensionável. Para garantir que um intervalo válido é mantido, Window avalia os valores das propriedades de tamanho usando a ordem de precedência a seguir.

Para 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

Você pode usar o Janela dimensionando ordem de precedência de exemplo para fazer experiências com a ordem de precedência.

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

Estado da Janela

Durante o ciclo de vida de uma janela redimensionável, ele pode ter três estados: normal, minimizadas e maximizadas. 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 alça de redimensionamento ou a borda, se é redimensionável.

Uma janela com um estado minimized recolhe a seu botão da barra de tarefas se ShowInTaskbar estiver definida como true; caso contrário, ele recolhe ao menor tamanho possível que ela pode ser e realoca a si própria para o canto inferior esquerdo da área de trabalho. Nenhum tipo de janela minimizada pode ser redimensionada usando uma borda ou alça redimensionável, embora uma janela minimizada que não é mostrada na barra de tarefas pode ser arrastada em torno a área de trabalho.

Uma janela com um estado maximized expande para o seu tamanho máximo, o qual será apenas tão grande quanto suas propriedades MaxWidth, MaxHeight e SizeToContent permitirem. Como uma janela minimizada, uma janela maximizada não pode ser redimensionada usando uma alça 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 da enumeração WindowState:

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

<Window 
    xmlns="https://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 for mostrada, os usuários podem pressionar os botões de minimizar, maximizar e restaurar na barra de título para alterar o estado da janela.

Aparência da Janela

Você altera a aparência da área cliente de uma janela adicionando conteúdo específico de janela a ela, tais 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 um ícone da 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 um modo de redimensionamento da janela, estilo da janela, e se ela aparece como um botão na barra de tarefas da Área de Trabalho.

Esta seção contém as seguintes subseções.

  • Modo de Redimensionamento
  • Estilos de Janela
  • Presença da barra de tarefas

Modo de Redimensionamento

Dependendo da propriedade WindowStyle, você pode controlar como (e se) os usuários podem redimensionar a janela. A opção de estilo da janela afeta se um usuário pode redimensionar a janela arrastando sua borda com o mouse, se os botões de Minimize, Maximize, e Resize aparecem na área não cliente, e, se elas forem exibidas, se elas estão habilitadas.

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

Como com WindowStyle, o modo de redimensionamento de uma janela é improvável de ser alterado durante seu ciclo de vida, o que significa que você vai provavelmente defini-la a partir da marcação XAML.

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


...


</Window>

Observe que você pode detectar se uma janela está maximizada, minimizada ou restaurada inspecionando a propriedade WindowState.

Estilos de Janela

A borda que é exposta da área não cliente de uma janela é adequada para a maioria dos aplicativos. No entanto, existem circunstâncias onde diferentes tipos de bordas são necessários, ou nenhuma bordas são necessárias, dependendo do tipo de janela.

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

O efeito desses estilos de janela estão ilustrados na figura a seguir.

Estilos de janela

Você pode definir WindowStyle usando tanto marcação XAML quanto código; porque ela é improvável de ser alterada durante o ciclo de vida de uma janela, você irá provavelmente configurá-la usando marcação XAML.

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


...


</Window>

Estilo de Janela não Retangular

Existem também situações onde os estilos da borda que WindowStyle permite que você tenha não forem suficientes. Por exemplo, você pode desejar criar um aplicativo com uma borda não retangular, como Microsoft Windows Media Player usa.

Por exemplo, considere a janela de bolhas de fala mostrada na figura a seguir.

Janela Nonrectangular

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

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


...


</Window>

Essa combinação de valores instrui a janela para renderizar completamente transparente. Nesse estado, os ornamentos da área cliente da janela (o Menu Fechar, Botões Minimize, Maximize e a restore e assim por diante) não podem ser usados. Consequentemente, você precisará fornecer seu próprio. Para mais detalhes, consulte Exemplo do Windows não retangular.

Presença da barra de tarefas

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

Janela com um botão da barra de tarefas

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

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


...


</Window>

Considerações sobre segurança

Window requer permissão de segurança UnmanagedCode para ser instanciado. Para aplicativos instalados e iniciados na máquina local, isso se encaixa dentro do 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 de zona de intranet da Internet ou local usando ClickOnce. Consequentemente, os usuários receberão um aviso de segurança ClickOnce e precisarão elevar o conjunto de permissões do aplicativo para confiança total.

Além disso, XBAPs não é pode mostrar janelas ou caixas de diálogo por padrão. Para uma discussão sobre as considerações de segurança de aplicativo autônomo, consulte Estratégia de segurança do Windows Presentation Foundation - Segurança da Plataforma.

Outros tipos de Windows

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

Caixas de diálogo são janelas que são normalmente usadas para reunir informações de um usuário para concluir uma função. Por exemplo, quando um usuário desejar abrir um arquivo, a caixa de diálogo Open File é normalmente exibida por um aplicativo para obter o nome de arquivo do usuário. Para obter mais informações, consulte Dialog Boxes Overview.

Consulte também

Conceitos

Dialog Boxes Overview

Building a WPF Application (WPF)

Referência

Window

MessageBox

NavigationWindow

Application

Date

History

Motivo

Julho de 2008

Adicionado Impedindo a ativação de janela seção.

Alteração de recurso do SP1.