Partilhar via

RadialController Classe

  • Referência

Definição

Namespace:
Windows.UI.Input
Editar

Representa um acessório ou dispositivo de entrada de roda de rolagem, como o Surface Dial.

Surface Dial com Surface Studio e Caneta.

Com um fator forma com base em uma ação (ou gesto) girar, o Surface Dial destina-se como um dispositivo de entrada secundário para vários tipos de mídia que complementa a entrada de um dispositivo principal. Na maioria dos casos, o dispositivo é manipulado pela mão não dominante de um usuário durante a execução de uma tarefa com a mão dominante (por exemplo, escrita à tinta com uma caneta). Ele não foi projetado para entrada de ponteiro de precisão (por exemplo, toque, caneta ou mouse).

O Surface Dial também dá suporte às ações pressionar e segurar e clicar. Pressionar e segurar tem uma única função: exibir um menu de comandos. Se o menu estiver ativo, a entrada por girar e clicar será processada pelo menu. Caso contrário, a entrada será transmitida ao seu aplicativo para processamento.

O RadialController e as APIs relacionadas (confira o fim do tópico) permitem personalizar o menu de comando integrado e a experiência de interação com suporte do seu aplicativo.

public ref class RadialController sealed
/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 196608)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
class RadialController final
[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 196608)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
public sealed class RadialController
Public NotInheritable Class RadialController
Herança
Object Platform::Object IInspectable RadialController
Atributos
ContractVersionAttribute MarshalingBehaviorAttribute

Requisitos do Windows

Família de dispositivos
Windows 10 Anniversary Edition (introduzida na 10.0.14393.0)
API contract
Windows.Foundation.UniversalApiContract (introduzida na v3.0)

Exemplos

Neste exemplo, adicionamos uma ferramenta personalizada ao menu surface dial e declaramos os manipuladores de entrada RadialController.

  1. Primeiro, criamos uma referência ao objeto RadialController para o Surface Dial (myController) chamando CreateForCurrentView.
  2. Em seguida, criamos uma instância de um RadialControllerMenuItem (myItem) chamando RadialControllerMenuItem.CreateFromIcon.
  3. Em seguida, acrescentamos esse item à coleção de itens de menu.
  4. Declaramos os manipuladores de eventos de entrada (ButtonClicked e RotationChanged) para o objeto RadialController.
  5. Por fim, definimos os manipuladores de eventos.
public sealed partial class MainPage : Page
 {
     RadialController myController;

     public MainPage()
     {
         this.InitializeComponent();
         // Create a reference to the RadialController.
         myController = RadialController.CreateForCurrentView();

         // Create an icon for the custom tool.
         RandomAccessStreamReference icon =
           RandomAccessStreamReference.CreateFromUri(
             new Uri("ms-appx:///Assets/StoreLogo.png"));

         // Create a menu item for the custom tool.
         RadialControllerMenuItem myItem =
           RadialControllerMenuItem.CreateFromIcon("Sample", icon);

         // Add the custom tool to the RadialController menu.
         myController.Menu.Items.Add(myItem);

         // Declare input handlers for the RadialController.
         myController.ButtonClicked += MyController_ButtonClicked;
         myController.RotationChanged += MyController_RotationChanged;
     }

     // Handler for rotation input from the RadialController.
     private void MyController_RotationChanged(RadialController sender,
       RadialControllerRotationChangedEventArgs args)
     {
         if (RotationSlider.Value + args.RotationDeltaInDegrees > 100)
         {
             RotationSlider.Value = 100;
             return;
         }
         else if (RotationSlider.Value + args.RotationDeltaInDegrees < 0)
         {
             RotationSlider.Value = 0;
             return;
         }
         RotationSlider.Value += args.RotationDeltaInDegrees;
     }

     // Handler for click input from the RadialController.
     private void MyController_ButtonClicked(RadialController sender,
       RadialControllerButtonClickedEventArgs args)
     {
         ButtonToggle.IsOn = !ButtonToggle.IsOn;
     }
 }

