Modernizando a entrada no Windows 8

Blog do desenvolvedor de aplicativos do Windows 8

Ideias sobre a criação de aplicativos com o estilo Metro para o Windows 8, da equipe de engenharia do Windows 8

Modernizando a entrada no Windows 8

  • Comments 2

No Windows 8, iniciamos uma jornada para modernizar nossa plataforma de entrada. Nosso objetivo era simplificar o desenvolvimento na plataforma de entrada, mas também queríamos criar uma base que pudesse crescer e dar suporte a novas modalidades de entrada, acompanhando a evolução do Windows e dos aplicativos.

Para isso, voltamos ao básico e focamos nos princípios fundamentais que orientam nosso design. Nesta postagem do blog, compartilharei a importância desses princípios e como tirar proveito da plataforma para desenvolver excelentes aplicativos no Windows 8.

Princípios da plataforma

O Windows sempre foi um reflexo dos aplicativos que são desenvolvidos com base nele. É por meio desse mundo de aplicativos que muitos usuários exploram o Windows, principalmente o Windows 8. No Windows 8, a grande maioria dos recursos do sistema operacional é apresentada por meio da interação com aplicativos. Por esse motivo, a interação com os aplicativos deve ser muito mais previsível, para inspirar a confiança do usuário. De forma semelhante, a plataforma e o processo de desenvolvimento precisam ser consistentes e previsíveis. Já blogamos sobre nossos esforços de hardware em Experimentando o toque do Windows 8 no hardware do Windows 7 e em Hardware de toque e o Windows 8, e discutimos alguns aspectos dos comentários de nossos clientes. Sabemos que uma plataforma bem-sucedida precisa facilitar o desenvolvimento, ser consistente e inspirar confiança, além de ter amplo alcance, para que você possa realmente liberar sua criatividade. Começamos com os seguintes princípios:

Amplo alcance

Você deseja direcionar o máximo possível de dispositivos com facilidade. Do ponto de vista da plataforma de entrada, isso significa que precisamos dar suporte a uma ampla gama de tipos de entrada (mouse, toque, caneta, touchpads) e formatos (slate, computador tudo em um, desktop, laptops, conversíveis). O sucesso e a popularidade do Windows se devem, em parte, ao seu suporte a muitos formatos e dispositivos. A plataforma, por sua vez, deve facilitar essa compatibilidade.

Consistência e confiança

Queremos que você tenha uma experiência consistente e confiável. Como desenvolvedor de aplicativos, sua função não é ensinar aos usuários novas interações ou paradigmas de entrada. Você precisa tirar proveito de uma experiência consistente no Windows, com a certeza de que os usuários saberão interagir com seu aplicativo. Isso aumenta a confiança do usuário nos aplicativos e no ecossistema, além de tornar sua vida mais fácil.

Fácil desenvolvimento

Nenhuma plataforma poderá ser bem-sucedida se for muito complicada, inconsistente ou dificultar o desenvolvimento de alguma forma. A facilidade de desenvolvimento é um dos princípios que seguimos.

Introdução à plataforma de entrada

A plataforma de entrada é desenvolvida em camadas. Em sua camada inferior estão as APIs de entrada do Tempo de Execução do Windows, que proporcionam potência e flexibilidade. Acima dessa camada, estão os eventos de gestos e ponteiros nas estruturas de HTML e XAML, que fornecem eventos de dados brutos e gestos comuns para os aplicativos. Por último, estão os controles e modelos de aplicativos, que fornecem recursos básicos que você pode usar em diversas situações.

As camadas superiores da plataforma de entrada focam nos cenários em primeiro plano, e as camadas inferiores adicionam flexibilidade e potência de forma progressiva
Figura 1: a plataforma de entrada. As camadas superiores da plataforma de entrada focam nos cenários em primeiro plano, e as camadas inferiores adicionam flexibilidade e potência de forma progressiva.

