/// <inheritdoc />
protected override void OnApplyTemplate()
{
_canvasTextBoxTools = (StackPanel)GetTemplateChild("CanvasTextBoxTools");
_canvasTextBoxColorPicker = (ColorPicker)GetTemplateChild("CanvasTextBoxColorPicker");
_canvasTextBoxFontSizeTextBox = (TextBox)GetTemplateChild("CanvasTextBoxFontSizeTextBox");
_canvasTextBoxItlaicButton = (ToggleButton)GetTemplateChild("CanvasTextBoxItlaicButton");
_canvasTextBoxBoldButton = (ToggleButton)GetTemplateChild("CanvasTextBoxBoldButton");
_drawingSurfaceRenderer = (InfiniteCanvasVirtualDrawingSurface)GetTemplateChild("DrawingSurfaceRenderer");
_mainContainer = (Canvas)GetTemplateChild("MainContainer");
_infiniteCanvasScrollViewer = (ScrollViewer)GetTemplateChild("InfiniteCanvasScrollViewer");
_eraseAllButton = (Button)GetTemplateChild("EraseAllButton");
_canvasTextBox = (InfiniteCanvasTextBox)GetTemplateChild("CanvasTextBox");
_enableTextButton = (InkToolbarCustomToolButton)GetTemplateChild("EnableTextButton");
_enableTouchInkingButton = (InkToolbarCustomToggleButton)GetTemplateChild("EnableTouchInkingButton");
_inkCanvasToolBar = (InkToolbar)GetTemplateChild("InkCanvasToolBar");
_canvasToolbarContainer = (StackPanel)GetTemplateChild("CanvasToolbarContainer");
_inkCanvas = (InkCanvas)GetTemplateChild("DrawingInkCanvas");
_undoButton = (Button)GetTemplateChild("UndoButton");
_redoButton = (Button)GetTemplateChild("RedoButton");
_fontColorIcon = (FontIcon)GetTemplateChild("FontColorIcon");
UnRegisterEvents();
RegisterEvents();
ConfigureControls();
base.OnApplyTemplate();
}
/// <summary>
/// Selects the highlighter option with the specified color.
/// </summary>
/// <param name="color">
/// The color.
/// </param>
/// <returns>
/// The <see cref="InkToolbarPage"/>.
/// </returns>
public InkToolbarPage SelectHighlighterColor(string color)
{
InkToolbar inkToolbar = this.WindowsApp.FindElement(this.inkToolbarQuery);
inkToolbar.SetBallpointPenColor(color);
return(this);
}
/// <summary>
/// This gets an example for inking
/// </summary>
/// <returns></returns>
internal Control GetInk()
{
var panel = new Panel();
panel.BackColor = Color.LightBlue;
InkCanvas inkCanvas = new InkCanvas();
inkCanvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Pen | CoreInputDeviceTypes.Mouse | CoreInputDeviceTypes.Touch;
inkCanvas.Width = 800;
inkCanvas.Height = 300;
inkCanvas.Top = 2;
inkCanvas.Left = 2;
inkCanvas.Margin = new Padding(4);
InkToolbar toolbar = new InkToolbar();
toolbar.ButtonFlyoutPlacement = Microsoft.Toolkit.Win32.UI.Controls.Interop.WinRT.InkToolbarButtonFlyoutPlacement.Top;
toolbar.Dock = System.Windows.Forms.DockStyle.Top;
toolbar.Location = new System.Drawing.Point(2, 2);
toolbar.MinimumSize = new System.Drawing.Size(13, 48);
toolbar.TabIndex = 2;
toolbar.TargetInkCanvas = inkCanvas;
panel.Controls.Add(toolbar);
panel.Controls.Add(inkCanvas);
panel.Margin = new Padding(0, 10, 0, 0);
panel.Size = new System.Drawing.Size(inkCanvas.Width + 4, inkCanvas.Height + 4);
return(panel);
}
protected override void OnHandleCreated(EventArgs e)
{
base.OnHandleCreated(e);
if (this.DesignMode)
{
return;
}
if (_inkCanvas != null)
{
return;
}
if (_inkToolbar != null)
{
return;
}
_inkCanvas = new InkCanvas();
_inkCanvas.Dock = DockStyle.Fill;
this.Controls.Add(_inkCanvas);
_inkToolbar = new InkToolbar();
_inkToolbar.Dock = DockStyle.Top;
_inkToolbar.Height = (int)(48f * this.GetDpiScaleFactor());
_inkToolbar.AutoScaleMode = AutoScaleMode.Dpi;
_inkToolbar.TargetInkCanvas = _inkCanvas;
this.Controls.Add(_inkToolbar);
}
/**
* below are functions for the different modes in the tool bar
* */
// changing mode in tool bar
private void InkToolbar_ActiveToolChanged(InkToolbar sender, object args)
{
ClearAllHandlers();
if (inkToolbar.Children.Contains(animationPen))
{
inkToolbar.Children.Remove(animationPen);
}
if (inkToolbar.ActiveTool == toolButtonLasso)
{
inkCanvas.RightTapped += ClickSelect;
//for passing modified input to the app for custom processing
inkCanvas.InkPresenter.InputProcessingConfiguration.RightDragAction = InkInputRightDragAction.LeaveUnprocessed;
//Listeners for unprocessed pointer events from the modified input
inkCanvas.InkPresenter.UnprocessedInput.PointerPressed += UnprocessedInput_PointerPressed;
inkCanvas.InkPresenter.UnprocessedInput.PointerMoved += UnprocessedInput_PointerMoved;
inkCanvas.InkPresenter.UnprocessedInput.PointerReleased += UnprocessedInput_PointerReleased;
//Listeners for new ink or erase strokes so that selection could be cleared when inking or erasing is detected
inkCanvas.InkPresenter.StrokeInput.StrokeStarted += StrokeInput_StrokeStarted;
inkCanvas.InkPresenter.StrokesErased += InkPresenter_StrokesErased;
}
else if (inkToolbar.ActiveTool == toolButtonComment)
{
inkCanvas.InkPresenter.InputProcessingConfiguration.RightDragAction = InkInputRightDragAction.LeaveUnprocessed;
inkCanvas.InkPresenter.UnprocessedInput.PointerPressed += MakeComment;
}
}
public StrokeSynchronization(InkCanvas canvas, InkToolbar inkToolbar, StrokeChangeBroker strokeChangeBroker)
{
this.canvas = canvas;
this.inkToolbar = inkToolbar;
this.strokeChangeBroker = strokeChangeBroker;
strokeBuilder = new InkStrokeBuilder();
idToStrokeMapping = new Dictionary <Guid, InkStroke>();
strokeChangeBroker.StrokeCollected += StrokeChangeBrokerOnStrokeCollected;
strokeChangeBroker.StrokeErased += StrokeChangeBrokerOnStrokeErased;
strokeChangeBroker.AllStrokeErased += StrokeChangeBrokerOnAllStrokeErased;
strokeChangeBroker.ResendAllStrokesRequested += StrokeChangeBrokerOnResendAllStrokesRequested;
inkToolbar.EraseAllClicked += InkToolbarOnEraseAllClicked;
canvas.InkPresenter.StrokesCollected += InkPresenterOnStrokesCollected;
canvas.InkPresenter.StrokesErased += InkPresenterOnStrokesErased;
canvas.InkPresenter.StrokeInput.StrokeContinued += StrokeInput_StrokeContinued;
canvas.InkPresenter.StrokeInput.StrokeStarted += StrokeInput_StrokeStarted;
canvas.InkPresenter.StrokeInput.StrokeEnded += StrokeInput_StrokeEnded;
canvas.InkPresenter.StrokesCollected += InkPresenter_StrokesCollected;
points = new List <Point>();
}
private void ViewModelOnColoringLoadCompleted(object sender, EventArgs eventArgs)
{
CanvasViewbox.MaxHeight = ColoringHolderGrid.ActualHeight;
CanvasViewbox.MaxWidth = ColoringHolderGrid.ActualWidth;
Controller.InkScale = Controller.TemplateImageWidth / ColoringHolderGrid.ActualWidth;
InkToolbar.SetInkScaling(Controller.InkScale);
}
private async void inkToolbar_InkDrawingAttributesChanged(InkToolbar sender, object args)
{
// Change the color of the button icon for the calligraphic pen button
if (CalligraphicPenButton == inkToolbar.ActiveTool)
{
await ColorizeCustomButtonAsync(sender.InkDrawingAttributes.Color);
}
}
private void CurrentToolChanged(InkToolbar sender, object args)
{
bool enabled = sender.ActiveTool.Equals(toolButtonLasso);
ButtonCut.IsEnabled = enabled;
ButtonCopy.IsEnabled = enabled;
ButtonPaste.IsEnabled = enabled;
}
protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
base.OnNavigatingFrom(e);
MainGrid.Children.Remove(inkToolbar);
MainGrid.Children.Remove(inkCanvas);
//release the reference
inkToolbar = null;
inkCanvas = null;
}
public CanvasElements(InkCanvas can, InkToolbar tools,
CommandBar com, Button open, Button close)
{
canvas = can;
toolbar = tools;
commandBar = com;
openHamburger = open;
closeHamburger = close;
}
private void AddInkToolbar()
{
inkToolbar = new InkToolbar();
inkToolbar.TargetInkCanvas = inkCanvas;
inkToolbar.HorizontalAlignment = HorizontalAlignment.Center;
inkToolbar.VerticalAlignment = VerticalAlignment.Bottom;
inkToolbar.Margin = new Thickness(0, 0, 0, 105);
MainGrid.Children.Add(inkToolbar);
}
/// <inheritdoc />
protected override void OnApplyTemplate()
{
_canvasTextBoxTools = (StackPanel)GetTemplateChild(CanvasTextBoxToolsName);
this._canvasTextBoxColorPicker = (Windows.UI.Xaml.Controls.ColorPicker)GetTemplateChild(CanvasTextBoxColorPickerName);
_canvasTextBoxFontSizeTextBox = (TextBox)GetTemplateChild(CanvasTextBoxFontSizeTextBoxName);
_canvasTextBoxItalicButton = (ToggleButton)GetTemplateChild(CanvasTextBoxItalicButtonName);
_canvasTextBoxBoldButton = (ToggleButton)GetTemplateChild(CanvasTextBoxBoldButtonName);
_drawingSurfaceRenderer = (InfiniteCanvasVirtualDrawingSurface)GetTemplateChild(DrawingSurfaceRendererName);
_mainContainer = (Canvas)GetTemplateChild(MainContainerName);
_infiniteCanvasScrollViewer = (ScrollViewer)GetTemplateChild(InfiniteCanvasScrollViewerName);
_eraseAllButton = (Button)GetTemplateChild(EraseAllButtonName);
_canvasTextBox = (InfiniteCanvasTextBox)GetTemplateChild(CanvasTextBoxName);
_enableTextButton = (InkToolbarCustomToolButton)GetTemplateChild(EnableTextButtonName);
_enableTouchInkingButton = (InkToolbarCustomToggleButton)GetTemplateChild(EnableTouchInkingButtonName);
_inkCanvasToolBar = (InkToolbar)GetTemplateChild(InkCanvasToolBarName);
_canvasToolbarContainer = (StackPanel)GetTemplateChild(CanvasToolbarContainerName);
_inkCanvas = (InkCanvas)GetTemplateChild(DrawingInkCanvasName);
_undoButton = (Button)GetTemplateChild(UndoButtonName);
_redoButton = (Button)GetTemplateChild(RedoButtonName);
_fontColorIcon = (FontIcon)GetTemplateChild(FontColorIconName);
UnRegisterEvents();
RegisterEvents();
ConfigureControls();
if (double.IsNaN(_infiniteCanvasScrollViewer.Width))
{
if (ControlHelpers.IsXamlRootAvailable && _infiniteCanvasScrollViewer.XamlRoot != null)
{
_infiniteCanvasScrollViewer.Width = _infiniteCanvasScrollViewer.XamlRoot.Size.Width;
}
else
{
_infiniteCanvasScrollViewer.Width = Window.Current.Bounds.Width;
}
}
if (double.IsNaN(_infiniteCanvasScrollViewer.Height))
{
if (ControlHelpers.IsXamlRootAvailable && _infiniteCanvasScrollViewer.XamlRoot != null)
{
_infiniteCanvasScrollViewer.Height = _infiniteCanvasScrollViewer.XamlRoot.Size.Height;
}
else
{
_infiniteCanvasScrollViewer.Height = Window.Current.Bounds.Height;
}
}
base.OnApplyTemplate();
}
private void InkToolbar_InkDrawingAttributesChanged(InkToolbar sender, object args)
{
if (!this.inkToolBarInitialized && sender.InkDrawingAttributes != null)
{
this.LoadInkToolbarPreferences(this.ViewModel.InkToolbarPreferences);
this.inkToolBarInitialized = true;
return;
}
this.SaveInkToolbarPreferences(sender);
}
public void Init()
{
ShowSignBoard(false);
var toolbar = new InkToolbar();
InkToolbarContainer.Content = toolbar;
var canvas = new Microsoft.Toolkit.Wpf.UI.Controls.InkCanvas();
canvas.InkPresenter.InputDeviceTypes = CoreInputDeviceTypes.Mouse | CoreInputDeviceTypes.Touch | CoreInputDeviceTypes.Pen;
InkCanvasContainer.Content = canvas;
MapControlContainer.Content = MapControlHelper.Initialize();
}
private void InkTB_OnInkDrawingAttributesChanged(InkToolbar sender, object args)
{
var drawingAttributes = InkTB.InkDrawingAttributes;
if (ViewModel.IsLockColor)
{
drawingAttributes.Color = ViewModel.CustomOverrideColor;
}
else
{
PlainColorPicker.Color = sender.InkDrawingAttributes.Color;
}
drawingAttributes.IgnoreTilt = !Settings.EnablePenTilt;
drawingAttributes.FitToCurve = Settings.FitToCurve;
Ink.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
}
private void InkTB_OnActiveToolChanged(InkToolbar sender, object args)
{
if (ViewModel.IsLockColor)
{
var drawingAttributes = InkTB.InkDrawingAttributes;
drawingAttributes.Color = ViewModel.CustomOverrideColor;
Ink.InkPresenter.UpdateDefaultDrawingAttributes(drawingAttributes);
}
else
{
PlainColorPicker.Color = sender.InkDrawingAttributes.Color;
}
if (IsBoundRectPresent)
{
ClearSelection();
}
}
public DetailedCardPage()
{
this.InitializeComponent();
FrontGrid = frontGrid;
BackGrid = backGrid;
front = frontgrid;
back = backgrid;
fb = fbindicator;
frontbar = FrontInkBar;
backbar = BackInkBar;
FrontText = FrontTextBox;
BackText = BackTextBox;
FrontInk = FrontInkCanvas;
BackInk = BackInkCanvas;
showfront = showfrontstory;
showback = showbackstory;
fontsize = fontsizedrop;
FrontRESIZE = frontresize;
BackRESIZE = backresize;
}
protected override void OnNavigatedFrom(NavigationEventArgs e)
{
base.OnNavigatedFrom(e);
// Disable Back button.
SystemNavigationManager.GetForCurrentView().BackRequested -= ColoringPage_BackRequested;
// Deregister printer helper.
PrintHelper?.UnregisterForPrinting();
InkToolbar.UnregisterRadialController();
var display = DisplayInformation.GetForCurrentView();
display.DpiChanged -= Display_DpiChanged;
// Remove custom dial options.
RadialControlHelper?.Unregister();
Controller.CleanUp();
}
protected override void OnHandleDestroyed(EventArgs e)
{
base.OnHandleDestroyed(e);
if (this.DesignMode)
{
return;
}
if (_inkToolbar != null)
{
this.Controls.Remove(_inkToolbar);
_inkToolbar.Dispose();
_inkToolbar = null;
}
if (_inkCanvas != null)
{
this.Controls.Remove(_inkCanvas);
_inkCanvas.Dispose();
_inkCanvas = null;
}
}
private void SaveInkToolbarPreferences(InkToolbar sender)
{
if (!this.inkToolBarInitialized)
{
return;
}
var pencilButton = (InkToolbarPenButton)this.InkToolbar.GetToolButton(InkToolbarTool.Pencil);
this.ViewModel.InkToolbarPreferences.PencilWidth = pencilButton.SelectedStrokeWidth;
this.ViewModel.InkToolbarPreferences.PencilBrushIndex = pencilButton.SelectedBrushIndex;
var penButton = (InkToolbarPenButton)this.InkToolbar.GetToolButton(InkToolbarTool.BallpointPen);
this.ViewModel.InkToolbarPreferences.PenWidth = penButton.SelectedStrokeWidth;
this.ViewModel.InkToolbarPreferences.PenBrushIndex = penButton.SelectedBrushIndex;
var highlighterButton = (InkToolbarPenButton)this.InkToolbar.GetToolButton(InkToolbarTool.Highlighter);
this.ViewModel.InkToolbarPreferences.HighlighterWidth = highlighterButton.SelectedStrokeWidth;
this.ViewModel.InkToolbarPreferences.HighlighterBrushIndex = highlighterButton.SelectedBrushIndex;
}
//InkinkToolsChanged
private void InkToolbar_ActiveToolChanged(InkToolbar sender, object args)
{
if (BallPointPen_Button.IsChecked == true)
{
ViewModel.SelectedInkingToolIndex = 0;
ViewModel.SelectedPen = BallPointPen_Button;
}
else if (Pencil_Button.IsChecked == true)
{
ViewModel.SelectedInkingToolIndex = 1;
ViewModel.SelectedPen = Pencil_Button;
}
else if (Highlighter_Button.IsChecked == true)
{
ViewModel.SelectedInkingToolIndex = 2;
ViewModel.SelectedPen = Highlighter_Button;
}
else if (Laserpointer_Button.IsChecked == true)
{
ViewModel.SelectedInkingToolIndex = 3;
ViewModel.ActivateLaserpointer(InkCanvas_GeometrySketch, Ellipse_Laserpointer, TranslateTransform_Ellipse_Laserpointer);
}
else if (Eraser_Button.IsChecked == true)
{
ViewModel.SelectedInkingToolIndex = 4;
ViewModel.ActivateEraser(InkCanvas_GeometrySketch, Rectangle_Eraser, TranslateTransform_Rectangle_Eraser);
}
if (IsInkingToolAutoChanged != true)
{
LastInkingTool = ViewModel.SelectedInkingToolIndex;
}
GridView_Colors.DataContext = null;
ViewModel.PenAttributesChanged(PreviewInkStrokeCanvas);
GridView_Colors.DataContext = ViewModel.SelectedPen;
}
private void MainPage_Loaded(object sender, RoutedEventArgs e)
{
var display = DisplayInformation.GetForCurrentView();
display.DpiChanged += Display_DpiChanged;
Display_DpiChanged(display, null);
var maxSize = Math.Max(CanvasContainer.Width, CanvasContainer.Height);
ScrollViewer.MaxZoomFactor = MaxImageSize / System.Convert.ToSingle(maxSize);
#region multi stylus support
// Set supported inking device types.
InkCanvas.InkPresenter.InputDeviceTypes = Windows.UI.Core.CoreInputDeviceTypes.Pen | Windows.UI.Core.CoreInputDeviceTypes.Mouse;
// Phase 1: we need to discover the three user clicks with pen on the toolbar, we store only the unique stylus id (into Dictionary<int, InkDrawingAttributes> _stylusAttributes) and no InkDrawingAttributes because at this time user has still
// not choosen the tool and color. So in that phase we do have an entry on the _stylusAttributes with a key but with a null value
// get reference to inktoolbar buttons
InkToolbarBallpointPenButton penButton = InkToolbar.GetToolButton(InkToolbarTool.BallpointPen) as InkToolbarBallpointPenButton;
InkToolbarHighlighterButton highlighterButton = InkToolbar.GetToolButton(InkToolbarTool.Highlighter) as InkToolbarHighlighterButton;
InkToolbarPencilButton pencilButton = InkToolbar.GetToolButton(InkToolbarTool.Pencil) as InkToolbarPencilButton;
// subscribing to inktoolbar button events
// TODO: unsubscribe to all those events
if (penButton != null)
{
penButton.PointerEntered += this.OnConfigButtonPointerEntered;
penButton.Click += this.OnPenButtonClicked;
}
// TODO: unsubscribe to all those events
if (highlighterButton != null)
{
highlighterButton.PointerEntered += this.OnConfigButtonPointerEntered;
highlighterButton.Click += this.OnPenButtonClicked;
}
// TODO: unsubscribe to all those events
if (pencilButton != null)
{
pencilButton.PointerEntered += this.OnConfigButtonPointerEntered;
pencilButton.Click += this.OnPenButtonClicked;
}
this.InkToolbar.ActiveToolChanged += this.OnActiveToolbarToolChanged;
this.InkToolbar.InkDrawingAttributesChanged += this.OnToolbarAttributesChanged;
// Phase 1 (ConfigControl_PointerExited): Every time user select (or not) a new property we sotre it for its own unique stylus id
// Phase 2 (unprocessedInput.PointerHovered): when the user starts inking just a moment before the ink starts we get the unique stylus id from the PointerHovered
// we look into _stylusAttributes for the InkDrawingAttributes of that stylus and we apply to the InkCanvas.InkPresenter.UpdateDefaultDrawingAttributes
#endregion
// 1. Activate custom drawing
this.inkSynchronizer = InkCanvas.InkPresenter.ActivateCustomDrying();
InkCanvas.InkPresenter.SetPredefinedConfiguration(InkPresenterPredefinedConfiguration.SimpleMultiplePointer);
// 2. add use custom drawing when strokes are collected
InkCanvas.InkPresenter.StrokesCollected += InkPresenter_StrokesCollected;
// 3. Get the eraser button to handle custom dry ink and replace the erase all button with new logic
var eraser = InkToolbar.GetToolButton(InkToolbarTool.Eraser) as InkToolbarEraserButton;
if (eraser != null)
{
eraser.Checked += Eraser_Checked;
eraser.Unchecked += Eraser_Unchecked;
}
InkCanvas.InkPresenter.InputProcessingConfiguration.RightDragAction = InkInputRightDragAction.LeaveUnprocessed;
var unprocessedInput = InkCanvas.InkPresenter.UnprocessedInput;
unprocessedInput.PointerPressed += UnprocessedInput_PointerPressed;
unprocessedInput.PointerMoved += UnprocessedInput_PointerMoved;
unprocessedInput.PointerReleased += UnprocessedInput_PointerReleased;
unprocessedInput.PointerExited += UnprocessedInput_PointerExited;
unprocessedInput.PointerLost += UnprocessedInput_PointerLost;
unprocessedInput.PointerHovered += UnprocessedInput_PointerHovered;
this.eraseAllFlyout = FlyoutBase.GetAttachedFlyout(eraser) as Flyout;
if (this.eraseAllFlyout != null)
{
var button = this.eraseAllFlyout.Content as Button;
if (button != null)
{
var newButton = new Button();
newButton.Style = button.Style;
newButton.Content = button.Content;
newButton.Click += EraseAllInk;
this.eraseAllFlyout.Content = newButton;
}
}
this.InkCanvas.Holding += this.OnHolding;
}
private void InkToolbar_IsRulerButtonCheckedChanged(InkToolbar sender, object args)
{
var rulerButton = (InkToolbarRulerButton)InkToolbar.GetToggleButton(InkToolbarToggle.Ruler);
BringIntoViewButton.IsEnabled = rulerButton.IsChecked.Value;
}
private void InkToolbar_ActiveToolChanged(InkToolbar sender, object args)
{
textLogs.Text = "ActiveToolChanged\n" + textLogs.Text;
}
private void InkToolbar_InkDrawingAttributesChanged(InkToolbar sender, object args)
{
textLogs.Text = "InkDrawingAttributesChanged\n" + textLogs.Text;
}
private void InkToolbar_EraseAllClicked(InkToolbar sender, object args)
{
textLogs.Text = "EraseAllClicked\n" + textLogs.Text;
}
private void InkToolbar_IsStencilButtonCheckedChanged(InkToolbar sender, InkToolbarIsStencilButtonCheckedChangedEventArgs args)
{
textLogs.Text = $"IsStencilButtonCheckedChanged(Kind = {args.StencilKind}, IsChecked = {args.StencilButton.IsChecked.Value})\n" + textLogs.Text;
}
private void ActiveToolChanged(InkToolbar sender, object args)
{
SetActiveToolKind(AssociatedObject, sender.ActiveTool.ToolKind);
}
private void CurrentToolChanged(InkToolbar sender, object args)
{
bool enabled = sender.ActiveTool.Equals(toolButtonLasso);
ButtonCut.IsEnabled = enabled;
ButtonCopy.IsEnabled = enabled;
ButtonPaste.IsEnabled = enabled;
}
private void InkToolbar_EraseAllClicked(InkToolbar sender, object args)
{
textLogs.Text = "EraseAllClicked\n" + textLogs.Text;
}
private void InkToolbar_IsRulerButtonCheckedChanged(InkToolbar sender, object args)
{
textLogs.Text = "IsRulerButtonCheckedChanged\n" + textLogs.Text;
}
private void InkToolbar_ActiveToolChanged(InkToolbar sender, object args)
{
textLogs.Text = "ActiveToolChanged\n" + textLogs.Text;
}
private void OnActiveToolbarToolChanged(InkToolbar sender, object args)
{
this.SetStylusAttributes(this.activePointerId);
}
private void InkToolbarOnEraseAllClicked(InkToolbar sender, object args)
{
idToStrokeMapping.Clear();
strokeChangeBroker.SendEraseAllStrokes();
}
private void InkToolbar_InkDrawingAttributesChanged(InkToolbar sender, object args)
{
textLogs.Text = "InkDrawingAttributesChanged\n" + textLogs.Text;
}
