Visão geral das caixas de diálogo

 

Publicado: junho de 2016

Aplicativos autônomos geralmente têm uma janela principal que exibe os principais dados sobre os quais o aplicativo opera e expõe a funcionalidade para processar os dados por meio de UI (interface do usuário) mecanismos, como barras de menus, barras de ferramentas e barras de status. Um aplicativo não-trivial também pode exibir janelas adicionais para fazer o seguinte:

  • Exibir informações específicas aos usuários.

  • Colete informações de usuários.

  • Exibir e coletar informações.

Esses tipos de janelas são conhecidos como caixas de diálogo, e há dois tipos: modal e sem janela restrita.

A modal caixa de diálogo é exibida por uma função quando a função precisa de dados adicionais de um usuário para continuar. Como a função depende da caixa de diálogo modal para coletar dados, a caixa de diálogo modal também impede que um usuário ative outras janelas no aplicativo enquanto ele permanece aberto. Na maioria dos casos, uma caixa de diálogo modal permite que o usuário sinalize quando ele tiveram terminado com a caixa de diálogo modal pressionando uma uma Okey ou Cancelar botão. Pressionar o Okey botão indica que um usuário inseriu dados e quer que a função continue o processamento com esses dados. Pressionar o Cancelar botão indica que um usuário deseja parar a função execução totalmente. Os exemplos de caixas de diálogo modais mais comuns são mostrados para abrir, salvar e imprimir dados.

A sem janela restrita caixa de diálogo, por outro lado, não impede que um usuário ative outras janelas enquanto ela estiver aberta. Por exemplo, se um usuário desejar localizar ocorrências de uma palavra específica em um documento, uma janela principal geralmente abrirá uma caixa de diálogo para solicitar um usuário qual palavra que estão procurando. Como a busca por uma palavra não impede que um usuário editar o documento, no entanto, a caixa de diálogo não precisa ser modal. Uma caixa de diálogo sem janela restrita fornece pelo menos um fechar botão para fechar a caixa de diálogo e pode fornecer outros botões para executar funções específicas, como um Localizar próxima botão para localizar a próxima palavra que corresponde aos critérios de localização de uma pesquisa de palavra.

Windows Presentation Foundation (WPF)permite que você crie vários tipos de caixas de diálogo, incluindo caixas de mensagem, caixas de diálogo comuns e caixas de diálogo personalizadas. Este tópico aborda cada um e o exemplo de caixa de diálogo fornece os exemplos correspondentes.

Entity with relative path '../Token/autoOutline_md.md' can not be found, for source topic '{"project_id":"3fedad16-eaf1-41a6-8f96-0c1949c68f32","entity_id":"0d23d544-a393-4a02-a3aa-d8cd5d3d6511","entity_type":"Article","locale":"pt-BR"}'.

A caixa de mensagem é uma caixa de diálogo que pode ser usada para exibir informações textuais e para permitir que os usuários tomem decisões com botões. A figura a seguir mostra uma caixa de mensagem que exibe informações textuais, faz uma pergunta e fornece ao usuário três botões para responder à pergunta.

Caixa de diálogo processador de texto

Para criar uma caixa de mensagem, use o MessageBox classe. MessageBox permite que você configure o texto da caixa de mensagem, título, ícone e botões, usando código semelhante ao seguinte.

            // Configure the message box to be displayed
            string messageBoxText = "Do you want to save changes?";
            string caption = "Word Processor";
            MessageBoxButton button = MessageBoxButton.YesNoCancel;
            MessageBoxImage icon = MessageBoxImage.Warning;

Para mostrar uma caixa de mensagem, você chama o static Mostrar método, conforme demonstrado no código a seguir.

            // Display message box
            MessageBox.Show(messageBoxText, caption, button, icon);