Na maioria das vezes, você pode simplesmente usar os modelos de aplicativos e nossos controles de HTML e XAML, como o ListView ou o SemanticZoom. Com isso, os desenvolvedores obtêm recursos básicos e vantagens adicionais, como o suporte a padrões comuns de interação (ex: linguagem de toque), suporte para seleção por área de toque, acessibilidade, integração de ferramentas etc.

Em particular, um dos cenários mais comuns para o uso do toque é o movimento panorâmico e de zoom, e os controles de exibição de rolagem de HTML e XAML no Windows 8 permitem comportamentos como inércia, salto em limites de conteúdo e pontos de ajuste que você pode controlar. Esses comportamentos também proporcionam o desempenho que "obedece" ao seu dedo, baseado em um componente adjacente chamado de DirectManipulation. Por exemplo, o menu Iniciar no Windows 8 foi criado com base nesse suporte.

Digamos que você esteja desenvolvendo um jogo, um controle personalizado, visualizações personalizadas, gestos para manipulação em 3D ou algo que requer dados brutos ou compilações baseadas nos gestos do Windows 8. Você provavelmente começará pelos eventos de estrutura de ponteiros e gestos (HTML e XAML). Os gestos incluem interações simples, como o toque, e outras mais complicadas, como zoom, movimento panorâmico e rotação ao mesmo tempo. As APIs de ponteiros, sobre as quais falaremos com mais detalhes em breve, proporcionam uma forma simplificada de obter dados de mouse, toque e caneta no Windows 8. O acesso a esses eventos facilita o uso da linguagem de interação do Windows no seu aplicativo.

E, finalmente, as APIs de entrada do Tempo de Execução do Windows ficam na camada inferior da pilha. Essas APIs (GestureRecognizer, PointerPoint, PointerDevice) proporcionam flexibilidade e controle completos, para que você tenha acesso total aos dados brutos de entrada e suas propriedades associadas, ao conjunto completo de gestos e configurações de gestos, às APIs de dispositivos de ponteiros etc. A superfície de API do WinRT para entrada é um superconjunto do que é fornecido nas demais camadas, com a adição de variedade e potência. Libere sua criatividade!

Os conceitos por trás da plataforma de entrada são compartilhados por todas as estruturas de aplicativos Metro, e as superfícies de APIs são bastante semelhantes. Isso se deve porque quisemos facilitar a transferência de conhecimentos entre as estruturas. Depois de criar um aplicativo HTML estilo Metro, você poderá lidar facilmente com a entrada em um aplicativo XAML estilo Metro ou criar diretamente com o CoreWindows.

Nas próximas seções, nos dedicaremos às duas camadas inferiores da plataforma de entrada, apresentaremos alguns dos conceitos adjacentes à plataforma e as razões pelas quais era importante mudar.

Ponteiro - entrada unificadora

O mouse é um dispositivo de entrada simples, especialmente em comparação com o toque. Ele tem uma posição e o estado de alguns botões. Por outro lado, a manipulação natural com o toque começa a agregar uma complexidade que não existe no mouse. Os usuários podem usar vários dedos ao mesmo tempo, e você precisa de alguma forma de diferenciar os fluxos de entrada. O mouse tem um estado de passagem, mas a maioria dos dispositivos de toque no mercado atualmente não suportam o gesto de passagem. O toque também oferece propriedades interessantes para aplicativos, como a geometria de contato. Um dedo é maior e menos preciso que o mouse. Analisando o mouse, o toque e a caneta, percebemos que as APIs e abordagens existentes eram insuficientes.

Ficou claro rapidamente que faria sentido considerar a entrada por classificação. Havia a "entrada por apontador", como mouse, toque e caneta; a "entrada de texto", como teclados, manuscrito, reconhecimento de fala etc. Levamos em consideração outros dispositivos de entrada interessantes, como o Surface e o Kinect, e começamos a ver semelhanças entre esses dispositivos e modalidades. Adotamos a abordagem de unificar as entradas por apontador em uma superfície de API coerente que chamamos de ponteiro. Isso se tornou uma mudança de paradigma para nós, dando origem a uma forma mais simples e coerente para o uso de mouse, toque e caneta, em alinhamento com nossos princípios para a plataforma.

