RadialController Classe

Référence

Définition

Espace de noms:: Windows.UI.Input

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Modifier

Représente un appareil d’entrée de roue ou un accessoire tel que Surface Dial.

Surface Dial avec Surface Studio et stylet.

Avec un format appelant à une action de rotation (ou de mouvement), Surface Dial est conçu à la manière d’un appareil d’entrée secondaire multimode venant compléter la saisie à partir d’un appareil principal. Dans la plupart des cas, l’utilisateur manipule l’appareil avec sa main non dominante tout en effectuant une tâche avec sa main dominante (par exemple, l’entrée manuscrite avec un stylet). L’appareil n’est pas conçu pour effectuer des entrées d’un pointeur de précision (par exemple, interaction tactile, stylet ou souris).

Surface Dial prend également en charge les actions Appui prolongé et Clic. L’appui prolongé a une fonction unique : afficher un menu de commandes. Si le menu est actif, l’entrée rotation et clic est traitée par le menu. Dans le cas contraire, l’entrée est transmise à votre application pour le traitement.

RadialController et les API associées (voir la fin de la rubrique) vous permettent de personnaliser à la fois le menu de commandes intégré et l’expérience d’interaction prise en charge par votre application.

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

Héritage: Object Platform::Object IInspectable RadialController

Attributs: ContractVersionAttribute MarshalingBehaviorAttribute

Configuration requise pour Windows

Famille d’appareils	Windows 10 Anniversary Edition (introduit dans 10.0.14393.0)
API contract	Windows.Foundation.UniversalApiContract (introduit dans v3.0)

Exemples

Dans cet exemple, nous ajoutons un outil personnalisé au menu Surface Dial et déclarons les gestionnaires d’entrée RadialController.

Tout d’abord, nous créons une référence à l’objet RadialController pour le Surface Dial (myController) en appelant CreateForCurrentView.
Nous créons ensuite une instance d’un RadialControllerMenuItem (myItem) en appelant RadialControllerMenuItem.CreateFromIcon.
Ensuite, nous ajoutons cet élément à la collection d’éléments de menu.
Nous déclarons les gestionnaires d’événements d’entrée (ButtonClicked et RotationChanged) pour l’objet RadialController.
Enfin, nous définissons les gestionnaires d’événements.

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

Dans la fonction d’initialisation illustrée ici, nous déclarons les différents gestionnaires d’événements d’entrée pour l’objet 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();
}

Dans le gestionnaire ButtonClicked , l’interaction définit l’état d’un bouton bascule sur activé ou décoché.

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

Dans le gestionnaire RotationChanged , l’interaction modifie la valeur d’un curseur.

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

Remarques

Historique des versions

Version de Windows	Version du SDK	Valeur ajoutée
1703	15063	ButtonHolding
1703	15063	ButtonPressed
1703	15063	ButtonReleased

Propriétés

Menu	Obtient une référence au menu associé à l’objet RadialController .
RotationResolutionInDegrees	Obtient ou définit la valeur de rotation minimale requise pour que l’objet RadialController déclenche un événement RotationChanged .
UseAutomaticHapticFeedback	Obtient ou définit si le retour haptique est activé sur le dispositif de roue pour chaque événement RotationChanged déclenché par radialController.

Méthodes

CreateForCurrentView()	Instancie un objet RadialController pour le dispositif de roue et le lie à l’application active.
IsSupported()	Récupère une valeur qui indique si les périphériques wheel sont pris en charge par le système.

Événements

