TOC

This article has been localized into Portuguese by the community.

Controles comuns de interface:

O controle Menu

Uma das partes mais comuns de um aplicativo do Windows é o menu, às vezes chamado de menu principal, porque normalmente só existe um no aplicativo. O menu é prático porque oferece muitas opções, usando muito pouco espaço, e mesmo que a Microsoft esteja empurrando o Ribbon como um substituto para o menu antigo e as barras de ferramentas, eles definitivamente ainda têm seu lugar na caixa de ferramentas de todos os bons desenvolvedores.

O WPF vem com um ótimo controle para criar menus chamados ... Menu. Adicionar itens a ele é muito simples - você simplesmente adiciona elementos MenuItem a ele, e cada MenuItem pode ter um intervalo de subitens, permitindo que você crie menus hierárquicos como você os conhece em muitos aplicativos do Windows. Vamos pular direto para um exemplo em que usamos o menu:

<Window x:Class="WpfTutorialSamples.Common_interface_controls.MenuSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MenuSample" Height="200" Width="200">
    <DockPanel>
        <Menu DockPanel.Dock="Top">
            <MenuItem Header="_File">
                <MenuItem Header="_New" />
                <MenuItem Header="_Open" />
                <MenuItem Header="_Save" />
                <Separator />
                <MenuItem Header="_Exit" />
            </MenuItem>
        </Menu>
        <TextBox AcceptsReturn="True" />
    </DockPanel>
</Window>

Como na maioria dos aplicativos do Windows, meu menu é colocado na parte superior da janela, mas, de acordo com a enorme flexibilidade do WPF, você pode colocar um controle Menu onde desejar e em qualquer largura ou altura que desejar.

Eu defini um único item de nível superior, com 4 itens filhos e um separador. Eu uso a propriedade Header para definir o rótulo do item e você deve observar o sublinhado antes do primeiro caractere de cada rótulo. Ele diz ao WPF para usar esse caractere como a tecla aceleradora, o que significa que o usuário pode pressionar a tecla Alt seguida do caractere fornecido, para ativar o item de menu. Isso funciona desde o item de nível superior e abaixo da hierarquia, o que significa que neste exemplo eu poderia pressionar Alt, F e N, para ativar o item Novo.

Ícones e checkboxes

Duas características comuns de um item de menu são o ícone, usado para identificar mais facilmente o item de menu e o que ele faz, e a capacidade de ter itens de menu verificáveis, que podem ativar ou desativar um recurso específico. O MenuItem do WPF suporta ambos, e é muito fácil de usar:

<Window x:Class="WpfTutorialSamples.Common_interface_controls.MenuIconCheckableSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MenuIconCheckableSample" Height="150" Width="300">
    <DockPanel>
        <Menu DockPanel.Dock="Top">
            <MenuItem Header="_File">
                <MenuItem Header="_Exit" />
            </MenuItem>
            <MenuItem Header="_Tools">
                <MenuItem Header="_Manage users">
                    <MenuItem.Icon>
                        <Image Source="/WpfTutorialSamples;component/Images/user.png" />
                    </MenuItem.Icon>
                </MenuItem>
                <MenuItem Header="_Show groups" IsCheckable="True" IsChecked="True" />
            </MenuItem>
        </Menu>
        <TextBox AcceptsReturn="True" />
    </DockPanel>
</Window>

Para este exemplo, criei um item de nível superior secundário, no qual adicionei dois itens: um com um ícone definido, usando a propriedade Icon com um controle Image padrão dentro dele e um onde usamos a propriedade IsCheckable para permitir que o usuário marque e desmarque o item. Eu até usei a propriedade IsChecked para que ela fosse marcada por padrão. De Code-behind, esta é a mesma propriedade que você pode ler para saber se um determinado item de menu está marcado ou não.

Manipulando cliques

Quando o usuário clica em um item de menu, normalmente você quer que algo aconteça. A maneira mais fácil é simplesmente adicionar um manipulador de eventos de clique ao MenuItem, assim:

<MenuItem Header="_New" Click="mnuNew_Click" />

No Code-behind, você precisará implementar o método mnuNew_Click, desta forma:

private void mnuNew_Click(object sender, RoutedEventArgs e)
{
	MessageBox.Show("New");
}

Isso será suficiente para os aplicativos mais simples, ou quando está prototipando algo, mas o jeito no WPF é usar um Comando para isso.

Teclas de atalho e Comandos

Você pode manipular facilmente o evento Click de um item de menu como fizemos acima, mas a abordagem mais comum é usar os comandos do WPF. Há muita teoria sobre como usar e criar comandos, então eles têm sua própria categoria de artigos aqui no site, mas por enquanto, posso dizer que eles têm algumas vantagens quando usados no WPF, especialmente em combinação com um menu. ou uma barra de ferramentas.

Primeiro de tudo, eles garantem que você pode ter a mesma ação em uma barra de ferramentas, um menu e até mesmo um menu de contexto, sem ter que implementar o mesmo código em vários lugares. Eles também facilitam muito o manuseio de atalhos de teclado, porque, ao contrário do WinForms, o WPF não está atendendo automaticamente os atalhos do teclado se você os atribuir a, por exemplo, um item de menu - você terá que fazer isso manualmente.

No entanto, ao usar comandos, o WPF é todo ouvidos e responde automaticamente aos atalhos de teclado. O texto (Cabeçalho) do item de menu também é definido automaticamente (embora você possa sobrescrevê-lo, se necessário), assim como o InputGestureText, que mostra ao usuário qual atalho de teclado pode ser usado para chamar o item de menu específico. Vamos pular direto para um exemplo de combinação do menu com os comandos do WPF:

<Window x:Class="WpfTutorialSamples.Common_interface_controls.MenuWithCommandsSample"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        Title="MenuWithCommandsSample" Height="200" Width="300">
    <Window.CommandBindings>
        <CommandBinding Command="New" CanExecute="NewCommand_CanExecute" Executed="NewCommand_Executed" />
    </Window.CommandBindings>
    <DockPanel>
        <Menu DockPanel.Dock="Top">
            <MenuItem Header="_File">
                <MenuItem Command="New" />
                <Separator />
                <MenuItem Header="_Exit" />
            </MenuItem>
            <MenuItem Header="_Edit">
                <MenuItem Command="Cut" />
                <MenuItem Command="Copy" />
                <MenuItem Command="Paste" />
            </MenuItem>
        </Menu>

        <TextBox AcceptsReturn="True" Name="txtEditor" />
    </DockPanel>
</Window>
using System;
using System.Windows;
using System.Windows.Input;

namespace WpfTutorialSamples.Common_interface_controls
{
	public partial class MenuWithCommandsSample : Window
	{
		public MenuWithCommandsSample()
		{
			InitializeComponent();
		}

		private void NewCommand_CanExecute(object sender, CanExecuteRoutedEventArgs e)
		{
			e.CanExecute = true;
		}

		private void NewCommand_Executed(object sender, ExecutedRoutedEventArgs e)
		{
			txtEditor.Text = "";
		}
	}
}

Pode não ser completamente óbvio, mas usando comandos, nós apenas temos um monte de coisas de graça: Atalhos de teclado, texto e InputGestureText nos itens e o WPF ativa/desativa automaticamente os itens dependendo do controle ativo e seu estado. Nesse caso, Recortar e Copiar estão desabilitados porque nenhum texto está selecionado, mas Colar está habilitado, porque minha área de transferência não está vazia!

E porque o WPF sabe como lidar com certos comandos em combinação com certos controles, neste caso os comandos Recortar/Copiar/Colar em combinação com um controle de entrada de texto, nem precisamos lidar com os eventos Execute - eles funcionam imediatamente! Nós temos que lidar com isso com o Novo comando, já que o WPF não tem como adivinhar o que queremos fazer quando o usuário o ativa. Isso é feito com os CommandBindings da janela, todos explicados em detalhes no capítulo sobre comandos.

Resumo

Trabalhar com o controle de menu do WPF é fácil e rápido, simplificando a criação de hierarquias de menus complexas e, ao combiná-las com comandos do WPF, você obtém muita funcionalidade de graça.

This article has been fully translated into the following languages: Is your preferred language not on the list? Click here to help us translate this article into your language!