Quando o código que mostra uma caixa de mensagem precisa detectar e processar a decisão do usuário (qual botão foi pressionado), o código pode inspecionar o resultado da caixa de mensagem, conforme mostrado no código a seguir.

            // Display message box
            MessageBoxResult result = MessageBox.Show(messageBoxText, caption, button, icon);

            // Process message box results
            switch (result)
            {
                case MessageBoxResult.Yes:
                    // User pressed Yes button
                    // ...
                    break;
                case MessageBoxResult.No:
                    // User pressed No button
                    // ...
                    break;
                case MessageBoxResult.Cancel:
                    // User pressed Cancel button
                    // ...
                    break;
            }

Para obter mais informações sobre como usar caixas de mensagens, consulte MessageBox, exemplo MessageBox, e exemplo de caixa de diálogo.

Embora MessageBox pode oferecer uma experiência de usuário de caixa de diálogo simples, a vantagem de usar MessageBox é que é o único tipo de janela que pode ser mostrado por aplicativos executados em uma área restrita de confiança parcial (consulte segurança), como XBAPs (aplicativos de navegador XAML).

A maioria das caixas de diálogo exibem e coletam dados mais complexos que o resultado de uma caixa de mensagem, inclusive texto, seleção (check boxes), seleção mutuamente exclusiva (botões de opção) e lista de seleção (caixas de listagem, caixas de combinação, caixas de listagem suspensa). Nesses casos, Windows Presentation Foundation (WPF) fornece várias caixas de diálogo comuns e permite que você crie suas próprias caixas de diálogo, embora o uso deles é limitado a aplicativos executados com confiança total.

Windowsimplementa uma variedade de caixas de diálogo reutilizáveis que são comuns a todos os aplicativos, incluindo caixas de diálogo para abrir arquivos, salvar arquivos e impressão. Como essas caixas de diálogo são implementadas pelo sistema operacional, eles podem ser compartilhados entre todos os aplicativos que são executados no sistema operacional, que ajuda o usuário a experiência de consistência. Quando os usuários estiverem familiarizados com o uso de uma caixa de diálogo fornecida pelo sistema operacional em um aplicativo, eles não precisam aprender a usar a caixa de diálogo em outros aplicativos. Como essas caixas de diálogo estão disponíveis para todos os aplicativos e como elas ajudam a fornecer uma experiência de usuário consistente, elas são conhecidas como caixas de diálogo comuns.

Windows Presentation Foundation (WPF)encapsula o arquivo aberto, salve o arquivo e impressão caixas de diálogo comuns e as expõe como classes gerenciadas para usar em aplicativos autônomos. Este tópico fornece uma breve visão geral de cada um.

Caixa de diálogo Abrir arquivo

A caixa de diálogo Abrir arquivo, mostrada na figura a seguir, é usada pela funcionalidade de abertura de arquivo para recuperar o nome de um arquivo para abrir.

Caixa de diálogo Abrir

A caixa de diálogo de abertura de arquivo comum é implementada como o OpenFileDialog classe e está localizado no Win32 namespace. O código a seguir mostra como criar, configurar e mostrar uma e como processar o resultado.

            // Configure open file dialog box
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();
            dlg.FileName = "Document"; // Default file name
            dlg.DefaultExt = ".txt"; // Default file extension
            dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

            // Show open file dialog box
            Nullable<bool> result = dlg.ShowDialog();

            // Process open file dialog box results
            if (result == true)
            {
                // Open document
                string filename = dlg.FileName;
            }

Para obter mais informações sobre a caixa de diálogo Abrir arquivo, consulte Microsoft.Win32.OpenFileDialog.

System_CAPS_ICON_note.jpg Observação

OpenFileDialog pode ser usado para recuperar nomes de arquivos com segurança por aplicativos executados com confiança parcial (consulte segurança).

Caixa de diálogo arquivo Salvar

Salvar caixa de diálogo de arquivo, mostrada na figura a seguir, é usada pela funcionalidade de salvamento de arquivo para recuperar o nome de um arquivo para salvar.

Caixa de diálogo Salvar como