ButtonClicked	Se produit lorsque l’appareil de roue est enfoncé, puis relâché pendant qu’un outil RadialController personnalisé est actif. Votre application ne reçoit pas cet événement lorsque : Le menu RadialController est actif Un outil intégré est actif Notes Lorsqu’un seuil de temps est franchi, le clic devient une action appuyez longuement. Dans ce cas, le menu intégré des commandes d’application contextuelles associées à l’objet RadialController s’affiche et les événements de rotation et de clic suivants sont traités par le menu.
ButtonHolding	Se produit lorsque l’utilisateur appuie sur l’appareil de roue et le maintient enfoncé.
ButtonPressed	Se produit lorsque le dispositif de roue est enfoncé.
ButtonReleased	Se produit lorsque l’appareil de roue est enfoncé, puis relâché.
ControlAcquired	Se produit lorsqu’un outil RadialController personnalisé (défini par une application) est sélectionné dans le menu, ou lorsqu’une application associée à l’objet RadialController est mise au premier plan pendant qu’un outil RadialController personnalisé est actif.
ControlLost	Se produit lorsqu’un outil RadialController personnalisé (défini par une application) est actif et que l’application associée à l’objet RadialController est envoyée à l’arrière-plan ou que l’utilisateur active le menu RadialController .
RotationChanged	Se produit lorsque l’appareil de roue est pivoté pendant qu’un outil RadialController personnalisé est actif. Votre application ne reçoit pas cet événement lorsque : Le menu RadialController est actif Un outil intégré est actif
ScreenContactContinued	Se produit uniquement lorsque l’appareil de roue est déplacé en contact avec la surface du numériseur et qu’un outil RadialController personnalisé est actif. Votre application ne reçoit pas cet événement lorsque : Le menu RadialController est actif Un outil intégré est actif Conseil En plus de l’expérience de menu appuyez longuement par défaut, le Surface Dial peut également être placé directement sur l’écran du Surface Studio. Cela permet d’afficher un menu « à l’écran » spécial. En détectant à la fois l’emplacement du contact et les limites du Surface Dial, le système peut gérer l’occlusion par l’appareil et afficher une version plus grande du menu qui entoure l’extérieur de la numérotation. Ces mêmes informations peuvent également être utilisées par votre application pour adapter l’interface utilisateur à la présence de l’appareil et à son utilisation prévue, notamment au placement de la main et du bras de l’utilisateur. Cet événement se produit après ScreenContactStarted et s’arrête sur ScreenContactEnded.
ScreenContactEnded	Se produit lorsqu’un appareil de roue qui est en contact avec la surface du numériseur est supprimé (ou n’est plus détecté) et qu’un outil RadialController personnalisé est actif. Votre application ne reçoit pas cet événement lorsque : Le menu RadialController est actif Un outil intégré est actif Conseil En plus de l’expérience de menu appuyez longuement par défaut, le Surface Dial peut également être placé directement sur l’écran du Surface Studio. Cela permet d’afficher un menu « à l’écran » spécial. En détectant à la fois l’emplacement du contact et les limites du Surface Dial, le système peut gérer l’occlusion par l’appareil et afficher une version plus grande du menu qui entoure l’extérieur de la numérotation. Ces mêmes informations peuvent également être utilisées par votre application pour adapter l’interface utilisateur à la présence de l’appareil et à son utilisation prévue, notamment au placement de la main et du bras de l’utilisateur. Cet événement se produit après ScreenContactStarted.
ScreenContactStarted	Se produit quand un contact initial est détecté entre un dispositif de roue et la surface du numériseur, et qu’un outil RadialController personnalisé est actif. Votre application ne reçoit pas cet événement lorsque : Le menu RadialController est actif Un outil intégré est actif Conseil En plus de l’expérience de menu appuyez longuement par défaut, le Surface Dial peut également être placé directement sur l’écran du Surface Studio. Cela permet d’afficher un menu « à l’écran » spécial. En détectant à la fois l’emplacement du contact et les limites du Surface Dial, le système peut gérer l’occlusion par l’appareil et afficher une version plus grande du menu qui entoure l’extérieur de la numérotation. Ces mêmes informations peuvent également être utilisées par votre application pour adapter l’interface utilisateur à la présence de l’appareil et à son utilisation prévue, notamment au placement de la main et du bras de l’utilisateur.

S’applique à