Usando como exemplo um aplicativo de pintura bastante básico, temos a necessidade de eventos de manipulação para baixo, para cima e de movimentação, por meio de diversas entradas. Se você desejar responder com toque, caneta e mouse, uma plataforma tradicional poderá obrigá-lo a criar 9 manipuladores de eventos diferentes e redundantes. Veja como você pode agir nessa plataforma tradicional:

// BAD! Don’t do this in your code.
class NaivePlatform
{
Dictionary<uint, Polyline> strokes = new Dictionary <uint, Polyline>();
Canvas PaintArea = new Canvas();

void OnMouseDown(MouseEventArgs e) { CommonDownHandler(e.Id, e.Position); }
void OnMouseMove(MouseEventArgs e) { CommonMoveHandler(e.Id, e.Position); }
void OnMouseUp(MouseEventArgs e) { CommonUpHandler(e.Id, e.Position); }

void OnPenDown(PenEventArgs e) { CommonDownHandler(e.Id, e.Position); }
void OnPenMove(PenEventArgs e) { CommonMoveHandler(e.Id, e.Position); }
void OnPenUp(PenEventArgs e) { CommonUpHandler(e.Id, e.Position); }

void OnTouchDown(TouchEventArgs e) { CommonDownHandler(e.Id, e.Position); }
void OnTouchMove(TouchEventArgs e) { CommonMoveHandler(e.Id, e.Position); }
void OnTouchUp(TouchEventArgs e) { CommonUpHandler(e.Id, e.Position); }

void CommonDownHandler(uint pointerId, Point position)
{
// Create a new stroke for this pointer and set its basic properties
var stroke = new Polyline();
stroke.Points.Add(position);
stroke.Stroke = new SolidColorBrush(Colors.Red);
stroke.StrokeThickness = 3;

// Add the stroke to dictionary so we can update it in CommonMoveHandler
strokes[pointerId] = stroke;

// Add the stroke to the canvas so that it is rendered
PaintArea.Children.Add(stroke);
}

void CommonMoveHandler(uint pointerId, Point position)
{
try
{
// Update the stroke associated to this pointer with the new point
strokes[pointerId].Points.Add(position);
}
catch (KeyNotFoundException)
{
// this pointer is not painting - ignore it
}
}

void CommonUpHandler(uint pointerId, Point position)
{
// This stroke is completed, so remove it from the dictionary.
// It will still be rendered because we are not removing it from the canvas.
strokes.Remove(pointerId);
}
}

Obviamente, esse tipo de código é complicado e está sujeito a erros durante o processo de copiar e colar. Esse é um exemplo extremamente simplificado. Um verdadeiro aplicativo de pintura precisaria de eventos de manipulador de cancelamento e reversão do pincel. Se você quiser que a pressão da caneta ou a geometria de contato do toque afete a tinta, o uso de manipuladores de eventos comuns se tornará muito mais difícil. Esse processo poderá forçá-lo a criar alguma abstração além dos dados brutos de entrada, e você poderá acabar tendo que criar algo como um ponteiro.

Por outro lado, na versão com ponteiro do aplicativo de pintura, você tem um conjunto simples de manipuladores para baixo, para cima e de movimentação.

// GOOD! Do this instead of the previous code.
void OnPointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
// Retrieve current point, in the coordinate system of the painting area
var currentPoint = e.GetCurrentPoint(PaintArea);

// Create new stroke for this pointer and set its basic properties
var stroke = new Windows.UI.Xaml.Shapes.Polyline();
stroke.Points.Add(currentPoint.Position);
stroke.Stroke = new Windows.UI.Xaml.Media.SolidColorBrush(Windows.UI.Colors.Red);
stroke.StrokeThickness = 3;