Salvar caixa de diálogo de arquivo comum é implementada como o SaveFileDialog classe e está localizado no Win32 namespace. O código a seguir mostra como criar, configurar e mostrar uma e como processar o resultado.

            // Configure save file dialog box
            Microsoft.Win32.SaveFileDialog dlg = new Microsoft.Win32.SaveFileDialog();
            dlg.FileName = "Document"; // Default file name
            dlg.DefaultExt = ".text"; // Default file extension
            dlg.Filter = "Text documents (.txt)|*.txt"; // Filter files by extension

            // Show save file dialog box
            Nullable<bool> result = dlg.ShowDialog();

            // Process save file dialog box results
            if (result == true)
            {
                // Save document
                string filename = dlg.FileName;
            }

Para obter mais informações sobre salvar arquivo de caixa de diálogo, consulte Microsoft.Win32.SaveFileDialog.

Caixa de diálogo Imprimir

A caixa de diálogo de impressão, mostrada na figura a seguir, é usada pela funcionalidade de impressão para escolher e configurar a impressora que um usuário deseja imprimir dados.

Caixa de diálogo Imprimir

A caixa de diálogo de impressão comum é implementada como o PrintDialog classe e está localizado no System.Windows.Controls namespace. O código a seguir mostra como criar, configurar e mostrar uma.

            // Configure printer dialog box
            System.Windows.Controls.PrintDialog dlg = new System.Windows.Controls.PrintDialog();
            dlg.PageRangeSelection = PageRangeSelection.AllPages;
            dlg.UserPageRangeEnabled = true;

            // Show save file dialog box
            Nullable<bool> result = dlg.ShowDialog();

            // Process save file dialog box results
            if (result == true)
            {
                // Print document
            }

Para obter mais informações sobre a caixa de diálogo de impressão, consulte System.Windows.Controls.PrintDialog. Para obter informações detalhadas de impressão em WPF, consulte visão geral sobre impressão.

Enquanto caixas de diálogo comuns são úteis e devem ser usadas quando possível, eles não suportam os requisitos de caixas de diálogo específicas do domínio. Nesses casos, você precisa criar sua própria caixa de diálogo. Como você verá uma caixa de diálogo é uma janela com comportamentos especiais. Janela implementa esses comportamentos e, consequentemente, você usará janela para criar caixas de diálogo personalizadas modais e sem janela restrita.

Criando uma caixa de diálogo Modal personalizada

Este tópico mostra como usar janela para criar uma implementação de caixa de diálogo modal típica, usando o Margins caixa de diálogo como um exemplo (consulte caixa de diálogo de exemplo). O Margins caixa de diálogo é mostrada na figura a seguir.

Caixa de diálogo margens

Configurando uma caixa de diálogo Modal

A interface do usuário para uma caixa de diálogo típica inclui o seguinte:

  • Os vários controles que são necessários para coletar os dados desejados.

  • Mostrando um Okey botão que os usuários clicam para fechar a caixa de diálogo, volte para a função e continuam o processamento.

  • Mostrando um Cancelar botão que os usuários clicam para fechar a caixa de diálogo e parar a processamento da função.

  • Mostrando um fechar botão na barra de título.

  • Mostrar um ícone.

  • Showing Minimize, Maximize, and Restore buttons.

  • Mostrando um sistema menu para minimizar, maximizar, restaurar e fechar a caixa de diálogo.

  • Abrindo acima e no centro da janela que abriu a caixa de diálogo.

  • Caixas de diálogo devem ser redimensionáveis sempre que possível, então, para impedir que a caixa de diálogo seja muito pequena e fornecer ao usuário um tamanho padrão útil, você precisa definir padrão e um mínimo dimensões respectivamente.

  • Pressionar a tecla ESC deve ser configurado como um atalho de teclado que faz com que o Cancelar botão seja pressionado. Isso é feito definindo a IsCancel propriedade o Cancelar botão true.

  • Pressionar a tecla ENTER (ou retorno) deve ser configurado como um atalho de teclado que faz com que o Okey botão seja pressionado. Isso é feito definindo a IsDefault propriedade o Okey botão true.

O código a seguir demonstra essa configuração.


