public int PromoteAdjacentSegments(PathEditContext pathEditContext)
{
int partIndex = pathEditContext.PartIndex;
int index = partIndex;
PathFigureEditor figureEditor = this.PathEditorTarget.CreateFigureEditor(pathEditContext.FigureIndex);
bool flag = false;
if (figureEditor.GetPointKind(partIndex) != PathPointKind.Cubic && figureEditor.GetPointKind(partIndex) != PathPointKind.Start)
{
index = this.PromoteSegment(pathEditContext.FigureIndex, partIndex);
if (index != partIndex)
{
flag = true;
}
}
int num = figureEditor.GetLastIndexOfDownstreamSegment(index) % PathFigureUtilities.PointCount(figureEditor.PathFigure);
if (index != num && figureEditor.GetPointKind(num) != PathPointKind.Cubic && this.PromoteSegment(pathEditContext.FigureIndex, num) != num)
{
flag = true;
}
if (flag)
{
this.PathEditorTarget.EndEditing(false);
this.PathEditorTarget.BeginEditing();
}
return(index);
}
protected override void OnDrag(MouseDevice mouseDevice, double zoom)
{
Point point = PathFigureUtilities.GetPoint(this.PathEditContext.GetPathFigure(this.Path), this.PathEditContext.PartIndex);
Point point1 = this.geometryToDocument.Transform(point);
Point viewRootCoordinates = this.GetPointInViewRootCoordinates(mouseDevice, true);
Vector vector = viewRootCoordinates - point1;
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(vector, this.geometryToDocument, this.IsShiftDown ? this.AxisConstraint : (AxisConstraint)null);
if (this.hasMoved || Tolerances.HaveMoved(point1, viewRootCoordinates, zoom))
{
this.hasMoved = true;
PathGeometry path = this.Path;
int figureIndex = this.PathEditContext.FigureIndex;
int partIndex = this.PathEditContext.PartIndex;
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
PathFigureEditor pathFigureEditor = new PathFigureEditor(path.Figures[figureIndex]);
if (partIndex > 0 || PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure))
{
pathGeometryEditor.SetPoint(figureIndex, partIndex - 1, point - correspondingVector);
}
if (pathFigureEditor.GetLastIndexOfDownstreamSegment(partIndex) != partIndex)
{
pathGeometryEditor.SetPoint(figureIndex, partIndex + 1, point + correspondingVector);
}
if (partIndex == PathFigureUtilities.PointCount(pathFigureEditor.PathFigure) - 1 && PathFigureUtilities.IsOpen(pathFigureEditor.PathFigure))
{
this.LastTangent = vector;
}
this.PathEditorTarget.AddCriticalEdit();
}
base.OnDrag(mouseDevice, zoom);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
this.View.ViewModel.PathPartSelectionSet.SetSelection((PathPart) new PathPoint((SceneElement)this.PathEditorTarget.EditingElement, this.PathEditorTarget.PathEditMode, pathEditContext.FigureIndex, pathEditContext.PartIndex));
this.geometryToDocument = this.EditingElementTransformToRoot;
int figureIndex = pathEditContext.FigureIndex;
int num = pathEditContext.PartIndex;
PathFigureEditor pathFigureEditor = new PathFigureEditor(pathEditContext.GetPathFigure(this.Path));
Point point = pathFigureEditor.GetPoint(num);
int downstreamSegment = pathFigureEditor.GetLastIndexOfDownstreamSegment(num);
if (pathFigureEditor.GetPointKind(num) != PathPointKind.Cubic && pathFigureEditor.GetPointKind(num) != PathPointKind.Start || pathFigureEditor.GetPointKind(downstreamSegment) != PathPointKind.Cubic)
{
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
num = this.PromoteAdjacentSegments(pathEditContext);
pathFigureEditor = new PathFigureEditor(pathGeometryEditor.PathGeometry.Figures[figureIndex]);
this.PathEditContext = new PathEditContext(figureIndex, num);
this.View.ViewModel.PathPartSelectionSet.SetSelection((PathPart) new PathPoint((SceneElement)this.PathEditorTarget.EditingElement, this.PathEditorTarget.PathEditMode, this.PathEditContext.FigureIndex, this.PathEditContext.PartIndex));
}
if (this.zeroTangents)
{
if ((num > 0 || PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure)) && !VectorUtilities.ArePathPointsVeryClose(pathFigureEditor.GetPoint(num), pathFigureEditor.GetPoint(num - 1)))
{
this.BeginEditing().SetPoint(figureIndex, num - 1, point);
}
if (pathFigureEditor.GetLastIndexOfDownstreamSegment(num) != num && !VectorUtilities.ArePathPointsVeryClose(pathFigureEditor.GetPoint(num), pathFigureEditor.GetPoint(num + 1)))
{
this.BeginEditing().SetPoint(figureIndex, num + 1, point);
}
if (num == PathFigureUtilities.PointCount(pathFigureEditor.PathFigure) - 1 && PathFigureUtilities.IsOpen(pathFigureEditor.PathFigure))
{
this.LastTangent = new Vector(0.0, 0.0);
}
}
base.OnBegin(pathEditContext, mouseDevice);
}
public void Execute(ICollection <PathPart> pathPartSelection)
{
this.SplitComponentsByFigure(pathPartSelection);
for (int figureIndex = this.pathEditorTarget.PathGeometry.Figures.Count - 1; figureIndex >= 0; --figureIndex)
{
List <int> segmentsByFigure = this.selectedSegments[figureIndex];
List <int> pointsByFigure = this.selectedPoints[figureIndex];
segmentsByFigure.Sort();
segmentsByFigure.Reverse();
pointsByFigure.Sort();
pointsByFigure.Reverse();
if (segmentsByFigure.Count == 0)
{
this.RemovePointsByFigure(figureIndex, pointsByFigure);
}
else
{
if (PathFigureUtilities.IsClosed(this.pathEditorTarget.PathGeometry.Figures[figureIndex]))
{
this.OpenFigureAndShiftIndices(figureIndex, segmentsByFigure, pointsByFigure);
}
this.RemovePointsAndSegmentsFromOpenFigure(figureIndex, segmentsByFigure, pointsByFigure);
}
if (PathFigureUtilities.IsIsolatedPoint(this.pathEditorTarget.PathGeometry.Figures[figureIndex]))
{
this.pathEditorTarget.CreateGeometryEditor().RemoveFigure(figureIndex);
}
}
}
private void OpenFigureAndShiftIndices(int figureIndex, List <int> segmentsByFigure, List <int> pointsByFigure)
{
PathFigureEditor figureEditor = this.pathEditorTarget.CreateFigureEditor(figureIndex);
int pointIndex = segmentsByFigure[0];
figureEditor.Open(pointIndex);
if (pointIndex == 0)
{
int num = PathFigureUtilities.PointCount(figureEditor.PathFigure) - 1;
segmentsByFigure[0] = num;
}
else
{
int num = PathFigureUtilities.PointCount(figureEditor.PathFigure) - 1 - pointIndex;
for (int index = 0; index < segmentsByFigure.Count; ++index)
{
segmentsByFigure[index] = segmentsByFigure[index] + num;
}
for (int index = 0; index < pointsByFigure.Count; ++index)
{
pointsByFigure[index] = pointsByFigure[index] < pointIndex ? pointsByFigure[index] + num : pointsByFigure[index] - pointIndex;
}
}
segmentsByFigure.Sort();
segmentsByFigure.Reverse();
pointsByFigure.Sort();
pointsByFigure.Reverse();
}
protected override void CreatePathAdorners(List <Adorner> oldAdornerList, List <Adorner> newAdornerList)
{
base.CreatePathAdorners(oldAdornerList, newAdornerList);
this.lastTangentAdorner = (PenTangentAdorner)null;
this.activeSegmentAdornerIndex = -1;
this.activePointAdornerIndex = -1;
if (!this.IsActive || this.AdornerList.Count <= 0 || (this.PathGeometry == null || this.PathGeometry.Figures.Count <= 0))
{
return;
}
int index1 = this.ActiveFigureIndex;
if (index1 < 0 || index1 >= this.PathGeometry.Figures.Count)
{
index1 = 0;
}
PathFigure figure = this.PathGeometry.Figures[index1];
int num = !PathFigureUtilities.IsClosed(figure) ? PathFigureUtilities.PointCount(figure) - 1 : 0;
PathPointAdorner pathPointAdorner1 = (PathPointAdorner)null;
for (int index2 = 0; index2 < this.AdornerList.Count; ++index2)
{
Adorner adorner = this.AdornerList[index2];
PathPointAdorner pathPointAdorner2 = adorner as PathPointAdorner;
if (pathPointAdorner2 != null)
{
if (pathPointAdorner2.FigureIndex == this.ActiveFigureIndex && pathPointAdorner2.PointIndex == num)
{
pathPointAdorner2.IsActive = true;
pathPointAdorner1 = pathPointAdorner2;
this.activePointAdornerIndex = index2;
}
else
{
pathPointAdorner2.IsActive = false;
}
}
PathSegmentAdorner pathSegmentAdorner = adorner as PathSegmentAdorner;
if (pathSegmentAdorner != null)
{
if (pathSegmentAdorner.FigureIndex == this.ActiveFigureIndex && pathSegmentAdorner.LastPointIndex == num)
{
pathSegmentAdorner.IsActive = true;
this.activeSegmentAdornerIndex = index2;
}
else
{
pathSegmentAdorner.IsActive = false;
}
}
}
if (pathPointAdorner1 == null || PathFigureUtilities.IsClosed(this.PathGeometry.Figures[this.ActiveFigureIndex]))
{
return;
}
this.lastTangentAdorner = new PenTangentAdorner(pathPointAdorner1);
newAdornerList.Add((Adorner)this.lastTangentAdorner);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
this.ViewModel.PathPartSelectionSet.SetSelection((PathPart) new PathPoint((SceneElement)this.PathEditorTarget.EditingElement, this.PathEditorTarget.PathEditMode, pathEditContext.FigureIndex, pathEditContext.PartIndex));
Point point = PathFigureUtilities.GetPoint(pathEditContext.GetPathFigure(this.Path), pathEditContext.PartIndex);
Matrix elementTransformToRoot = this.EditingElementTransformToRoot;
this.Initialize(elementTransformToRoot.Transform(point), false, elementTransformToRoot);
base.OnBegin(pathEditContext, mouseDevice);
}
protected override void OnDrag(MouseDevice mouseDevice, double zoom)
{
this.currentTangentPoint = this.GetPointInViewRootCoordinates(mouseDevice, true);
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(this.currentTangentPoint - this.currentNodePoint, this.geometryToDocument, this.IsShiftDown ? this.AxisConstraint : (AxisConstraint)null);
Vector lastTangent = this.LastTangent;
this.LastTangent = correspondingVector;
PathFigure pathFigure = this.PathEditContext.GetPathFigure(this.Path);
PathFigureEditor pathFigureEditor = pathFigure == null ? (PathFigureEditor)null : new PathFigureEditor(pathFigure);
if (pathFigureEditor != null && !PathFigureUtilities.IsIsolatedPoint(pathFigureEditor.PathFigure))
{
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
bool flag = PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure);
int index = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure) - (flag ? 0 : 1);
Point point1 = pathFigureEditor.GetPoint(index - 1);
Point point2 = pathFigureEditor.GetPoint(index);
if (pathFigureEditor.GetPointKind(index) == PathPointKind.Line)
{
pathGeometryEditor.RemoveLastSegmentOfFigure(this.PathEditContext.FigureIndex);
if (flag)
{
pathGeometryEditor.CloseFigureWithCubicBezier(point1, point2, this.PathEditContext.FigureIndex);
}
else
{
pathGeometryEditor.AppendCubicBezier(point1, point2, point2, this.PathEditContext.FigureIndex);
}
pathFigureEditor = new PathFigureEditor(this.PathEditContext.GetPathFigure(this.Path));
}
if (!this.IsAltDown)
{
if (!this.areTangentsSymmetric)
{
double length = this.LastTangent.Length;
if (length > 0.0)
{
int num1 = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure);
double num2 = (pathFigureEditor.GetPoint(num1 - 1) - pathFigureEditor.GetPoint(num1 - 2)).Length / length;
pathGeometryEditor.SetPoint(this.PathEditContext.FigureIndex, num1 - 2, point2 - num2 * this.LastTangent);
}
}
else
{
int pointIndex = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure) - (PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure) ? 1 : 2);
pathGeometryEditor.SetPoint(this.PathEditContext.FigureIndex, pointIndex, point2 - this.LastTangent);
}
}
if (PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure) && pathFigureEditor.GetPointKind(3) == PathPointKind.Cubic && this.areTangentsSymmetric)
{
pathGeometryEditor.SetPoint(this.PathEditContext.FigureIndex, 1, point2 + this.LastTangent);
}
this.PathEditorTarget.AddCriticalEdit();
}
base.OnDrag(mouseDevice, zoom);
}
private PenAction GetAction(PathPartAdorner adorner)
{
PenAction penAction = (PenAction)null;
PathSegmentAdorner pathSegmentAdorner = adorner as PathSegmentAdorner;
PathEditorTarget pathEditorTarget = (PathEditorTarget)null;
if (adorner != null)
{
pathEditorTarget = adorner.PathAdornerSet.PathEditorTarget;
}
if (pathSegmentAdorner != null)
{
penAction = (PenAction) new InsertAction(pathEditorTarget, this.ActiveSceneViewModel);
}
else
{
PathPointAdorner pathPointAdorner = adorner as PathPointAdorner;
if (pathPointAdorner != null)
{
penAction = (PenAction) new DeletePointAction(pathEditorTarget, this.ActiveSceneViewModel);
PathFigure figure1 = pathEditorTarget.PathGeometry.Figures[pathPointAdorner.FigureIndex];
if (PathFigureUtilities.IsOpen(figure1) && !PathFigureUtilities.IsIsolatedPoint(figure1))
{
bool flag1 = pathPointAdorner.PointIndex == 0;
bool flag2 = pathPointAdorner.PointIndex == PathFigureUtilities.PointCount(figure1) - 1;
bool flag3 = pathPointAdorner.PathAdornerSet.PathEditorTarget == this.pathEditorTarget;
bool flag4 = this.pathEditContext != null && pathPointAdorner.FigureIndex == this.pathEditContext.FigureIndex;
bool flag5 = this.pathEditorTarget != null && pathPointAdorner.PathAdornerSet.PathEditorTarget.PathEditMode == this.pathEditorTarget.PathEditMode;
bool flag6 = pathPointAdorner.PathAdornerSet.PathEditorTarget.PathEditMode == PathEditMode.ScenePath;
PathFigure figure2 = this.pathEditContext == null || this.pathEditorTarget == null ? (PathFigure)null : this.pathEditContext.GetPathFigure(this.pathEditorTarget.PathGeometry);
bool flag7 = figure2 != null && PathFigureUtilities.IsOpen(figure2);
bool flag8 = (flag3 && !flag4 || flag5 && flag6) && flag7;
if (flag1)
{
penAction = !flag3 || !flag4 ? (!flag8 ? (PenAction) new ExtendAction(pathEditorTarget, this.ActiveSceneViewModel) : (PenAction) new JoinAction(pathEditorTarget, this.ActiveSceneViewModel, this.pathEditorTarget, this.pathEditContext)) : (PenAction) new CloseAction(pathEditorTarget, this.ActiveSceneViewModel);
}
else if (flag2)
{
penAction = !flag3 || !flag4 ? (!flag8 ? (PenAction) new ExtendAction(pathEditorTarget, this.ActiveSceneViewModel) : (PenAction) new JoinAction(pathEditorTarget, this.ActiveSceneViewModel, this.pathEditorTarget, this.pathEditContext)) : (PenAction) new AdjustAction(pathEditorTarget, this.ActiveSceneViewModel);
}
}
if (PathFigureUtilities.IsIsolatedPoint(figure1) && this.pathEditContext == null)
{
penAction = (PenAction) new ExtendAction(pathEditorTarget, this.ActiveSceneViewModel);
}
}
}
if (penAction == null)
{
penAction = !this.IsActive || this.pathEditorTarget == null || (this.pathEditorTarget.PathGeometry.Figures.Count <= 0 || this.pathEditorTarget.PathGeometry.Figures[this.pathEditorTarget.PathGeometry.Figures.Count - 1].IsClosed) ? (PenAction) new StartAction(this, (PathEditorTarget)null, this.ActiveSceneViewModel) : (PenAction) new AppendAction(this.pathEditorTarget, this.ActiveSceneViewModel);
}
return(penAction);
}
private void RemovePointsAndSegmentsFromOpenFigure(int figureIndex, List <int> segmentsByFigure, List <int> pointsByFigure)
{
PathGeometryEditor geometryEditor = this.pathEditorTarget.CreateGeometryEditor();
int index1 = 0;
int index2 = 0;
while (index1 < segmentsByFigure.Count || index2 < pointsByFigure.Count)
{
int pointIndex1 = -1;
int pointIndex2 = -1;
if (index1 < segmentsByFigure.Count)
{
pointIndex1 = segmentsByFigure[index1];
}
if (index2 < pointsByFigure.Count)
{
pointIndex2 = pointsByFigure[index2];
}
int num = PathFigureUtilities.PointCount(geometryEditor.PathGeometry.Figures[figureIndex]) - 1;
if (pointIndex2 == num || pointIndex1 == num)
{
geometryEditor.RemoveLastSegmentOfFigure(figureIndex);
if (pointIndex2 == num)
{
++index2;
}
if (pointIndex1 == num)
{
++index1;
}
}
else if (pointIndex1 > pointIndex2)
{
geometryEditor.SplitFigure(figureIndex, pointIndex1);
geometryEditor.RemoveLastSegmentOfFigure(figureIndex);
++index1;
}
else if (pointIndex1 < pointIndex2)
{
geometryEditor.RemovePoint(figureIndex, pointIndex2);
++index2;
}
else
{
geometryEditor.SplitFigure(figureIndex, pointIndex2);
geometryEditor.RemoveLastSegmentOfFigure(figureIndex);
geometryEditor.RemoveFirstSegmentOfFigure(geometryEditor.PathGeometry.Figures.Count - 1);
++index2;
++index1;
}
}
}
protected override void DoDelete(PathEditContext pathEditContext)
{
PathFigure pathFigure = pathEditContext.GetPathFigure(this.Path);
PathFigureEditor pathFigureEditor = new PathFigureEditor(pathFigure);
int index1 = PathFigureUtilities.PointCount(pathFigure) - (PathFigureUtilities.IsClosed(pathFigure) ? 0 : 1);
if (pathFigureEditor.GetPointKind(index1) == PathPointKind.Cubic)
{
int index2 = index1 - 3;
this.LastTangent = pathFigureEditor.GetPoint(index2 + 1) - pathFigureEditor.GetPoint(index2);
}
this.BeginEditing().RemoveLastSegmentOfFigure(pathEditContext.FigureIndex);
}
public static List <PathElement> ReleaseCompoundPaths(PathElement pathElement, SceneEditTransaction editTransaction)
{
List <PathElement> list = new List <PathElement>();
PathGeometry pathGeometry1 = pathElement.PathGeometry;
Transform geometryTransform = pathElement.GeometryTransform;
ISceneNodeCollection <SceneNode> collectionContainer = pathElement.GetCollectionContainer();
int num = collectionContainer.IndexOf((SceneNode)pathElement);
int oldFigureIndex = 0;
foreach (PathFigure original in pathGeometry1.Figures)
{
PathFigure pathFigure = PathFigureUtilities.Copy(original, geometryTransform);
PathGeometry pathGeometry2 = new PathGeometry();
if (pathGeometry1.Transform != null && pathGeometry1.Transform.Value != Matrix.Identity)
{
pathGeometry2.Transform = pathGeometry1.Transform.Clone();
}
if (pathGeometry2.FillRule != pathGeometry1.FillRule)
{
pathGeometry2.FillRule = pathGeometry1.FillRule;
}
pathGeometry2.Figures.Add(pathFigure);
DocumentNode node = pathElement.DocumentNode.Clone(pathElement.DocumentContext);
PathElement pathElement1 = (PathElement)pathElement.ViewModel.GetSceneNode(node);
collectionContainer.Insert(num++, (SceneNode)pathElement1);
Rect extent = pathGeometry2.Bounds;
extent = PathCommandHelper.InflateRectByStrokeWidth(extent, pathElement1, false);
Vector vector = new Vector(-extent.Left, -extent.Top);
PathCommandHelper.ReplacePathGeometry(pathElement1, pathGeometry2, editTransaction);
Matrix transformToElement = pathElement.GetComputedTransformToElement((SceneElement)pathElement1);
transformToElement.OffsetX += vector.X;
transformToElement.OffsetY += vector.Y;
PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(pathElement.Platform);
PathCommandHelper.TransferPathFigureAnimations(pathElement, pathElement1, propertyReference, oldFigureIndex, 0, (Transform) new MatrixTransform(transformToElement));
PathCommandHelper.AdjustPathForAnimations(pathElement1, editTransaction);
list.Add(pathElement1);
++oldFigureIndex;
}
string name = pathElement.Name;
pathElement.ViewModel.ElementSelectionSet.RemoveSelection((SceneElement)pathElement);
pathElement.ViewModel.AnimationEditor.DeleteAllAnimationsInSubtree((SceneElement)pathElement);
pathElement.Remove();
foreach (SceneNode sceneNode in list)
{
sceneNode.Name = name;
}
return(list);
}
private void DeleteIsolatedPoint(PathEditContext pathEditContext)
{
if (!PathFigureUtilities.IsIsolatedPoint(pathEditContext.GetPathFigure(this.Path)))
{
return;
}
if (this.Path.Figures.Count > 1)
{
this.BeginEditing().RemoveFigure(pathEditContext.FigureIndex);
}
else
{
this.RemovePath();
}
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
this.DoPreDelete();
if (!PathFigureUtilities.IsIsolatedPoint(pathEditContext.GetPathFigure(this.Path)))
{
this.DoDelete(pathEditContext);
if (this.PathEditorTarget.PathEditMode == PathEditMode.MotionPath)
{
this.DeleteIsolatedPoint(pathEditContext);
}
}
else
{
this.DeleteIsolatedPoint(pathEditContext);
}
base.OnBegin(pathEditContext, mouseDevice);
this.End();
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
Point point = PathFigureUtilities.FirstPoint(pathEditContext.GetPathFigure(this.Path));
Matrix elementTransformToRoot = this.EditingElementTransformToRoot;
if (VectorUtilities.IsZero(this.LastTangent))
{
pathGeometryEditor.CloseFigureWithLineSegment(pathEditContext.FigureIndex);
}
else
{
Point q = this.GetLastPoint(pathEditContext.FigureIndex) + this.LastTangent;
pathGeometryEditor.CloseFigureWithCubicBezier(q, point, pathEditContext.FigureIndex);
}
this.Initialize(elementTransformToRoot.Transform(point), true, elementTransformToRoot);
base.OnBegin(pathEditContext, mouseDevice);
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
PerformanceUtility.MeasurePerformanceUntilRender(PerformanceEvent.EditPath);
Vector lastTangent = this.LastTangent;
base.OnBegin(pathEditContext, mouseDevice);
PathGeometryEditor pathGeometryEditor = this.BeginEditing();
Matrix elementTransformToRoot = this.EditingElementTransformToRoot;
Point lastPoint = this.GetLastPoint(pathEditContext.FigureIndex);
Point point1 = elementTransformToRoot.Transform(lastPoint);
Vector vector = this.GetPointInViewRootCoordinates(mouseDevice, true) - point1;
Size devicePixelSize = DeviceUtilities.GetDevicePixelSize(this.View.Zoom);
if (Math.Abs(vector.X) < devicePixelSize.Width / 2.0)
{
vector.X = 0.0;
}
if (Math.Abs(vector.Y) < devicePixelSize.Height / 2.0)
{
vector.Y = 0.0;
}
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(vector, elementTransformToRoot, this.IsShiftDown ? this.AxisConstraint : (AxisConstraint)null);
Point point2 = lastPoint + correspondingVector;
if (VectorUtilities.IsZero(lastTangent))
{
pathGeometryEditor.AppendLineSegment(point2, pathEditContext.FigureIndex);
}
else
{
Point q = lastPoint + lastTangent;
pathGeometryEditor.AppendCubicBezier(q, point2, point2, pathEditContext.FigureIndex);
}
int figureIndex = pathEditContext.FigureIndex;
PathFigure figure = this.Path.Figures[figureIndex];
this.PathEditContext = new PathEditContext(figureIndex, PathFigureUtilities.PointCount(figure) - 1);
this.Initialize(elementTransformToRoot.Transform(point2), true, elementTransformToRoot);
}
public static void UpdateAllPoints(PathGeometry geometry, Transform transform)
{
for (int index1 = 0; index1 < geometry.Figures.Count; ++index1)
{
PathFigure figure = geometry.Figures[index1];
PathFigureEditor pathFigureEditor = new PathFigureEditor(figure);
int index2 = 1;
if (!PathFigureUtilities.IsClosed(figure) || !PathFigureUtilities.IsCloseSegmentDegenerate(figure))
{
pathFigureEditor.SetPoint(0, transform.Transform(figure.StartPoint));
}
for (int index3 = 0; index3 < figure.Segments.Count; ++index3)
{
System.Windows.Media.PathSegment segment = figure.Segments[index3];
int pointCount = PathSegmentUtilities.GetPointCount(segment);
for (int index4 = 0; index4 < pointCount; ++index4)
{
Point point = PathSegmentUtilities.GetPoint(segment, index4);
pathFigureEditor.SetPoint(index2, transform.Transform(point));
++index2;
}
}
}
}
private void SubdivideSegment(PathGeometry oldGeometry, int figure, int segment, int pointIndex, double parameter, Dictionary <TimelineSceneNode, StoryboardTimelineSceneNode> subdivisionProperties)
{
PropertyReference propertyReference1 = new PropertyReference(this.pathProperty).Append(PathElement.FiguresProperty).Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathFigureCollection, figure));
PropertyReference propertyReference2 = propertyReference1.Append(PathElement.PathFigureSegmentsProperty);
PropertyReference propertyReference3 = segment != oldGeometry.Figures[figure].Segments.Count ? propertyReference2.Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathSegmentCollection, segment)) : propertyReference1.Append(PathElement.PathFigureStartPointProperty);
PropertyReference propertyReference4;
if (segment == 0)
{
propertyReference4 = propertyReference1.Append(PathElement.PathFigureStartPointProperty);
}
else
{
ReferenceStep step = (ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathSegmentCollection, segment - 1);
propertyReference4 = propertyReference2.Append(step).Append(this.LastPointProperty(oldGeometry.Figures[figure].Segments[segment - 1]));
}
PropertyReference propertyReference5 = (PropertyReference)null;
if (segment == oldGeometry.Figures[figure].Segments.Count - 1 && PathFigureUtilities.IsClosed(oldGeometry.Figures[figure]) && PathFigureUtilities.IsCloseSegmentDegenerate(oldGeometry.Figures[figure]))
{
propertyReference5 = propertyReference1.Append(PathElement.PathFigureStartPointProperty);
}
foreach (StoryboardTimelineSceneNode timelineSceneNode1 in this.targetElement.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(this.targetElement.StoryboardContainer))
{
Dictionary <double, List <KeyFrameSceneNode> > keyFrames1 = new Dictionary <double, List <KeyFrameSceneNode> >();
foreach (KeyValuePair <TimelineSceneNode, StoryboardTimelineSceneNode> keyValuePair in subdivisionProperties)
{
if (keyValuePair.Value == timelineSceneNode1)
{
KeyFrameAnimationSceneNode keyFrameNode = keyValuePair.Key as KeyFrameAnimationSceneNode;
if (keyFrameNode != null)
{
this.RecordKeyFrames(keyFrames1, keyFrameNode);
}
}
}
Dictionary <double, List <KeyFrameSceneNode> > keyFrames2 = new Dictionary <double, List <KeyFrameSceneNode> >();
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
if (timelineSceneNode2.TargetElement == this.targetElement && timelineSceneNode2.TargetProperty != null && (propertyReference3.Equals((object)timelineSceneNode2.TargetProperty) || propertyReference3.IsPrefixOf(timelineSceneNode2.TargetProperty) || propertyReference4.Equals((object)timelineSceneNode2.TargetProperty) || propertyReference5 != null && propertyReference5.Equals((object)timelineSceneNode2.TargetProperty)))
{
KeyFrameAnimationSceneNode keyFrameNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (keyFrameNode != null)
{
this.RecordKeyFrames(keyFrames2, keyFrameNode);
}
}
}
foreach (KeyValuePair <double, List <KeyFrameSceneNode> > keyValuePair in keyFrames2)
{
PathGeometry path = oldGeometry.Clone();
PathGeometryEditor pathGeometryEditor = new PathGeometryEditor(path);
foreach (KeyFrameSceneNode keyFrameSceneNode in keyValuePair.Value)
{
PropertyReference propertyReference6 = this.targetElement.ViewModel.DefaultView.ConvertToWpfPropertyReference(keyFrameSceneNode.TargetProperty.Subreference(1));
object valueToSet = this.targetElement.ViewModel.DefaultView.ConvertToWpfValue(keyFrameSceneNode.Value);
propertyReference6.SetValue((object)path, valueToSet);
}
pathGeometryEditor.SubdivideSegment(figure, pointIndex, parameter);
List <KeyFrameSceneNode> list;
if (keyFrames1.TryGetValue(keyValuePair.Key, out list))
{
foreach (KeyFrameSceneNode keyFrameSceneNode in list)
{
object obj = this.targetElement.ViewModel.DefaultView.ConvertFromWpfValue(this.targetElement.ViewModel.DefaultView.ConvertToWpfPropertyReference(keyFrameSceneNode.TargetProperty.Subreference(1)).GetCurrentValue((object)path));
keyFrameSceneNode.Value = obj;
}
}
}
}
}
private void MoveSelection()
{
Matrix matrixToAdornerLayer = this.pathPartAdorner.PathAdornerSet.GetTransformMatrixToAdornerLayer();
Point pointInAdornerLayer = this.GetSnappedPointInAdornerLayer();
PathTangentAdorner pathTangentAdorner = this.pathPartAdorner as PathTangentAdorner;
PathEditContext pathEditContext = new PathEditContext(this.pathPartAdorner.FigureIndex, this.pathPartAdorner.PartIndex);
if (pathTangentAdorner != null)
{
this.EnsureEditTransaction();
this.pathEditorTarget.BeginEditing();
if (!this.HasMouseMovedAfterDown)
{
this.startRootPoint = PathFigureUtilities.GetPoint(this.pathEditorTarget.PathGeometry.Figures[pathEditContext.FigureIndex], pathEditContext.PartIndex, false);
this.correspondingPoint = PathFigureUtilities.GetPoint(this.pathEditorTarget.PathGeometry.Figures[pathEditContext.FigureIndex], pathEditContext.PartIndex, true);
}
Point point = this.IsShiftDown ? this.correspondingPoint : this.startRootPoint;
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(pointInAdornerLayer - point * matrixToAdornerLayer, matrixToAdornerLayer, this.IsShiftDown ? this.axisConstraint : (AxisConstraint)null);
new PathFigureEditor(pathEditContext.GetPathFigure(this.pathEditorTarget.PathGeometry)).MoveTangent(pathEditContext.PartIndex, point + correspondingVector, this.isEnforcingSmoothness);
this.ActiveView.AdornerLayer.InvalidateAdornerVisuals(this.EditingElement);
}
else
{
this.EnsureEditTransaction();
PathPointAdorner pathPointAdorner = this.pathPartAdorner as PathPointAdorner;
PathSegmentAdorner pathSegmentAdorner = this.pathPartAdorner as PathSegmentAdorner;
this.pathPartAdorner.PathAdornerSet.PathEditorTarget.BeginEditing();
if (!this.HasMouseMovedAfterDown)
{
Point point;
if (pathPointAdorner != null)
{
point = PathFigureUtilities.GetPoint(pathEditContext.GetPathFigure(this.pathEditorTarget.PathGeometry), pathEditContext.PartIndex);
}
else
{
PathFigureEditor pathFigureEditor = new PathFigureEditor(pathEditContext.GetPathFigure(this.pathEditorTarget.PathGeometry));
int segmentIndex;
int segmentPointIndex;
PathFigureUtilities.GetSegmentFromPointIndex(pathEditContext.GetPathFigure(this.pathEditorTarget.PathGeometry), pathEditContext.PartIndex, out segmentIndex, out segmentPointIndex);
point = pathFigureEditor.Evaluate(segmentIndex, segmentPointIndex, this.pathSegmentParameter) * pathSegmentAdorner.PathGeometryTransformMatrix;
}
this.startRootPoint = point;
this.previousRootPoint = this.startRootPoint;
}
Vector correspondingVector = ElementUtilities.GetCorrespondingVector(pointInAdornerLayer - this.startRootPoint * matrixToAdornerLayer, matrixToAdornerLayer, this.IsShiftDown ? this.axisConstraint : (AxisConstraint)null);
double zoom = this.ActiveView.Artboard.Zoom;
Vector rootToArtboardScale = this.ActiveView.Artboard.ViewRootToArtboardScale;
correspondingVector.X /= zoom * rootToArtboardScale.X;
correspondingVector.Y /= zoom * rootToArtboardScale.Y;
Vector vector = this.startRootPoint - this.previousRootPoint + correspondingVector;
this.previousRootPoint = this.startRootPoint + correspondingVector;
Vector deltaOffset = matrixToAdornerLayer.Transform(vector);
PathPartSelectionSet partSelectionSet = this.ActiveSceneViewModel.PathPartSelectionSet;
if (partSelectionSet == null)
{
return;
}
foreach (BaseFrameworkElement sceneElement in (IEnumerable <SceneElement>)partSelectionSet.SelectedPaths)
{
this.MovePathParts(partSelectionSet, sceneElement, PathEditMode.ScenePath, deltaOffset);
this.MovePathParts(partSelectionSet, sceneElement, PathEditMode.MotionPath, deltaOffset);
this.MovePathParts(partSelectionSet, sceneElement, PathEditMode.ClippingPath, deltaOffset);
}
}
}
internal static void TranslateSelection(PathEditorTarget pathEditorTarget, ICollection <PathPart> pathParts, Vector offset)
{
List <BitArray> list = new List <BitArray>(pathEditorTarget.PathGeometry.Figures.Count);
for (int index = 0; index < pathEditorTarget.PathGeometry.Figures.Count; ++index)
{
list.Add(new BitArray(PathFigureUtilities.PointCount(pathEditorTarget.PathGeometry.Figures[index]), false));
}
foreach (PathPart pathPart in (IEnumerable <PathPart>)pathParts)
{
PathPoint pathPoint = pathPart as PathPoint;
if ((PathPart)pathPoint != (PathPart)null)
{
if (pathPoint.PartIndex < list[pathPoint.FigureIndex].Count)
{
list[pathPoint.FigureIndex][pathPoint.PartIndex] = true;
}
}
else
{
PathSegment pathSegment = pathPart as PathSegment;
if ((PathPart)pathSegment != (PathPart)null)
{
list[pathSegment.FigureIndex][pathSegment.PartIndex] = true;
PathFigure pathFigure = pathEditorTarget.PathGeometry.Figures[pathPart.FigureIndex];
if (pathFigure.IsClosed && pathPart.PartIndex == 0)
{
int num1 = PathFigureUtilities.PointCount(pathFigure);
int num2 = 1;
if (PathFigureUtilities.IsCloseSegmentDegenerate(pathFigure))
{
num2 = PathSegmentUtilities.GetPointCount(pathFigure.Segments[pathFigure.Segments.Count - 1]);
}
list[pathSegment.FigureIndex][num1 - num2] = true;
}
else
{
int segmentIndex;
int segmentPointIndex;
PathFigureUtilities.GetSegmentFromPointIndex(pathFigure, pathPart.PartIndex, out segmentIndex, out segmentPointIndex);
int pointCount = PathSegmentUtilities.GetPointCount(pathFigure.Segments[segmentIndex]);
int index = pathSegment.PartIndex - pointCount;
if (index >= 0)
{
list[pathSegment.FigureIndex][index] = true;
}
}
}
}
}
for (int figureIndex = 0; figureIndex < pathEditorTarget.PathGeometry.Figures.Count; ++figureIndex)
{
BitArray bitArray = list[figureIndex];
PathFigureEditor pathFigureEditor = new PathFigureEditor(pathEditorTarget.PathGeometry.Figures[figureIndex], pathEditorTarget.PathDiffChangeList, figureIndex);
int num = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure);
for (int index = 0; index < num; ++index)
{
if (bitArray[index])
{
pathFigureEditor.MovePoint(index, offset + pathFigureEditor.GetPoint(index));
}
}
}
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
this.startRootPoint = PathFigureUtilities.GetPoint(this.PathEditorTarget.PathGeometry.Figures[pathEditContext.FigureIndex], pathEditContext.PartIndex, true);
this.geometryToDocument = this.PathEditorTarget.GetTransformToAncestor((IViewObject)this.View.HitTestRoot);
base.OnBegin(pathEditContext, mouseDevice);
}
protected virtual void CreatePathAdorners(List <Adorner> oldAdornerList, List <Adorner> newAdornerList)
{
this.adornerCounts.Clear();
this.adornerOffsets.Clear();
PathPartSelectionSet partSelectionSet = this.PathPartSelectionSet;
List <PathPointAdorner> list1 = new List <PathPointAdorner>();
List <PathSegmentAdorner> list2 = new List <PathSegmentAdorner>();
List <PathTangentAdorner> list3 = new List <PathTangentAdorner>();
int index1 = 0;
int index2 = 0;
int index3 = 0;
foreach (Adorner adorner in oldAdornerList)
{
PathPointAdorner pathPointAdorner;
if ((pathPointAdorner = adorner as PathPointAdorner) != null)
{
list1.Add(pathPointAdorner);
}
else
{
PathSegmentAdorner pathSegmentAdorner;
if ((pathSegmentAdorner = adorner as PathSegmentAdorner) != null)
{
list2.Add(pathSegmentAdorner);
}
else
{
PathTangentAdorner pathTangentAdorner;
if ((pathTangentAdorner = adorner as PathTangentAdorner) != null)
{
list3.Add(pathTangentAdorner);
}
}
}
}
for (int figureIndex = 0; figureIndex < this.PathGeometry.Figures.Count; ++figureIndex)
{
PathFigure figure = this.PathGeometry.Figures[figureIndex];
PathFigureEditor pathFigureEditor = new PathFigureEditor(figure);
this.adornerOffsets.Add((object)this.AdornerList.Count);
int length1 = PathFigureUtilities.PointCount(figure);
int length2 = length1 + (PathFigureUtilities.IsClosed(figure) ? true : false);
PathSegmentAdorner[] pathSegmentAdornerArray = new PathSegmentAdorner[length2];
PathPointKind[] pathPointKindArray = new PathPointKind[length2];
pathPointKindArray[0] = pathFigureEditor.GetPointKind(0);
int num1 = 1;
for (int index4 = 0; index4 < figure.Segments.Count; ++index4)
{
System.Windows.Media.PathSegment segment = figure.Segments[index4];
int pointCount = PathSegmentUtilities.GetPointCount(segment);
for (int index5 = 0; index5 < pointCount; ++index5)
{
pathPointKindArray[num1++] = PathSegmentUtilities.GetPointKind(segment, index5);
}
}
int index6 = 1;
for (int segmentIndex = 0; segmentIndex < figure.Segments.Count; ++segmentIndex)
{
int pointCount = PathSegmentUtilities.GetPointCount(figure.Segments[segmentIndex]);
for (int segmentPointIndex = 0; segmentPointIndex < pointCount; ++segmentPointIndex)
{
if (pathPointKindArray[index6] != PathPointKind.BezierHandle)
{
PathSegmentAdorner pathSegmentAdorner;
if (index2 < list2.Count)
{
pathSegmentAdorner = list2[index2];
pathSegmentAdorner.Initialize(figureIndex, index6 % length1, segmentIndex, segmentPointIndex);
oldAdornerList.Remove((Adorner)pathSegmentAdorner);
++index2;
}
else
{
pathSegmentAdorner = new PathSegmentAdorner(this, figureIndex, index6 % length1, segmentIndex, segmentPointIndex);
}
if (partSelectionSet != null)
{
pathSegmentAdorner.IsActive = partSelectionSet.IsSelected((PathPart)(PathSegment)pathSegmentAdorner);
}
newAdornerList.Add((Adorner)pathSegmentAdorner);
pathSegmentAdornerArray[index6] = pathSegmentAdorner;
}
else
{
pathSegmentAdornerArray[index6] = (PathSegmentAdorner)null;
}
++index6;
}
}
if (figure.IsClosed && figure.Segments.Count > 0)
{
Point lastPoint = PathSegmentUtilities.GetLastPoint(figure.Segments[figure.Segments.Count - 1]);
if (!VectorUtilities.ArePathPointsVeryClose(figure.StartPoint, lastPoint))
{
PathSegmentAdorner pathSegmentAdorner;
if (index2 < list2.Count)
{
pathSegmentAdorner = list2[index2];
pathSegmentAdorner.Initialize(figureIndex, index6 % length1, -1, 0);
oldAdornerList.Remove((Adorner)pathSegmentAdorner);
++index2;
}
else
{
pathSegmentAdorner = new PathSegmentAdorner(this, figureIndex, index6 % length1, -1, 0);
}
if (partSelectionSet != null)
{
pathSegmentAdorner.IsActive = partSelectionSet.IsSelected((PathPart)(PathSegment)pathSegmentAdorner);
}
newAdornerList.Add((Adorner)pathSegmentAdorner);
pathSegmentAdornerArray[index6] = pathSegmentAdorner;
}
}
this.adornerCounts.Add((object)(this.AdornerList.Count - (int)this.adornerOffsets[this.adornerOffsets.Count - 1]));
this.adornerTypes.Add((object)PathPart.PartType.PathSegment);
PathPointAdorner[] pathPointAdornerArray = new PathPointAdorner[length1];
int index7 = 0;
for (int segmentIndex = -1; segmentIndex < figure.Segments.Count; ++segmentIndex)
{
int num2 = 1;
if (segmentIndex != -1)
{
num2 = PathSegmentUtilities.GetPointCount(figure.Segments[segmentIndex]);
}
for (int segmentPointIndex = 0; segmentPointIndex < num2 && index7 < length1; ++segmentPointIndex)
{
if (pathPointKindArray[index7] == PathPointKind.BezierHandle)
{
pathPointAdornerArray[index7] = (PathPointAdorner)null;
}
else
{
PathPointAdorner pathPointAdorner;
if (index1 < list1.Count)
{
pathPointAdorner = list1[index1];
pathPointAdorner.Initialize(figureIndex, index7, segmentIndex, segmentPointIndex);
oldAdornerList.Remove((Adorner)pathPointAdorner);
++index1;
}
else
{
pathPointAdorner = new PathPointAdorner(this, figureIndex, index7, segmentIndex, segmentPointIndex);
}
pathPointAdornerArray[index7] = pathPointAdorner;
if (partSelectionSet != null)
{
pathPointAdornerArray[index7].IsActive = partSelectionSet.IsSelected((PathPart)(PathPoint)pathPointAdornerArray[index7]);
}
}
++index7;
}
}
int endPointIndex = 0;
for (int segmentIndex = -1; segmentIndex < figure.Segments.Count; ++segmentIndex)
{
int num2 = 1;
if (segmentIndex != -1)
{
num2 = PathSegmentUtilities.GetPointCount(figure.Segments[segmentIndex]);
}
for (int segmentPointIndex = 0; segmentPointIndex < num2 && endPointIndex < length1; ++segmentPointIndex)
{
if (pathPointKindArray[endPointIndex] == PathPointKind.BezierHandle)
{
PathPointAdorner pathPointAdorner = (PathPointAdorner)null;
PathSegmentAdorner pathSegmentAdorner = (PathSegmentAdorner)null;
if (pathPointKindArray[endPointIndex] == PathPointKind.BezierHandle && endPointIndex + 2 < pathPointKindArray.Length && pathPointKindArray[endPointIndex + 2] == PathPointKind.Cubic)
{
pathPointAdorner = pathPointAdornerArray[endPointIndex - 1];
pathSegmentAdorner = pathSegmentAdornerArray[endPointIndex + 2];
}
else if (pathPointKindArray[endPointIndex] == PathPointKind.BezierHandle && endPointIndex + 1 < pathPointKindArray.Length && pathPointKindArray[endPointIndex + 1] == PathPointKind.Cubic)
{
pathPointAdorner = pathPointAdornerArray[(endPointIndex + 1) % length1];
pathSegmentAdorner = pathSegmentAdornerArray[endPointIndex + 1];
}
if (pathPointAdorner != null)
{
PathTangentAdorner pathTangentAdorner;
if (index3 < list3.Count)
{
pathTangentAdorner = list3[index3];
pathTangentAdorner.Initialize(figureIndex, endPointIndex, segmentIndex, segmentPointIndex, pathPointAdorner, pathSegmentAdorner);
oldAdornerList.Remove((Adorner)pathTangentAdorner);
++index3;
}
else
{
pathTangentAdorner = new PathTangentAdorner(this, figureIndex, endPointIndex, segmentIndex, segmentPointIndex, pathPointAdorner, pathSegmentAdorner);
}
newAdornerList.Add((Adorner)pathTangentAdorner);
}
}
++endPointIndex;
}
}
foreach (PathPointAdorner pathPointAdorner in pathPointAdornerArray)
{
if (pathPointAdorner != null)
{
newAdornerList.Add((Adorner)pathPointAdorner);
}
}
this.adornerOffsets.Add((object)this.AdornerList.Count);
this.adornerCounts.Add((object)(this.AdornerList.Count - (int)this.adornerOffsets[this.adornerOffsets.Count - 1]));
this.adornerTypes.Add((object)PathPart.PartType.PathPoint);
}
}
protected Point GetLastPoint(int pathFigureIndex)
{
PathFigure pathFigure = this.Path.Figures[pathFigureIndex];
return(PathFigureUtilities.GetPoint(pathFigure, PathFigureUtilities.PointCount(pathFigure) - 1));
}
protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
{
BaseFrameworkElement frameworkElement = this.oldPathEditorTarget.EditingElement.GetCommonAncestor((SceneNode)this.EditingElement) as BaseFrameworkElement;
Base2DElement editingElement = this.oldPathEditorTarget.EditingElement;
Base2DElement base2Delement = (Base2DElement)this.EditingElement;
if (frameworkElement != base2Delement && !base2Delement.GetComputedTransformToElement((SceneElement)frameworkElement).HasInverse)
{
this.End();
}
else
{
int figureIndex1 = pathEditContext.FigureIndex;
int num1 = PathFigureUtilities.PointCount(this.oldPathEditContext.GetPathFigure(this.oldPathEditorTarget.PathGeometry));
if (editingElement != base2Delement)
{
this.PathEditorTarget.EndEditing(false);
figureIndex1 += this.oldPathEditorTarget.PathGeometry.Figures.Count;
List <PathElement> otherElements = new List <PathElement>();
PathElement mainElement = (PathElement)editingElement;
PathElement pathElement = (PathElement)base2Delement;
otherElements.Add(pathElement);
PathCommandHelper.MakeCompoundPath(mainElement, otherElements, this.EditTransaction);
this.UpdateEditTransaction();
this.PathEditorTarget = this.oldPathEditorTarget;
}
this.PathEditorTarget.BeginEditing();
PathGeometryEditor geometryEditor = this.PathEditorTarget.CreateGeometryEditor();
if (pathEditContext.PartIndex != 0)
{
geometryEditor.CreatePathFigureEditor(figureIndex1).Reverse();
}
geometryEditor.JoinFigure(this.oldPathEditContext.FigureIndex, figureIndex1);
int figureIndex2 = this.oldPathEditContext.FigureIndex;
if (pathEditContext.FigureIndex < this.oldPathEditContext.FigureIndex && editingElement == base2Delement)
{
--figureIndex2;
}
this.UpdateEditTransaction();
this.View.UpdateLayout();
PathFigureEditor pathFigureEditor = geometryEditor.CreatePathFigureEditor(figureIndex2);
int downstreamSegment1 = pathFigureEditor.GetLastIndexOfDownstreamSegment(num1 - 1);
if (pathFigureEditor.GetPointKind(downstreamSegment1) == PathPointKind.Cubic)
{
Vector lastTangent = this.oldPathEditorTarget.LastTangent;
pathFigureEditor.SetPoint(downstreamSegment1 - 2, pathFigureEditor.GetPoint(downstreamSegment1 - 2) + lastTangent);
}
this.PathEditorTarget.EndEditing(false);
int downstreamSegment2 = pathFigureEditor.GetLastIndexOfDownstreamSegment(num1 - 1);
this.PathEditContext = new PathEditContext(figureIndex2, downstreamSegment2);
int num2 = PathFigureUtilities.PointCount(pathFigureEditor.PathFigure);
if (pathFigureEditor.GetPointKind(num2 - 1) == PathPointKind.Cubic)
{
this.LastTangent = pathFigureEditor.GetPoint(num2 - 1) - pathFigureEditor.GetPoint(num2 - 2);
}
else
{
this.LastTangent = new Vector(0.0, 0.0);
}
this.UpdateEditTransaction();
this.zeroTangents = false;
this.PathEditorTarget.BeginEditing();
base.OnBegin(this.PathEditContext, mouseDevice);
}
}