// Add the stroke to dictionary so we can update it in PointerMoved event handler
strokes[currentPoint.PointerId] = stroke;

// Add the stroke to the painting area so that it is rendered
PaintArea.Children.Add(stroke);
}

void OnPointerMoved(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
// Retrieve current point, in the coordinate system of the painting area
var currentPoint = e.GetCurrentPoint(PaintArea);

try
{
// Update the stroke associated to this pointer with the new point
strokes[currentPoint.PointerId].Points.Add(currentPoint.Position);
}
catch (System.Collections.Generic.KeyNotFoundException)
{
// this pointer is not painting - ignore it
}
}

void OnPointerReleased(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
// Retrieve current point, in the coordinate system of the painting area
var currentPoint = e.GetCurrentPoint(PaintArea);

// This stroke is completed, remove it from the dictionary.
// It will still be rendered because we are not removing it from PaintArea.
strokes.Remove(currentPoint.PointerId);
}

Os eventos de ponteiro que representam a entrada de toque, caneta e mouse têm propriedades básicas comuns, como a posição da entrada o tipo e uma ID associada. Cada modalidade pode ter dados exclusivos que devem sem vinculados aos seus eventos de ponteiro. Por exemplo, a caneta pode conter informações de pressão ou inclinação, o mouse normalmente contém mais estados de botões, e um dispositivo como o Surface pode inserir dados de marca ou de visão. Adicionamos a capacidade de expor esses dados exclusivos juntamente com o ponteiro. Se você tiver dados de ponteiro da entrada de toque, haverá propriedades básicas como a posição e uma ID de ponteiro, além de dados específicos de toque como o retângulo de contato.

Essa combinação começa a abrir um conjunto mais consistente de APIs que permite que a maioria dos códigos de entrada de ponteiros permaneça generalizada e simples e, ainda assim, proporcione experiências de entrada diferenciadas. Um exemplo importante aqui seria um aplicativo de anotações. A caneta pode escrever, o toque pode fazer o movimento panorâmico e zoom, e o mouse pode ter um modelo de seleção tradicional. Cada modalidade tem sua exclusividade representada, mas o código é fundamentalmente simples e direto.

Levando a Web em consideração por um momento, o ponteiro é exibido em aplicativos HTML estilo Metro e no navegador (estilo Metro e desktop). É claro que esses ambientes continuam com suporte para padrões W3C, como eventos de mouse, mas oferecem recursos limitados em comparação com o ponteiro. O ponteiro pode ser estendido de forma limpa para tipos futuros de entrada e evita o excesso de novos objetos que são adicionados para cada entrada nova (ex: TouchEvent, TouchList e Touch). Estamos muito animados sobre o que o ponteiro tem a oferecer aqui.

Entre os princípios que guiam nosso trabalho no Win8, estão a rapidez e a fluidez. Se a pilha de entrada não for rápida e fluida, nada mais será. Trabalhamos arduamente para remover quaisquer armazenamentos em buffer e atrasos no processamento da entrada de toque, e fizemos grandes investimentos no desempenho das pilhas relacionadas ao toque em todo o sistema. Esses esforços resultaram em entradas rápidas e sem lag no Windows 8. No hardware do Windows 8, a latência de ponto a ponto (de um contato com o dedo no digitalizador até a tela mudar em resposta) leva cerca de 60 a 70 ms. A pilha de entrada reduz 1 a 2 ms desse tempo!

Um gráfico que analisa as áreas de investimento no desempenho do toque no Windows 8
Figura 2: Uma análise das áreas de investimento no desempenho do toque no Windows 8

O ponteiro e sua interação com o sistema de gestos foram importantes nos aprimoramentos do desempenho. O ponteiro se alinha naturalmente aos princípios da nossa plataforma, facilitando a manipulação de diferentes entradas permitindo alcance automático, reduzindo linhas de códigos e simplificando o desenvolvimento.

