Visão geral da entrada

 

Publicado: junho de 2016

OWindows Presentation Foundation (WPF) subsistema fornece uma poderosa API para obter entrada de uma variedade de dispositivos, incluindo o mouse, teclado, toque e caneta. Este tópico descreve os serviços fornecidos pelo WPF e explica a arquitetura dos sistemas de entrada.

A entrada principal API exposição é encontrada nas classes de elemento base: UIElement, ContentElement, FrameworkElement, e FrameworkContentElement. Para obter mais informações sobre os elementos base, consulte visão geral de elementos Base. Essas classes fornecem funcionalidade para eventos de entrada relacionados ao pressionamentos de teclas, botões, roda do mouse, movimento do mouse, gerenciamento de foco e captura do mouse, para citar alguns. Colocando a entrada API nos elementos base, em vez de tratar todos os eventos de entrada como um serviço, a arquitetura de entrada permite que os eventos de entrada para ser originado de um objeto específico na interface do usuário e oferecer suporte a um esquema de roteamento de eventos no qual mais de um elemento tem a oportunidade de manipular um evento de entrada. Muitos eventos de entrada tem um par de eventos associados a eles. Por exemplo, a chave de evento é associada com o KeyDown e PreviewKeyDown eventos. A diferença nesses eventos está em como elas são roteadas para o elemento de destino. Túnel de eventos de visualização abaixo da árvore de elemento do elemento raiz ao elemento de destino. Eventos propagados para cima do elemento de destino para o elemento raiz. Roteamento de eventos no WPF é abordado em mais detalhes posteriormente nesta visão geral e, no visão geral de eventos roteados.

Classes de Mouse e teclado

Além de entrada API nas classes de elemento base, o teclado classe e Mouse classes fornecem adicionais API para trabalhar com a entrada de mouse e teclado.

Exemplos de entrada API no teclado classe são o modificadores propriedade, que retorna o ModifierKeys pressionadas no momento e o IsKeyDown método, que determina se uma chave especificada é pressionada.

O exemplo a seguir usa o GetKeyStates método para determinar se um chave está no estado inativo.

            // Uses the Keyboard.GetKeyStates to determine if a key is down.
            // A bitwise AND operation is used in the comparison. 
            // e is an instance of KeyEventArgs.
            if ((Keyboard.GetKeyStates(Key.Return) & KeyStates.Down) > 0)
            {
                btnNone.Background = Brushes.Red;
            }

Exemplos de entrada API sobre o Mouse são MiddleButton, que obtém o estado do botão do meio do mouse, e DirectlyOver, que obtém o elemento que o ponteiro do mouse está sobre.

O exemplo a seguir determina se o LeftButton no mouse está no pressionado estado.

            if (Mouse.LeftButton == MouseButtonState.Pressed)
            {
                UpdateSampleResults("Left Button Pressed");
            }

O Mouse e teclado classes são abordadas com mais detalhes nesta visão geral.

Entrada de caneta

WPFtem suporte integrado para o caneta. O caneta é uma entrada de caneta popularizada pelo Tablet. WPFaplicativos podem tratar a caneta como um mouse, usando o mouse API, mas WPF também expõe uma abstração de dispositivo de caneta que usam um modelo semelhante ao teclado e mouse. Todas as relacionadas à caneta APIs contêm a palavra "Caneta".

Como a caneta pode atuar como um mouse, aplicativos que dão suporte apenas a entrada de mouse ainda podem obter algum nível de suporte de caneta automaticamente. Quando a caneta é usada dessa forma, o aplicativo tem a oportunidade para manipular o evento de caneta apropriado e, em seguida, manipula o evento de mouse correspondente. Além disso, os serviços de alto nível, como entrada de tinta também estão disponíveis por meio da abstração do dispositivo de caneta. Para obter mais informações sobre tinta como entrada, consulte Introdução à tinta.

A FrameworkElement podem conter outros elementos como elementos filho em seu modelo de conteúdo, formando uma árvore de elementos. Em WPF, o elemento pai pode participar de entrada direcionada para seus elementos filho ou outros descendentes pelo envio de eventos. Isso é especialmente útil para a criação de controles sem controles menores, um processo conhecido como "composição de controle" ou "composição". Para obter mais informações sobre árvores de elementos e como árvores de elementos se relacionam às rotas de evento, consulte árvores no WPF.