<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarginsDialogBox"
    xmlns:local="clr-namespace:SDKSample"
    Title="Margins"
    Height="190"
    Width="300"
    MinHeight="10"
    MinWidth="300"
    ResizeMode="CanResizeWithGrip"
    ShowInTaskbar="False"
    WindowStartupLocation="CenterOwner" 
    FocusManager.FocusedElement="{Binding ElementName=leftMarginTextBox}">

  <Grid>

    <!-- Accept or Cancel -->
    <StackPanel Grid.Column="0" Grid.ColumnSpan="2" Grid.Row="4">
      <Button Name="okButton" Click="okButton_Click" IsDefault="True">OK</Button>
      <Button Name="cancelButton" IsCancel="True">Cancel</Button>
    </StackPanel>

  </Grid >

</Window>

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

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

    }
}

A experiência do usuário para uma caixa de diálogo também se estende à barra de menus da janela que abre a caixa de diálogo. Quando um item de menu executa uma função que requer interação do usuário por meio de uma caixa de diálogo antes de continuar a função, o item de menu para a função terá reticências em seu cabeçalho, conforme mostrado aqui.

        <!--Main Window-->

        <MenuItem Name="formatMarginsMenuItem" Header="_Margins..." Click="formatMarginsMenuItem_Click" />

Quando um item de menu executa uma função que exibe uma caixa de diálogo que não requer interação do usuário, como uma caixa de diálogo sobre, reticências não são necessárias.

Abrir uma caixa de diálogo Modal

Uma caixa de diálogo geralmente é mostrada como resultado de um usuário selecionando um item de menu para executar uma função específica de domínio, como definir as margens de um documento em um processador de texto. Mostrar uma janela como uma caixa de diálogo é semelhante a mostrar uma janela normal, embora ele exija configuração específicas da caixa de diálogo adicionais. Todo o processo de criar uma instância, configurar e abrir uma caixa de diálogo é mostrado no código a seguir.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {

        void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Instantiate the dialog box
            MarginsDialogBox dlg = new MarginsDialogBox();

            // Configure the dialog box
            dlg.Owner = this;
            dlg.DocumentMargin = this.documentTextBox.Margin;

            // Open the dialog box modally 
            dlg.ShowDialog();



    }
}

Aqui, o código está passando informações padrão (as margens atuais) para a caixa de diálogo. Ele também define o Window.Owner propriedade com uma referência para a janela que está mostrando a caixa de diálogo. Em geral, você deve sempre definir o proprietário de uma caixa de diálogo para fornecer comportamentos relacionados a estados de janela que são comuns a todas as caixas de diálogo (consulte visão geral do Windows WPF para obter mais informações).

System_CAPS_ICON_note.jpg Observação

Você deve fornecer um proprietário para oferecer suporte a UI (interface do usuário) automação para caixas de diálogo (consulte visão geral de automação de interface do usuário).

Depois que a caixa de diálogo estiver configurada, ela é mostrada modalmente chamando o ShowDialog método.

Validando dados fornecidos pelo usuário

Quando uma caixa de diálogo é aberta e o usuário fornece os dados necessários, uma caixa de diálogo é responsável por garantir que os dados fornecidos são válidos pelos seguintes motivos:

  • De uma perspectiva de segurança, todas as entradas devem ser validadas.

  • De uma perspectiva específica de domínio, validação de dados impede que dados errados sejam processadas pelo código, o que pode potencialmente lançar exceções.

  • Da perspectiva da experiência do usuário, uma caixa de diálogo pode ajudar os usuários mostrando-lhes quais dados inseridos são inválidos.

  • Da perspectiva do desempenho, validação de dados em um aplicativo de várias camada pode reduzir o número de processamentos entre o cliente e as camadas de aplicativo, especialmente quando o aplicativo é composto de serviços da Web ou de bancos de dados baseados em servidor.

Para validar um controle associado em WPF, você precisa definir uma regra de validação e associá-la com a vinculação. Uma regra de validação é uma classe personalizada que é derivada de ValidationRule. O exemplo a seguir mostra uma regra de validação, MarginValidationRule, que verifica se um valor associado é um Double e está dentro do intervalo especificado.