Gestos: incluindo a linguagem de toque como parte do seu aplicativo

Todos nós estamos familiarizados com os gestos. A maioria dos usuários não pensa duas vezes ao fazer um movimento panorâmico no navegador da Web ou ao tocar em um aplicativo para iniciá-lo. Para nós, os gestos são a expressão da linguagem de interação do Windows 8. Os gestos manipulam a entrada do usuário e a mapeiam em operações naturais nos aplicativos e no sistema.

Como sabemos, a entrada de gestos se baseia na extremidade do ponteiro. A maioria dos aplicativos é consumidora de gestos; lidam com toques, movimentos panorâmicos e zooms, e não utilizam muito os dados brutos do ponteiro, exceto ao transformá-los na detecção do gesto.

Levando em consideração as camadas da plataforma de entrada novamente, cada nível suporta um conjunto consistente de gestos, e esse conjunto espelha o idioma de interação do Windows 8. Na maioria dos casos, você não precisará ensinar aos usuários novos conceitos para usar seu aplicativo.

Uma imagem mostrando que a linguagem de interação do Windows 8 é mapeada no conjunto de gestos suportado
Figura 3: a linguagem de interação do Windows 8. Observe como ela é mapeada no conjunto suportado de gestos.

No Windows 8, nosso modelo oferece entrada de ponteiro a todos os aplicativos por padrão e permite que eles escolham o conjunto de dados que deve lidar com a detecção de gestos, como configurar a detecção dos gestos e o que fazer com a saída. Essa flexibilidade proporciona um poder maior para você desenvolver exatamente as experiências que pretende.

Nossa linguagem de interação foca em um princípio de manipulação direta: o conteúdo deve "obedecer" aos seus dedos. A manipulação torna isso realidade. Do ponto de vista da plataforma, um gesto é qualquer interação que reconhecemos e sobre a qual apresentamos uma notificação. A manipulação é um desses tipos de gestos, juntamente com outros gestos, como pressionar, segurar e tocar. As manipulações são combinações de alterações de rotação, conversão e escala (transformações em 2D na álgebra linear) Por exemplo, na nova experiência do Iniciar, quando você faz o movimento panorâmico, é uma manipulação agindo nos bastidores. Se você pressionar um segundo dedo para baixo e começar a aplicar zoom, também é uma manipulação. E, não só isso, podemos expressar facilmente a transição da interação de um dedo para dois dedos e a transição entre o movimento panorâmico e o zoom (ou a combinação dos dois).

As estruturas HTML e XAML fornecem eventos de gestos por você, e isso é o suficiente, na maioria dos casos. Se você precisar de mais controle, digamos, para opções adicionais de configuração, use o Tempo de Execução do Windows GestureRecognizer. Para começar, você configurar desta forma:

C#
// C#
public GestureManager(Windows.UI.Xaml.Shapes.Rectangle target, Windows.UI.Xaml.UIElement parent)
{
// Configure gesture recognizer
gestureRecognizer = new Windows.UI.Input.GestureRecognizer();
gestureRecognizer.GestureSettings =
Windows.UI.Input.GestureSettings.Hold |
Windows.UI.Input.GestureSettings.ManipulationRotate |
Windows.UI.Input.GestureSettings.ManipulationRotateInertia |
Windows.UI.Input.GestureSettings.ManipulationScale |
Windows.UI.Input.GestureSettings.ManipulationScaleInertia |
Windows.UI.Input.GestureSettings.ManipulationTranslateInertia |
Windows.UI.Input.GestureSettings.ManipulationTranslateX |
Windows.UI.Input.GestureSettings.ManipulationTranslateY |
Windows.UI.Input.GestureSettings.RightTap |
Windows.UI.Input.GestureSettings.Tap;

// Register event handlers for gestures
gestureRecognizer.ManipulationStarted += OnManipulationStarted;
gestureRecognizer.ManipulationUpdated += OnManipulationUpdated;
gestureRecognizer.ManipulationInertiaStarting += OnManipulationInertiaStarting;
gestureRecognizer.ManipulationCompleted += OnManipulationCompleted;
gestureRecognizer.Holding += OnHolding;
gestureRecognizer.RightTapped += OnRightTapped;
gestureRecognizer.Tapped += OnTapped;
}