Roteamento de eventos é o processo de encaminhamento de eventos para vários elementos, para que um determinado objeto ou um elemento ao longo da rota pode optar por oferecer uma resposta significativa (por meio de manipulação) a um evento que pode originado por um elemento diferente. Eventos roteados usam uma de três mecanismos de roteamentos: direct, bolha e encapsulamento. No roteamento direto, o elemento de origem é o único elemento notificado e o evento não será roteado para todos os outros elementos. No entanto, o evento roteado direto ainda oferece alguns recursos adicionais que só estão presentes para eventos roteados em vez do padrão CLR eventos. Propagação funciona na árvore de elemento primeiro notificando o elemento que a origem do evento, em seguida, o elemento pai e assim por diante. Encapsulamento iniciado na raiz da árvore de elemento e funciona, terminando com o elemento de origem original. Para obter mais informações sobre eventos roteados, consulte visão geral de eventos roteados.

WPFeventos de entrada geralmente vêm em pares, que consiste em um evento de túnel e um evento bolha. Eventos por túnel são diferenciados dos eventos com o prefixo "Visualização". Por exemplo, PreviewMouseMove é a versão de encapsulamento de um evento de movimentação do mouse e MouseMove versão bubbling desse evento. Esse emparelhamento de evento é uma convenção que é implementada no nível de elemento e não é um recurso inerente a WPF sistema de eventos. Para obter detalhes, consulte a seção de eventos de entrada do WPF em visão geral de eventos roteados.

Para receber a entrada em um elemento, um manipulador de eventos deve ser associado ao evento. Em XAML isso é fácil: você referenciar o nome do evento como um atributo do elemento que escutará esse evento. Em seguida, você deve definir o valor do atributo como o nome do manipulador de eventos que você definir, com base em um delegado. O manipulador de eventos deve ser escrito em código como C# e pode ser incluído em um arquivo code-behind.

Eventos de teclado ocorrem quando o sistema operacional relatórios principais ações que ocorrem enquanto o foco do teclado está em um elemento. Eventos mouse e caneta cada se enquadram em duas categorias: eventos que muda de relatório na posição do ponteiro relativa do elemento e que o relatório alterações no estado dos botões do dispositivo.

Exemplo de evento de entrada do teclado

O exemplo a seguir ouve um pressionamento de tecla de seta para a esquerda. A StackPanel é criada e tem uma botão. Um manipulador de eventos de escuta para o pressionamento de tecla de seta para a esquerda está associado a botão instância.

A primeira seção do exemplo cria o StackPanel e botão e anexa o manipulador de eventos para o KeyDown.

    <StackPanel>
      <Button Background="AliceBlue"
              KeyDown="OnButtonKeyDown"
              Content="Button1"/>
    </StackPanel>

            // Create the UI elements.
            StackPanel keyboardStackPanel = new StackPanel();
            Button keyboardButton1 = new Button();

            // Set properties on Buttons.
            keyboardButton1.Background = Brushes.AliceBlue;
            keyboardButton1.Content = "Button 1";

            // Attach Buttons to StackPanel.
            keyboardStackPanel.Children.Add(keyboardButton1);

            // Attach event handler.
            keyboardButton1.KeyDown += new KeyEventHandler(OnButtonKeyDown);

A segunda seção é escrita em código e define o manipulador de eventos. Quando é pressionada a tecla de seta para a esquerda e o botão tem o foco do teclado, a execução do Gerenciador e o em segundo plano cores do botão é alterado. Se a tecla é pressionada, mas não é a tecla de seta para a esquerda, o fundo cores do botão é alterada para a cor inicial.

        private void OnButtonKeyDown(object sender, KeyEventArgs e)
        {
            Button source = e.Source as Button;
            if (source != null)
            {
                if (e.Key == Key.Left)
                {
                    source.Background = Brushes.LemonChiffon;
                }
                else
                {
                    source.Background = Brushes.AliceBlue;
                }
            }
        }

Exemplo de evento de entrada de mouse

No exemplo a seguir, o fundo cor de um botão é alterado quando o ponteiro do mouse entra o botão. O fundo cor é restaurada quando o mouse sai do botão.