using System.Globalization;
using System.Windows.Controls;

namespace SDKSample
{
    public class MarginValidationRule : ValidationRule
    {
        double minMargin;
        double maxMargin;

        public double MinMargin
        {
            get { return this.minMargin; }
            set { this.minMargin = value; }
        }

        public double MaxMargin
        {
            get { return this.maxMargin; }
            set { this.maxMargin = value; }
        }

        public override ValidationResult Validate(object value, CultureInfo cultureInfo)
        {
            double margin;

            // Is a number?
            if (!double.TryParse((string)value, out margin))
            {
                return new ValidationResult(false, "Not a number.");
            }

            // Is in range?
            if ((margin < this.minMargin) || (margin > this.maxMargin))
            {
                string msg = string.Format("Margin must be between {0} and {1}.", this.minMargin, this.maxMargin);
                return new ValidationResult(false, msg);
            }

            // Number is valid
            return new ValidationResult(true, null);
        }
    }
}

Nesse código, a lógica de validação de uma regra de validação é implementada ao substituir o validar método, que valida os dados e retorna um número apropriado ValidationResult.

Para associar o controle ligado a regra de validação, use a marcação a seguir.

<Window 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    x:Class="SDKSample.MarginsDialogBox"
    xmlns:local="clr-namespace:SDKSample"
    Title="Margins"
    Height="190"
    Width="300"
    MinHeight="10"
    MinWidth="300"
    ResizeMode="CanResizeWithGrip"
    ShowInTaskbar="False"
    WindowStartupLocation="CenterOwner" 
    FocusManager.FocusedElement="{Binding ElementName=leftMarginTextBox}">

  <Grid>
    

    <Label Grid.Column="0" Grid.Row="0">Left Margin:</Label>
    <TextBox Name="leftMarginTextBox" Grid.Column="1" Grid.Row="0">
      <TextBox.Text>
        <Binding Path="Left" UpdateSourceTrigger="PropertyChanged">
          <Binding.ValidationRules>
            <local:MarginValidationRule MinMargin="0" MaxMargin="10" />
          </Binding.ValidationRules>
        </Binding>
      </TextBox.Text>
    </TextBox>

</Window>

Depois que a regra de validação estiver associada, WPF automaticamente aplicará quando os dados são inseridos no controle vinculado. Quando um controle contiver dados inválidos, WPF exibirá uma borda vermelha ao redor do controle inválido, como mostrado na figura a seguir.

Margem esquerda inválida

WPFnão restringe um usuário ao controle inválido até que ele tenha inserido dados válidos. Isso é bom comportamento para uma caixa de diálogo. um usuário poderá navegar livremente entre os controles em uma caixa de diálogo se os dados são válidos ou não. No entanto, isso significa que um usuário pode inserir dados inválidos e pressionar o Okey botão. Por esse motivo, o código também precisa validar todos os controles em uma caixa de diálogo caixa quando o Okey botão for pressionado, tratando o clique eventos.

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {

        void okButton_Click(object sender, RoutedEventArgs e)
        {
            // Don't accept the dialog box if there is invalid data
            if (!IsValid(this)) return;

        }

        // Validate all dependency objects in a window
        bool IsValid(DependencyObject node)
        {
            // Check if dependency object was passed
            if (node != null)
            {
                // Check if dependency object is valid.
                // NOTE: Validation.GetHasError works for controls that have validation rules attached 
                bool isValid = !Validation.GetHasError(node);
                if (!isValid)
                {
                    // If the dependency object is invalid, and it can receive the focus,
                    // set the focus
                    if (node is IInputElement) Keyboard.Focus((IInputElement)node);
                    return false;
                }
            }

            // If this dependency object is valid, check all child dependency objects
            foreach (object subnode in LogicalTreeHelper.GetChildren(node))
            {
                if (subnode is DependencyObject)
                {   
                    // If a child dependency object is invalid, return false immediately,
                    // otherwise keep checking
                    if (IsValid((DependencyObject)subnode) == false) return false;
                }
            }

            // All dependency objects are valid
            return true;
        }
    }
}

