Exportar (0) Imprimir
Expandir Tudo
Este artigo foi traduzido por máquina. Coloque o ponteiro do mouse sobre as frases do artigo para ver o texto original. Mais informações.
Tradução
Original

Visão geral das caixas de diálogo

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 através de mecanismos da interface do usuário (UI) (barras de menu, 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

  • Coletar informações a partir dos 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-modo.

Uma caixa de diálogo modal é exibida por uma função quando a função precisa de dados adicionais vindos do 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 o usuário ative outras janelas no aplicativo enquanto ela permanecer aberta. Na maioria dos casos, um caixa de diálogo modal permite que o usuário sinalize quando ele tiver terminado de usá-la pressionando um botão OK ou Cancel. Ao pressionar o botão OK, o usuário indica que ele inseriu os dados e quer que a função continue o processamento com esses dados. Ao pressionar o botão Cancel, ele indica que ele deseja que a função interrompa sua execução totalmente. Os exemplos de caixas de diálogo modais mais comuns são mostrados para abrir, salvar, e imprimir dados.

Uma caixa de diálogo sem-modo, por outro lado, não impede que o usuário ative outras janelas enquanto ela estiver aberta. Por exemplo, se o usuário desejar localizar ocorrências de uma palavra específica em um documento, uma janela principal geralmente abrirá um caixa de diálogo para pedir ao usuário qual palavra ele está procurando. Como a busca por uma palavra não impede que o usuário edite o documento, no entanto, a caixa de diálogo não precisa ser modal. Uma caixa de diálogo sem-modo fornece pelo menos um botão para fechar a caixa de diálogo, Close, e pode fornecer outros botões para executar funções específicas, como um botão Localizar próximo para localizar a próxima palavra que corresponde aos critérios de localização de uma pesquisa por 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 comum, e caixas de diálogo personalizadas. Este tópico discute cada um e o O exemplo de caixa de diálogo fornece exemplos correspondentes.

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

Uma caixa de mensagem é um 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 um caixa de mensagem que exibe informações textuais, faz uma pergunta, e oferece ao usuário três botões para responder à pergunta.

Word Processor dialog box

Para criar uma caixa de mensagem, use o MessageBox classe. MessageBox permite configurar 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 método staticShow, 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 o 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 o exemplo de caixa de diálogo.

Embora MessageBox possa oferecer ao usuário uma experiência simples de caixa de diálogo, a vantagem de usar MessageBox é que é o único tipo de janela que pode ser mostrado por aplicativos executados em uma proteção de segurança parcialmente confiável (consulte Segurança (WPF)), como aplicativos de navegador XAML (XBAPs).

A maioria das caixas de diálogo exibem e coletam dados mais complexos do que o resultado de uma caixa de mensagem, inclusive texto, seleção (check boxes), seleção mutuamente exclusiva (botões de opção), e seleção a partir de uma lista (caixas de listagem, caixas de combinação, caixas drop-down). Para esses, 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 de ambas as técnicas seja limitado a aplicativos executados com confiança total.

Windows implementa 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 executados no sistema operacional, o que ajuda a manter a consistência da experiência do usuário; quando os usuários estiverem familiarizados com o uso de uma caixa de diálogo fornecida pelo sistema operaciona em um aplicativo, eles não precisarão aprender a usar aquela 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 um experiência de usuário consistente, elas são conhecidas como caixas de diálogo comuns.

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

Aa969773.collapse_all(pt-br,VS.110).gifDiálogo para abertura de arquivo

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

Open dialog box

A caixa de diálogo para abertura de arquivo comum é implementada como a classe OpenFileDialog e está localizada no namespace Microsoft.Win32. 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 mais informações sobre a caixa de diálogo para abertura de arquivo, consulte Microsoft.Win32.OpenFileDialog.

Observação Observação

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

Aa969773.collapse_all(pt-br,VS.110).gifCaixa de diálogo para salvamento de arquivo

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

Save As dialog box

A caixa de diálogo para salvamento de arquivo comum é implementada como a classe SaveFileDialog e está localizada no namespace Microsoft.Win32. 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 mais informações sobre a caixa de diálogo para salvamento de arquivo, consulte Microsoft.Win32.SaveFileDialog.

Aa969773.collapse_all(pt-br,VS.110).gifCaixa de diálogo para impressão

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

Print dialog box

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


// 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 para impressão, consulte System.Windows.Controls.PrintDialog. Para uma discussão detalhada sobre a impressão em WPF, consulte Visão geral da impressão.

Enquanto caixas de diálogo comuns são úteis e devem ser usadas quando possível, elas não têm suporte para os requisitos de caixas de diálogo específicas do domínio. Nesses casos, você precisará criar suas próprias caixas de diálogo. Como veremos, uma caixa de diálogo é uma janela com comportamentos especiais. Window implementa esses comportamentos e, conseqüentemente, usar Window para criar caixas de diálogo de janela restrita e sem janela restrita personalizada.

Aa969773.collapse_all(pt-br,VS.110).gifCriando uma caixa de diálogo modal personalizada

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

Margins dialog box

Aa969773.collapse_all(pt-br,VS.110).gifConfigurando 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 botão OK que os usuários clicam para fechar a caixa de diálogo, retornar à função, e continuar o processamento.

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

  • Mostrar um botão Close na barra de título.

  • Mostrar um ícone.

  • Mostrar botões Minimize, Maximize e Restore.

  • Mostrar um menu System 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 esta seja muito pequena e fornecer ao usuário um tamanho padrão útil, você precisa definir dimensões mínimas e padrão, respectivamente.

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

  • Pressionando a tecla ENTER (ou RETURN) deve ser configurado como um atalho de teclado que faz com que o botão OK seja pressionado. Isso é conseguido definindo a propriedade IsDefault do botão OK como 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>



Imports System.Windows ' Window, RoutedEventArgs, IInputElement, DependencyObject
Imports System.Windows.Controls ' Validation
Imports System.Windows.Input ' Keyboard

Namespace SDKSample


Public Class MarginsDialogBox
    Inherits Window
    Public Sub New()
        Me.InitializeComponent()
    End Sub


...


End Class

End Namespace



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 um caixa de diálogo também se estende à barra de menu 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 através 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 um 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.

Aa969773.collapse_all(pt-br,VS.110).gifAbrindo uma caixa de diálogo modal

Um caixa de diálogo geralmente é mostrada como resultado de uma seleção que o usuário fez em um 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 um caixa de diálogo é semelhante a mostrar uma janela normal, embora ele exija configuração adicional específica das caixas de diálogo. Todo o processo de criar uma instância, configurar e abrir um 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 a propriedade Window.Owner 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 janelas que são comuns a todas as caixas de diálogo (consulte Visão geral do WPF do Windows para mais informações).

Observação Observação

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

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

Aa969773.collapse_all(pt-br,VS.110).gifValidação de dados fornecidos pelo usuário

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

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

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

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

  • A partir de uma perspectiva de desempenho, a validação de dados em um aplicativo de várias camadas pode reduzir o número de viagens entre o cliente e as camadas do aplicativo, particularmente quando o aplicativo é composto de serviços da Web ou baseado em um servidor bancos de dados.

Para validar um controle acoplado em WPF, você precisará definir uma regra de validação e associá-la com a ligação. Uma regra de validação é uma classe personalizada que deriva de ValidationRule. O exemplo a seguir mostra um regra de validação, MarginValidationRule, que verifica se um valor vinculado é um Double e está dentro de um 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 método Validate, que valida os dados e retorna um ValidationResult adequado.

Para associar a regra de validação ao controle vinculado, 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 aplicá-la-á quando dados forem 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.

Invalid left margin

WPF não restringe um usuário ao controle inválido até que ele tenha inserido dados válidos. Isso é um bom comportamento para uma caixa de diálogo; um usuário deve poder navegar livremente entre os controles em um caixa de diálogo independentemente da validade dos dados. No entanto, isso significa que um usuário pode inserir dados inválidos e pressionar o botão OK. Por esse motivo, o código também precisa validar todos os controles em um caixa de diálogo quando o botão OK for pressionado, tratando o evento Click.


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 qualquer um estiver inválido (como retornado por GetHasError, o controle inválido obtém o foco, o método IsValid retorna false, e a janela é considerada inválida.

Depois que um 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 que a chamou.

Aa969773.collapse_all(pt-br,VS.110).gifDefinindo o resultado do 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é que ShowDialog retorne. Quando ShowDialog retorna, o código que a chamou precisa decidir se deve continuar o processamento ou parar o processamento, dependendo se o usuário pressionou o botão OK ou Cancel. Para facilitar essa decisão, a caixa de diálogo precisa retornar a opção do usuário como um valor Boolean que é retornado pelo método ShowDialog.

Ao clicar no botão OK, ShowDialog deve retornar true. Isso é conseguido definindo a propriedade DialogResult da caixa de diálogo quando o botão OK é clicado.

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

Ao clicar no botão Cancel, ShowDialog deve retornar false, que também requer a definição da propriedade DialogResult.


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 a propriedade IsCancel de um botão for definida como true e o usuário pressionar o botão Cancel ou o tecla ESC, DialogResult é automaticamente definida como false. A marcação a seguir tem o mesmo efeito do código anterior, sem precisar tratar o evento Click.


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


Um caixa de diálogo retorna automaticamente false quando um usuário pressiona o botão Close na barra de título ou escolhe o item de menu Close do menu System.

Aa969773.collapse_all(pt-br,VS.110).gifProcessamento 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 verificando a propriedade DialogResult quando ShowDialog retornar.


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 do diálogo for true, a função usa isso como uma deixa para recuperar e processar os dados fornecidos pelo usuário.

Observação Observação

Após o retorno de ShowDialog, a caixa de diálogo não pode ser reaberta. Em vez disso, você precisará criar uma nova instância.

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

Aa969773.collapse_all(pt-br,VS.110).gifCriando uma caixa de diálogo personalizada sem-modo

Um caixa de diálogo sem-modo, como a caixa de diálogo Localizar mostrada na figura a seguir, tem a mesma aparência fundamental que a caixa de diálogo modal.

Find dialog box

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

Aa969773.collapse_all(pt-br,VS.110).gifAbrindo uma caixa de diálogo sem-modo

Um caixa de diálogo sem-modo é aberta chamando o método Show.


<!--Main Window-->




Imports System '  EventArgs
Imports System.ComponentModel '  CancelEventArgs
Imports System.Windows '  Window, MessageBoxXxx, RoutedEventArgs
Imports System.Windows.Controls '  TextChangedEventArgs
Imports Microsoft.Win32 '  OpenFileDialog

Namespace SDKSample

Public Class MainWindow
    Inherits Window


...


Private Sub editFindMenuItem_Click(ByVal sender As Object, ByVal e As RoutedEventArgs)
    Dim dlg As New FindDialogBox(Me.documentTextBox)
    dlg.Owner = Me
    AddHandler dlg.TextFound, New TextFoundEventHandler(AddressOf Me.dlg_TextFound)
    dlg.Show()
End Sub


...


End Class

End Namespace



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, Show retorna imediatamente. Consequentemente, a janela que fez a chamada não pode saber quando a caixa de diálogo sem-modo está fechada e, portanto, não sabe quando procurar um resultado na caixa de diálogo ou obter dados a partir 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 que a janela que fez a chamada os processe.

Aa969773.collapse_all(pt-br,VS.110).gifProcessamento de dados retornados de uma caixa de diálogo sem-modo

Nesse exemplo, o FindDialogBox pode retornar um ou mais resultados para a janela principal, dependendo do texto que está sendo procurado sem qualquer frequência específica. Como ocorre com uma caixa de diálogo modal, uma caixa de diálogo sem-modo pode retornar resultados usando propriedades. No entanto, a janela que é proprietária da caixa de diálogo precisa saber quando verificar essas propriedades. Uma maneira de habilitar esse destina-se a caixa de diálogo para implementar um evento gerado sempre que o texto é encontrado. FindDialogBoximplementa o TextFoundEvent para essa finalidade, que primeiro requer um delegado.


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


Usando o representante TextFoundEventHandler, FindDialogBox implementa o 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 gerar 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 proprietária precisará 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();
        }
    }
}


Aa969773.collapse_all(pt-br,VS.110).gifFechando uma caixa de diálogo sem-modo

Porque DialogResult não precisa ser definida, uma caixa de diálogo sem-modo pode ser fechada usando mecanismos fornecidos pelo sistema, incluindo o seguinte:

  • Clicando no botão Close na barra de título.

  • Pressionando ALT+F4.

  • Escolhendo Close no menu System.

Como alternativa, seu código pode chamar Close quando o botão Close for 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();
        }
    }
}


Contribuições da comunidade

ADICIONAR
Mostrar:
© 2014 Microsoft