A primeira seção do exemplo cria o StackPanel e botão controlar e anexa os manipuladores de eventos para o MouseEnter e MouseLeave eventos para o botão.

    <StackPanel>
      <Button Background="AliceBlue"
              MouseEnter="OnMouseExampleMouseEnter"
              MouseLeave="OnMosueExampleMouseLeave">Button
              
      </Button>
    </StackPanel>

            // Create the UI elements.
            StackPanel mouseMoveStackPanel = new StackPanel();
            Button mouseMoveButton = new Button();

            // Set properties on Button.
            mouseMoveButton.Background = Brushes.AliceBlue;
            mouseMoveButton.Content = "Button";

            // Attach Buttons to StackPanel.
            mouseMoveStackPanel.Children.Add(mouseMoveButton);

            // Attach event handler.
            mouseMoveButton.MouseEnter += new MouseEventHandler(OnMouseExampleMouseEnter);
            mouseMoveButton.MouseLeave += new MouseEventHandler(OnMosueExampleMouseLeave);

A segunda seção do exemplo é escrita em código e define os manipuladores de eventos. Quando o mouse entra o botão, o fundo cor do botão é alterado para Cinza-azulado. Quando o mouse sai do botão, o em segundo plano cores do botão é alterada para AliceBlue.

        private void OnMouseExampleMouseEnter(object sender, MouseEventArgs e)
        {
            // Cast the source of the event to a Button.
            Button source = e.Source as Button;

            // If source is a Button.
            if (source != null)
            {
                source.Background = Brushes.SlateGray;
            }
        }

        private void OnMosueExampleMouseLeave(object sender, MouseEventArgs e)
        {
            // Cast the source of the event to a Button.
            Button source = e.Source as Button;

            // If source is a Button.
            if (source != null)
            {
                source.Background = Brushes.AliceBlue;
            }
        }

O TextInput evento permite que você ouvir entrada de texto de forma independente de dispositivo. O teclado é o principal meio de manuscrito de entrada, mas fala, texto e outros dispositivos de entrada podem gerar o texto de entrada também.

Para entrada de teclado, WPF envia primeiro apropriado KeyDown/KeyUp eventos. Se esses eventos não são processados e a chave é textual em vez (uma chave de controle, como as setas direcionais) ou teclas de função, uma TextInput é gerado. Nem sempre há um mapeamento simple entre KeyDown/KeyUp e TextInput eventos porque vários pressionamentos de teclas podem gerar um único caractere de entrada de texto e pressionamentos de tecla únicos podem gerar cadeias de caracteres de vários caracteres. Isso é especialmente verdadeiro para idiomas como chinês, japonês e coreano que usam IMEs (Editores de Método de Entrada) para gerar os milhares de caracteres possíveis em seus alfabetos correspondentes.

Quando WPF envia um KeyUp/KeyDown eventos, chave é definido como Key.System se os pressionamentos de teclas pode se tornar parte de um TextInput evento (se ALT + S é pressionado, por exemplo). Isso permite que o código em um KeyDown manipulador de eventos para verificar se há Key.System e, se encontrados, o processamento para o manipulador de subsequentemente gerado TextInput eventos. Nesses casos, as várias propriedades do TextCompositionEventArgs argumento pode ser usado para determinar os pressionamentos de teclas originais. Da mesma forma, se um IME está ativa, chave tem o valor de Key.ImeProcessed, e ImeProcessedKey fornece o pressionamento de tecla ou pressionamentos de tecla original.

O exemplo a seguir define um manipulador para o clique evento e um manipulador para o KeyDown eventos.

O primeiro segmento de código ou marcação cria a interface do usuário.

    <StackPanel KeyDown="OnTextInputKeyDown">
      <Button Click="OnTextInputButtonClick"
              Content="Open" />
      <TextBox> . . . </TextBox>
    </StackPanel>

            // Create the UI elements.
            StackPanel textInputStackPanel = new StackPanel();
            Button textInputeButton = new Button();
            TextBox textInputTextBox = new TextBox();
            textInputeButton.Content = "Open";

            // Attach elements to StackPanel.
            textInputStackPanel.Children.Add(textInputeButton);
            textInputStackPanel.Children.Add(textInputTextBox);

            // Attach event handlers.
            textInputStackPanel.KeyDown += new KeyEventHandler(OnTextInputKeyDown);
            textInputeButton.Click += new RoutedEventHandler(OnTextInputButtonClick);