Esse código enumera todos os objetos de dependência em uma janela e, se algum for inválido (conforme retornado por GetHasError, o controle inválido obtém o foco, a IsValid método retorna false, e a janela é considerada inválida.

Depois que uma caixa de diálogo for válida, ele pode fechar e retornar com segurança. Como parte do processo de retorno, ela precisa retornar um resultado para a função de chamada.

Definindo o resultado da caixa de diálogo Modal

Abrir uma caixa de diálogo usando ShowDialog é fundamentalmente como chamar um método: o código que abriu a caixa de diálogo usando ShowDialog aguarda até ShowDialog retorna. Quando ShowDialog retorna, o código que chamou precisa decidir se continuar o processamento ou parar o processamento, com base em se o usuário pressionou o Okey botão ou o Cancelar botão. Para facilitar essa decisão, a caixa de diálogo precisa retornar a opção do usuário como um Boolean valor que é retornado de ShowDialog método.

Quando o Okey botão é clicado, ShowDialog deve retornar true. Isso é feito definindo a DialogResult caixa de propriedade da caixa de diálogo quando o Okey botão é clicado.

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {

        void okButton_Click(object sender, RoutedEventArgs e)
        {

            // Dialog box accepted
            this.DialogResult = true;
        }

    }
}

Observe que a configuração de DialogResult propriedade também faz com que a janela feche automaticamente, o que minimiza a necessidade de chamar explicitamente fechar.

Quando o Cancelar botão é clicado, ShowDialog deve retornar false, que também requer a definição de DialogResult propriedade.

using System.Windows; // Window, RoutedEventArgs, IInputElement, DependencyObject
using System.Windows.Controls; // Validation
using System.Windows.Input; // Keyboard

namespace SDKSample
{
    public partial class MarginsDialogBox : Window
    {

        void cancelButton_Click(object sender, RoutedEventArgs e)
        {
            // Dialog box canceled
            this.DialogResult = false;
        }

    }
}

Quando um botão IsCancel está definida como true e o usuário pressiona o o Cancelar botão ou a tecla ESC, DialogResult é definida automaticamente como false. A marcação a seguir tem o mesmo efeito que o código anterior, sem a necessidade de lidar com o clique eventos.

      <Button Name="cancelButton" IsCancel="True">Cancel</Button>

Uma caixa de diálogo retorna automaticamente false quando um usuário pressiona o fechar botão na barra de título ou escolhe o fechar item de menu a sistema menu.

Processamento de dados retornados de uma caixa de diálogo Modal

Quando DialogResult é definido por uma caixa de diálogo, a função que a abriu pode obter o resultado da caixa de diálogo inspecionando o DialogResult propriedade quando ShowDialog retorna.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {

        void formatMarginsMenuItem_Click(object sender, RoutedEventArgs e)
        {

            // Process data entered by user if dialog box is accepted
            if (dlg.DialogResult == true)
            {
                // Update fonts
                this.documentTextBox.Margin = dlg.DocumentMargin;
            }
        }

    }
}

Se o resultado de diálogo for true, a função usa como uma indicação para recuperar e processar os dados fornecidos pelo usuário.

System_CAPS_ICON_note.jpg Observação

Depois de ShowDialog retornou, uma caixa de diálogo não pode ser reaberta. Em vez disso, você precisa criar uma nova instância.

Se o resultado de diálogo for false, a função deve terminar o processamento de forma adequada.

Criar uma caixa de diálogo sem janela restrita

Uma caixa de diálogo sem janela restrita, como mostrado na figura a seguir, a caixa de diálogo Localizar tem a mesma aparência fundamental que a caixa de diálogo modal.

Caixa de diálogo Localizar

No entanto, o comportamento é ligeiramente diferente, conforme descrito nas seções a seguir.

Abrir uma caixa de diálogo sem janela restrita

Uma caixa de diálogo sem janela restrita é aberta, chamando o Mostrar método.

        <!--Main Window-->

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {

        void editFindMenuItem_Click(object sender, RoutedEventArgs e)
        {
            // Instantiate the dialog box
            FindDialogBox dlg = new FindDialogBox(this.documentTextBox);

            // Configure the dialog box
            dlg.Owner = this;
            dlg.TextFound += new TextFoundEventHandler(dlg_TextFound);

            // Open the dialog box modally
            dlg.Show();
        }

    }
}

Ao contrário de ShowDialog, Mostrar retorna imediatamente. Consequentemente, a janela de chamada não pode saber quando a caixa de diálogo sem janela restrita é fechada e, portanto, não sabe quando procurar um resultado da caixa de diálogo ou obter dados de caixa de diálogo para processamento adicional. Em vez disso, a caixa de diálogo precisa criar uma maneira alternativa de retornar dados para a janela de chamada para processamento.

Processamento de dados retornados de uma caixa de diálogo sem janela restrita

Neste exemplo, o FindDialogBox pode retornar um ou mais encontrar resultados na janela principal, dependendo do texto que está sendo procurado sem qualquer frequência específica. Assim como acontece com uma caixa de diálogo modal, uma caixa de diálogo sem janela restrita pode retornar resultados usando propriedades. No entanto, a janela que possui a caixa de diálogo precisa saber quando verificar essas propriedades. Uma maneira de habilitar essa opção destina-se a caixa de diálogo para implementar um evento que é gerado sempre que o texto for encontrado. FindDialogBoximplementa o TextFoundEvent para essa finalidade, que primeiro exige um delegado.

using System;
namespace SDKSample
{
    public delegate void TextFoundEventHandler(object sender, EventArgs e);
}

Using the TextFoundEventHandler delegate, FindDialogBox implements the TextFoundEvent.

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {
        public event TextFoundEventHandler TextFound;
        protected virtual void OnTextFound()
        {
            TextFoundEventHandler textFound = this.TextFound;
            if (textFound != null) textFound(this, EventArgs.Empty);
        }

    }
}

Consequentemente, Find pode disparar o evento quando um resultado de pesquisa for encontrado.

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {

        void findNextButton_Click(object sender, RoutedEventArgs e)
        {

                // Text found
                this.index = match.Index;
                this.length = match.Length;
                OnTextFound();


    }
}

A janela do proprietário deve, em seguida, registrar e tratar esse evento.

using System; // EventArgs
using System.ComponentModel; // CancelEventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextChangedEventArgs
using Microsoft.Win32; // OpenFileDialog

namespace SDKSample
{
    public partial class MainWindow : Window
    {

        void dlg_TextFound(object sender, EventArgs e)
        {
            // Get the find dialog box that raised the event
            FindDialogBox dlg = (FindDialogBox)sender;

            // Get find results and select found text
            this.documentTextBox.Select(dlg.Index, dlg.Length);
            this.documentTextBox.Focus();
        }
    }
}

Fechar uma caixa de diálogo sem janela restrita

Porque DialogResult não precisa ser definida, uma caixa de diálogo sem janela restrita poderá ser fechada sistema fornecem mecanismos, incluindo o seguinte:

  • Clicar a fechar botão na barra de título.

  • Pressione ALT + F4.

  • Choosing Close from the System menu.

Como alternativa, seu código pode chamar fechar quando o fechar botão é clicado.

using System; // EventArgs
using System.Windows; // Window, MessageBoxXxx, RoutedEventArgs
using System.Windows.Controls; // TextBox, TextChangedEventArgs
using System.Text.RegularExpressions; // Regex

namespace SDKSample
{
    public partial class FindDialogBox : Window
    {

        void closeButton_Click(object sender, RoutedEventArgs e)
        {
            // Close dialog box
            this.Close();
        }
    }
}

Visão geral de pop-up
Exemplo de caixa de diálogo
Exemplo de controle personalizado ColorPicker

Mostrar: