public void ApplyTransformToNewAnimations(Transform transform) { foreach (KeyValuePair <StoryboardTimelineSceneNode, TimelineSceneNode> keyValuePair in this.toAdd) { PathCommandHelper.ApplyTransformToAnimation(keyValuePair.Value, transform); } }
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 static void MoveVertexAnimations(SceneElement source, PropertyReference sourceReferencePrefix, SceneElement destination, PropertyReference destinationReferencePrefix, Transform transform) { PathAnimationMovePackage animationMove = new PathAnimationMovePackage(); PathCommandHelper.MoveVertexAnimations(source, sourceReferencePrefix, destination, destinationReferencePrefix, transform, animationMove); animationMove.AddAndRemove(); }
public static void MoveVertexAnimations(SceneElement source, PropertyReference sourceReferencePrefix, SceneElement destination, PropertyReference destinationReferencePrefix, Transform transform, PathAnimationMovePackage animationMove) { foreach (StoryboardTimelineSceneNode parent in source.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(source.StoryboardContainer)) { foreach (TimelineSceneNode timeline1 in (IEnumerable <TimelineSceneNode>)parent.Children) { if (timeline1.TargetElement == source && timeline1.TargetProperty != null && sourceReferencePrefix.IsPrefixOf(timeline1.TargetProperty)) { PropertyReference propertyReference = destinationReferencePrefix; for (int count = sourceReferencePrefix.Count; count < timeline1.TargetProperty.Count; ++count) { propertyReference = propertyReference.Append(timeline1.TargetProperty[count]); } TimelineSceneNode timeline2 = (TimelineSceneNode)source.ViewModel.GetSceneNode(timeline1.DocumentNode.Clone(timeline1.DocumentContext)); if (transform != null) { PathCommandHelper.ApplyTransformToAnimation(timeline2, transform); } timeline2.TargetProperty = propertyReference; timeline2.TargetElement = (SceneNode)destination; animationMove.Add(parent, timeline2); animationMove.Remove(parent, timeline1); } } } }
public override void Execute() { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitReleaseCompoundPath)) { SceneElementSelectionSet elementSelectionSet = this.SceneViewModel.ElementSelectionSet; ICollection <SceneElement> collection = (ICollection <SceneElement>)elementSelectionSet.Selection; elementSelectionSet.Clear(); SceneElementCollection elementCollection = new SceneElementCollection(); foreach (SceneElement sceneElement in (IEnumerable <SceneElement>)collection) { PathElement pathElement1 = sceneElement as PathElement; if (ReleaseCompoundPathCommand.GetFigureCount(pathElement1) > 1) { foreach (PathElement pathElement2 in PathCommandHelper.ReleaseCompoundPaths(pathElement1, editTransaction)) { elementCollection.Add((SceneElement)pathElement2); } } else { elementCollection.Add(sceneElement); } } elementSelectionSet.SetSelection((ICollection <SceneElement>)elementCollection, (SceneElement)null); editTransaction.Commit(); } }
private static void TransferPathFigureAnimations(PathElement oldElement, PathElement newElement, PropertyReference pathProperty, int oldFigureIndex, int newFigureIndex, Transform transform) { PathAnimationMovePackage animationMove = new PathAnimationMovePackage(); PathCommandHelper.TransferPathFigureAnimations(oldElement, newElement, pathProperty, oldFigureIndex, newFigureIndex, transform, animationMove); animationMove.AddAndRemove(); }
public override void Execute() { using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove()) { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitConvertToPath, false)) { PathCommandHelper.ConvertSelectionToPath(this.SceneViewModel.ElementSelectionSet); editTransaction.Commit(); } } }
private void ConvertSelectedElementsToPathIfNecessary() { using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove()) { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitConvertToPath, true)) { PathCommandHelper.ConvertSelectionToPathIfNeeded(this.SceneViewModel.ElementSelectionSet, new SceneElementFilter(BooleanCommand.IsElementToPathConversionNecessary)); editTransaction.Commit(); } } }
private static void TransferPathFigureAnimations(PathElement oldElement, PathElement newElement, PropertyReference pathProperty, int oldFigureIndex, int newFigureIndex, Transform transform, PathAnimationMovePackage animationMove) { IProjectContext projectContext = newElement.ProjectContext; IType type = projectContext.ResolveType(PlatformTypes.PathFigureCollection); PropertyReference propertyReference = pathProperty.Append(PathElement.FiguresProperty); ReferenceStep step1 = (ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)projectContext, type.RuntimeType, oldFigureIndex); PropertyReference sourceReferencePrefix = propertyReference.Append(step1); ReferenceStep step2 = (ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((ITypeResolver)projectContext, type.RuntimeType, newFigureIndex); PropertyReference destinationReferencePrefix = propertyReference.Append(step2); PathCommandHelper.MoveVertexAnimations((SceneElement)oldElement, sourceReferencePrefix, (SceneElement)newElement, destinationReferencePrefix, transform, animationMove); }
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 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); }
public static void MakeCompoundPath(PathElement mainElement, List <PathElement> otherElements, SceneEditTransaction editTransaction) { PathElement pathElement = otherElements[otherElements.Count - 1]; ISceneElementCollection elementCollection = (ISceneElementCollection) new SceneElementCollection(); PathAnimationMovePackage animationMove = new PathAnimationMovePackage(); PathGeometry pathGeometry = new PathGeometry(); System.Windows.Media.Geometry geometry1 = (System.Windows.Media.Geometry)mainElement.TransformedGeometry; pathGeometry.AddGeometry(geometry1); foreach (PathElement oldElement in otherElements) { System.Windows.Media.Geometry geometry2 = (System.Windows.Media.Geometry)oldElement.TransformedGeometry; Matrix transformToElement = oldElement.GetComputedTransformToElement((SceneElement)mainElement); bool isIdentity = transformToElement.IsIdentity; Transform transform = isIdentity ? Transform.Identity : (Transform) new MatrixTransform(transformToElement); transform.Freeze(); if (!isIdentity) { GeometryGroup geometryGroup = new GeometryGroup(); geometryGroup.Children.Add(geometry2); geometryGroup.Transform = transform; geometry2 = (System.Windows.Media.Geometry)geometryGroup; } int count = pathGeometry.Figures.Count; pathGeometry.AddGeometry(geometry2); int num = pathGeometry.Figures.Count - count; PropertyReference propertyReference = PathCommandHelper.GetPathDataPropertyReference(oldElement.Platform); for (int oldFigureIndex = 0; oldFigureIndex < num; ++oldFigureIndex) { PathCommandHelper.TransferPathFigureAnimations(oldElement, mainElement, propertyReference, oldFigureIndex, count + oldFigureIndex, transform, animationMove); } elementCollection.Add((SceneElement)oldElement); } animationMove.Remove(); Transform transform1 = PathCommandHelper.ReplacePathGeometry(mainElement, pathGeometry, editTransaction); animationMove.ApplyTransformToNewAnimations(transform1); animationMove.Add(); PathCommandHelper.AdjustPathForAnimations(mainElement, editTransaction); foreach (SceneElement element in (IEnumerable <SceneElement>)elementCollection) { element.ViewModel.AnimationEditor.DeleteAllAnimationsInSubtree(element); element.ViewModel.RemoveElement((SceneNode)element); } }
public override void Execute() { using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitMakeCompoundPath)) { SceneElementSelectionSet elementSelectionSet = this.SceneViewModel.ElementSelectionSet; List <PathElement> otherElements = new List <PathElement>(); foreach (SceneElement element in elementSelectionSet.Selection) { PathElement pathElement = element as PathElement; if (pathElement != null) { otherElements.Add(pathElement); } else if (PathConversionHelper.CanConvert(element)) { otherElements.Add(PathCommandHelper.ConvertToPath((BaseFrameworkElement)element)); } } editTransaction.Update(); this.DesignerContext.ActiveView.UpdateLayout(); otherElements.Sort((IComparer <PathElement>) new ZOrderComparer <PathElement>(this.SceneViewModel.RootNode)); elementSelectionSet.Clear(); PathElement mainElement = otherElements[0]; BaseFrameworkElement frameworkElement = (BaseFrameworkElement)otherElements[otherElements.Count - 1]; ISceneNodeCollection <SceneNode> collectionForChild = frameworkElement.ParentElement.GetCollectionForChild((SceneNode)frameworkElement); int num = collectionForChild.IndexOf((SceneNode)frameworkElement); SceneNode sceneNode = num + 1 < collectionForChild.Count ? collectionForChild[num + 1] : (SceneNode)null; otherElements.RemoveAt(0); PathCommandHelper.MakeCompoundPath(mainElement, otherElements, editTransaction); mainElement.Remove(); if (sceneNode == null) { collectionForChild.Add((SceneNode)mainElement); } else { collectionForChild.Insert(collectionForChild.IndexOf(sceneNode), (SceneNode)mainElement); } elementSelectionSet.SetSelection((SceneElement)mainElement); editTransaction.Commit(); } }
public static Rect InflateRectByStrokeWidth(Rect extent, PathElement pathElement, bool justCreated) { double halfStrokeWidth = PathCommandHelper.GetHalfStrokeWidth(pathElement); if (halfStrokeWidth != 0.0 && !extent.IsEmpty) { if (justCreated) { double num1 = Math.Truncate(halfStrokeWidth); double num2 = halfStrokeWidth - num1; extent.Inflate(num1, num1); extent.Width += num2 * 2.0; extent.Height += num2 * 2.0; } else { extent.Inflate(halfStrokeWidth, halfStrokeWidth); } } return(extent); }
public static void ConvertSelectionToPathIfNeeded(SceneElementSelectionSet sceneSelectionSet, SceneElementFilter isConversionNeeded) { ReadOnlyCollection <SceneElement> selection = sceneSelectionSet.Selection; SceneElement primarySelection1 = sceneSelectionSet.PrimarySelection; SceneElement primarySelection2 = (SceneElement)null; sceneSelectionSet.Clear(); List <SceneElement> list = new List <SceneElement>(selection.Count); foreach (SceneElement element in selection) { SceneElement sceneElement = element; if (isConversionNeeded(element)) { sceneElement = (SceneElement)PathCommandHelper.ConvertToPath((BaseFrameworkElement)element); } if (element == primarySelection1) { primarySelection2 = sceneElement; } list.Add(sceneElement); } sceneSelectionSet.SetSelection((ICollection <SceneElement>)list, primarySelection2); }
public static void ConvertSelectionToPath(SceneElementSelectionSet sceneSelectionSet) { PathCommandHelper.ConvertSelectionToPathIfNeeded(sceneSelectionSet, (SceneElementFilter)(element => true)); }
public static PathElement ConvertToPath(BaseFrameworkElement element) { SceneViewModel viewModel = element.ViewModel; PathGeometry pathGeometry = PathConversionHelper.ConvertToPathGeometry((SceneElement)element); PathElement pathElement = (PathElement)viewModel.CreateSceneNode(PlatformTypes.Path); ILayoutDesigner designerForChild = viewModel.GetLayoutDesignerForChild((SceneElement)element, true); Rect childRect = designerForChild.GetChildRect(element); Transform transform1 = Transform.Identity; if (element.IsSet(Base2DElement.RenderTransformProperty) == PropertyState.Set) { transform1 = (Transform)element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty); } Point point1 = new Point(0.5, 0.5); if (element.IsSet(Base2DElement.RenderTransformOriginProperty) == PropertyState.Set) { point1 = (Point)element.GetComputedValueAsWpf(Base2DElement.RenderTransformOriginProperty); } bool flag = false; using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoUnitConvertToPath, true)) { using (viewModel.ForceBaseValue()) { pathElement.PathGeometry = pathGeometry; pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)Stretch.Fill); Brush textForeground = PathCommandHelper.GetTextForeground(element); if (textForeground != null) { flag = true; pathElement.SetValueAsWpf(ShapeElement.FillProperty, (object)textForeground); } viewModel.AnimationEditor.DeleteAllAnimations((SceneNode)element); Dictionary <IPropertyId, SceneNode> properties = SceneElementHelper.StoreProperties((SceneNode)element); ISceneNodeCollection <SceneNode> collectionForChild = element.Parent.GetCollectionForChild((SceneNode)element); int index = collectionForChild.IndexOf((SceneNode)element); collectionForChild[index] = (SceneNode)pathElement; if (flag) { List <IPropertyId> list = new List <IPropertyId>(); foreach (KeyValuePair <IPropertyId, SceneNode> keyValuePair in properties) { IPropertyId key = keyValuePair.Key; DependencyPropertyReferenceStep propertyReferenceStep = key as DependencyPropertyReferenceStep; if (propertyReferenceStep != null && !propertyReferenceStep.IsAttachable && (propertyReferenceStep.MemberType != MemberType.DesignTimeProperty && !PlatformTypeHelper.GetDeclaringType((IMember)propertyReferenceStep).IsAssignableFrom(typeof(Path)))) { list.Add(key); } } foreach (IPropertyId key in list) { properties.Remove(key); } } SceneElementHelper.ApplyProperties((SceneNode)pathElement, properties); } if (ProjectNeutralTypes.PrimitiveShape.IsAssignableFrom((ITypeId)element.Type)) { using (viewModel.ForceBaseValue()) { Rect bounds = pathGeometry.Bounds; double halfStrokeWidth = PathCommandHelper.GetHalfStrokeWidth(pathElement); bounds.Inflate(halfStrokeWidth / 2.0, halfStrokeWidth / 2.0); if (transform1 != Transform.Identity && bounds.Size != childRect.Size) { Point point2 = (Point)pathElement.GetComputedValueAsWpf(Base2DElement.RenderTransformOriginProperty); Point point3 = new Point(point2.X * childRect.Width, point2.Y * childRect.Height); Point point4 = new Point((point3.X - bounds.X) / bounds.Width, (point3.Y - bounds.Y) / bounds.Height); pathElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)point4); } bounds.Offset(childRect.Left, childRect.Top); editTransaction.Update(); designerForChild.SetChildRect((BaseFrameworkElement)pathElement, bounds); } } if (flag && !pathGeometry.IsEmpty()) { using (viewModel.ForceBaseValue()) { Rect bounds = pathGeometry.Bounds; bounds.Offset(childRect.Left, childRect.Top); Point point2 = new Point(bounds.Left + point1.X * bounds.Width, bounds.Top + point1.Y * bounds.Height); Point point3 = new Point(childRect.Left + childRect.Width * point1.X, childRect.Top + childRect.Height * point1.Y); Point point4 = new TransformGroup() { Children = { (Transform) new TranslateTransform(-point3.X, -point3.Y), transform1, (Transform) new TranslateTransform(point3.X, point3.Y) } }.Transform(point2); Transform transform2 = (Transform) new CanonicalTransform(transform1) { TranslationX = 0.0, TranslationY = 0.0 }.TransformGroup; Rect rect = new Rect(point4.X - bounds.Width * point1.X, point4.Y - bounds.Height * point1.Y, bounds.Width, bounds.Height); pathElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)point1); editTransaction.Update(); designerForChild.SetChildRect((BaseFrameworkElement)pathElement, rect); pathElement.RenderTransform = transform2; } } editTransaction.Commit(); } return(pathElement); }
public static void GrokPathPointPrecision(PathGeometry geometry, int decimalNumber) { if (geometry == null) { return; } for (int index1 = 0; index1 < geometry.Figures.Count; ++index1) { PathFigure pathFigure = geometry.Figures[index1]; pathFigure.StartPoint = PathCommandHelper.Round(pathFigure.StartPoint, decimalNumber); for (int index2 = 0; index2 < pathFigure.Segments.Count; ++index2) { PathSegment pathSegment = pathFigure.Segments[index2]; if (pathSegment is BezierSegment) { BezierSegment bezierSegment = pathSegment as BezierSegment; bezierSegment.Point1 = PathCommandHelper.Round(bezierSegment.Point1, decimalNumber); bezierSegment.Point2 = PathCommandHelper.Round(bezierSegment.Point2, decimalNumber); bezierSegment.Point3 = PathCommandHelper.Round(bezierSegment.Point3, decimalNumber); } else if (pathSegment is LineSegment) { LineSegment lineSegment = pathSegment as LineSegment; lineSegment.Point = PathCommandHelper.Round(lineSegment.Point, decimalNumber); } else if (pathSegment is QuadraticBezierSegment) { QuadraticBezierSegment quadraticBezierSegment = pathSegment as QuadraticBezierSegment; quadraticBezierSegment.Point1 = PathCommandHelper.Round(quadraticBezierSegment.Point1, decimalNumber); quadraticBezierSegment.Point2 = PathCommandHelper.Round(quadraticBezierSegment.Point2, decimalNumber); } else if (pathSegment is PolyLineSegment) { PointCollection points = (pathSegment as PolyLineSegment).Points; for (int index3 = 0; index3 < points.Count; ++index3) { points[index3] = PathCommandHelper.Round(points[index3], decimalNumber); } } else if (pathSegment is PolyQuadraticBezierSegment) { PointCollection points = (pathSegment as PolyQuadraticBezierSegment).Points; int index3 = 0; while (index2 < points.Count) { points[index3] = PathCommandHelper.Round(points[index3], decimalNumber); ++index3; } } else if (pathSegment is PolyBezierSegment) { PointCollection points = (pathSegment as PolyBezierSegment).Points; for (int index3 = 0; index3 < points.Count; ++index3) { points[index3] = PathCommandHelper.Round(points[index3], decimalNumber); } } else if (pathSegment is ArcSegment) { ArcSegment arcSegment = pathSegment as ArcSegment; arcSegment.Point = PathCommandHelper.Round(arcSegment.Point, decimalNumber); } } } }
public static Point Round(Point point, int decimalNumber) { return(new Point(PathCommandHelper.Round(point.X, decimalNumber), PathCommandHelper.Round(point.Y, decimalNumber))); }
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); }
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); }