Surface Dial Control Turntable, Stylus Pen for Microsoft Surface, Controller Knob Painting Assistant Tool Match Graphic Tablet Accessory Stylus, Compatible with Microsoft Surface, Wacom, Huion, XP-Pen 2. To dial a number from Teams, go to Calls, and then enter the number of the person you want to reach by using the dial pad located on the left. Then click Call. To call a person by name, type the name of a person into the dial pad. And to make group calls, enter multiple names and/or numbers, and click Call.

• Microsoft Dialogpt
• Microsoft Dial App
• Microsoft Dialog Box
• Microsoft Dialogpt
• Microsoft Dial Review
• Microsoft Dial 2
• Microsoft Dial Box

Jun 21, 2021 A dial plan's scope determines the hierarchical level at which the dial plan can be applied. Clients get the appropriate dial plan through provisioning settings that are automatically provided when users sign in to Teams. As an admin, you can manage and assign dial plan scope levels by using the Microsoft Teams admin center or Remote PowerShell. Press and hold your Surface Dial to see other tools in the wheel menu. Turn the dial left or right to highlight the tool you want to use. To select it, press down and release. Customize what Surface Dial does. To change the tools you see when you rotate Surface Dial, select the Start button, then select Settings Devices Wheel.

Surface Dial with Surface Studio and Surface Pen (available for purchase at the Microsoft Store).

This tutorial steps through how to customize the user interaction experiences supported by wheel devices such as the Surface Dial. We use snippets from a sample app, which you can download from GitHub (see Sample code), to demonstrate the various features and associated RadialController APIs discussed in each step.

We focus on the following:

• Specifying which built-in tools are displayed on the RadialController menu
• Adding a custom tool to the menu
• Controlling haptic feedback
• Customizing click interactions
• Customizing rotation interactions

For more about implementing these and other features, see Surface Dial interactions in Windows apps.

Introduction

The Surface Dial is a secondary input device that helps users to be more productive when used together with a primary input device such as pen, touch, or mouse. As a secondary input device, the Dial is typically used with the non-dominant hand to provide access both to system commands and to other, more contextual, tools and functionality.

The Dial supports three basic gestures:

• Press and hold to display the built-in menu of commands.
• Rotate to highlight a menu item (if the menu is active) or to modify the current action in the app (if the menu is not active).
• Click to select the highlighted menu item (if the menu is active) or to invoke a command in the app (if the menu is not active).

Prerequisites

• A computer (or a virtual machine) running Windows 10 Creators Update, or newer
• A wheel device (only the Surface Dial at this time)
• If you're new to Windows app development with Visual Studio, have a look through these topics before you start this tutorial:

Set up your devices

1. Make sure your Windows device is on.
2. Go to Start, select Settings > Devices > Bluetooth & other devices, and then turn Bluetooth on.
3. Remove the bottom of the Surface Dial to open the battery compartment, and make sure that there are two AAA batteries inside.
4. If the battery tab is present on the underside of the Dial, remove it.
5. Press and hold the small, inset button next to the batteries until the Bluetooth light flashes.
6. Go back to your Windows device and select Add Bluetooth or other device.
7. In the Add a device dialog, select Bluetooth > Surface Dial. Your Surface Dial should now connect and be added to the list of devices under Mouse, keyboard, & pen on the Bluetooth & other devices settings page.
8. Test the Dial by pressing and holding it down for a few seconds to display the built-in menu.
9. If the menu isn't displayed on your screen (the Dial should also vibrate), go back to the Bluetooth settings, remove the device, and try connecting the device again.

Note

Wheel devices can be configured through the Wheel settings:

1. On the Start menu, select Settings.
2. Select Devices > Wheel.
   

Now you’re ready to start this tutorial.

Sample code

Throughout this tutorial, we use a sample app to demonstrate the concepts and functionality discussed.

Download this Visual Studio sample and source code from GitHub at windows-appsample-get-started-radialcontroller sample:

1. Select the green Clone or download button.
   
2. If you have a GitHub account, you can clone the repo to your local machine by choosing Open in Visual Studio.
3. If you don't have a GitHub account, or you just want a local copy of the project, choose Download ZIP (you'll have to check back regularly to download the latest updates).

Important

Most of the code in the sample is commented out. As we go through each step in this topic, you'll be asked to uncomment various sections of the code. In Visual Studio, just highlight the lines of code, and press CTRL-K and then CTRL-U.

Microsoft Dialogpt

Components that support wheel functionality

These objects provide the bulk of the wheel device experience for Windows apps.

Step 1: Run the sample

After you've downloaded the RadialController sample app, verify that it runs:

1. Open the sample project in Visual Studio .
2. Set the Solution Platforms dropdown to a non-ARM selection.
3. Press F5 to compile, deploy, and run.

Note

Alternatively, you can select Debug > Start debugging menu item, or select the Local Machine Run button shown here:

The app window opens, and after a splash screen appears for a few seconds, you’ll see this initial screen.

Okay, we now have the basic Windows app that we’ll use throughout the rest of this tutorial. In the following steps, we add our RadialController functionality.

Step 2: Basic RadialController functionality

With the app running and in the foreground, press and hold the Surface Dial to display the RadialController menu.

We haven't done any customization for our app yet, so the menu contains a default set of contextual tools.

These images show two variations of the default menu. (There are many others, including just basic system tools when the Windows Desktop is active and no apps are in the foreground, additional inking tools when an InkToolbar is present, and mapping tools when you’re using the Maps app.

Microsoft Dial App

Now we'll start with some basic customization.

Step 3: Add controls for wheel input

First, let's add the UI for our app:

1. Open the MainPage_Basic.xaml file.

2. Find the code marked with the title of this step ('<!-- Step 3: Add controls for wheel input -->').

3. Uncomment the following lines.

At this point, only the Initialize sample button, slider, and toggle switch are enabled. The other buttons are used in later steps to add and remove RadialController menu items that provide access to the slider and toggle switch.

Step 4: Customize the basic RadialController menu

Now let's add the code required to enable RadialController access to our controls.

1. Open the MainPage_Basic.xaml.cs file.
2. Find the code marked with the title of this step ('// Step 4: Basic RadialController menu customization').
3. Uncomment the following lines:

   • The Windows.UI.Input and Windows.Storage.Streams type references are used for functionality in subsequent steps:

   • These global objects (RadialController, RadialControllerConfiguration, RadialControllerMenuItem) are used throughout our app.

   • Here, we specify the Click handler for the button that enables our controls and initializes our custom RadialController menu item.

   • Next, we initialize our RadialController object and set up handlers for the RotationChanged and ButtonClicked events.

   • Here, we initialize our custom RadialController menu item. We use CreateForCurrentView to get a reference to our RadialController object, we set the rotation sensitivity to '1' by using the RotationResolutionInDegrees property, we then create our RadialControllerMenuItem by using CreateFromFontGlyph, we add the menu item to the RadialController menu item collection, and finally, we use SetDefaultMenuItems to clear the default menu items and leave only our custom tool.

4. Now, run the app again.
5. Select the Initialize radial controller button.
6. With the app in the foreground, press and hold the Surface Dial to display the menu. Notice that all default tools have been removed (by using the RadialControllerConfiguration.SetDefaultMenuItems method), leaving only the custom tool. Here’s the menu with our custom tool.

7. Select the custom tool and try out the interactions now supported through the Surface Dial:
   • A rotate action moves the slider.
   • A click sets the toggle to on or off.

Ok, let's hook up those buttons.

Step 5: Configure menu at runtime

In this step, we hook up the Add/Remove item and Reset RadialController menu buttons to show how you can dynamically customize the menu.

1. Open the MainPage_Basic.xaml.cs file.

2. Find the code marked with the title of this step ('// Step 5: Configure menu at runtime').

3. Uncomment the code in the following methods and run the app again, but don't select any buttons (save that for the next step).

4. Select the Remove item button and then press and hold the Dial to display the menu again.

   Notice that the menu now contains the default collection of tools. Recall that, in Step 3, while setting up our custom menu, we removed all the default tools and added just our custom tool. We also noted that, when the menu is set to an empty collection, the default items for the current context are reinstated. (We added our custom tool before removing the default tools.)

5. Select the Add item button and then press and hold the Dial.

   Notice that the menu now contains both the default collection of tools and our custom tool.

6. Select the Reset RadialController menu button and then press and hold the Dial.

   Notice that the menu is back to its original state.

Step 6: Customize the device haptics

The Surface Dial, and other wheel devices, can provide users with haptic feedback corresponding to the current interaction (based on either click or rotation).

In this step, we show how you can customize haptic feedback by associating our slider and toggle switch controls and using them to dynamically specify haptic feedback behavior. For this example, the toggle switch must be set to on for feedback to be enabled while the slider value specifies how often the click feedback is repeated.

Note

Haptic feedback can be disabled by the user in the Settings > Devices > Wheel page.

1. Open the App.xaml.cs file.

2. Find the code marked with the title of this step ('Step 6: Customize the device haptics').

3. Comment the first and third lines ('MainPage_Basic' and 'MainPage') and uncomment the second ('MainPage_Haptics').

4. Open the MainPage_Haptics.xaml file.

5. Find the code marked with the title of this step ('<!-- Step 6: Customize the device haptics -->').

6. Uncomment the following lines. (This UI code simply indicates what haptics features are supported by the current device.)

7. Open the MainPage_Haptics.xaml.cs file

8. Find the code marked with the title of this step ('Step 6: Haptics customization')

9. Uncomment the following lines:

   • The Windows.Devices.Haptics type reference is used for functionality in subsequent steps.

   • Here, we specify the handler for the ControlAcquired event that is triggered when our custom RadialController menu item is selected.

   • Next, we define the ControlAcquired handler, where we disable default haptic feedback and initialize our haptics UI.

   • In our RotationChanged and ButtonClicked event handlers, we connect the corresponding slider and toggle button controls to our custom haptics.

   • Finally, we get the requested Waveform (if supported) for the haptic feedback.

Now run the app again to try out the custom haptics by changing the slider value and toggle-switch state.

Step 7: Define on-screen interactions for Surface Studio and similar devices

Paired with the Surface Studio, the Surface Dial can provide an even more distinctive user experience.

In addition to the default press and hold menu experience described, the Surface Dial can also be placed directly on the screen of the Surface Studio. This enables a special 'on-screen' menu.

By detecting both the contact location and bounds of the Surface Dial, the system handles occlusion by the device and displays a larger version of the menu that wraps around the outside of the Dial. This same info can also be used by your app to adapt the UI for both the presence of the device and its anticipated usage, such as the placement of the user's hand and arm.

The sample that accompanies this tutorial includes a slightly more complex example that demonstrates some of these capabilities.

To see this in action (you'll need a Surface Studio):

1. Download the sample on a Surface Studio device (with Visual Studio installed)

2. Open the sample in Visual Studio

3. Open the App.xaml.cs file

4. Find the code marked with the title of this step ('Step 7: Define on-screen interactions for Surface Studio and similar devices')

5. Comment the first and second lines ('MainPage_Basic' and 'MainPage_Haptics') and uncomment the third ('MainPage')

6. Run the app and place the Surface Dial in each of the two control regions, alternating between them.
   

   Here's a video of this sample in action:

Summary

Congratulations, you've completed the Get Started Tutorial: Support the Surface Dial (and other wheel devices) in your Windows app! We showed you the basic code required for supporting a wheel device in your Windows apps, and how to provide some of the richer user experiences supported by the RadialController APIs.

Related articles

API reference

Samples

Topic samples

Other samples

Surface Dial with Surface Studio and Pen (available for purchase at the Microsoft Store).

Overview

Windows wheel devices, such as the Surface Dial, are a new category of input device that enable a host of compelling and unique user interaction experiences for Windows and Windows apps.

Important

In this topic, we refer specifically to Surface Dial interactions, but the info is applicable to all Windows wheel devices.

Surface Dial for devs

With a form factor based on a rotate action (or gesture), the Surface Dial is intended as a secondary, multi-modal input device that complements input from a primary device. In most cases, the device is manipulated by a user's non-dominant hand while performing a task with their dominant hand (such as inking with a pen). It is not designed for precision pointer input (like touch, pen, or mouse).

The Surface Dial also supports both a press and hold action and a click action. Press and hold has a single function: display a menu of commands. If the menu is active, the rotate and click input is processed by the menu. Otherwise, the input is passed to your app for processing.

As with all Windows input devices, you can customize and tailor the Surface Dial interaction experience to suit the functionality in your apps.

Tip

Used together, the Surface Dial and the new Surface Studio can provide an even more distinctive user experience.

In addition to the default press and hold menu experience described, the Surface Dial can also be placed directly on the screen of the Surface Studio. This enables a special 'on-screen' menu.

By detecting both the contact location and bounds of the Surface Dial, the system uses this info to handle occlusion by the device and display a larger version of the menu that wraps around the outside of the Dial. This same info can also be used by your app to adapt the UI for both the presence of the device and its anticipated usage, such as the placement of the user's hand and arm.

Surface Dial on-screen menu

System integration

The Surface Dial is tightly integrated with Windows and supports a set of built-in tools on the menu: system volume, scroll, zoom in/out, and undo/redo.

This collection of built-in tools adapts to the current system context to include:

• A system brightness tool when the user is on the Windows Desktop
• A previous/next track tool when media is playing

In addition to this general platform support, the Surface Dial is also tightly integrated with the Windows Ink platform controls (InkCanvas and InkToolbar).

Surface Dial with Surface Pen

When used with the Surface Dial, these controls enable additional functionality for modifying ink attributes and controlling the ink toolbar’s ruler stencil.

When you open the Surface Dial Menu in an inking application that uses the ink toolbar, the menu now includes tools for controlling pen type and brush thickness. When the ruler is enabled, a corresponding tool is added to the menu that lets the device control the position and angle of the ruler.

Surface Dial menu with pen selection tool for the Windows Ink toolbar

Surface Dial menu with stroke size tool for the Windows Ink toolbar

Surface Dial menu with ruler tool for the Windows Ink toolbar

User customization

Users can customize some aspects of their Dial experience through the Windows Settings -> Devices -> Wheel page, including default tools, vibration (or haptic feedback), and writing (or dominant) hand.

When customizing the Surface Dial user experience, you should always ensure that a particular function or behavior is available and enabled by the user.

Custom tools

Here we discuss both UX and developer guidance for customizing the tools exposed on the Surface Dial menu.

UX guidance for custom tools

Ensure your tools correspond to the current contextWhen you make it clear and intuitive what a tool does and how the Surface Dial interaction works, you help users learn quickly and stay focused on their task.

Minimize the number of app tools as much as possible
The Surface Dial menu has room for seven items. If there are eight or more items, the user needs to turn the Dial to see which tools are available in an overflow flyout, making the menu difficult to navigate and tools difficult to discover and select.

We recommend providing a single custom tool for your app or app context. Doing so enables you to set that tool based on what the user is doing without requiring them to activate the Surface Dial menu and select a tool.

Dynamically update the collection of tools
Because Surface Dial menu items do not support a disabled state, you should dynamically add and remove tools (including built-in, default tools) based on user context (current view or focused window). If a tool is not relevant to the current activity or it’s redundant, remove it.

Important

When you add an item to the menu, ensure the item does not already exist.

Don’t remove the built-in system volume setting tool
Volume control is typically always required by user. They might be listening to music while using your app, so volume and next track tools should always be accessible from the Surface Dial menu. (The next track tool is automatically added to the menu when media is playing.)

Be consistent with menu organization
This helps users with discovering and learning what tools are available when using your app, and helps improve their efficiency when switching tools.

Provide high-quality icons consistent with the built-in icons
Icons can convey professionalism and excellence, and inspire trust in users.

• Provide a high-quality 64 x 64 pixel PNG image (44 x 44 is the smallest supported)
• Ensure the background is transparent
• The icon should fill most of the image
• A white icon should have a black outline to be visible in high contrast mode

Icon displayed on wheel menu with default theme

Icon displayed on wheel menu with High Contrast White theme

Use concise and descriptive names
The tool name is displayed in the tool menu along with the tool icon and is also used by screen readers.

• Names should be short to fit inside the central circle of the wheel menu
• Names should clearly identify the primary action (a complementary action can be implied):
  • Scroll indicates the effect of both rotation directions
  • Undo specifies a primary action, but redo (the complementary action) can be inferred and easily discovered by the user

Developer guidance

You can customize the Surface Dial experience to complement the functionality in your apps through a comprehensive set of Windows Runtime APIs.

As previously mentioned, the default Surface Dial menu is pre-populated with a set of built-in tools covering a broad range of basic system features (system volume, system brightness, scroll, zoom, undo, and media control when the system detects ongoing audio or video playback). However, these default tools might not provide the functionality required by your app.

Microsoft Dialog Box

In the following sections, we describe how to add a custom tool to the Surface Dial menu and specify which built-in tools are exposed.

Download a more robust version of this sample from RadialController customization.

Add a custom tool

In this example, we add a basic custom tool that passes the input data from both the rotation and click events to some XAML UI controls.

1. First, we declare our UI (just a slider and toggle button) in XAML.

   
   The sample app UI

2. Then, in code-behind, we add a custom tool to the Surface Dial menu and declare the RadialController input handlers.

   We get a reference to the RadialController object for the Surface Dial (myController) by calling CreateForCurrentView.

   We then create an instance of a RadialControllerMenuItem (myItem) by calling RadialControllerMenuItem.CreateFromIcon.

   Next, we append that item to the collection of menu items.

   We declare the input event handlers (ButtonClicked and RotationChanged) for the RadialController object.

   Finally, we define the event handlers.

When we run the app, we use the Surface Dial to interact with it. First, we press and hold to open the menu and select our custom tool. Once the custom tool is activated, the slider control can be adjusted by rotating the Dial and the switch can be toggled by clicking the Dial.

The sample app UI activated using the Surface Dial custom tool

Specify the built-in tools

You can use the RadialControllerConfiguration class to customize the collection of built-in menu items for your app.

For example, if your app doesn’t have any scrolling or zooming regions and doesn’t require undo/redo functionality, these tools can be removed from the menu. This opens space on the menu to add custom tools for your app.

Important

The Surface Dial menu must have at least one menu item. If all default tools are removed before you add one of your custom tools, the default tools are restored and your tool is appended to the default collection.

Per the design guidelines, we do not recommend removing the media control tools (volume and previous/next track) as users often have background music playing while they perform other tasks.

Here, we show how to configure the Surface Dial menu to include only media controls for volume and next/previous track.

Custom interactions

As mentioned, the Surface Dial supports three gestures (press and hold, rotate, click) with corresponding default interactions.

Ensure any custom interactions based on these gestures make sense for the selected action or tool.

Note

The interaction experience is dependent on the state of the Surface Dial menu. If the menu is active, it processes the input; otherwise, your app does.

Press and hold

This gesture activates and shows the Surface Dial menu, there is no app functionality associated with this gesture.

By default, the menu is displayed at the center of the user’s screen. However, the user can grab it and move it anywhere they choose.

Note

When the Surface Dial is placed on the screen of the Surface Studio, the menu is centered at the on-screen location of the Surface Dial.

Rotate

The Surface Dial is primarily designed to support rotation for interactions that involve smooth, incremental adjustments to analog values or controls.

The device can be rotated both clockwise and counter-clockwise, and can also provide haptic feedback to indicate discrete distances.

Note

Haptic feedback can be disabled by the user in the Windows Settings -> Devices -> Wheel page.

UX guidance for custom interactions

Tools with continuous or high rotational sensitivity should disable haptic feedback

Haptic feedback matches the rotational sensitivity of the active tool. We recommend disabling haptic feedback for tools with continuous or high rotational sensitivity as the user experience can get uncomfortable.

Dominant hand should not affect rotation-based interactions

The Surface Dial cannot detect which hand is being used, but the user can set the writing (or dominant hand) in Windows Settings -> Device -> Pen & Windows Ink.

Locale should be considered for all rotation interactions

Maximize customer satisfaction by accomodating and adapting your interactions to locale and right-to-left layouts.

The built-in tools and commands on the Dial menu follow these guidelines for rotation-based interactions:

Developer guidance

As the user rotates the device, RadialController.RotationChanged events are fired based on a delta (RadialControllerRotationChangedEventArgs.RotationDeltaInDegrees) relative to the direction of rotation. The sensitivity (or resolution) of the data can be set with the RadialController.RotationResolutionInDegrees property.

Note

By default, a rotational input event is delivered to a RadialController object only when the device is rotated a minimum of 10 degrees. Each input event causes the device to vibrate.

Microsoft Dialogpt

In general, we recommend disabling haptic feedback when the rotation resolution is set to less than 5 degrees. This provides a smoother experience for continuous interactions.

You can enable and disable haptic feedback for custom tools by setting the RadialController.UseAutomaticHapticFeedback property.

Note

You cannot override the haptic behavior for system tools such as the volume control. For these tools, haptic feedback can be disabled only by the user from the wheel settings page.

Here’s an example of how to customize the resolution of the rotation data and enable or disable haptic feedback.

Click

Clicking the Surface Dial is similar to clicking the left mouse button (the rotation state of the device has no effect on this action).

UX guidance

Do not map an action or command to this gesture if the user cannot easily recover from the result

Any action taken by your app based on the user clicking the Surface Dial must be reversible. Always enable the user to easily traverse the app back stack and restore a previous app state.

Binary operations such as mute/unmute or show/hide provide good user experiences with the click gesture.

Modal tools should not be enabled or disabled by clicking the Surface Dial

Some app/tool modes can conflict with, or disable, interactions that rely on rotation. Tools such as the ruler in the Windows Ink toolbar, should be toggled on or off through other UI affordances (the Ink Toolbar provides a built-in ToggleButton control).

For modal tools, map the active Surface Dial menu item to the target tool or to the previously selected menu item.

Developer guidance

When the Surface Dial is clicked, a RadialController.ButtonClicked event is fired. The RadialControllerButtonClickedEventArgs include a Contact property that contains the location and bounding area of the Surface Dial contact on the Surface Studio screen. If the Surface Dial is not in contact with the screen, this property is null.

On-screen

As described earlier, the Surface Dial can be used in conjunction with the Surface Studio to display the Surface Dial menu in a special on-screen mode.

When in this mode, you can integrate and customize your Dial interaction experiences with your apps even further. Examples of unique experiences only possible with the Surface Dial and Surface Studio include:

• Displaying contextual tools (such as a color palette) based on the position of the Surface Dial, which makes them easier to find and use
• Setting the active tool based on the UI the Surface Dial is placed on
• Magnifying a screen area based on location of the Surface Dial
• Unique game interactions based on screen location

UX guidance for on-screen interactions

Apps should respond when the Surface Dial is detected on-screen

Visual feedback helps indicate to users that your app has detected the device on the screen of the Surface Studio.

Adjust Surface Dial-related UI based on device location

The device (and the user's body) can occlude critical UI depending on where the user places it.

Adjust Surface Dial-related UI based on user interaction

In addition to hardware occlusion, a user’s hand and arm can occlude part of the screen when using the device.

The occluded area depends on which hand is being used with the device. As the device is designed to be used primarily with the non-dominant hand, Surface Dial-related UI should adjust for the opposite hand specified by the user (Windows Settings > Devices > Pen & Windows Ink > Choose which hand you write with setting).

Interactions should respond to Surface Dial position rather than movement

The foot of the device is designed to stick to the screen rather than slide, as it is not a precision pointing device. Therefore, we expect it to be more common for users to lift and place the Surface Dial rather than drag it across the screen.

Use screen position to determine user intent

Setting the active tool based on UI context, such as proximity to a control, canvas, or window, can improve the user experience by reducing the steps required to perform a task.

Developer guidance

When the Surface Dial is placed onto the digitizer surface of the Surface Studio, a RadialController.ScreenContactStarted event is fired and the contact info (RadialControllerScreenContactStartedEventArgs.Contact) is provided to your app.

Similarly, if the Surface Dial is clicked when in contact with the digitizer surface of the Surface Studio, a RadialController.ButtonClicked event is fired and the contact info (RadialControllerButtonClickedEventArgs.Contact) is provided to your app.

The contact info (RadialControllerScreenContact) includes the X/Y coordinate of the center of the Surface Dial in the coordinate space of the app (RadialControllerScreenContact.Position), as well as the bounding rectangle (RadialControllerScreenContact.Bounds) in Device Independent Pixels (DIPs). This info is very useful for providing context to the active tool and providing device-related visual feedback to the user.

In the following example, we’ve created a basic app with four different sections, each of which includes one slider and one toggle. We then use the onscreen position of the Surface Dial to dictate which set of sliders and toggles are controlled by the Surface Dial.

1. First, we declare our UI (four sections, each with a slider and toggle button) in XAML.

   
   The sample app UI

2. Here's the code-behind with handlers defined for Surface Dial screen position.

When we run the app, we use the Surface Dial to interact with it. First, we place the device on the Surface Studio screen, which the app detects and associates with the lower right section (see image). We then press and hold the Surface Dial to open the menu and select our custom tool. Once the custom tool is activated, the slider control can be adjusted by rotating the Surface Dial and the switch can be toggled by clicking the Surface Dial.

The sample app UI activated using the Surface Dial custom tool

Summary

Microsoft Dial Review

This topic provides an overview of the Surface Dial input device with UX and developer guidance on how to customize the user experience for off-screen scenarios as well as on-screen scenarios when used with Surface Studio.

Please send your questions, suggestions, and feedback to radialcontroller@microsoft.com.

Related articles

Microsoft Dial 2

API reference

Samples

Microsoft Dial Box

Topic samples

Other samples