O segundo segmento de código contém os manipuladores de eventos.

        private void OnTextInputKeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.O && Keyboard.Modifiers == ModifierKeys.Control)
            {
                handle();
                e.Handled = true;
            }
        }

        private void OnTextInputButtonClick(object sender, RoutedEventArgs e)
        {
            handle();
            e.Handled = true;
        } 

        public void handle()
        {
            MessageBox.Show("Pretend this opens a file");
        }

Como eventos de entrada emergir a rota de eventos, o StackPanel recebe a entrada, independentemente de qual elemento tem o foco do teclado. O TextBox controle é notificado pela primeira vez e o OnTextInputKeyDown manipulador é chamado apenas se o TextBox não processou a entrada. Se o PreviewKeyDown evento é usado em vez do KeyDown evento, o OnTextInputKeyDown manipulador é chamado primeiro.

Neste exemplo, a lógica de tratamento é gravada duas vezes — uma vez para CTRL + O e novamente para o botão do evento de clique. Isso pode ser simplificado usando comandos, em vez de manipular os eventos de entrada diretamente. Comandos são abordados nesta visão geral e, na visão geral do comando.

Novo hardware e a API no sistema operacional Windows 7 fornecem aplicativos a capacidade de receber entradas de toques vários simultaneamente. WPFpermite que os aplicativos detectar e responder ao toque de maneira semelhante a responder a outra entrada, como o mouse ou teclado, gerando eventos quando ocorre de toque.

WPFexpõe dois tipos de eventos quando ocorre toque: eventos e manipulação de eventos de toque. Eventos de toque fornecem dados brutos de cada dedo em uma tela sensível ao toque e o movimento. Eventos Manipulation interpretam a entrada como determinadas ações. Ambos os tipos de eventos são discutidos nesta seção.

Pré-requisitos

Você precisará dos seguintes componentes para desenvolver um aplicativo que responde ao toque.

  • Microsoft Visual Studio 2010.

  • O Windows 7.

  • Um dispositivo, como uma tela sensível ao toque, que oferece suporte a Windows Touch.

Terminologia

Os seguintes termos são usados ao toque é discutido.

  • Toque é um tipo de entrada do usuário que é reconhecida pelo Windows 7. Geralmente, toque é iniciado, colocando os dedos em uma tela sensível ao toque. Observe que toque não dão suporte a dispositivos como um teclado sensível ao toque comuns em computadores laptop se o dispositivo simplesmente converte o dedo posição e movimentação como entrada de mouse.

  • Multitoque é toque ocorre simultaneamente de mais de um ponto. O Windows 7 e WPF oferece suporte a multitoque. Sempre que o toque é discutido na documentação do WPF, os conceitos se aplicam para multitoque.

  • A manipulação ocorre quando o toque é interpretado como uma ação física que é aplicada a um objeto. Em WPF, eventos manipulation interpretam a entrada como uma manipulação de tradução, expansão ou rotação.

  • Um touch device representa um dispositivo que produz a entrada de toque, como um único dedo em uma tela sensível ao toque.

Controles que responder ao toque

Os seguintes controles podem ser rolados arrastando um dedo entre o controle se ele tem conteúdo que esteja fora da exibição.

O ScrollViewer define o ScrollViewer.PanningMode anexado a propriedade que permite que você especifique se a panorâmica de toque é habilitado na horizontal, vertical, ambos ou nenhum. O ScrollViewer.PanningDeceleration propriedade especifica a rapidez a rolagem diminui quando o usuário levanta o dedo da tela sensível ao toque. O ScrollViewer.PanningRatio propriedade anexada Especifica a taxa de deslocamento para traduzir o deslocamento de manipulação de rolagem.

Eventos de toque

As classes base, UIElement, UIElement3D, e ContentElement, definir os eventos que você pode se inscrever para seu aplicativo responderá ao toque. Eventos de toque são úteis quando seu aplicativo interpreta toque como algo diferente de manipular um objeto. Por exemplo, um aplicativo que permite que um usuário desenhar com um ou mais dedos deve inscrever-se para eventos de toque.

Todas as três classes definem os eventos a seguir, que se comportam da mesma forma, independentemente da definição de classe.

Como os eventos de teclado e mouse, os eventos de toque são eventos roteados. Os eventos que começam com Preview são encapsulamento eventos e os eventos que começam com Touch são eventos. Para obter mais informações sobre eventos roteados, consulte visão geral de eventos roteados. Ao lidar com esses eventos, você pode obter a posição da entrada, em relação a qualquer elemento, chamando o GetTouchPoint ou GetIntermediateTouchPoints método.

Para compreender a interação entre os eventos de toque, considere o cenário em que um usuário coloca um dedo em um elemento, move o dedo no elemento e, em seguida, levanta o dedo do elemento. A ilustração a seguir mostra a execução dos eventos bolha (os eventos por túnel são omitidos para manter a simplicidade).

A sequência de eventos de toque.
Eventos de toque

A lista a seguir descreve a sequência de eventos na ilustração anterior.

  1. O TouchEnter evento ocorre uma vez quando o usuário coloca um dedo no elemento.

  2. O TouchDown evento ocorre uma vez.

  3. O TouchMove evento ocorre várias vezes enquanto o usuário move o dedo dentro do elemento.

  4. O Retocar evento ocorre uma vez quando o usuário levanta o dedo do elemento.

  5. O TouchLeave evento ocorre uma vez.

Quando são usados com mais de dois dedos, ocorrem os eventos para cada dedo.

Manipulação de eventos

Para casos em que um aplicativo permite que um usuário manipular um objeto, o UIElement classe define os eventos manipulation. Diferentemente de eventos de toque que simplesmente relatar a posição de toque, os eventos manipulation relatório como a entrada pode ser interpretada. Há três tipos de rotação, translação, expansão e manipulações. A lista a seguir descreve como invocar os três tipos de manipulações.

  • Coloque um dedo em um objeto e mover o dedo na tela de toque para invocar uma manipulação de tradução. Geralmente, isso move o objeto.

  • Coloque dois dedos em um objeto e mover os dedos próximo juntos ou futuramente além uns aos outros para invocar uma manipulação de expansão. Isso geralmente redimensiona o objeto.

  • Coloque dois dedos em um objeto e girar os dedos em torno do outro para invocar uma manipulação de rotação. Isso geralmente gira o objeto.

Mais de um tipo de manipulação pode ocorrer simultaneamente.

Quando fazem com objetos para responder às manipulações, você pode ter o objeto parece ter inércia. Isso pode tornar seus objetos simular mundo físico. Por exemplo, quando você envia um livro em uma tabela, se você enviar o disco rígido suficiente o livro continuará mover depois de liberá-lo. WPFpermite simular esse comportamento, gerando eventos manipulation após os dedos do usuário libera o objeto.

Para obter informações sobre como criar um aplicativo que permite que o usuário mover, redimensionar e girar um objeto, consulte passo a passo: Criando seu primeiro toque aplicativo.

O UIElement define os seguintes eventos de manipulação.

Por padrão, uma UIElement não receber esses eventos manipulation. Para receber eventos manipulation em uma UIElement, defina UIElement.IsManipulationEnabled para true.

O caminho de execução de manipulação de eventos

Considere um cenário onde um usuário "lança" um objeto. O usuário coloca um dedo no objeto, o move o dedo a tela sensível ao toque para uma distância curta e, em seguida, levanta o dedo enquanto ele está se movendo. O resultado disso é que o objeto moverá sob o dedo do usuário e continuar a mover depois do usuário levanta o dedo.

A ilustração a seguir mostra o caminho de execução de eventos manipulation e informações importantes sobre cada evento.

A sequência de eventos de manipulação.
Eventos de manipulação

A lista a seguir descreve a sequência de eventos na ilustração anterior.

  1. O ManipulationStarting evento ocorre quando o usuário coloca um dedo no objeto. Entre outras coisas, este evento permite que você defina o ManipulationContainer propriedade. Os eventos subsequentes, a posição da manipulação de será relativo a ManipulationContainer. Eventos de ManipulationStarting, essa propriedade é somente leitura, para que o ManipulationStarting evento é a única vez que você pode definir essa propriedade.

  2. O ManipulationStarted evento ocorre em seguida. Esse evento informa a origem da manipulação de.

  3. O ManipulationDelta evento ocorre várias vezes como mover de dedos do usuário em uma tela sensível ao toque. O DeltaManipulation propriedade o ManipulationDeltaEventArgs classe informa se a manipulação é interpretada como a movimentação, expansão e conversão. Isso é onde você realizar a maioria do trabalho de manipulação de um objeto.

  4. O ManipulationInertiaStarting evento ocorre quando os dedos do usuário perdessem o contato com o objeto. Esse evento permite que você especifique a desaceleração das manipulações durante inércia. Isso é para que seu objeto pode emular espaços físicos diferentes ou atributos se você escolher. Por exemplo, suponha que seu aplicativo tem dois objetos que representam itens no mundo físico e um é mais pesado que o outro. Você pode fazer com que o objeto mais pesado desacelerar mais rápido do que o objeto mais leve.

  5. O ManipulationDelta evento ocorre várias vezes enquanto ocorre a inércia. Observe que este evento ocorre quando os dedos do usuário movam entre a tela sensível ao toque e quando WPF simula inércia. Em outras palavras, ManipulationDelta antes e depois o ManipulationInertiaStarting eventos. O ManipulationDeltaEventArgs.IsInertial relatórios de propriedade se o ManipulationDelta eventos ocorre durante a inércia, você pode verificar essa propriedade e executar ações diferentes, dependendo de seu valor.

  6. O ManipulationCompleted evento ocorre quando a manipulação e qualquer inércia termina. Isto é, após todo o ManipulationDelta eventos ocorrem, o ManipulationCompleted ocorre um evento para sinalizar que a manipulação foi concluída.

O UIElement também define o ManipulationBoundaryFeedback eventos. Esse evento ocorre quando o ReportBoundaryFeedback método é chamado no ManipulationDelta eventos. O ManipulationBoundaryFeedback evento permite que aplicativos ou componentes fornecer feedback visual quando um objeto atinge um limite. Por exemplo, o janela identificadores de classe de ManipulationBoundaryFeedback eventos para fazer com que a janela mover ligeiramente quando sua borda é encontrada.

Você pode cancelar a manipulação chamando o Cancelar método dos argumentos de evento em qualquer evento de manipulação de exceção ManipulationBoundaryFeedback eventos. Quando você chama Cancelar, os eventos manipulation não são gerados e eventos de mouse ocorrem para toque. A tabela a seguir descreve a relação entre a hora em que a manipulação é cancelada e os eventos de mouse que ocorrem.

O evento Cancelar é chamado noOs eventos de mouse que ocorrem para entrada já ocorreu
ManipulationStarting e ManipulationStartedEventos de mouse.
ManipulationDeltaMouse para baixo e eventos de movimento do mouse.
ManipulationInertiaStarting e ManipulationCompletedMouse para baixo, mover mouse e eventos de mouse.

Observe que, se você chamar Cancelar quando a manipulação está inércia, o método retorna false e a entrada não gera eventos de mouse.

A relação entre o toque e manipulação de eventos

A UIElement sempre pode receber eventos de toque. Quando o IsManipulationEnabled está definida como true, um UIElement pode receber eventos de toque e manipulação. Se o TouchDown evento não é tratado (ou seja, o Handled é de propriedade false), a lógica de manipulação de toque para o elemento de captura e gera os eventos manipulation. Se o Handled está definida como true no TouchDown a lógica de manipulação de evento não gera eventos manipulation. A ilustração a seguir mostra a relação entre eventos de toque e eventos manipulation.

Relação entre eventos de toque e manipulação
Toque e manipulação de eventos

A lista a seguir descreve a relação entre os eventos de toque e manipulação é mostrado na ilustração anterior.

Há dois principais conceitos relativos ao foco em WPF: foco do teclado e foco lógico.

Foco do teclado

O foco do teclado refere-se ao elemento que está recebendo a entrada do teclado. Pode haver apenas um elemento em toda a área de trabalho que tem o foco do teclado. Em WPF, o elemento que tem o foco do teclado terá IsKeyboardFocused é definida como true. Estático teclado método FocusedElement retorna o elemento que tem o foco do teclado no momento.

O foco do teclado pode ser obtido por tabulações para um elemento ou clicando o mouse sobre determinados elementos, como um caixa de texto. O foco do teclado também pode ser obtido programaticamente usando o foco método o teclado classe. Foco foco do teclado tenta dar ao elemento especificado. O elemento retornado por foco é o elemento que tem o foco do teclado no momento.

Para que um elemento Obtenha o foco do teclado a Focusable propriedade e o IsVisible propriedades devem ser definidas como true. Algumas classes, como painel, ter Focusable definida como false por padrão; portanto, você precisará definir essa propriedade como true se você quiser que esse elemento para ser capaz de obter o foco.

O exemplo a seguir usa foco para definir o foco do teclado em uma botão. O local recomendado para definir o foco inicial em um aplicativo está no Loaded manipulador de eventos.

        private void OnLoaded(object sender, RoutedEventArgs e)
        {
            // Sets keyboard focus on the first Button in the sample.
            Keyboard.Focus(firstButton);
        }

Para obter mais informações sobre o foco do teclado, consulte visão geral do foco.

Foco lógico

Foco lógico refere-se para o FocusManager.FocusedElement em um escopo de foco. Pode haver vários elementos que têm foco lógico em um aplicativo, mas pode haver apenas um elemento que tenha foco lógico em um escopo específico de foco.

Um escopo de foco é um elemento de contêiner que controla o FocusedElement dentro de seu escopo. Quando o foco deixa um escopo de foco, o elemento focalizado perderá o foco do teclado mas manterá foco lógico. Quando o foco retorna para o escopo de foco, o elemento focalizado obterá o foco do teclado. Isso permite que o foco do teclado seja alterado entre vários escopos de foco mas assegura que o elemento focalizado dentro do escopo de foco permaneça o elemento focalizado quando o foco retorna.

Um elemento pode ser ativado para um escopo de foco no XAML (linguagem XAML) , definindo o FocusManager propriedade anexada IsFocusScope para true, ou no código, definindo a propriedade anexada usando o SetIsFocusScope método.

O exemplo a seguir faz uma StackPanel em um escopo de foco definindo a IsFocusScope propriedade anexada.

    <StackPanel Name="focusScope1" 
                FocusManager.IsFocusScope="True"
                Height="200" Width="200">
      <Button Name="button1" Height="50" Width="50"/>
      <Button Name="button2" Height="50" Width="50"/>
    </StackPanel>

            StackPanel focuseScope2 = new StackPanel();
            FocusManager.SetIsFocusScope(focuseScope2, true);

Classes em WPF que são escopos de foco por padrão são janela, Menu, ferramentas, e ContextMenu.

Um elemento que tem o foco do teclado também terá foco lógico para o escopo de foco pertence Portanto, definir o foco em um elemento com o foco método o teclado classe ou classes de elemento base tenta dar o foco do teclado ao elemento e foco lógico.

Para determinar o elemento focalizado em um escopo de foco, use GetFocusedElement. Para alterar o elemento focalizado de um escopo de foco, use SetFocusedElement.

Para obter mais informações sobre foco lógico, consulte visão geral do foco.

O WPF entrada API fornece informações úteis em relação a espaços de coordenadas. Por exemplo, coordenar (0,0) é a coordenada superior esquerdo, mas o canto superior esquerdo do qual elemento na árvore? O elemento que é o destino de entrada? O elemento que você anexou o manipulador de eventos? Ou alguma outra coisa? Para evitar confusão, o WPF entrada API exige que você especifique o quadro de referência ao trabalhar com coordenadas obtidas por meio do mouse. O GetPosition método retorna as coordenadas do ponteiro do mouse em relação ao elemento especificado.

Dispositivos de mouse especificamente mantêm uma característica modal conhecida como captura do mouse. Captura do mouse é usada para manter o estado de transição de entrada quando uma operação de arrastar e soltar é iniciada, para que outras operações que envolvem o nominal na tela posição do ponteiro do mouse não necessariamente ocorrem. Durante a arrastar, o usuário não poderá clicar sem anulando o arrastar e soltar, que torna a maioria das indicações mouseover inadequado enquanto a captura do mouse é mantida por origem de arrastar. O sistema de entrada expõe APIs que pode determinar o estado de captura do mouse, bem como APIs que pode forçar a captura do mouse em um elemento específico ou desmarcar o estado de captura do mouse. Para obter mais informações sobre operações de arrastar e soltar, consulte arrastar e soltar Overview.

