private void MenuItem_Invoked(RadialControllerMenuItem sender, object args)
{
if (sender?.DisplayText == "Undo")
{
//TODO reset image to tempFile
return;
}
var selectedEffect = PageViewModel.VideoEffects.FirstOrDefault(e => e.DisplayName == sender?.DisplayText);
if (selectedEffect == null)
{
return;
}
// If the selected effect was already selected, then remove the effect from the video stream
if (selectedEffect == PageViewModel.SelectedEffect)
{
PageViewModel.SelectedEffect = null;
return;
}
// Set the currently selected effect
PageViewModel.SelectedEffect = selectedEffect;
}
public MainPage()
{
this.InitializeComponent();
controller = RadialController.CreateForCurrentView();
controller.UseAutomaticHapticFeedback = false;
controller.RotationResolutionInDegrees = 1;
customItem = RadialControllerMenuItem.CreateFromKnownIcon("Rotate", RadialControllerMenuKnownIcon.Ruler);
controller.Menu.Items.Add(customItem);
controller.Menu.SelectMenuItem(customItem);
config = RadialControllerConfiguration.GetForCurrentView();
config.ActiveControllerWhenMenuIsSuppressed = controller;
config.SetDefaultMenuItems(new[] { RadialControllerSystemMenuItemKind.Volume, RadialControllerSystemMenuItemKind.Scroll });
//comment these three lines to supress menu scenario
controller.ControlLost += Controller_ControlLost;
controller.ControlAcquired += Controller_ControlAcquired;
controller.RotationChanged += Controller_RotationChanged;
//uncomment it to supress the default menu
//config.IsMenuSuppressed = true;
//controller.ButtonHolding += Controller_ButtonHolding;
}
private async Task AddMenuItemInternalAsync(string moniker, string iconFilePath)
{
await Task.Yield();
await TaskScheduler.Default;
StorageFile file = await StorageFile.GetFileFromPathAsync(iconFilePath);
var stream = RandomAccessStreamReference.CreateFromFile(file);
var menuItem = RadialControllerMenuItem.CreateFromIcon(moniker, stream);
menuItem.Invoked += (sender, args) =>
{
_status.Text = sender.DisplayText;
_controllers.FirstOrDefault(c => c.Moniker == moniker)?.OnActivate();
};
await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
foreach (var controller in controllersMapping.Values)
{
if (!controller.Menu.Items.Any(i => i.DisplayText == moniker))
{
controller.Menu.Items.Add(menuItem);
}
}
}
public OnScreenVisualPage()
{
this.InitializeComponent();
RadialControllerConfiguration myConfiguration = RadialControllerConfiguration.GetForCurrentView();
myConfiguration.SetDefaultMenuItems(new[]
{
RadialControllerSystemMenuItemKind.Volume,
RadialControllerSystemMenuItemKind.Scroll
});
// 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/dial_icon_custom_visual.png"));
// Create a menu item for the custom tool.
screenColorMenuItem =
RadialControllerMenuItem.CreateFromIcon("Screen Color", icon);
// Add the custom tool to the RadialController menu.
myController.Menu.Items.Add(screenColorMenuItem);
screenColorMenuItem.Invoked += ColorMenuItem_Invoked;
myController.ScreenContactStarted += MyController_ScreenContactStarted;
myController.ScreenContactContinued += MyController_ScreenContactContinued;
myController.ScreenContactEnded += MyController_ScreenContactEnded;
myController.RotationChanged += MyController_RotationChanged;
}
/// <summary>
/// When a Surface Dial TextBox gets focus, ensure the proper events are setup, and connect the Surface Dial itself.
/// </summary>
/// <param name="sender">The TextBox in being affected.</param>
/// <param name="e">The event arguments.</param>
private static void TextBox_GotFocus(object sender, RoutedEventArgs e)
{
_textBox = sender as TextBox;
if (_textBox == null)
{
return;
}
if (!IsSupported)
{
return;
}
_controller = _controller ?? RadialController.CreateForCurrentView();
if (GetForceMenuItem(_textBox))
{
_stepTextMenuItem = RadialControllerMenuItem.CreateFromKnownIcon("Step Text Box", GetIcon(_textBox));
_controller.Menu.Items.Add(_stepTextMenuItem);
_controller.Menu.SelectMenuItem(_stepTextMenuItem);
}
_controller.UseAutomaticHapticFeedback = GetEnableHapticFeedback(_textBox);
_controller.RotationResolutionInDegrees = 1;
_controller.RotationChanged += Controller_RotationChanged;
if (GetEnableTapToNextControl(_textBox))
{
_controller.ButtonClicked += Controller_ButtonClicked;
}
}
public MenuItemPage()
{
this.InitializeComponent();
RadialControllerConfiguration myConfiguration = RadialControllerConfiguration.GetForCurrentView();
//determine which operating system menu items should be shown
myConfiguration.SetDefaultMenuItems(new[]
{
RadialControllerSystemMenuItemKind.Volume,
RadialControllerSystemMenuItemKind.NextPreviousTrack,
RadialControllerSystemMenuItemKind.Scroll
});
// 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/dial_icon_custom_item.png"));
// Create a menu item for the custom tool.
selectImageMenuItem =
RadialControllerMenuItem.CreateFromIcon("Select Image", icon);
// Add the custom tool to the RadialController menu.
myController.Menu.Items.Add(selectImageMenuItem);
// Declare input handlers for the RadialController.
myController.RotationChanged += MyController_RotationChanged;
selectImageMenuItem.Invoked += SelectImageItem_Invoked;
}
private void StarController()
{
var interop = (IRadialControllerInterop)System.Runtime.InteropServices.WindowsRuntime.WindowsRuntimeMarshal
.GetActivationFactory(typeof(RadialController));
Guid guid = typeof(RadialController).GetInterface("IRadialController").GUID;
Window window = Window.GetWindow(this);
var wih = new WindowInteropHelper(window);
IntPtr hWnd = wih.Handle;
controller = interop.CreateForWindow(hWnd, ref guid);
controller.ControlAcquired += Controller_ControlAcquired;
controller.ControlLost += Controller_ControlLost;
controller.RotationChanged += Controller_RotationChanged;
controller.ButtonClicked += Controller_ButtonClicked;
controller.RotationResolutionInDegrees = 1;
var button = RadialControllerMenuItem.CreateFromKnownIcon("Item 1", RadialControllerMenuKnownIcon.Ruler);
var button2 = RadialControllerMenuItem.CreateFromKnownIcon("Item 2", RadialControllerMenuKnownIcon.PenType);
button.Invoked += Button_Invoked;
button2.Invoked += Button_Invoked;
controller.Menu.Items.Add(button);
controller.Menu.Items.Add(button2);
mainClicks = 0;
}
private void SetupController()
{
if (null == Controller)
{
Controller = RadialController.CreateForCurrentView();
}
RadialControllerConfiguration _dialConfiguration = RadialControllerConfiguration.GetForCurrentView();
// Remove standard menu items
_dialConfiguration.SetDefaultMenuItems(new RadialControllerSystemMenuItemKind[] { });
// Create an icon for the custom tool.
RandomAccessStreamReference icon =
RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/List/specs_creative.png"));
// Create a menu item for the custom tool.
_brushColorMenuItem = RadialControllerMenuItem.CreateFromIcon("Brush Color", icon);
// Add the custom tool to the RadialController menu.
Controller.Menu.Items.Add(_brushColorMenuItem);
// Set rotation degrees
Controller.RotationResolutionInDegrees = ROTATION_DEGREES;
// Bind dial controls to local methods
_brushColorMenuItem.Invoked += ColorMenuItem_Invoked;
Controller.RotationChanged += Controller_RotationChanged;
Controller.ButtonClicked += Controller_ButtonClicked;
Controller.ScreenContactStarted += Controller_ScreenContactStarted;
Controller.ScreenContactContinued += Controller_ScreenContactContinued;
Controller.ScreenContactEnded += Controller_ScreenContactEnded;
}
private void AddCustomItems()
{
radialController.Menu.Items.Add(RadialControllerMenuItem.CreateFromKnownIcon("Ruler", RadialControllerMenuKnownIcon.Ruler));
AddItemFromImage();
AddItemsFromFont();
}
private async void MenuItem_Invoked(RadialControllerMenuItem sender, object args)
{
var selectedEffect = PageViewModel.VideoEffects.FirstOrDefault(e => e.DisplayName == sender?.DisplayText);
if (selectedEffect == null)
{
return;
}
// If the selected effect was already selected, then remove the effect from the video stream
if (selectedEffect == PageViewModel.SelectedEffect)
{
await ClearVideoEffectsAsync();
PageViewModel.SelectedEffect = null;
return;
}
// Set the currently selected effect
PageViewModel.SelectedEffect = selectedEffect;
// Clear previous effect
await ClearVideoEffectsAsync();
// Apply new effect
await ApplyVideoEffectAsync();
}
private void InitializeDial()
{
radialController = RadialController.CreateForCurrentView();
// Set rotation resolution to 1 degree of sensitivity.
radialController.RotationResolutionInDegrees = 36;
// create new dial menu item
//ToggleMenuItem =
// RadialControllerMenuItem.CreateFromFontGlyph("Toggle Light", "\xE793", "Segoe MDL2 Assets");
//radialController.Menu.Items.Add(ToggleMenuItem);
BrightnessMenuItem =
RadialControllerMenuItem.CreateFromFontGlyph("Brightness", "\xE706", "Segoe MDL2 Assets");
radialController.Menu.Items.Add(BrightnessMenuItem);
ColorMenuItem =
RadialControllerMenuItem.CreateFromFontGlyph("Color", "\xE790", "Segoe MDL2 Assets");
radialController.Menu.Items.Add(ColorMenuItem);
// clear all default item
RadialControllerConfiguration config = RadialControllerConfiguration.GetForCurrentView();
config.SetDefaultMenuItems(new RadialControllerSystemMenuItemKind[] { });
// bind dial menu item to CurrentTool Enum
//ToggleMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.ToggleItem;
BrightnessMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.BrightnessItem;
ColorMenuItem.Invoked += (sender, args) => thisTool = CurrentTool.ColorItem;
// subscribe click and rotation of the dial
radialController.ButtonClicked += (sender, args) => { RadialController_ButtonClicked(sender, args); };
radialController.RotationChanged += (sender, args) => { RadialController_RotationChanged(sender, args); };
}
private void InitializeSurfaceDial()
{
_radialController = RadialController.CreateForCurrentView();
_radialController.ButtonClicked += _radialController_ButtonClicked;
_radialController.RotationChanged += _radialController_RotationChanged;
var bluricon = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Blur.png"));
var fogicon = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Fog.png"));
var hueicon = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Hue.png"));
var saturationicon = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Saturation.png"));
var sepiaicon = RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Sepia.png"));
var blurItem = RadialControllerMenuItem.CreateFromIcon(TAGS.Blur, bluricon);
blurItem.Tag = blurItem.DisplayText;
var fogItem = RadialControllerMenuItem.CreateFromIcon(TAGS.Fog, fogicon);
fogItem.Tag = fogItem.DisplayText;
var hueItem = RadialControllerMenuItem.CreateFromIcon(TAGS.Hue, hueicon);
hueItem.Tag = hueItem.DisplayText;
var saturationItem = RadialControllerMenuItem.CreateFromIcon(TAGS.Saturation, saturationicon);
saturationItem.Tag = saturationItem.DisplayText;
var sepiaItem = RadialControllerMenuItem.CreateFromIcon(TAGS.Sepia, sepiaicon);
sepiaItem.Tag = sepiaItem.DisplayText;
_radialController.Menu.Items.Add(blurItem);
_radialController.Menu.Items.Add(fogItem);
_radialController.Menu.Items.Add(hueItem);
_radialController.Menu.Items.Add(saturationItem);
_radialController.Menu.Items.Add(sepiaItem);
}
private void CreateMenuItems()
{
menuItems = new List <RadialControllerMenuItem>
{
RadialControllerMenuItem.CreateFromKnownIcon("Item0", RadialControllerMenuKnownIcon.InkColor),
RadialControllerMenuItem.CreateFromKnownIcon("Item1", RadialControllerMenuKnownIcon.NextPreviousTrack),
RadialControllerMenuItem.CreateFromKnownIcon("Item2", RadialControllerMenuKnownIcon.Volume),
RadialControllerMenuItem.CreateFromIcon("Item3", RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Item3.png"))),
RadialControllerMenuItem.CreateFromIcon("Item4", RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Item4.png"))),
RadialControllerMenuItem.CreateFromIcon("Item5", RandomAccessStreamReference.CreateFromUri(new Uri("ms-appx:///Assets/Item5.png")))
};
sliders = new List <Slider> {
Slider0, Slider1, Slider2, Slider3, Slider4, Slider5
};
toggles = new List <ToggleSwitch> {
Toggle0, Toggle1, Toggle2, Toggle3, Toggle4, Toggle5
};
for (int i = 0; i < menuItems.Count; ++i)
{
RadialControllerMenuItem radialControllerItem = menuItems[i];
int index = i;
radialControllerItem.Invoked += (sender, args) => { OnItemInvoked(index); };
}
}
public void AddMenuItem(string moniker, string iconFilePath)
{
if (_radialController.Menu.Items.Any(i => i.DisplayText == moniker))
{
return;
}
IAsyncOperation <StorageFile> operation = StorageFile.GetFileFromPathAsync(iconFilePath);
operation.Completed += (asyncInfo, asyncStatus) =>
{
if (asyncStatus == AsyncStatus.Completed)
{
StorageFile file = asyncInfo.GetResults();
var stream = RandomAccessStreamReference.CreateFromFile(file);
var menuItem = RadialControllerMenuItem.CreateFromIcon(moniker, stream);
menuItem.Invoked += (sender, args) =>
{
_status.UpdateSelectedItem(sender.DisplayText);
_controllers.FirstOrDefault(c => c.Moniker == moniker)?.OnActivate();
};
ThreadHelper.Generic.BeginInvoke(DispatcherPriority.Normal, () =>
{
_radialController.Menu.Items.Add(menuItem);
});
}
};
}
public void RemoveMenuItem(RadialControllerMenuItem item)
{
if (RadialController != null && RadialController.Menu.Items.Contains(item))
{
RadialController.Menu.Items.Remove(item);
}
}
public void AddMenuItem(RadialControllerMenuItem item)
{
if (RadialController != null && !RadialController.Menu.Items.Contains(item))
{
RadialController.Menu.Items.Add(item);
}
}
private void ConfigureRadialController()
{
if (!RadialControllerConfiguration.IsAppControllerEnabled)
{
return;
}
// Setup DialController
dialController = RadialController.CreateForCurrentView();
dialController.RotationResolutionInDegrees = 1;
// Wireup event handler for rotation
dialController.RotationChanged += DialController_RotationChanged;
dialController.ButtonClicked += DialController_ButtonClicked;
// Remove the default items to make more room for our custom items
var config = RadialControllerConfiguration.GetForCurrentView();
config.SetDefaultMenuItems(new[] { RadialControllerSystemMenuItemKind.Scroll });
// Add a custom menu item for each of the video effects
foreach (VideoEffectItemViewModel effect in PageViewModel.VideoEffects)
{
// Create a menu item, using the effect's name and thumbnail
var menuItem = RadialControllerMenuItem.CreateFromIcon(effect.DisplayName,
RandomAccessStreamReference.CreateFromUri(new Uri(effect.IconImagePath)));
// Hook up the menu item's invoked (aka clicked/selected) event handler
menuItem.Invoked += MenuItem_Invoked;
// Add it to the RadialDial
dialController.Menu.Items.Add(menuItem);
}
}
private void ColorMenuItem_Invoked(RadialControllerMenuItem sender, object args)
{
if (!IsActive)
{
IsActive = true;
}
}
#pragma warning restore VSTHRD200 // Use "Async" suffix for async methods
internal static async Task <RadialControllerMenuItem> CreateMenuItemAsync(string moniker, string iconFilePath)
{
StorageFile file = await StorageFile.GetFileFromPathAsync(iconFilePath);
var stream = RandomAccessStreamReference.CreateFromFile(file);
return(RadialControllerMenuItem.CreateFromIcon(moniker, stream));
}
public async void AddMenuItem(string title, Texture2D icon)
{
var memStream = await GetRandomAccessStreamReferenceForIcon(icon);
var menuItem = RadialControllerMenuItem.CreateFromIcon(title, memStream);
_controller.Menu.Items.Add(menuItem);
}
private void OnImageFileFound(IAsyncOperation <StorageFile> asyncInfo, AsyncStatus asyncStatus)
{
if (asyncStatus == AsyncStatus.Completed)
{
StorageFile imageFile = asyncInfo.GetResults();
radialController.Menu.Items.Add(RadialControllerMenuItem.CreateFromIcon("Custom Image", RandomAccessStreamReference.CreateFromFile(imageFile)));
}
}
public MainPage()
{
this.InitializeComponent();
UpdatePreview();
highlightedItem = RValue;
myCanvas.InkPresenter.InputDeviceTypes = Windows.UI.Core.CoreInputDeviceTypes.Pen | Windows.UI.Core.CoreInputDeviceTypes.Touch;
RValue.ValueChanged += Slider_ValueChanged;
GValue.ValueChanged += Slider_ValueChanged;
BValue.ValueChanged += Slider_ValueChanged;
//Hide our custom tool's UI until it is activated
ToolPanel.Visibility = Visibility.Collapsed;
// Create a reference to the RadialController.
myController = RadialController.CreateForCurrentView();
// Create a menu item for the custom tool.
//RadialControllerMenuItem myItem =
// RadialControllerMenuItem.CreateFromKnownIcon("Background", RadialControllerMenuKnownIcon.InkColor);
RadialControllerMenuItem myItem =
RadialControllerMenuItem.CreateFromFontGlyph("Background", "\xE7B5", "Segoe MDL2 Assets");
//Add the custom tool's menu item to the menu
myController.Menu.Items.Add(myItem);
//Create a handler for when the menu item is selected
myItem.Invoked += MyItem_Invoked;
//Create handlers for button and rotational input
myController.RotationChanged += MyController_RotationChanged;
myController.ButtonClicked += MyController_ButtonClicked;
myController.ButtonPressed += MyController_ButtonPressed;
myController.ButtonReleased += MyController_ButtonReleased;
//Remove Scroll/Zoom/Undo tools as app doesn't support them
RadialControllerConfiguration config = RadialControllerConfiguration.GetForCurrentView();
config.SetDefaultMenuItems(new RadialControllerSystemMenuItemKind[] { RadialControllerSystemMenuItemKind.Volume });
//Query user's handedness for on-screen UI
Windows.UI.ViewManagement.UISettings settings = new Windows.UI.ViewManagement.UISettings();
isRightHanded = (settings.HandPreference == Windows.UI.ViewManagement.HandPreference.RightHanded);
//Create handlers for when RadialController provides an on-screen position
myController.ScreenContactStarted += MyController_ScreenContactStarted;
myController.ScreenContactContinued += MyController_ScreenContactContinued;
myController.ScreenContactEnded += MyController_ScreenContactEnded;
//Create handlers for when RadialController focus changes
myController.ControlAcquired += MyController_ControlAcquired;
myController.ControlLost += MyController_ControlLost;
}
private void RemoveItem(object sender, RoutedEventArgs e)
{
RadialControllerMenuItem radialControllerMenuItem = GetRadialControllerMenuItemFromSender(sender);
if (Controller.Menu.Items.Contains(radialControllerMenuItem))
{
Controller.Menu.Items.Remove(radialControllerMenuItem);
}
}
public Scenario2_SystemDefaultMenu()
{
this.InitializeComponent();
controller = RadialController.CreateForCurrentView();
controller.RotationChanged += Controller_RotationChanged;
customItem = RadialControllerMenuItem.CreateFromKnownIcon("Item1", RadialControllerMenuKnownIcon.InkColor);
}
public Scenario2_SystemDefaultMenu()
{
this.InitializeComponent();
controller = RadialController.CreateForCurrentView();
controller.RotationChanged += Controller_RotationChanged;
customItem = RadialControllerMenuItem.CreateFromKnownIcon("Item1", RadialControllerMenuKnownIcon.InkColor);
}
public BookmarksController(RadialControllerMenuItem menuItem, DTE2 dte) : base(menuItem)
{
_commands = dte.Commands;
// Switched in provider
#pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread
_events = dte.Events.WindowEvents;
_events.WindowActivated += OnToolWindowActivated;
#pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
}
public void RequestActivation(string moniker)
{
RadialControllerMenuItem item = _radialController.Menu.Items.FirstOrDefault(i => i.DisplayText == moniker);
if (item != null)
{
_radialController.Menu.SelectMenuItem(item);
}
}
public void RemoveMenuItem(string moniker)
{
RadialControllerMenuItem item = _radialController.Menu.Items.FirstOrDefault(i => i.DisplayText == moniker);
if (item != null && _radialController.Menu.Items.Contains(item))
{
_radialController.Menu.Items.Remove(item);
}
}
public ErrorsController(RadialControllerMenuItem menuItem, DTE2 dte) : base(menuItem)
{
_dte = dte;
// Switched in provider
#pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread
_errorList = _dte.ToolWindows.ErrorList as IErrorList;
_events = _dte.Events.WindowEvents;
_events.WindowActivated += OnToolWindowActivated;
#pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
}
private void AddItemsFromFont()
{
// Using custom font
string fontFilePath = GetSharedFilePath("Symbols.ttf");
radialController.Menu.Items.Add(RadialControllerMenuItem.CreateFromFontGlyph("Custom Font Icon", "\xe102", "Symbols", new Uri(fontFilePath)));
// Using system font
radialController.Menu.Items.Add(RadialControllerMenuItem.CreateFromFontGlyph("System Font Icon", "\xD83D\xDC31\x200D\xD83D\xDC64", "Segoe UI Emoji"));
}
public DebugController(RadialControllerMenuItem menuItem, DTE2 dte) : base(menuItem)
{
_dte = dte;
// Switched in provider
#pragma warning disable VSTHRD010 // Invoke single-threaded types on Main thread
_events = dte.Events.DebuggerEvents;
_events.OnEnterBreakMode += delegate { DialPackage.DialControllerHost.RequestActivation(this); };
_events.OnEnterDesignMode += delegate { DialPackage.DialControllerHost.ReleaseActivation(); };
#pragma warning restore VSTHRD010 // Invoke single-threaded types on Main thread
}
