// Token: 0x06006D43 RID: 27971 RVA: 0x001F5D74 File Offset: 0x001F3F74
private EditingBehavior GetBehavior(InkCanvasEditingMode editingMode)
{
EditingBehavior result;
switch (editingMode)
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.GestureOnly:
case InkCanvasEditingMode.InkAndGesture:
result = this.InkCollectionBehavior;
break;
case InkCanvasEditingMode.Select:
result = this.SelectionEditor;
break;
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
result = this.EraserBehavior;
break;
default:
result = null;
break;
}
return(result);
}
// Token: 0x06006D64 RID: 28004 RVA: 0x001F6780 File Offset: 0x001F4980
protected override void OnActivate()
{
base.OnActivate();
InkCanvasEditingMode activeEditingMode = base.EditingCoordinator.ActiveEditingMode;
if (this._cachedEraseMode != activeEditingMode)
{
this._cachedEraseMode = activeEditingMode;
base.EditingCoordinator.InvalidateBehaviorCursor(this);
return;
}
if (activeEditingMode == InkCanvasEditingMode.EraseByPoint)
{
bool flag = this._cachedStylusShape != null;
if (flag && (this._cachedStylusShape.Width != base.InkCanvas.EraserShape.Width || this._cachedStylusShape.Height != base.InkCanvas.EraserShape.Height || this._cachedStylusShape.Rotation != base.InkCanvas.EraserShape.Rotation || this._cachedStylusShape.GetType() != base.InkCanvas.EraserShape.GetType()))
{
this.ResetCachedPointEraserCursor();
flag = false;
}
if (!flag)
{
base.EditingCoordinator.InvalidateBehaviorCursor(this);
}
}
}
// Token: 0x06006DB5 RID: 28085 RVA: 0x001F84DC File Offset: 0x001F66DC
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
switch (mode)
{
case InkCanvasEditingMode.None:
base.Commit(false);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.GestureOnly:
case InkCanvasEditingMode.InkAndGesture:
base.Commit(false);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
return;
case InkCanvasEditingMode.Select:
break;
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
base.Commit(false);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
return;
default:
return;
}
}
internal void RaiseInkChange(InkCanvasEditingMode inkCanvasEditingMode)
{
foreach (PDFRendererPageControl page_control in ObjPagesPanel.Children.OfType <PDFRendererPageControl>())
{
page_control.RaiseInkChange(inkCanvasEditingMode);
}
}
public void selectState(InkCanvas _InkCanvas, InkCanvasEditingMode _InkCanvasEditingMode, string _state)
{
if (duplicateButtonCheck)
{
duplicateButtonCheck = false;
}
_InkCanvas.EditingMode = _InkCanvasEditingMode;
setState(_state);
}
public StrokesAddedOrRemovedStroke(CommandStack commandStack, InkCanvasEditingMode editingMode, StrokeCollection added, StrokeCollection removed, int editingOperationCount)
: base(commandStack) {
_editingMode = editingMode;
_added = added;
_removed = removed;
_editingOperationCount = editingOperationCount;
}
private static bool ValidateEditingMode(object value)
{
InkCanvasEditingMode mode = (InkCanvasEditingMode)value;
return(mode == InkCanvasEditingMode.EraseByPoint ||
mode == InkCanvasEditingMode.EraseByStroke ||
mode == InkCanvasEditingMode.Ink ||
mode == InkCanvasEditingMode.None);
}
public ElementAddOrRem(CommandStack commandStack, InkCanvasEditingMode editingMode,
UIElementCollection added, UIElementCollection removed, int editingOperationCount)
: base(commandStack) {
_editingMode = editingMode;
_added = added;
_removed = removed;
_editingOperationCount = editingOperationCount;
}
/// <summary>
/// Returns true if the EditingMode is Select
/// </summary>
public object Convert(object o, Type type, object parameter, CultureInfo culture)
{
InkCanvasEditingMode editingMode = (InkCanvasEditingMode)o;
if (editingMode == InkCanvasEditingMode.Select)
{
return(true);
}
return(false);
}
public ExtendedInkTool(string ToolName,
InkCanvasEditingMode EditingMode,
Func <DynamicRenderer> DynamicRendererFunc = null,
Cursor Cursor = null)
{
this.ToolName = ToolName;
this.EditingMode = EditingMode;
this.Cursor = Cursor;
this.DynamicRendererFunc = DynamicRendererFunc;
}
public StrokesAddedOrRemovedCI(DoCommandStack commandStack, InkCanvasEditingMode editingMode, StrokeCollection added, StrokeCollection removed, int editingOperationCount)
: base(commandStack)
{
_editingMode = editingMode;
_added = added;
_removed = removed;
_editingOperationCount = editingOperationCount;
}
public ExtendedInkTool(string toolName,
InkCanvasEditingMode editingMode,
Func <DynamicRenderer> dynamicRendererFunc = null,
Cursor cursor = null)
{
ToolName = toolName;
EditingMode = editingMode;
Cursor = cursor;
DynamicRendererFunc = dynamicRendererFunc;
}
public ElementAddOrRem(CommandStack commandStack, InkCanvasEditingMode editingMode,
UIElementCollection added, UIElementCollection removed, int editingOperationCount)
: base(commandStack)
{
_editingMode = editingMode;
_added = added;
_removed = removed;
_editingOperationCount = editingOperationCount;
}
// Token: 0x06006DF2 RID: 28146 RVA: 0x001FA2CC File Offset: 0x001F84CC
internal void SwitchToMode(InkCanvasEditingMode mode)
{
this._disableInput = true;
try
{
this.OnSwitchToMode(mode);
}
finally
{
this._disableInput = false;
}
}
//-------------------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// Overrides SwitchToMode as the following expectations
/// 31. From Select To InkAndGesture
/// Lasso is discarded. After mode change ink is being collected, gesture event fires. If its not a gesture, StrokeCollected event fires.
/// 32. From Select To GestureOnly
/// Lasso is discarded. After mode change ink is being collected. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if its not a gesture.
/// 33. From Select To EraseByPoint
/// Lasso is discarded. PointErasing is performed after changing the mode.
/// 34. From Select To EraseByStroke
/// Lasso is discarded. StrokeErasing is performed after changing the mode.
/// 35. From Select To Ink
/// Ink collection starts when changing the mode.
/// 36. From Select To None
/// Nothing gets selected.
/// </summary>
/// <param name="mode"></param>
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");
switch (mode)
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.InkAndGesture:
case InkCanvasEditingMode.GestureOnly:
{
// Discard the lasso
Commit(false);
// Change the mode. The dynamic renderer will be reset automatically.
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
{
// Discard the lasso
Commit(false);
// Change the mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.Select:
{
Debug.Assert(false, "Cannot switch from Select to Select in mid-stroke");
break;
}
case InkCanvasEditingMode.None:
{
// Discard the lasso.
Commit(false);
// Change to the None mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
default:
Debug.Assert(false, "Unknown InkCanvasEditingMode!");
break;
}
}
internal void RaiseInkChange(InkCanvasEditingMode inkCanvasEditingMode)
{
ObjInkCanvas.EditingMode = inkCanvasEditingMode;
if (inkCanvasEditingMode == InkCanvasEditingMode.Ink)
{
ObjInkCanvas.Cursor = Cursors.Pen;
ObjInkCanvas.UseCustomCursor = true;
}
else
{
ObjInkCanvas.UseCustomCursor = false;
}
}
/// <summary>
/// Ensure the new InkCanvasEditingMode on the InkCanvas
/// </summary>
/// <param name="mode"></param>
private void EnsureEditingMode(InkCanvasEditingMode mode)
{
if (MyInkCanvas.EditingMode != mode)
{
MyInkCanvas.EditingMode = mode;
}
if ((mode == InkCanvasEditingMode.EraseByPoint || mode == InkCanvasEditingMode.EraseByStroke) &&
MyInkCanvas.EditingModeInverted != mode)
{
// We update the EditingModeInverted if the new mode is one of the erase modes.
MyInkCanvas.EditingModeInverted = mode;
}
}
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
if (value != null && parameter != null)
{
InkCanvasEditingMode expectedMode = (InkCanvasEditingMode)parameter;
InkCanvasEditingMode currentMode = (InkCanvasEditingMode)value;
// If the current EditingMode is the mode which menuitem is expecting, return true for IsChecked.
if (currentMode == expectedMode)
{
return(true);
}
}
return(DependencyProperty.UnsetValue);
}
/// <summary>
/// Change the ink mode option
/// </summary>
/// <param name="option"></param>
private void ChangeInkModeOption(OptionId option)
{
// Change the option setting.
SetValue(CurrentInkModeOptionPropertyKey, option);
// If the InkCanvas is under one of any inking mode, we need to update the new inking mode at once.
InkCanvasEditingMode currentEditingMode = MyInkCanvas.EditingMode;
if (currentEditingMode == InkCanvasEditingMode.Ink ||
currentEditingMode == InkCanvasEditingMode.InkAndGesture ||
currentEditingMode == InkCanvasEditingMode.GestureOnly)
{
EnsureEditingMode(_inkModeOptions[CurrentInkModeOption - OptionId.InkAndGesture]);
}
}
//--------------------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// Overrides SwitchToMode as the following expectations
/// 31. From Select To InkAndGesture
/// Lasso is discarded. After mode change ink is being collected, gesture event fires. If its not a gesture, StrokeCollected event fires.
/// 32. From Select To GestureOnly
/// Lasso is discarded. After mode change ink is being collected. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if its not a gesture.
/// 33. From Select To EraseByPoint
/// Lasso is discarded. PointErasing is performed after changing the mode.
/// 34. From Select To EraseByStroke
/// Lasso is discarded. StrokeErasing is performed after changing the mode.
/// 35. From Select To Ink
/// Ink collection starts when changing the mode.
/// 36. From Select To None
/// Nothing gets selected.
/// </summary>
/// <param name="mode"></param>
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");
switch ( mode )
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.InkAndGesture:
case InkCanvasEditingMode.GestureOnly:
{
// Discard the lasso
Commit(false);
// Change the mode. The dynamic renderer will be reset automatically.
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
{
// Discard the lasso
Commit(false);
// Change the mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.Select:
{
Debug.Assert(false, "Cannot switch from Select to Select in mid-stroke");
break;
}
case InkCanvasEditingMode.None:
{
// Discard the lasso.
Commit(false);
// Change to the None mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
default:
Debug.Assert(false, "Unknown InkCanvasEditingMode!");
break;
}
}
//-------------------------------------------------------------------------------
//
// Internal Methods
//
//-------------------------------------------------------------------------------
#region Internal Methods
/// <summary>
/// An internal method which performs a mode change in mid-stroke.
/// </summary>
/// <param name="mode"></param>
internal void SwitchToMode(InkCanvasEditingMode mode)
{
//
// The dispather frames can be entered. If one calls InkCanvas.Select/Paste from a dispather frame
// during the user editing, this method will be called. But before the method is processed completely,
// the user input could kick in AddStylusPoints. So EditingCoordinator.UserIsEditing flag may be messed up.
// Now we use _disableInput to disable the input during changing the mode in mid-stroke.
_disableInput = true;
try
{
OnSwitchToMode(mode);
}
finally
{
_disableInput = false;
}
}
//-------------------------------------------------------------------------------
//
// Internal Methods
//
//-------------------------------------------------------------------------------
#region Internal Methods
/// <summary>
/// An internal method which performs a mode change in mid-stroke.
/// </summary>
/// <param name="mode"></param>
internal void SwitchToMode(InkCanvasEditingMode mode)
{
// NTRAID:WINDOWSOS#1464481-2006/01/30/-WAYNEZEN,
// The dispather frames can be entered. If one calls InkCanvas.Select/Paste from a dispather frame
// during the user editing, this method will be called. But before the method is processed completely,
// the user input could kick in AddStylusPoints. So EditingCoordinator.UserIsEditing flag may be messed up.
// Now we use _disableInput to disable the input during changing the mode in mid-stroke.
_disableInput = true;
try
{
OnSwitchToMode(mode);
}
finally
{
_disableInput = false;
}
}
void OnToolChange(InkCanvasEditingMode Tool)
{
InkCanvas.EditingMode = Tool;
if (Tool == InkCanvasEditingMode.Ink)
{
InkCanvas.UseCustomCursor = true;
InkCanvas.Cursor = Cursors.Pen;
}
else
{
InkCanvas.UseCustomCursor = false;
}
InkCanvas.Background = new SolidColorBrush(Tool == InkCanvasEditingMode.None
? Colors.Transparent
: Color.FromArgb(1, 0, 0, 0));
}
protected override void OnActivate()
{
base.OnActivate();
InkCanvasEditingMode newEraseMode = EditingCoordinator.ActiveEditingMode;
Debug.Assert(newEraseMode == InkCanvasEditingMode.EraseByPoint ||
newEraseMode == InkCanvasEditingMode.EraseByStroke);
// Check whether we have to update cursor.
if (_cachedEraseMode != newEraseMode)
{
// EraseMode is changed
_cachedEraseMode = newEraseMode;
EditingCoordinator.InvalidateBehaviorCursor(this);
}
else if (newEraseMode == InkCanvasEditingMode.EraseByPoint)
{
// Invalidate the PointEraser if we don't have the cache yet.
bool isPointEraserCursorValid = _cachedStylusShape != null;
// NTRAID:WINDOWSOS#1673398-2006/05/23-WAYNEZEN,
// If the cached EraserShape is different from the current EraserShape, we shoud just reset the cache.
// The new cursor will be generated when it's needed later.
if (isPointEraserCursorValid &&
(_cachedStylusShape.Width != InkCanvas.EraserShape.Width ||
_cachedStylusShape.Height != InkCanvas.EraserShape.Height ||
_cachedStylusShape.Rotation != InkCanvas.EraserShape.Rotation ||
_cachedStylusShape.GetType() != InkCanvas.EraserShape.GetType()))
{
Debug.Assert(_cachedPointEraserCursor != null, "_cachedPointEraserCursor shouldn't be null.");
ResetCachedPointEraserCursor();
isPointEraserCursorValid = false;
}
if (!isPointEraserCursorValid)
{
// EraserShape is changed when the new mode is EraseByPoint
EditingCoordinator.InvalidateBehaviorCursor(this);
}
}
}
// Token: 0x06006D63 RID: 28003 RVA: 0x001F66D4 File Offset: 0x001F48D4
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
switch (mode)
{
case InkCanvasEditingMode.None:
base.Commit(true);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.GestureOnly:
case InkCanvasEditingMode.InkAndGesture:
base.Commit(true);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
return;
case InkCanvasEditingMode.Select:
{
StylusPointCollection stylusPointCollection = (this._stylusPoints != null) ? this._stylusPoints.Clone() : null;
base.Commit(true);
IStylusEditing stylusEditing = base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
if (stylusPointCollection != null && stylusEditing != null)
{
stylusEditing.AddStylusPoints(stylusPointCollection, false);
return;
}
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
base.Commit(true);
base.EditingCoordinator.ChangeStylusEditingMode(this, mode);
return;
default:
return;
}
}
/// <summary>
/// Change to the ink mode with a pen/highlighter setting.
/// </summary>
/// <param name="editingModeId"></param>
private void ChangeToInkMode(EditingModeId editingModeId)
{
// Ensure the ink Mode based on the current option.
InkCanvasEditingMode currentInkMode = _inkModeOptions[CurrentInkModeOption - OptionId.InkAndGesture];
EnsureEditingMode(currentInkMode);
// Get the Drawing Attributes which is associated to the pen/highlighter setting.
// Then update the InkCanvas' DefaultDrawingAttributes property.
DrawingAttributes da = DrawingAttributesCollection[editingModeId - EditingModeId.Pen1];
MyInkCanvas.DefaultDrawingAttributes = da;
// Update the read-only DependencyProperties so that the UI can react to the change correspondingly.
if (editingModeId >= EditingModeId.Pen1 && editingModeId <= EditingModeId.Pen5)
{
SetValue(SampleWindow.CurrentPenModePropertyKey, editingModeId);
}
else if (editingModeId >= EditingModeId.Highlighter1 && editingModeId <= EditingModeId.Highlighter5)
{
SetValue(SampleWindow.CurrentHighlighterModePropertyKey, editingModeId);
}
}
public void SetEditingMode(InkCanvasEditingMode mode)
{
EditingMode = mode;
}
public void SetMode(InkCanvasEditingMode mode, EditorMode customMode)
{
UpdateStrokeAndSetToNull();
_currentInkCanvas.EditingMode = mode;
_curEditorMode = customMode;
}
//-------------------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// Overrides SwitchToMode
/// As the following expected results
/// 1. From Ink To InkAndGesture
/// Packets between StylusDown and StylusUp are sent to the gesture reco. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
/// 2. From Ink To GestureOnly
/// Packets between StylusDown and StylusUp are send to the gesture reco. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if it’s not a gesture.
/// 3. From Ink To EraseByPoint
/// Stroke is discarded. PointErasing is performed after changing the mode.
/// 4. From Ink To EraseByStroke
/// Stroke is discarded. StrokeErasing is performed after changing the mode.
/// 5. From Ink To Select
/// Stroke is discarded. Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
/// 6. From Ink To None
/// Stroke is discarded.
/// 7. From InkAndGesture To Ink
/// Stroke is collected for all packets between StylusDown and StylusUp. Gesture event does not fire.
/// 8. From InkAndGesture To GestureOnly
/// Packets between StylusDown and StylusUp are sent to the gesture reco. Stroke gets removed on StylusUp even if it’s not a gesture.
/// 9. From InkAndGesture To EraseByPoint
/// Stroke is discarded. PointErasing is performed after changing the mode, gesture event does not fire.
/// 10. From InkAndGesture To EraseByStroke
/// Stroke is discarded. StrokeErasing is performed after changing the mode, gesture event does not fire.
/// 11. From InkAndGesture To Select
/// Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
/// 12. From InkAndGesture To None
/// Stroke is discarded, no gesture is recognized.
/// 13. From GestureOnly To InkAndGesture
/// Packets between StylusDown and StylusUp are sent to the gesture reco. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
/// 14. From GestureOnly To Ink
/// Stroke is collected. Gesture event does not fire.
/// 15. From GestureOnly To EraseByPoint
/// Stroke is discarded PointErasing is performed after changing the mode, gesture event does not fire
/// 16. From GestureOnly To EraseByStroke
/// Stroke is discarded. StrokeErasing is performed after changing the mode, gesture event does not fire.
/// 17. From GestureOnly To Select
/// Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
/// 18. From GestureOnly To None
/// Stroke is discarded. Gesture event does not fire.
/// </summary>
/// <param name="mode"></param>
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");
switch (mode)
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.InkAndGesture:
case InkCanvasEditingMode.GestureOnly:
{
// We are under one of those Ink modes now. Nothing to change here except raising the mode change event.
InkCanvas.RaiseActiveEditingModeChanged(new RoutedEventArgs(InkCanvas.ActiveEditingModeChangedEvent, InkCanvas));
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
{
// Discard the collected ink.
Commit(false);
// Change the Erase mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.Select:
{
// Make a copy of the current cached points.
StylusPointCollection cachedPoints = _stylusPoints != null?
_stylusPoints.Clone() : null;
// Discard the collected ink.
Commit(false);
// Change the Select mode
IStylusEditing newBehavior = EditingCoordinator.ChangeStylusEditingMode(this, mode);
if (cachedPoints != null
// NOTICE-2006/04/27-WAYNEZEN,
// EditingCoordinator.ChangeStylusEditingMode raises external event.
// The user code could take any arbitrary action for instance calling InkCanvas.ReleaseMouseCapture()
// So there is no guarantee that we could receive the newBehavior.
&& newBehavior != null)
{
// Now add the previous points to the lasso behavior
// The SelectionBehavior doesn't check userInitiated, pass false
// even if our _userInitiated flag is true
newBehavior.AddStylusPoints(cachedPoints, false /*userInitiated*/);
}
break;
}
case InkCanvasEditingMode.None:
{
// Discard the collected ink.
Commit(false);
// Change to the None mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
default:
Debug.Assert(false, "Unknown InkCanvasEditingMode!");
break;
}
}
//-------------------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// An abstract method which performs a mode change in mid-stroke.
/// </summary>
/// <param name="mode"></param>
protected abstract void OnSwitchToMode(InkCanvasEditingMode mode);
/// <summary>
/// The editing mode changed
/// </summary>
/// <param name="mode">Ink, Eraser, Select</param>
void Session_EditingModeChanged(InkCanvasEditingMode mode)
{
drawingCanvas.EditingMode = mode;
//drawingCanvas.EditingMode = InkCanvasEditingMode.None;
if (mode == InkCanvasEditingMode.Ink)
{
drawingCanvas.Cursor = Cursors.Pen;
}
else if (mode == InkCanvasEditingMode.Select)
{
drawingCanvas.Cursor = Cursors.Hand;
}
else if (mode == InkCanvasEditingMode.EraseByPoint || mode == InkCanvasEditingMode.EraseByStroke)
{
drawingCanvas.Cursor = Session.EraserCursor;
}
else
{
drawingCanvas.Cursor = Cursors.Arrow;
}
}
// Helper like Enum.IsDefined, for InkCanvasEditingMode.
internal static bool IsDefined(InkCanvasEditingMode InkCanvasEditingMode)
{
return(InkCanvasEditingMode >= InkCanvasEditingMode.None && InkCanvasEditingMode <= InkCanvasEditingMode.EraseByStroke);
}
private void SetEnable(bool enable, DrawMode mode)
{
_enable = enable;
_mode = mode;
InkCanvasEditingMode editingMode = InkCanvasEditingMode.Ink;
bool bUseCustomCursor = true;
switch (_mode)
{
case DrawMode.Select:
bUseCustomCursor = false;
editingMode = InkCanvasEditingMode.Select;
break;
case DrawMode.Pen:
editingMode = InkCanvasEditingMode.Ink;
break;
case DrawMode.Text:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Line:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Arrow:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Rectangle:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Circle:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Ray:
editingMode = InkCanvasEditingMode.None;
break;
case DrawMode.Erase:
bUseCustomCursor = false;
editingMode = InkCanvasEditingMode.EraseByStroke;
break;
default:
_mode = DrawMode.Select;
break;
}
MainInkCanvas.Cursor = _mode == DrawMode.Ray ? new Cursor(new MemoryStream(Properties.Resources.raycursor)) : Cursors.Cross;
if (_mode == DrawMode.Text)
{
if (FontIncreaseButton.Opacity == 0)
{
FontIncreaseButton.BeginAnimation(OpacityProperty, new DoubleAnimation(0, 1, Duration3));
}
if (FontReduceButton.Opacity == 0)
{
FontReduceButton.BeginAnimation(OpacityProperty, new DoubleAnimation(0, 1, Duration3));
}
}
else
{
if (FontIncreaseButton.Opacity == 1)
{
FontIncreaseButton.BeginAnimation(OpacityProperty, new DoubleAnimation(1, 0, Duration3));
}
if (FontReduceButton.Opacity == 1)
{
FontReduceButton.BeginAnimation(OpacityProperty, new DoubleAnimation(1, 0, Duration3));
}
}
MainInkCanvas.UseCustomCursor = bUseCustomCursor;
MainInkCanvas.EditingMode = editingMode;
EnableButton.IsChecked = !enable;
Background = Application.Current.Resources[enable ? "FakeTransparent" : "TrueTransparent"] as Brush;
SelectButton.IsChecked = _enable && _mode == DrawMode.Select;
PenButton.IsChecked = _enable && _mode == DrawMode.Pen;
TextButton.IsChecked = _enable && _mode == DrawMode.Text;
LineButton.IsChecked = _enable && _mode == DrawMode.Line;
ArrowButton.IsChecked = _enable && _mode == DrawMode.Arrow;
RectangleButton.IsChecked = _enable && _mode == DrawMode.Rectangle;
CircleButton.IsChecked = _enable && _mode == DrawMode.Circle;
RayButton.IsChecked = _enable && _mode == DrawMode.Ray;
EraserButton.IsChecked = _enable && _mode == DrawMode.Erase;
}
internal void RaiseInkChange(InkCanvasEditingMode inkCanvasEditingMode)
{
this.CanvasInk.RaiseInkChange(inkCanvasEditingMode);
}
private void RaiseInkChange(InkCanvasEditingMode inkCanvasEditingMode)
{
FeatureTrackingManager.Instance.UseFeature(Features.Document_ChangeInkEditingMode);
pdf_renderer_control.RaiseInkChange(inkCanvasEditingMode);
}
//--------------------------------------------------------------------------------
//
// Protected Methods
//
//--------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// An abstract method which performs a mode change in mid-stroke.
/// </summary>
/// <param name="mode"></param>
protected abstract void OnSwitchToMode(InkCanvasEditingMode mode);
private void SetMode(InkCanvasEditingMode _mode, CustomMode _CustomMode)
{
SetStroke();
_InkCanvas.EditingMode = _mode;
_CurCustomMode = _CustomMode;
}
// Token: 0x06006D31 RID: 27953 RVA: 0x001F5B60 File Offset: 0x001F3D60
internal IStylusEditing ChangeStylusEditingMode(StylusEditingBehavior sourceBehavior, InkCanvasEditingMode newMode)
{
if (this.IsInMidStroke && ((sourceBehavior != this.LassoSelectionBehavior && sourceBehavior == this.ActiveEditingBehavior) || (sourceBehavior == this.LassoSelectionBehavior && this.SelectionEditor == this.ActiveEditingBehavior)))
{
this.PopEditingBehavior();
EditingBehavior behavior = this.GetBehavior(this.ActiveEditingMode);
if (behavior != null)
{
this.PushEditingBehavior(behavior);
if (newMode == InkCanvasEditingMode.Select && behavior == this.SelectionEditor)
{
this.PushEditingBehavior(this.LassoSelectionBehavior);
}
}
else
{
this.ReleaseCapture(true);
}
this._inkCanvas.RaiseActiveEditingModeChanged(new RoutedEventArgs(InkCanvas.ActiveEditingModeChangedEvent, this._inkCanvas));
return(this.ActiveEditingBehavior as IStylusEditing);
}
return(null);
}
private void CB_PaintSize_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (DesignCanvas != null)
{
InkCanvasEditingMode emode = InkCanvasEditingMode.Ink;
if (DesignCanvas.EditingMode == InkCanvasEditingMode.EraseByPoint)
{
emode = InkCanvasEditingMode.EraseByPoint;
}
DesignCanvas.EditingMode = InkCanvasEditingMode.None;
switch (CB_PaintSize.SelectedIndex)
{
case 0:
DesignCanvas.DefaultDrawingAttributes.Width = 2;
DesignCanvas.DefaultDrawingAttributes.Height = 2;
DesignCanvas.EraserShape = new RectangleStylusShape(2, 2);
break;
case 1:
DesignCanvas.DefaultDrawingAttributes.Width = 4;
DesignCanvas.DefaultDrawingAttributes.Height = 4;
DesignCanvas.EraserShape = new RectangleStylusShape(4, 4);
break;
case 2:
DesignCanvas.DefaultDrawingAttributes.Width = 8;
DesignCanvas.DefaultDrawingAttributes.Height = 8;
DesignCanvas.EraserShape = new RectangleStylusShape(8, 8);
break;
case 3:
DesignCanvas.DefaultDrawingAttributes.Width = 12;
DesignCanvas.DefaultDrawingAttributes.Height = 12;
DesignCanvas.EraserShape = new RectangleStylusShape(12, 12);
break;
case 4:
DesignCanvas.DefaultDrawingAttributes.Width = 15;
DesignCanvas.DefaultDrawingAttributes.Height = 15;
DesignCanvas.EraserShape = new RectangleStylusShape(15, 15);
break;
case 5:
DesignCanvas.DefaultDrawingAttributes.Width = 18;
DesignCanvas.DefaultDrawingAttributes.Height = 18;
DesignCanvas.EraserShape = new RectangleStylusShape(18, 18);
break;
case 6:
DesignCanvas.DefaultDrawingAttributes.Width = 24;
DesignCanvas.DefaultDrawingAttributes.Height = 24;
DesignCanvas.EraserShape = new RectangleStylusShape(24, 24);
break;
case 7:
DesignCanvas.DefaultDrawingAttributes.Width = 30;
DesignCanvas.DefaultDrawingAttributes.Height = 30;
DesignCanvas.EraserShape = new RectangleStylusShape(30, 30);
break;
default:
DesignCanvas.DefaultDrawingAttributes.Width = 2;
DesignCanvas.DefaultDrawingAttributes.Height = 2;
DesignCanvas.EraserShape = new RectangleStylusShape(2, 2);
break;
}
DesignCanvas.EditingMode = emode;
}
}
// Helper like Enum.IsDefined, for InkCanvasEditingMode.
internal static bool IsDefined(InkCanvasEditingMode InkCanvasEditingMode)
{
return (InkCanvasEditingMode >= InkCanvasEditingMode.None && InkCanvasEditingMode <= InkCanvasEditingMode.EraseByStroke);
}
//-------------------------------------------------------------------------------
//
// Protected Methods
//
//-------------------------------------------------------------------------------
#region Protected Methods
/// <summary>
/// Overrides SwitchToMode as the following expectations
/// 19. From EraseByPoint To InkAndGesture
/// After mode change ink is being collected. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
/// 20. From EraseByPoint To GestureOnly
/// After mode change ink is being collected. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if it’s not a gesture.
/// 21. From EraseByPoint To Ink
/// Ink collection starts when changing the mode.
/// 22. From EraseByPoint To EraseByStroke
/// After mode change StrokeErasing is performed.
/// 23. From EraseByPoint To Select
/// Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected.
/// 24. From EraseByPoint To None
/// No erasing is performed after mode change.
/// 25. From EraseByStroke To InkAndGesture
/// After mode change ink is being collected. On StylusUp gesture event fires. If it’s not a gesture, StrokeCollected event fires.
/// 26. From EraseByStroke To GestureOnly
/// After mode change ink is being collected. On StylusUp gesture event fires. Stroke gets removed on StylusUp even if it’s not a gesture.
/// 27. From EraseByStroke To EraseByPoint
/// After mode change PointErasing is performed.
/// 28. From EraseByStroke To Ink
/// Ink collection starts when changing the mode.
/// 29. From EraseByStroke To Select
/// Lasso is drawn for all packets between StylusDown and StylusUp. Strokes/elements within the lasso will be selected
/// 30. From EraseByStroke To None
/// No erasing is performed after mode change.
/// </summary>
/// <param name="mode"></param>
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");
switch ( mode )
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.InkAndGesture:
case InkCanvasEditingMode.GestureOnly:
{
// Commit the current behavior
Commit(true);
// Change the mode. The dynamic renderer will be reset automatically.
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
{
Debug.Assert(_cachedEraseMode != mode);
// Commit the current behavior
Commit(true);
// Change the mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.Select:
{
// Make a copy of the current cached points.
StylusPointCollection cachedPoints = _stylusPoints != null ?
_stylusPoints.Clone() : null;
// Commit the current behavior.
Commit(true);
// Change the Select mode
IStylusEditing newBehavior = EditingCoordinator.ChangeStylusEditingMode(this, mode);
if ( cachedPoints != null
// NOTICE-2006/04/27-WAYNEZEN,
// EditingCoordinator.ChangeStylusEditingMode raises external event.
// The user code could take any arbitrary action for instance calling InkCanvas.ReleaseMouseCapture()
// So there is no guarantee that we could receive the newBehavior.
&& newBehavior != null )
{
// Now add the previous points to the lasso behavior
newBehavior.AddStylusPoints(cachedPoints, false/*userInitiated*/);
}
break;
}
case InkCanvasEditingMode.None:
{
// Discard the collected ink.
Commit(true);
// Change to the None mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
default:
Debug.Assert(false, "Unknown InkCanvasEditingMode!");
break;
}
}
protected override void OnSwitchToMode(InkCanvasEditingMode mode)
{
Debug.Assert(EditingCoordinator.IsInMidStroke, "SwitchToMode should only be called in a mid-stroke");
switch ( mode )
{
case InkCanvasEditingMode.Ink:
case InkCanvasEditingMode.InkAndGesture:
case InkCanvasEditingMode.GestureOnly:
{
// We are under one of those Ink modes now. Nothing to change here except raising the mode change event.
InkCanvas.RaiseActiveEditingModeChanged(new RoutedEventArgs(InkCanvas.ActiveEditingModeChangedEvent, InkCanvas));
break;
}
case InkCanvasEditingMode.EraseByPoint:
case InkCanvasEditingMode.EraseByStroke:
{
// Discard the collected ink.
Commit(false);
// Change the Erase mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
case InkCanvasEditingMode.Select:
{
// Make a copy of the current cached points.
StylusPointCollection cachedPoints = _stylusPoints != null ?
_stylusPoints.Clone() : null;
// Discard the collected ink.
Commit(false);
// Change the Select mode
IStylusEditing newBehavior = EditingCoordinator.ChangeStylusEditingMode(this, mode);
if ( cachedPoints != null
// NOTICE-2006/04/27-WAYNEZEN,
// EditingCoordinator.ChangeStylusEditingMode raises external event.
// The user code could take any arbitrary action for instance calling InkCanvas.ReleaseMouseCapture()
// So there is no guarantee that we could receive the newBehavior.
&& newBehavior != null)
{
// Now add the previous points to the lasso behavior
// The SelectionBehavior doesn't check userInitiated, pass false
// even if our _userInitiated flag is true
newBehavior.AddStylusPoints(cachedPoints, false/*userInitiated*/);
}
break;
}
case InkCanvasEditingMode.None:
{
// Discard the collected ink.
Commit(false);
// Change to the None mode
EditingCoordinator.ChangeStylusEditingMode(this, mode);
break;
}
default:
Debug.Assert(false, "Unknown InkCanvasEditingMode!");
break;
}
}