JavaScript
// JS
function GestureManager(target, parent) {
var gestureRecognizer = new Windows.UI.Input.GestureRecognizer;

// Configure GestureRecognizer
gestureRecognizer.gestureSettings =
Windows.UI.Input.GestureSettings.hold |
Windows.UI.Input.GestureSettings.manipulationRotate |
Windows.UI.Input.GestureSettings.manipulationRotateInertia |
Windows.UI.Input.GestureSettings.manipulationScale |
Windows.UI.Input.GestureSettings.manipulationScaleInertia |
Windows.UI.Input.GestureSettings.manipulationTranslateInertia |
Windows.UI.Input.GestureSettings.manipulationTranslateX |
Windows.UI.Input.GestureSettings.manipulationTranslateY |
Windows.UI.Input.GestureSettings.rightTap |
Windows.UI.Input.GestureSettings.tap;

// Register event handlers for gestures
gestureRecognizer.addEventListener('manipulationstarted', onManipulationStarted);
gestureRecognizer.addEventListener('manipulationupdated', onManipulationUpdated);
gestureRecognizer.addEventListener('manipulationcompleted', onManipulationCompleted);
gestureRecognizer.addEventListener('manipulationinertiastarting',
onManipulationInertiaStarting);
gestureRecognizer.addEventListener('manipulationinertiacompleted',
onManipulationInertiaCompleted);
gestureRecognizer.addEventListener('holding', onHolding);
gestureRecognizer.addEventListener('tapped', onTapped);
gestureRecognizer.addEventListener('righttapped', onRightTapped);
}

Basicamente, os aplicativos de interações dependem dos gestos. Na maioria dos aplicativos, o fluxo deve declarar os gestos que seu aplicativo busca, obter os dados do ponteiro que seu aplicativo vê, executá-los por meio da detecção dos gestos e manipular esses gestos.

Neste trecho de código, veja como todos os dados do ponteiro são orientados pela detecção do gesto sem a necessidade de verificar o tipo de entrada ou fazer qualquer processamento específico de tipos:

C#

// C#
void OnPointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
var currentPoint = e.GetCurrentPoint(parent);

// Make target capture the pointer associated to this event
target.CapturePointer(e.Pointer);

// Route the event to the gesture recognizer
gestureRecognizer.ProcessDownEvent(currentPoint);
}

void OnPointerMoved(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
// Route the event to the gesture recognizer
// We pass all intermediate points that might have been coalesced
// in a single PointerMove event.
gestureRecognizer.ProcessMoveEvents(e.GetIntermediatePoints(parent));
}

void OnPointerReleased(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
var currentPoint = e.GetCurrentPoint(parent);

// Route the event to the gesture recognizer
gestureRecognizer.ProcessUpEvent(currentPoint);

// Release pointer capture on the pointer associated to this event
target.ReleasePointerCapture(e.Pointer);
}

void OnPointerWheelChanged(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
var currentPoint = e.GetCurrentPoint(parent);
bool shift = (e.KeyModifiers & Windows.System.VirtualKeyModifiers.Shift) ==
Windows.System.VirtualKeyModifiers.Shift;
bool ctrl = (e.KeyModifiers & Windows.System.VirtualKeyModifiers.Control) ==
Windows.System.VirtualKeyModifiers.Control;

// Route the event to the gesture recognizer
gestureRecognizer.ProcessMouseWheelEvent(currentPoint, shift, ctrl);
}

JavaScript

// JS
function onPointerDown(evt) {
// Make target capture the pointer associated to this event
target.msSetPointerCapture(evt.pointerId);

// Route the event to the gesture recognizer
gestureRecognizer.processDownEvent(evt.getCurrentPoint(parent));
}

function onPointerMove(evt) {
// Route the event to the gesture recognizer
// We pass all intermediate points that might have been coalesced
// in a single PointerMove event.
gestureRecognizer.processMoveEvents(evt.getIntermediatePoints(parent));
}

function onPointerUp(evt) {
// Route the event to the gesture recognizer
gestureRecognizer.processUpEvent(evt.getCurrentPoint(parent));
}

function onWheel(evt) {
// Route the event to the gesture recognizer
gestureRecognizer.processMouseWheelEvent(evt.getCurrentPoint(parent), evt.shiftKey,
evt.ctrlKey);
}

Em um aplicativo de visualização de documentos, como o Word, devemos focar principalmente em movimentos panorâmicos e zooms. O reconhecimento de gestos pode ser configurado para esses dois componentes de manipulação (ignorando a rotação). Quando há dados de ponteiro na exibição principal, o aplicativo os envia para o reconhecimento de gestos, e o reconhecimento de gestos retorna a indicação de eventos que uma manipulação iniciou, está dando continuidade (possivelmente em transição para um estado de inércia) ou encerrou.

Códigos para amplo alcance entre modalidades e formatos

O conceito do ponteiro nos leva a pensar sobre a programação de entrada de forma diferente. O ponteiro contribui para a facilidade do desenvolvimento por exigir menos linhas de códigos, enviar seu aplicativo à Loja com mais rapidez e proporcionar um amplo alcance, facilitando o direcionamento de diferentes dispositivos de entrada. Ele também estimula você a ver a manipulação de entradas de forma mais simplificada. Uma manifestação do que chamados de "Crie o código do toque, deixe o sistema fazer o resto".

O código do toque, ou CFT ("Code for touch"), é um resultado da nossa entrada recriada e se tornou uma de nossas principais filosofias. Talvez seria mais apropriado dizer "crie o código para o ponteiro e obtenha os comportamentos padrão de mouse, caneta e toque grátis", pois o CFT permite que você crie códigos simples para manipular eventos unificados de ponteiros, sem precisar se preocupar com a criação de manipuladores redundantes para todas as três principais entradas de apontador. Se você tem componentes específicos de entrada ou quer ir além do que o sistema operacional oferece por padrão, isso também é possível.

Todos os manipuladores de eventos de ponteiro mostrados anteriormente são exemplos do CFT na vida real. Todos os manipuladores de ponteiro da amostra de gesto independem do tipo de entrada. Eles normalmente obtêm os dados do ponteiro, definem a captura, fazem o teste de toque ou outro gerenciamento de estados e, em seguida, encaminham os dados do ponteiro para o reconhecimento do gesto.

C#

// C#
void OnPointerPressed(object sender, Windows.UI.Xaml.Input.PointerRoutedEventArgs e)
{
var currentPoint = e.GetCurrentPoint(parent);

// Make target capture the pointer associated to this event
target.CapturePointer(e.Pointer);

// Route the event to the gesture recognizer
gestureRecognizer.ProcessDownEvent(currentPoint);
}

JavaScript

// JS
function onPointerDown(evt) {
// Make target capture the pointer associated to this event
target.msSetPointerCapture(evt.pointerId);

// Route the event to the gesture recognizer
gestureRecognizer.processDownEvent(evt.getCurrentPoint(parent));
}

O CFT não trata apenas de alcance e facilidade de desenvolvimento. Ele também está diretamente vinculado à consistência e confiança. Por exemplo, se você configurar a detecção de gesto para o toque, permitirá toques de todas as três modalidades de entrada. Configurando um evento unificado em mapas de SecondaryTap no mouse (clicar no botão direito do mouse), toque (pressionar e manter pressionado) e caneta (pressionar e manter pressionado ou tocar com o botão da caneta).

Veja este exemplo de gesto que mostra os manipuladores de gesto Toque e RightTap:

C#

// C#
void OnTapped(Windows.UI.Input.GestureRecognizer sender, Windows.UI.Input.TappedEventArgs
args)
{
byte[] rgb = new byte[3];

// Randomly change the color of target
randomGenerator.NextBytes(rgb);
target.Fill = new
Windows.UI.Xaml.Media.SolidColorBrush(Windows.UI.ColorHelper.FromArgb(255,
rgb[0], rgb[1], rgb[2]));
}

void OnRightTapped(Windows.UI.Input.GestureRecognizer sender,
Windows.UI.Input.RightTappedEventArgs args)
{
// Restore original values
target.Fill = initialBrush;
InitManipulationTransforms();
}

JavaScript

// JS
function onTapped(evt) {
target.style.backgroundColor = getNextColorFromColor(target.style.backgroundColor);
}

function onRightTapped(evt) {
// Reset target to its initial state (transform, color)
target.style.backgroundColor = target.initialColor;
target.style.msTransform = target.initialTransform;
}

Não há inspeção de tipos de ponteiro em nenhum desses manipuladores de evento. Eles acionam entradas apropriadas dos diferentes tipos de ponteiro sem exigir trabalho adicional da sua parte.

Resumindo

Queremos que você descubra facilmente o que precisa enquanto está explorando a plataforma. A entrada foi desenvolvida para que o caminho mais fácil tire proveito de uma experiência consistente dos aplicativos no Windows.

A plataforma de entrada foi desenvolvida com base em princípios, tendo como objetivos a facilidade do desenvolvimento, a consistência e a confiança, proporcionando amplo alcance. Conceitos como o ponteiro e o CFT poupam tempo e linhas de código. A detecção de gestos facilita o uso da linguagem de interação do Windows 8 no seu aplicativo e proporciona consistência e confiança aos usuários. Conceitos semelhantes nas plataformas e estruturas oferecem consistência aos desenvolvedores. O CFT e suas expressões nas APIs de gesto e ponteiro ajudam a simplificar o alcance entre os dispositivos.

Estamos animados com o trabalho que temos realizados no Windows e esperamos que você também goste!

Para saber mais sobre a plataforma de entrada, leia a nossa documentação, baixe nossos exemplos e faça perguntas nos fóruns.

Obrigado!

-- Reed Townsend, gerente geral de programas do Windows

Recursos adicionais

Link

Tipo

Destaques

Início rápido: Entrada por toque

Início rápido

Visão geral da manipulação de toque e gestos no seu aplicativo

Entrada: amostra de manipulação de eventos de ponteiro e gesto de DOM

Amostra

Suporte HTML para ponteiro, usa o elemento de tela HTML5, implementa o recurso de desenho, manipula eventos de ponteiro

Amostra de eventos de entrada de usuário XAML

Amostra

Suporte XAML para ponteiro e gestos, implementa recurso de desenho, captura e eventos de ponteiro, eventos de gesto, manipulações

Entrada: manipulações e gestos com o uso de C++

Amostra

Usa o GestureRecognizer do Tempo de Execução do Windows, classes PointerPointer e PointerDevice, cria sobre o CoreWindow

Entrada: manipulações e gestos com o uso de JavaScript

Amostra

Usa o PointerPoint e o GestureRecognizer do Tempo de Execução do Windows em um simples jogo em HTML

Eventos de gesto e ponteiro de estrutura HTML

Documentos

Eventos como onmspointerdown, onmsgesturetap, onmsgesturestart, onmsgestureend

Eventos de gesto e ponteiro de estrutura XAML

Documentos

Eventos como PointerPressed, Tapped, ManipulationStarted

Classes GestureRecognizer, PointerPoint, PointerDevice

Documentos

Documentação completa sobre classes do Tempo de Execução do Windows para ponteiros e gestos

  • Loading...
Leave a Comment
  • Please add 1 and 4 and type the answer here:
  • Post