Na função de inicialização mostrada aqui, declaramos os vários manipuladores de eventos de entrada para o objeto RadialController.

// Create and configure our radial controller.
private void InitializeController() 
{
    // Create a reference to the RadialController.
    radialController = RadialController.CreateForCurrentView();
    // Set rotation resolution to 1 degree of sensitivity.
    radialController.RotationResolutionInDegrees = 1;

    // Declare input handlers for the RadialController.
    radialController.ButtonClicked += (sender, args) =>
    { RadialController_ButtonClicked(sender, args); };
    radialController.RotationChanged += (sender, args) =>
    { RadialController_RotationChanged(sender, args); };

    radialController.ControlAcquired += (sender, args) =>
    { RadialController_ControlAcquired(sender, args); };
    radialController.ControlLost += (sender, args) =>
    { RadialController_ControlLost(sender, args); };
    radialController.ScreenContactStarted += (sender, args) =>
    { RadialController_ScreenContactStarted(sender, args); };
    radialController.ScreenContactContinued += (sender, args) =>
    { RadialController_ScreenContactContinued(sender, args); };
    radialController.ScreenContactEnded += (sender, args) =>
    { RadialController_ScreenContactEnded(sender, args); };
    AddToLog("Input handlers created");

    // Create the custom menu items.
    CreateMenuItems();
    // Specify the menu items.
    ConfigureMenu();
}

No manipulador ButtonClicked , a interação define o estado de um botão de alternância como marcado ou desmarcado.

// Occurs when the wheel device is pressed and then released 
// while a customRadialController tool is active.
// NOTE: Your app does not receive this event when the RadialController 
// menu is active or a built-in tool is active
// Send click input to toggle button of active region.
private void RadialController_ButtonClicked(RadialController sender,
  RadialControllerButtonClickedEventArgs args)
{
    toggles[activeMenuItemIndex].IsOn = !toggles[activeMenuItemIndex].IsOn;
}

No manipulador RotationChanged , a interação modifica o valor de um controle deslizante.

// Occurs when the wheel device is rotated while a custom 
// RadialController tool is active.
// NOTE: Your app does not receive this event when the RadialController 
// menu is active or a built-in tool is active
// Send rotation input to slider of active region.
private void RadialController_RotationChanged(RadialController sender,
  RadialControllerRotationChangedEventArgs args)
{
    Slider slider = sliders[activeMenuItemIndex];
    if (slider.Value + args.RotationDeltaInDegrees > 100)
    {
        slider.Value = 100;
        return;
    }
    else if (slider.Value + args.RotationDeltaInDegrees < 0)
    {
        slider.Value = 0;
        return;
    }
    slider.Value += args.RotationDeltaInDegrees;
    AddToLog("\nRotation: " + sliders[activeMenuItemIndex].Name + " value changed to " + slider.Value);
}

Comentários

Histórico de versão

Versão do Windows Versão do SDK Valor adicionado
1703 15063 ButtonHolding
1703 15063 ButtonPressed
1703 15063 ButtonReleased

Propriedades

Menu

Obtém uma referência ao menu associado ao objeto RadialController .
RotationResolutionInDegrees

Obtém ou define o valor rotacional mínimo necessário para que o objeto RadialController dispare um evento RotationChanged .
UseAutomaticHapticFeedback

Obtém ou define se os comentários hápticos estão habilitados no dispositivo de roda para cada evento RotationChanged disparado pelo RadialController.

Métodos

CreateForCurrentView()

Cria uma instância de um objeto RadialController para o dispositivo de roda e o associa ao aplicativo ativo.
IsSupported()

Recupera um valor que indica se os dispositivos wheel são compatíveis com o sistema.

Eventos

ButtonClicked

Ocorre quando o dispositivo de roda é pressionado e liberado enquanto uma ferramenta RadialController personalizada está ativa.

Seu aplicativo não recebe esse evento quando:

Observação

Quando um limite de tempo é ultrapassado, o clique se torna uma ação pressionar e segurar. Nesse caso, o menu integrado de comandos de aplicativo contextuais associados ao objeto RadialController é exibido e eventos de rotação e clique subsequentes são processados pelo menu.
ButtonHolding

Ocorre quando o usuário pressiona e segura o dispositivo de roda.
ButtonPressed

Ocorre quando o dispositivo de roda é pressionado.
ButtonReleased

Ocorre quando o dispositivo de roda é pressionado e liberado.
ControlAcquired

Ocorre quando uma ferramenta RadialController personalizada (definida por um aplicativo) é selecionada no menu ou quando um aplicativo associado ao objeto RadialController é levado para o primeiro plano enquanto uma ferramenta RadialController personalizada está ativa.
ControlLost

Ocorre enquanto uma ferramenta RadialController personalizada (definida por um aplicativo) está ativa e o aplicativo associado ao objeto RadialController é enviado para o plano de fundo ou o usuário ativa o menu RadialController .
RotationChanged

Ocorre quando o dispositivo de roda é girado enquanto uma ferramenta RadialController personalizada está ativa.

Seu aplicativo não recebe esse evento quando:
ScreenContactContinued

Ocorre somente quando o dispositivo de roda é movido enquanto está em contato com a superfície do digitalizador e uma ferramenta RadialController personalizada está ativa.

Seu aplicativo não recebe esse evento quando:

Dica

Além da experiência padrão de pressionar e segurar o menu, o Surface Dial também pode ser colocado diretamente na tela do Surface Studio. Isso ativa um menu "na tela" especial.

Ao detectar o local do contato e os limites do Surface Dial, o sistema pode manipular a oclusão pelo dispositivo e exibir uma versão maior do menu que envolve o lado de fora do Dial. Essas mesmas informações também podem ser usadas pelo seu aplicativo para adaptar a interface do usuário para a presença do dispositivo e seu uso previsto, como o posicionamento da mão e do braço do usuário.

Esse evento ocorre após ScreenContactStarted e é interrompido em ScreenContactEnded.
ScreenContactEnded

Ocorre quando um dispositivo de roda que está em contato com a superfície do digitalizador é removido (ou não é mais detectado) e uma ferramenta RadialController personalizada está ativa.

Seu aplicativo não recebe esse evento quando:

Dica

Além da experiência padrão de pressionar e segurar o menu, o Surface Dial também pode ser colocado diretamente na tela do Surface Studio. Isso ativa um menu "na tela" especial.

Ao detectar o local do contato e os limites do Surface Dial, o sistema pode manipular a oclusão pelo dispositivo e exibir uma versão maior do menu que envolve o lado de fora do Dial. Essas mesmas informações também podem ser usadas pelo seu aplicativo para adaptar a interface do usuário para a presença do dispositivo e seu uso previsto, como o posicionamento da mão e do braço do usuário.

Esse evento ocorre após ScreenContactStarted.
ScreenContactStarted

Ocorre quando o contato inicial é detectado entre um dispositivo de roda e a superfície do digitalizador, e uma ferramenta RadialController personalizada está ativa.

Seu aplicativo não recebe esse evento quando:

Dica

Além da experiência padrão de pressionar e segurar o menu, o Surface Dial também pode ser colocado diretamente na tela do Surface Studio. Isso ativa um menu "na tela" especial.

Ao detectar o local do contato e os limites do Surface Dial, o sistema pode manipular a oclusão pelo dispositivo e exibir uma versão maior do menu que envolve o lado de fora do Dial. Essas mesmas informações também podem ser usadas pelo seu aplicativo para adaptar a interface do usuário para a presença do dispositivo e seu uso previsto, como o posicionamento da mão e do braço do usuário.

Aplica-se a

Confira também