Os comandos permitem a manipulação de entrada em um nível semântico mais que a entrada do dispositivo. Comandos são diretivas simples, como Cut, Copy, Paste, ou Open. Comandos são úteis para centralizar sua lógica de comando. O mesmo comando pode ser acessado de um Menu, em uma ferramentas, ou por meio de um atalho de teclado. Comandos também fornecem um mecanismo para a desabilitação dos controles quando o comando se torna indisponível.

RoutedCommand é o WPF implementação de ICommand. Quando um RoutedCommand é executado, uma PreviewExecuted e uma Executed eventos são gerados no destino de comando, que túnel e bolha através da árvore de elementos, como outra entrada. Se um destino do comando não for definido, o elemento com o foco do teclado será o destino de comando. A lógica que executa o comando é anexada a um CommandBinding. Quando um executados evento alcançar um CommandBinding para esse comando específico, o ExecutedRoutedEventHandler no CommandBinding é chamado. Esse manipulador executa a ação do comando.

Para obter mais informações sobre comandos, consulte visão geral do comando.

WPFFornece uma biblioteca de comandos comuns que consiste em ApplicationCommands, MediaCommands, ComponentCommands, NavigationCommands, e EditingCommands, ou você pode definir seus próprios.

O exemplo a seguir mostra como configurar um MenuItem para que quando ele for clicado ele chamará o colar comando o TextBox, supondo que o caixa de texto tem o foco do teclado.

    <StackPanel>
      <Menu>
        <MenuItem Command="ApplicationCommands.Paste" />
      </Menu>
      <TextBox />
    </StackPanel>

            // Creating the UI objects
            StackPanel mainStackPanel = new StackPanel();
            TextBox pasteTextBox = new TextBox();
            Menu stackPanelMenu = new Menu();
            MenuItem pasteMenuItem = new MenuItem();
           
            // Adding objects to the panel and the menu
            stackPanelMenu.Items.Add(pasteMenuItem);
            mainStackPanel.Children.Add(stackPanelMenu);
            mainStackPanel.Children.Add(pasteTextBox);

            // Setting the command to the Paste command
            pasteMenuItem.Command = ApplicationCommands.Paste;
          
            // Setting the command target to the TextBox
            pasteMenuItem.CommandTarget = pasteTextBox;

Para obter mais informações sobre os comandos no WPF, consulte visão geral do comando.

Eventos, como os eventos anexados definidos por de entrada do Mouse, teclado, e caneta classes são gerados pelo sistema de entrada e injetados em uma posição específica no modelo de objeto com base na árvore visual em tempo de execução de teste de clique.

Cada um dos eventos que Mouse, teclado, e caneta definem como um evento anexado novamente também é exposto pelas classes de elemento base UIElement e ContentElement como um novo evento roteado. Os eventos roteado de elemento base são gerados pelas classes manipulando o evento anexado original e reutilizar os dados do evento.

Quando o evento de entrada é associado um elemento de origem em particular por meio de sua implementação de evento de entrada do elemento base, podem ser roteada através do restante de uma rota de eventos com base em uma combinação de objetos da árvore visual e lógico e ser manipulado pelo código do aplicativo. Geralmente, é mais conveniente lidar com esses eventos de entrada relacionados ao dispositivo usando os eventos roteados em UIElement e ContentElement, porque você pode usar o evento manipulador uma sintaxe mais intuitiva dois no XAML e no código. Você pode optar por manipular o evento anexado que iniciou o processo em vez disso, mas você enfrenta diversos problemas: o evento anexado pode ser marcado como manipulado pelo tratamento de classe do elemento base e você precisa usar os métodos acessadores em vez da sintaxe de evento true para anexar manipuladores de eventos anexados.

Agora você tem várias técnicas para manipular a entrada em WPF. Você também deve ter uma compreensão melhor dos vários tipos de eventos de entrada e os mecanismos de evento roteado usados pelo WPF.

Recursos adicionais estão disponíveis que explicam WPF elementos estruturais e roteamento de eventos em mais detalhes. Consulte as visões gerais a seguir para obter mais informações, visão geral de comandos, visão geral do foco, visão geral de elementos Base, árvores no WPF, e visão geral de eventos roteados.

Visão geral do foco
Visão geral de comando
Visão geral sobre eventos roteados
Visão geral de elementos base
Propriedades

Mostrar: