protected override void EndEditingInternal(bool pathJustCreated) { PathGeometry pathGeometry1 = PathGeometryUtilities.Copy(this.PathGeometry, false); bool isAnimated = this.IsAnimated; if (!isAnimated && this.ViewModel.AnimationEditor.IsKeyFraming) { System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry) this.editingElement.GetComputedValueAsWpf(Base2DElement.ClipProperty); PathGeometry geometry2 = new PathGeometry(); if (geometry1 != null) { geometry2.AddGeometry(geometry1); } PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(geometry2); SceneNode sceneNode = this.editingElement.ViewModel.CreateSceneNode(this.editingElement.ViewModel.DefaultView.ConvertFromWpfValue((object)geometry2)); sceneNode.SetLocalValueAsWpf(DesignTimeProperties.IsAnimatedProperty, (object)true); this.editingElement.SetValueAsSceneNode(Base2DElement.ClipProperty, sceneNode); this.editingElement.ViewModel.Document.OnUpdatedEditTransaction(); } if (this.EditingElement.IsAttached && (this.ViewModel.AnimationEditor.IsKeyFraming || isAnimated)) { new PathDiff(this.EditingElement, Base2DElement.ClipProperty, this.PathDiffChangeList).SetPathUsingMinimalDiff(pathGeometry1); } else { PathGeometry pathGeometry2 = PathGeometryUtilities.RemoveMapping(pathGeometry1, true); this.EditingElement.SetValueAsWpf(Base2DElement.ClipProperty, (object)pathGeometry2); } }
public static void AdjustPathForAnimations(PathElement pathElement, SceneEditTransaction editTransaction) { using (pathElement.ViewModel.ForceBaseValue()) { System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry)pathElement.GetLocalOrDefaultValueAsWpf(PathElement.DataProperty); PathGeometry pathGeometry = new PathGeometry(); pathGeometry.AddGeometry(geometry1); Rect bounds = PathCommandHelper.InflateRectByStrokeWidth(pathGeometry.Bounds, pathElement, false); PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(pathElement.Platform); Rect maxAnimatedExtent = PathCommandHelper.FindMaxAnimatedExtent((SceneElement)pathElement, bounds, propertyReference); double num1 = Math.Min(0.0, maxAnimatedExtent.Left); double num2 = Math.Min(0.0, maxAnimatedExtent.Top); Vector vector = new Vector(-num1, -num2); ILayoutDesigner designerForChild = pathElement.ViewModel.GetLayoutDesignerForChild((SceneElement)pathElement, true); editTransaction.Update(); Rect childRect = designerForChild.GetChildRect((BaseFrameworkElement)pathElement); childRect.X += num1; childRect.Y += num2; childRect.Width = Math.Max(maxAnimatedExtent.Width, childRect.Width); childRect.Height = Math.Max(maxAnimatedExtent.Height, childRect.Height); designerForChild.SetChildRect((BaseFrameworkElement)pathElement, childRect); Transform transform = (Transform) new TranslateTransform(vector.X, vector.Y); PathGeometry geometry2 = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry, transform); if (!pathElement.DesignerContext.ActiveDocument.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf)) { PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(geometry2); } pathElement.PathGeometry = geometry2; PathCommandHelper.TransformPointKeyframes((SceneElement)pathElement, propertyReference, transform); pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)(Stretch)(pathElement.HasVertexAnimations ? 0 : 1)); } }
public bool EnsureSingleSegmentsInPathGeometry() { PathGeometry pathGeometry = this.PathGeometry; bool flag = PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(pathGeometry); this.PathGeometry = pathGeometry; return(flag); }
protected void EnsureOnlySingleSegments() { if (!PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(this.PathGeometry)) { return; } this.AddCriticalEdit(); }
public override void PostDeleteAction() { if (!PathGeometryUtilities.IsEmpty(this.PathGeometry)) { return; } this.ViewModel.AnimationEditor.DeleteMotionPath((SceneNode)this.EditingElement); }
private System.Windows.Media.Geometry GetTransformedClippingGeometry(SceneElement clipper, Transform transform) { RectangleElement rectangleElement = clipper as RectangleElement; if (rectangleElement == null || !this.DesignerContext.ActiveDocument.ProjectContext.IsCapabilitySet(PlatformCapability.PrefersRectangularClippingPath)) { PathGeometry pathGeometry = PathGeometryUtilities.TransformGeometry(this.ApplyCurrentClippingToGeometry((System.Windows.Media.Geometry)PathConversionHelper.ConvertToPathGeometry(clipper), clipper), transform); if (pathGeometry.Bounds == Rect.Empty) { pathGeometry = new PathGeometry(); } return((System.Windows.Media.Geometry)pathGeometry); } RectangleGeometry rectangleGeometry = rectangleElement.ViewModel.DefaultView.GetRenderedGeometryAsWpf((SceneElement)rectangleElement) as RectangleGeometry; if (rectangleGeometry == null) { return((System.Windows.Media.Geometry) new RectangleGeometry()); } CanonicalDecomposition canonicalDecomposition = new CanonicalDecomposition(transform.Value); Matrix matrix = new Matrix(); matrix.Scale(canonicalDecomposition.ScaleX, canonicalDecomposition.ScaleY); matrix.Translate(canonicalDecomposition.TranslationX, canonicalDecomposition.TranslationY); Rect rect = rectangleGeometry.Rect; rect.Transform(matrix); rectangleGeometry.Rect = RoundingHelper.RoundRect(rect); CanonicalTransform canonicalTransform = new CanonicalTransform(); bool flag = false; canonicalTransform.CenterX = canonicalDecomposition.TranslationX; canonicalTransform.CenterY = canonicalDecomposition.TranslationY; if (canonicalDecomposition.RotationAngle != 0.0) { canonicalTransform.RotationAngle = canonicalDecomposition.RotationAngle; flag = true; } if (canonicalDecomposition.SkewX != 0.0 || canonicalDecomposition.SkewY != 0.0) { canonicalTransform.SkewX = RoundingHelper.RoundLength(canonicalDecomposition.SkewX); canonicalTransform.SkewY = RoundingHelper.RoundLength(canonicalDecomposition.SkewY); flag = true; } if (flag) { rectangleGeometry.Transform = (Transform)canonicalTransform.TransformGroup; } if ((double)rectangleElement.GetComputedValue(RectangleElement.RadiusXProperty) != 0.0 || (double)rectangleElement.GetComputedValue(RectangleElement.RadiusYProperty) != 0.0) { rectangleGeometry.ClearValue(RectangleGeometry.RadiusXProperty); rectangleGeometry.ClearValue(RectangleGeometry.RadiusYProperty); this.SceneView.ShowBubble(StringTable.ClippingRectanglePropertiesLostWarning, MessageBubbleType.Warning); } return((System.Windows.Media.Geometry)rectangleGeometry); }
private void NormalizePathGeometry() { PathGeometry pathGeometry = this.PathGeometry; Rect extent = PathCommandHelper.InflateRectByStrokeWidth(PathGeometryUtilities.TightExtent(pathGeometry, Matrix.Identity), this, false); Rect computedBounds = this.GetComputedBounds((Base2DElement)this); Transform transform = ScenePathEditorTarget.NormalizePathGeometry(pathGeometry, extent, computedBounds); this.PathGeometry = pathGeometry; PathCommandHelper.TransformPointKeyframes((SceneElement)this, new PropertyReference((ReferenceStep)this.ProjectContext.ResolveProperty(PathElement.DataProperty)), transform); }
public void SimplifyPathData(ref System.Windows.Media.Geometry geometry) { PathGeometry geometry1 = geometry as PathGeometry; BooleanCommand.CleanUpPathGeometry(ref geometry1); PathGeometry geometry2 = PathConversionHelper.RemoveDegeneratePoints((System.Windows.Media.Geometry)geometry1); PathGeometryUtilities.CollapseSingleSegmentsToPolySegments(geometry2); PathCommandHelper.GrokPathPointPrecision(geometry2, 3); geometry = (System.Windows.Media.Geometry)geometry2; }
public override void PostDeleteAction() { if (PathGeometryUtilities.IsEmpty(this.PathGeometry)) { this.RemovePath(); } else { this.EndEditing(false); } }
public override Rect GetComputedTightBounds(Base2DElement context) { PathGeometry renderedGeometry = this.RenderedGeometry; if (renderedGeometry == null) { return(Rect.Empty); } Matrix transformToElement = this.GetComputedTransformToElement((SceneElement)context); return(PathGeometryUtilities.TightExtent(renderedGeometry, transformToElement)); }
public override void Execute() { using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove()) { SceneElement clipper; SceneElement elementToBeClipped; this.GetClipperAndElementToBeClipped(this.SceneViewModel.ElementSelectionSet, out clipper, out elementToBeClipped); if (elementToBeClipped == null) { SceneElement root = this.SceneViewModel.ActiveEditingContainer as SceneElement; if (root != null) { elementToBeClipped = (SceneElement)PathTargetDialog.ChooseClippingPathTarget(root, clipper); } } if (elementToBeClipped == null) { return; } using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitMakeClippingPath, false)) { using (this.SceneViewModel.ForceBaseValue()) { this.SceneViewModel.ElementSelectionSet.Clear(); Transform geometryTransform = this.GetGeometryTransform(clipper, elementToBeClipped); System.Windows.Media.Geometry targetGeometry = this.GetTransformedClippingGeometry(clipper, geometryTransform); if (!this.DesignerContext.ActiveDocument.ProjectContext.IsCapabilitySet(PlatformCapability.PrefersRectangularClippingPath)) { targetGeometry = this.ApplyCurrentClippingToGeometry(targetGeometry, elementToBeClipped); } if (!this.DesignerContext.ActiveDocument.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf)) { PathGeometry original = targetGeometry as PathGeometry; if (original != null) { PathGeometry geometry = PathGeometryUtilities.RemoveMapping(original, true); PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(geometry); targetGeometry = (System.Windows.Media.Geometry)geometry; } } elementToBeClipped.SetValueAsWpf(Base2DElement.ClipProperty, (object)targetGeometry); ReferenceStep singleStep1 = (ReferenceStep)this.SceneViewModel.ProjectContext.ResolveProperty(PathElement.DataProperty); ReferenceStep singleStep2 = (ReferenceStep)this.SceneViewModel.ProjectContext.ResolveProperty(Base2DElement.ClipProperty); PathCommandHelper.MoveVertexAnimations(clipper, new PropertyReference(singleStep1), elementToBeClipped, new PropertyReference(singleStep2), geometryTransform); this.SceneViewModel.DeleteElementTree(clipper); this.SceneViewModel.ElementSelectionSet.SetSelection(elementToBeClipped); } editTransaction.Commit(); } } }
private void ReleaseClippingPath(SceneElement sceneElement, SceneEditTransaction editTransaction) { if (sceneElement.IsSet(Base2DElement.ClipProperty) != PropertyState.Set) { return; } SceneNode sceneNode = (SceneNode)sceneElement; for (SceneNode parent = sceneElement.Parent; parent != null; parent = parent.Parent) { PanelElement panelElement = parent as PanelElement; if (panelElement != null) { MatrixTransform matrixTransform = new MatrixTransform(sceneElement.GetComputedTransformToElement((SceneElement)panelElement)); PathGeometry pathGeometry1 = new PathGeometry(); System.Windows.Media.Geometry geometry = (System.Windows.Media.Geometry)sceneElement.GetLocalOrDefaultValueAsWpf(Base2DElement.ClipProperty); if (geometry != null) { pathGeometry1 = PathGeometryUtilities.TransformGeometry(geometry, (Transform)matrixTransform); } PathElement pathElement = (PathElement)this.SceneViewModel.CreateSceneNode(PlatformTypes.Path); using (pathElement.ViewModel.ForceBaseValue()) { this.DesignerContext.AmbientPropertyManager.ApplyAmbientProperties((SceneNode)pathElement); pathElement.SetValueAsWpf(ShapeElement.StrokeProperty, (object)Brushes.Black); pathElement.ClearValue(ShapeElement.FillProperty); pathElement.ClearValue(ShapeElement.StrokeThicknessProperty); panelElement.Children.Insert(panelElement.Children.IndexOf(sceneNode) + 1, (SceneNode)pathElement); ReferenceStep singleStep1 = (ReferenceStep)pathElement.ProjectContext.ResolveProperty(Base2DElement.ClipProperty); ReferenceStep singleStep2 = (ReferenceStep)pathElement.ProjectContext.ResolveProperty(PathElement.DataProperty); PathCommandHelper.MoveVertexAnimations(sceneElement, new PropertyReference(singleStep1), (SceneElement)pathElement, new PropertyReference(singleStep2), (Transform)matrixTransform); Rect bounds = PathCommandHelper.InflateRectByStrokeWidth(pathGeometry1.Bounds, pathElement, false); Rect maxAnimatedExtent = PathCommandHelper.FindMaxAnimatedExtent((SceneElement)pathElement, bounds, new PropertyReference(singleStep2)); editTransaction.Update(); Vector vector = new Vector(-maxAnimatedExtent.Left, -maxAnimatedExtent.Top); panelElement.LayoutDesigner.SetChildRect((BaseFrameworkElement)pathElement, maxAnimatedExtent); Transform transform = (Transform) new TranslateTransform(vector.X, vector.Y); PathGeometry pathGeometry2 = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry1, transform); pathElement.PathGeometry = pathGeometry2; PathCommandHelper.TransformPointKeyframes((SceneElement)pathElement, new PropertyReference(singleStep2), transform); pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)(Stretch)(pathElement.HasVertexAnimations ? 0 : 1)); break; } } else { sceneNode = parent; } } }
public override void Execute() { AnimationEditor animationEditor = this.SceneViewModel.AnimationEditor; SceneElement pathTarget = this.GetPathTarget(this.SceneViewModel.ElementSelectionSet); BaseFrameworkElement frameworkElement = (BaseFrameworkElement)this.GetAnimationTarget(this.SceneViewModel.ElementSelectionSet); if (frameworkElement == null) { SceneElement root = this.SceneViewModel.ActiveEditingContainer as SceneElement; if (root != null) { frameworkElement = PathTargetDialog.ChooseMotionPathTarget(root, pathTarget); } } if (frameworkElement == null) { return; } PathGeometry geometry = PathConversionHelper.ConvertToPathGeometry(pathTarget); if (PathGeometryUtilities.TotalSegmentCount(geometry) == 0) { this.DesignerContext.MessageDisplayService.ShowError(StringTable.ConvertToMotionPathNoSegmentsMessage); } else { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.ConvertToMotionPathUndo, false)) { StoryboardTimelineSceneNode targetTimeline = this.GetTargetTimeline(); if (targetTimeline == null) { this.SceneViewModel.AnimationEditor.CreateNewTimeline(TriggerCreateBehavior.Default); } else if (targetTimeline != this.SceneViewModel.ActiveStoryboardTimeline) { this.SceneViewModel.SetActiveStoryboardTimeline(targetTimeline.StoryboardContainer, targetTimeline, (TriggerBaseNode)null); } this.SceneViewModel.ElementSelectionSet.Clear(); Point elementCoordinates = frameworkElement.RenderTransformOriginInElementCoordinates; Matrix matrix = new TranslateTransform(-elementCoordinates.X, -elementCoordinates.Y).Value; Transform transform = (Transform) new MatrixTransform(pathTarget.GetComputedTransformToElement((SceneElement)frameworkElement) * frameworkElement.GetEffectiveRenderTransform(false) * matrix); PathGeometry path = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)geometry, transform); double animationTime = animationEditor.AnimationTime; animationEditor.SetMotionPath((SceneElement)frameworkElement, path, new double?(animationTime), new double?(animationTime + 2.0)); this.SceneViewModel.ElementSelectionSet.SetSelection((SceneElement)frameworkElement); editTransaction.Commit(); } } }
public void Update(double scaleX, double scaleY) { double num = 2.0 * this.halfStrokeThickness; if (this.initialSize.Width > num) { scaleX = (this.initialSize.Width * scaleX - num) / (this.initialSize.Width - num); } if (this.initialSize.Height > num) { scaleY = (this.initialSize.Height * scaleY - num) / (this.initialSize.Height - num); } this.transform = (Transform) new ScaleTransform(scaleX, scaleY, this.halfStrokeThickness, this.halfStrokeThickness); this.pathElement.PathGeometry = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry) this.initialGeometry, this.transform); }
public void EndEditing(bool pathJustCreated) { if (!this.isCurrentlyEditing) { return; } if (this.ShouldCollapseSegments() && PathGeometryUtilities.CollapseSingleSegmentsToPolySegments(this.PathGeometry)) { this.AddCriticalEdit(); } this.isCurrentlyEditing = false; this.ignoreFirstInserted = true; this.EditingElement.ViewModel.Document.AddUndoUnit((IUndoUnit) new PathEditorTarget.PathEditorTargetUndoUnit((BaseFrameworkElement)this.EditingElement, this.PathEditMode, true)); this.EndEditingInternal(pathJustCreated); this.EditingElement.ViewModel.Document.AddUndoUnit((IUndoUnit) new PathEditorTarget.PathEditorTargetUndoUnit((BaseFrameworkElement)this.EditingElement, this.PathEditMode, false)); }
public void SetPathUsingMinimalDiff(PathGeometry path) { PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(path); PathGeometry pathGeometry = this.targetElement.GetComputedValueAsWpf((IPropertyId)this.pathProperty) as PathGeometry; if (pathGeometry != null && path != null) { PathGeometryUtilities.EnsureOnlySingleSegmentsInGeometry(pathGeometry); if (this.changeList.Changes.Count == 0 && this.DoesStructureMatch(path, pathGeometry)) { this.SetPathGeometryUsingMinimalDiff(path, pathGeometry); } else { this.SetPathUsingMapping(path); } } else { this.targetElement.SetValueAsWpf((IPropertyId)this.pathProperty, (object)path); } }
public static PathGeometry ConvertToPathGeometry(SceneElement element) { PathGeometry[] pathGeometryArray = PathConversionHelper.ConvertToPathGeometries(element); if (pathGeometryArray.Length == 0) { return(new PathGeometry()); } if (pathGeometryArray.Length > 1) { for (int index = 1; index < pathGeometryArray.Length; ++index) { pathGeometryArray[0].AddGeometry((System.Windows.Media.Geometry)pathGeometryArray[index]); } } PathGeometry pathGeometry = pathGeometryArray[0]; if (pathGeometry != null && Enumerable.Any <PathFigure>((IEnumerable <PathFigure>)pathGeometry.Figures, (Func <PathFigure, bool>)(figure => Enumerable.Any <PathSegment>((IEnumerable <PathSegment>)figure.Segments, (Func <PathSegment, bool>)(segment => segment is ArcSegment))))) { pathGeometry = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry, (Transform) new TranslateTransform(1.0, 0.0)), (Transform) new TranslateTransform(-1.0, 0.0)); } return(pathGeometry); }
public override void UpdateCachedPath() { PathGeometry original = (PathGeometry)null; if (this.pathElement.IsAttached) { original = this.ViewModel.AnimationEditor.ActiveStoryboardTimeline == null ? this.pathElement.PathGeometry : PathGeometryUtilities.GetPathGeometryFromGeometry(this.pathElement.GetComputedValueAsWpf(PathElement.DataProperty) as System.Windows.Media.Geometry); } if (original != null) { this.PathGeometry = PathGeometryUtilities.Copy(original, false); if (!this.IsCurrentlyEditing) { return; } this.EnsureOnlySingleSegments(); } else { this.PathGeometry = new PathGeometry(); } }
public static void CleanUpPathGeometry(ref PathGeometry geometry) { if (geometry == null) { return; } if (geometry.Figures.Count == 0) { geometry = (PathGeometry)null; } else { geometry = PathGeometryUtilities.Copy(geometry, false); foreach (PathFigure pathFigure in geometry.Figures) { foreach (PathSegment pathSegment in pathFigure.Segments) { pathSegment.ClearValue(PathSegment.IsStrokedProperty); pathSegment.ClearValue(PathSegment.IsSmoothJoinProperty); } } } }
public override void UpdateCachedPath() { PathAnimationSceneNode pathAnimation = this.GetPathAnimation(); this.PathGeometry = pathAnimation == null || pathAnimation.Path == null ? new PathGeometry() : PathGeometryUtilities.Copy(pathAnimation.Path, true); }
private void SetPathUsingMapping(PathGeometry path) { SceneViewModel viewModel = this.targetElement.ViewModel; using (viewModel.AnimationProxyManager != null ? viewModel.AnimationProxyManager.ExpandAllProxiesInActiveContainer() : (IDisposable)null) { foreach (PathAction action in this.changeList.Changes) { System.Windows.Media.Geometry geometry = this.targetElement.GetLocalOrDefaultValueAsWpf((IPropertyId)this.pathProperty) as System.Windows.Media.Geometry; if (geometry == null && this.targetElement.IsValueExpression((IPropertyId)this.pathProperty)) { geometry = this.targetElement.ViewModel.DefaultView.ConvertToWpfValue(this.targetElement.ViewModel.CreateInstance(this.targetElement.GetLocalValueAsSceneNode((IPropertyId)this.pathProperty).DocumentNodePath)) as System.Windows.Media.Geometry; if (geometry == null) { geometry = this.targetElement.GetComputedValueAsWpf((IPropertyId)this.pathProperty) as System.Windows.Media.Geometry; if (geometry == null) { return; } } } PathGeometry oldGeometry = new PathGeometry(); oldGeometry.AddGeometry(geometry.Clone()); PathGeometry pathGeometry = new PathGeometry(); pathGeometry.AddGeometry(geometry); PathFigureEditor pathFigureEditor = new PathFigureEditor(pathGeometry.Figures[action.Figure]); PathGeometryEditor pathGeometryEditor = new PathGeometryEditor(pathGeometry); switch (action.Action) { case PathActionType.InsertPoint: pathFigureEditor.SubdivideSegment(action.PointIndex, action.Parameter); break; case PathActionType.DeletePoint: pathFigureEditor.RemovePoint(action.PointIndex); break; case PathActionType.DeleteSegment: if (action.Segment == 0 && pathFigureEditor.PathFigure.Segments.Count > 1) { pathFigureEditor.RemoveFirstSegment(); break; } pathFigureEditor.RemoveLastSegment(); break; case PathActionType.PromoteSegment: pathFigureEditor.PromoteSegment(action.PointIndex); break; case PathActionType.Rotate: pathFigureEditor.Rotate(); break; case PathActionType.Open: pathFigureEditor.Open(action.PointIndex); break; case PathActionType.Split: pathFigureEditor.Split(action.PointIndex); break; case PathActionType.SplitAndAdd: pathGeometryEditor.SplitFigure(action.Figure, action.PointIndex); break; case PathActionType.RemoveFigure: pathGeometryEditor.RemoveFigure(action.Figure); break; case PathActionType.AppendSegment: PathAppendLineAction appendLineAction; if ((appendLineAction = action as PathAppendLineAction) != null) { Point point = appendLineAction.Point; if (action.Figure < path.Figures.Count && action.Segment < path.Figures[action.Figure].Segments.Count) { LineSegment lineSegment = path.Figures[action.Figure].Segments[action.Segment] as LineSegment; if (lineSegment != null) { point = lineSegment.Point; } } pathFigureEditor.LineTo(point); break; } PathAppendQuadraticBezierAction quadraticBezierAction; if ((quadraticBezierAction = action as PathAppendQuadraticBezierAction) != null) { Point point1 = quadraticBezierAction.Point1; Point point2 = quadraticBezierAction.Point2; if (action.Figure < path.Figures.Count && action.Segment < path.Figures[action.Figure].Segments.Count) { QuadraticBezierSegment quadraticBezierSegment = path.Figures[action.Figure].Segments[action.Segment] as QuadraticBezierSegment; if (quadraticBezierSegment != null) { point1 = quadraticBezierSegment.Point1; point2 = quadraticBezierSegment.Point2; } } pathFigureEditor.QuadraticCurveTo(point1, point2); break; } PathAppendBezierAction appendBezierAction; if ((appendBezierAction = action as PathAppendBezierAction) != null) { Point point1 = appendBezierAction.Point1; Point point2 = appendBezierAction.Point2; Point point3 = appendBezierAction.Point3; if (action.Figure < path.Figures.Count && action.Segment < path.Figures[action.Figure].Segments.Count) { BezierSegment bezierSegment = path.Figures[action.Figure].Segments[action.Segment] as BezierSegment; if (bezierSegment != null) { point1 = bezierSegment.Point1; point2 = bezierSegment.Point2; point3 = bezierSegment.Point3; } } pathFigureEditor.CubicCurveTo(point1, point2, point3); break; } break; case PathActionType.Close: pathFigureEditor.CloseWithLineSegment(); break; case PathActionType.Join: pathGeometryEditor.JoinFigure(action.Figure, action.PointIndex); break; case PathActionType.Reverse: pathFigureEditor.Reverse(); break; } this.targetElement.SetLocalValueAsWpf((IPropertyId)this.pathProperty, (object)pathGeometry); this.ApplyAnimationChanges(oldGeometry, pathGeometry, action); if (action.Action == PathActionType.PromoteSegment && action.Segment < pathGeometry.Figures[action.Figure].Segments.Count) { this.targetElement.ViewModel.Document.OnUpdatedEditTransaction(); this.SetKeyframesForSegment(path, action.Figure, action.Segment); } } this.RemoveInvalidAnimations(PathGeometryUtilities.GetPathGeometryFromGeometry((System.Windows.Media.Geometry) this.targetElement.GetLocalOrDefaultValueAsWpf((IPropertyId)this.pathProperty))); } }
private HashSet <SceneElement> PathPartDelete(SceneEditTransaction editTransaction) { HashSet <SceneElement> hashSet = new HashSet <SceneElement>(); PathPartSelectionSet partSelectionSet = this.SceneViewModel.PathPartSelectionSet; Dictionary <PathEditMode, List <PathEditorTarget> > dictionary = new Dictionary <PathEditMode, List <PathEditorTarget> >(); dictionary[PathEditMode.ClippingPath] = new List <PathEditorTarget>(); dictionary[PathEditMode.ScenePath] = new List <PathEditorTarget>(); dictionary[PathEditMode.MotionPath] = new List <PathEditorTarget>(); Tool activeTool = this.SceneViewModel.DesignerContext.ToolManager.ActiveTool; if (activeTool != null) { foreach (PathPart pathPart in partSelectionSet.Selection) { BaseFrameworkElement frameworkElement = pathPart.SceneElement as BaseFrameworkElement; if (frameworkElement != null) { PathEditorTarget pathEditorTarget = activeTool.GetPathEditorTarget((Base2DElement)frameworkElement, pathPart.PathEditMode); if (pathEditorTarget != null && !dictionary[pathPart.PathEditMode].Contains(pathEditorTarget)) { dictionary[pathPart.PathEditMode].Add(pathEditorTarget); hashSet.Add((SceneElement)frameworkElement); } } } } List <PathEditorTarget> list1 = new List <PathEditorTarget>(); List <PathEditorTarget> list2 = new List <PathEditorTarget>(); foreach (KeyValuePair <PathEditMode, List <PathEditorTarget> > keyValuePair in dictionary) { foreach (PathEditorTarget pathEditorTarget in keyValuePair.Value) { pathEditorTarget.BeginEditing(); int count1 = pathEditorTarget.PathGeometry.Figures.Count; ICollection <PathPart> selectionByElement = partSelectionSet.GetSelectionByElement((SceneElement)pathEditorTarget.EditingElement, keyValuePair.Key); new DeleteCommand.SelectedComponentsRemover(pathEditorTarget).Execute(selectionByElement); pathEditorTarget.EndEditing(false); pathEditorTarget.PostDeleteAction(); if (keyValuePair.Key == PathEditMode.ScenePath) { if (!PathGeometryUtilities.IsEmpty(pathEditorTarget.PathGeometry)) { PathElement pathElement = (PathElement)pathEditorTarget.EditingElement; int count2 = pathElement.PathGeometry.Figures.Count; if (count1 == 1 && count2 > 1) { ISceneNodeCollection <SceneNode> collectionContainer = pathElement.GetCollectionContainer(); if (!collectionContainer.FixedCapacity.HasValue || collectionContainer.FixedCapacity.Value >= collectionContainer.Count - 1 + count2) { list2.Add(pathEditorTarget); } } } else { list1.Add(pathEditorTarget); } } pathEditorTarget.AddCriticalEdit(); } } List <SceneElement> list3 = new List <SceneElement>(); foreach (PathEditorTarget pathEditorTarget in list2) { PathElement pathElement1 = (PathElement)pathEditorTarget.EditingElement; using (this.SceneView.AdornerLayer.SuspendUpdates()) { this.SceneView.UpdateLayout(); foreach (PathElement pathElement2 in PathCommandHelper.ReleaseCompoundPaths(pathElement1, editTransaction)) { list3.Add((SceneElement)pathElement2); } } } foreach (PathEditorTarget pathEditorTarget in list1) { pathEditorTarget.RemovePath(); } partSelectionSet.Clear(); this.SceneViewModel.ElementSelectionSet.ExtendSelection((ICollection <SceneElement>)list3); foreach (SceneElement sceneElement in list3) { hashSet.Add(sceneElement); } return(hashSet); }
protected override void EndEditingInternal(bool pathJustCreated) { Matrix identity = Matrix.Identity; if (!pathJustCreated) { Transform geometryTransform = this.pathElement.GeometryTransform; if (geometryTransform != null) { identity = geometryTransform.Value; } } Rect extent1 = PathGeometryUtilities.TightExtent(this.PathGeometry, identity); Rect extent2 = extent1; bool flag1 = false; if (this.ViewModel.AnimationEditor.IsKeyFraming) { if ((Stretch)this.pathElement.GetLocalOrDefaultValueAsWpf(ShapeElement.StretchProperty) != Stretch.None) { flag1 = true; if (!pathJustCreated) { extent1 = PathGeometryUtilities.TightExtent(this.pathElement.PathGeometry, Matrix.Identity); } using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) { this.pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)Stretch.None); this.ViewModel.Document.OnUpdatedEditTransaction(); } } } if (this.pathElement.EnsureSingleSegmentsInPathGeometry()) { this.ViewModel.Document.OnUpdatedEditTransaction(); } } Rect extent3 = PathCommandHelper.InflateRectByStrokeWidth(extent1, this.pathElement, pathJustCreated); Rect rect1 = PathCommandHelper.InflateRectByStrokeWidth(extent2, this.pathElement, pathJustCreated); Rect computedBounds = this.pathElement.GetComputedBounds((Base2DElement)this.pathElement); PathGeometry pathGeometry1 = this.PathGeometry; if (flag1 && !pathJustCreated) { ScenePathEditorTarget.NormalizePathGeometry(pathGeometry1, extent3, computedBounds); } if (flag1) { this.OnMatrixChanged(); } Vector vector1 = new Vector(extent3.Left, extent3.Top); Transform transform = (Transform)null; Point centerPoint = new Point(); bool flag2 = (Stretch)this.pathElement.GetComputedValueAsWpf(ShapeElement.StretchProperty) == Stretch.None && (this.ViewModel.AnimationEditor.IsKeyFraming || this.pathElement.HasVertexAnimations) && !pathJustCreated; if (flag2 && !computedBounds.Contains(rect1)) { ILayoutDesigner designerForChild = this.ViewModel.GetLayoutDesignerForChild((SceneElement)this.pathElement, true); Rect childRect = designerForChild.GetChildRect((BaseFrameworkElement)this.pathElement); double x = Math.Min(0.0, rect1.Left); double y = Math.Min(0.0, rect1.Top); Vector vector2 = new Vector(x, y); centerPoint = this.pathElement.RenderTransformOrigin; transform = this.pathElement.RenderTransform; if (transform != null && !transform.Value.IsIdentity) { using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) this.UpdateCenterPoint(new Point(0.0, 0.0)); } vector2 *= transform.Value; } double num1 = Math.Max(0.0, rect1.Right - computedBounds.Right); double num2 = Math.Max(0.0, rect1.Bottom - computedBounds.Bottom); childRect.X += vector2.X; childRect.Y += vector2.Y; childRect.Width += -x + num1; childRect.Height += -y + num2; using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) designerForChild.SetChildRect((BaseFrameworkElement)this.pathElement, childRect); } if (x != 0.0 || y != 0.0) { this.AdjustKeyframes(new Vector(x, y)); ScenePathEditorTarget.UpdateAllPoints(pathGeometry1, new Vector(x, y), 1.0, 1.0); PathGeometry pathGeometry2 = this.pathElement.PathGeometry; ScenePathEditorTarget.UpdateAllPoints(pathGeometry2, new Vector(x, y), 1.0, 1.0); this.pathElement.PathGeometry = pathGeometry2; } this.ViewModel.Document.OnUpdatedEditTransaction(); if (transform != null && !transform.Value.IsIdentity) { using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) this.UpdateCenterPoint(centerPoint); } } } if (!flag2 && (Stretch)this.pathElement.GetComputedValueAsWpf(ShapeElement.StretchProperty) == Stretch.None) { ScenePathEditorTarget.UpdateAllPoints(pathGeometry1, vector1, 1.0, 1.0); } if (!flag2) { using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) { centerPoint = this.pathElement.RenderTransformOrigin; transform = this.pathElement.RenderTransform; if (!extent3.IsEmpty) { if (transform != null && !transform.Value.IsIdentity) { this.UpdateCenterPoint(new Point(0.0, 0.0)); vector1 *= transform.Value; } ILayoutDesigner designerForChild = this.ViewModel.GetLayoutDesignerForChild((SceneElement)this.pathElement, false); Rect rect2 = designerForChild.GetChildRect((BaseFrameworkElement)this.pathElement); if (pathJustCreated) { rect2 = new Rect(0.0, 0.0, 0.0, 0.0); } double width = extent3.Width; double height = extent3.Height; rect2.Offset(vector1); rect2.Width = width; rect2.Height = height; designerForChild.SetChildRect((BaseFrameworkElement)this.pathElement, rect2); } } } } if (this.pathElement.IsAttached && (this.ViewModel.AnimationEditor.IsKeyFraming || this.pathElement.HasVertexAnimations) && !pathJustCreated) { new PathDiff((Base2DElement)this.pathElement, PathElement.DataProperty, this.PathDiffChangeList).SetPathUsingMinimalDiff(pathGeometry1); } else { this.pathElement.PathGeometry = pathGeometry1; } if (flag2) { return; } using (this.ViewModel.ForceBaseValue()) { using (this.ViewModel.AnimationEditor.DeferKeyFraming()) { if (extent3.IsEmpty) { return; } this.ViewModel.Document.OnUpdatedEditTransaction(); if (transform == null || transform.Value.IsIdentity) { return; } this.UpdateCenterPoint(centerPoint); } } }
public override void Execute() { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(this.undoDescription)) { this.ConvertSelectedElementsToPathIfNecessary(); editTransaction.Update(); this.SceneViewModel.DefaultView.UpdateLayout(); SceneElementSelectionSet elementSelectionSet = this.SceneViewModel.ElementSelectionSet; SceneElement primarySelection = elementSelectionSet.PrimarySelection; System.Windows.Media.Geometry renderedGeometryAsWpf = this.SceneView.GetRenderedGeometryAsWpf(primarySelection); if (renderedGeometryAsWpf == null) { return; } this.Initialize(renderedGeometryAsWpf); SceneElementCollection elementCollection = new SceneElementCollection(); foreach (SceneElement shapeElement in elementSelectionSet.Selection) { if (shapeElement != primarySelection) { elementCollection.Add(shapeElement); System.Windows.Media.Geometry secondaryGeometry = this.SceneView.GetRenderedGeometryAsWpf(shapeElement); if (secondaryGeometry == null) { return; } Matrix transformToElement = shapeElement.GetComputedTransformToElement(primarySelection); if (!transformToElement.IsIdentity) { MatrixTransform matrixTransform = new MatrixTransform(transformToElement); matrixTransform.Freeze(); GeometryGroup geometryGroup = new GeometryGroup(); geometryGroup.Children.Add(secondaryGeometry); geometryGroup.Transform = (Transform)matrixTransform; secondaryGeometry = (System.Windows.Media.Geometry)geometryGroup; } this.Combine(secondaryGeometry); } } PathGeometry result = this.GetResult(); BooleanCommand.CleanUpPathGeometry(ref result); PathGeometry pathGeometry = PathConversionHelper.RemoveDegeneratePoints((System.Windows.Media.Geometry)result); elementSelectionSet.Clear(); PathGeometryUtilities.CollapseSingleSegmentsToPolySegments(pathGeometry); PathElement pathElement = (PathElement)this.SceneViewModel.CreateSceneNode(PlatformTypes.Path); Dictionary <IPropertyId, SceneNode> properties = (Dictionary <IPropertyId, SceneNode>)null; using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove()) { this.SceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree(primarySelection); properties = SceneElementHelper.StoreProperties((SceneNode)primarySelection); ISceneNodeCollection <SceneNode> collectionContainer = primarySelection.GetCollectionContainer(); int index = collectionContainer.IndexOf((SceneNode)primarySelection); collectionContainer[index] = (SceneNode)pathElement; } foreach (SceneElement element in elementCollection) { this.SceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree(element); element.Remove(); } using (this.SceneViewModel.ForceBaseValue()) { if (properties != null) { SceneElementHelper.ApplyProperties((SceneNode)pathElement, properties); } pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)Stretch.Fill); PathCommandHelper.ReplacePathGeometry(pathElement, pathGeometry, editTransaction); } elementSelectionSet.SetSelection((SceneElement)pathElement); editTransaction.Commit(); } }
public static Transform ReplacePathGeometry(PathElement pathElement, PathGeometry pathGeometry, SceneEditTransaction editTransaction) { Transform transform1 = Transform.Identity; using (pathElement.ViewModel.ForceBaseValue()) { if (pathGeometry == null) { pathElement.ClearLocalValue(PathElement.DataProperty); } else { editTransaction.Update(); ILayoutDesigner designerForChild = pathElement.ViewModel.GetLayoutDesignerForChild((SceneElement)pathElement, true); Rect childRect = designerForChild.GetChildRect((BaseFrameworkElement)pathElement); Path path = pathElement.Path; Transform transform2 = path == null ? (Transform)null : path.RenderTransform; Point point1 = path == null ? new Point(0.0, 0.0) : path.RenderTransformOrigin; double num = path == null || path.Stroke == null ? 0.0 : path.StrokeThickness; Rect bounds = pathGeometry.Bounds; PathGeometry pathGeometry1 = new PathGeometry(); pathGeometry1.AddGeometry((System.Windows.Media.Geometry)pathGeometry); Rect rect1 = PathCommandHelper.InflateRectByStrokeWidth(pathGeometry1.Bounds, pathElement, false); Vector vector1 = new Vector(-rect1.Left, -rect1.Top); transform1 = (Transform) new TranslateTransform(vector1.X, vector1.Y); PathGeometry pathGeometry2 = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)pathGeometry1, transform1); pathElement.PathGeometry = pathGeometry2; PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(pathElement.Platform); PathCommandHelper.TransformPointKeyframes((SceneElement)pathElement, propertyReference, transform1); if (!bounds.IsEmpty) { bounds.Inflate(num / 2.0, num / 2.0); Rect rect2 = new Rect(childRect.Left + bounds.Left, childRect.Top + bounds.Top, bounds.Width, bounds.Height); editTransaction.Update(); designerForChild.SetChildRect((BaseFrameworkElement)pathElement, rect2); if (pathElement.IsSet(Base2DElement.RenderTransformOriginProperty) != PropertyState.Set) { if (transform2 != null) { if (transform2.Value.IsIdentity) { goto label_15; } } else { goto label_15; } } Vector vector2 = childRect.TopLeft + new Vector(point1.X * childRect.Width, point1.Y * childRect.Height) - rect2.TopLeft; Point point2 = new Point(0.0, 0.0); if (rect2.Width != 0.0) { point2.X = vector2.X / rect2.Width; } if (rect2.Height != 0.0) { point2.Y = vector2.Y / rect2.Height; } pathElement.RenderTransformOrigin = point2; } } } label_15: return(transform1); }
protected override void EndEditingInternal(bool pathJustCreated) { this.ViewModel.AnimationEditor.SetMotionPath((SceneElement)this.editingElement, PathGeometryUtilities.Copy(this.PathGeometry, true), new double?(), new double?()); }