RadialController Classe

Riferimento

Definizione

Spazio dei nomi:: Windows.UI.Input

Importante

Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.

Modifica

Rappresenta un dispositivo o un accessorio di input della rotellina, ad esempio Surface Dial.

Surface Dial con Surface Studio e penna.

Con un fattore di forma basato su un'azione (o movimento) di rotazione, Surface Dial è pensato come dispositivo di input secondario multimodale che integra l'input da un dispositivo primario. Nella maggior parte dei casi, un utente maneggia il dispositivo con la mano non dominante mentre esegue un'attività con la mano dominante, ad esempio l'input penna. Il dispositivo non è progettato per l'input da un puntatore di precisione, come il tocco, la penna o il mouse.

Surface Dial supporta anche le azioni di pressione prolungata e di clic. La pressione prolungata ha una sola funzione, quella di visualizzare un menu di comandi. Se il menu è attivo, l'input della rotazione e del clic viene elaborato dal menu. Altrimenti l'input viene passato all'app per l'elaborazione.

RadialController e le API correlate (vedi fine dell'argomento) consentono di personalizzare sia il menu dei comandi integrato che l'esperienza di interazione supportata dall'app.

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

Ereditarietà: Object Platform::Object IInspectable RadialController

Attributi: ContractVersionAttribute MarshalingBehaviorAttribute

Requisiti Windows

Famiglia di dispositivi	Windows 10 Anniversary Edition (è stato introdotto in 10.0.14393.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v3.0)

Esempio

In questo esempio si aggiunge uno strumento personalizzato al menu Surface Dial e si dichiarano i gestori di input RadialController.

Prima di tutto, viene creato un riferimento all'oggetto RadialController per Surface Dial (myController) chiamando CreateForCurrentView.
Viene quindi creata un'istanza di radialControllerMenuItem (myItem) chiamando RadialControllerMenuItem.CreateFromIcon.
Poi aggiungiamo questo elemento alla raccolta di voci di menu.
Dichiariamo i gestori eventi di input (ButtonClicked e RotationChanged) per l'oggetto RadialController.
Infine definiamo i gestori eventi.

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;
     }
 }

Nella funzione di inizializzazione illustrata di seguito vengono dichiarati i vari gestori eventi di input per l'oggetto 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();
}

Nel gestore ButtonClicked l'interazione imposta lo stato di un interruttore per selezionare o deselezionare.

// 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;
}

Nel gestore RotationChanged l'interazione modifica il valore di un dispositivo di scorrimento.

// 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);
}

Commenti

Cronologia delle versioni

Versione di Windows	Versione dell'SDK	Valore aggiunto
1703	15063	ButtonHolding
1703	15063	ButtonPressed
1703	15063	ButtonReleased

Proprietà

Menu	Ottiene un riferimento al menu associato all'oggetto RadialController .
RotationResolutionInDegrees	Ottiene o imposta il valore minimo di rotazione necessario per l'oggetto RadialController per generare un evento RotationChanged .
UseAutomaticHapticFeedback	Ottiene o imposta se il feedback aptico è abilitato sul dispositivo ruota per ogni evento RotationChanged generato da RadialController.

Metodi

CreateForCurrentView()	Crea un'istanza di un oggetto RadialController per il dispositivo ruota e lo associa all'applicazione attiva.
IsSupported()	Recupera un valore che indica se i dispositivi a rotelle sono supportati dal sistema.

Eventi

ButtonClicked	Si verifica quando il dispositivo ruota viene premuto e quindi rilasciato mentre è attivo uno strumento RadialController personalizzato. L'app non riceve questo evento quando: Il menu RadialController è attivo Uno strumento predefinito è attivo Nota Quando viene superata una soglia di tempo, fare clic diventa un'azione di pressione e di blocco. In questo caso, viene visualizzato il menu integrato dei comandi dell'app contestuale associati all'oggetto RadialController e vengono elaborati gli eventi di rotazione e clic successivi dal menu.
ButtonHolding	Si verifica quando l'utente preme e tiene premuto il dispositivo ruota.
ButtonPressed	Si verifica quando il dispositivo ruota viene premuto.
ButtonReleased	Si verifica quando il dispositivo ruota viene premuto e quindi rilasciato.
ControlAcquired	Si verifica quando viene selezionato uno strumento RadialController personalizzato (definito da un'app) dal menu oppure quando un'app associata all'oggetto RadialController viene portata in primo piano mentre uno strumento RadialController personalizzato è attivo.
ControlLost	Si verifica quando uno strumento RadialController personalizzato (definito da un'app) è attivo e l'app associata all'oggetto RadialController viene inviata in background oppure l'utente attiva il menu RadialController .
RotationChanged	Si verifica quando il dispositivo ruotato mentre è attivo uno strumento RadialController personalizzato. L'app non riceve questo evento quando: Il menu RadialController è attivo Uno strumento predefinito è attivo
ScreenContactContinued	Si verifica solo quando il dispositivo ruota viene spostato in contatto con la superficie del digitalizzatore e uno strumento RadialController personalizzato è attivo. L'app non riceve questo evento quando: Il menu RadialController è attivo Uno strumento predefinito è attivo Suggerimento Oltre all'esperienza predefinita di premere e tenere premuto il menu, è anche possibile posizionare Surface Dial direttamente sullo schermo della Surface Studio. Questa azione abilita uno speciale menu "su schermo". Rilevando sia la posizione del contatto che i limiti di Surface Dial, il sistema può gestire l'occlusione dal dispositivo e visualizzare una versione più grande del menu che esegue il wrapping intorno all'esterno del dial. Queste stesse informazioni possono essere usate anche dalla tua app per adattare l'interfaccia utente sia alla presenza del dispositivo che al suo utilizzo anticipato, ad esempio all'appoggio della mano e del braccio dell'utente. Questo evento si verifica dopo ScreenContactStarted e si arresta in ScreenContactEnded.
ScreenContactEnded	Si verifica quando un dispositivo a rotelle in contatto con la superficie del digitalizzatore viene rimosso (o non viene più rilevato) e uno strumento RadialController personalizzato è attivo. L'app non riceve questo evento quando: Il menu RadialController è attivo Uno strumento predefinito è attivo Suggerimento Oltre all'esperienza predefinita di premere e tenere premuto il menu, è anche possibile posizionare Surface Dial direttamente sullo schermo della Surface Studio. Questa azione abilita uno speciale menu "su schermo". Rilevando sia la posizione del contatto che i limiti di Surface Dial, il sistema può gestire l'occlusione dal dispositivo e visualizzare una versione più grande del menu che esegue il wrapping intorno all'esterno del dial. Queste stesse informazioni possono essere usate anche dalla tua app per adattare l'interfaccia utente sia alla presenza del dispositivo che al suo utilizzo anticipato, ad esempio all'appoggio della mano e del braccio dell'utente. Questo evento si verifica dopo ScreenContactStarted.
ScreenContactStarted	Si verifica quando viene rilevato un contatto iniziale tra un dispositivo ruota e la superficie del digitalizzatore e uno strumento RadialController personalizzato è attivo. L'app non riceve questo evento quando: Il menu RadialController è attivo Uno strumento predefinito è attivo Suggerimento Oltre all'esperienza predefinita di premere e tenere premuto il menu, è anche possibile posizionare Surface Dial direttamente sullo schermo della Surface Studio. Questa azione abilita uno speciale menu "su schermo". Rilevando sia la posizione del contatto che i limiti di Surface Dial, il sistema può gestire l'occlusione dal dispositivo e visualizzare una versione più grande del menu che esegue il wrapping intorno all'esterno del dial. Queste stesse informazioni possono essere usate anche dalla tua app per adattare l'interfaccia utente sia alla presenza del dispositivo che al suo utilizzo anticipato, ad esempio all'appoggio della mano e del braccio dell'utente.

Si applica a

Condividi tramite