private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; Vector delta = this.dragCurrentPosition - this.dragStartPosition; if (this.isConstraining) { delta = this.ConstrainDeltaToAxis(delta); } if (delta == this.lastMove || this.IsAltDown) { return; } this.EnsureEditTransaction(); Vector vector1 = delta - this.lastMove; SceneElement primarySelection = viewModel.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null) { return; } object computedValue = primarySelection.GetComputedValue(propertyReference); if (computedValue != null && !PlatformTypes.IsInstance(computedValue, PlatformTypes.SolidColorBrush, (ITypeResolver)primarySelection.ProjectContext)) { Vector vector2 = vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.StartPointProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(LinearGradientBrushNode.EndPointProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext) && this.Tool is GradientBrushTool) { ReferenceStep referenceStep1 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.CenterProperty); ReferenceStep referenceStep2 = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(RadialGradientBrushNode.GradientOriginProperty); Point point1 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep1.GetCurrentValue(computedValue)) + vector2); Point point2 = RoundingHelper.RoundPosition((Point)viewModel.DefaultView.ConvertToWpfValue(referenceStep2.GetCurrentValue(computedValue)) + vector2); this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point1); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point2); } else { this.TranslateBrushPosition(vector1 * activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, false), primarySelection); } } activeView.EnsureVisible(this.dragStartPosition + delta, scrollNow); this.lastMove = delta; this.UpdateEditTransaction(); }
protected virtual void UpdateCenterPoint(Point centerPoint) { CanonicalTransform canonicalTransform = new CanonicalTransform((Transform)this.EditingElement.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty)); Point elementCoordinates = this.BaseEditingElement.RenderTransformOriginInElementCoordinates; Vector translation = canonicalTransform.Translation; Rect computedTightBounds = ((Base2DElement)this.EditingElement).GetComputedTightBounds(); Point renderTransformOrigin = this.BaseEditingElement.RenderTransformOrigin; Point point2 = new Point((centerPoint.X - computedTightBounds.Left) / (computedTightBounds.Width == 0.0 ? 1.0 : computedTightBounds.Width), (centerPoint.Y - computedTightBounds.Top) / (computedTightBounds.Height == 0.0 ? 1.0 : computedTightBounds.Height)); point2 = RoundingHelper.RoundPosition(point2); Point newOrigin = new Point(computedTightBounds.Left + point2.X * computedTightBounds.Width, computedTightBounds.Top + point2.Y * computedTightBounds.Height); canonicalTransform.UpdateForNewOrigin(elementCoordinates, newOrigin); canonicalTransform.TranslationX = RoundingHelper.RoundLength(canonicalTransform.TranslationX); canonicalTransform.TranslationY = RoundingHelper.RoundLength(canonicalTransform.TranslationY); if (!Point.Equals(renderTransformOrigin, point2)) { this.BaseEditingElement.RenderTransformOrigin = point2; } if (!object.Equals((object)translation.X, (object)canonicalTransform.TranslationX)) { this.EditingElement.SetValue(this.EditingElement.Platform.Metadata.CommonProperties.RenderTransformTranslationX, (object)canonicalTransform.TranslationX); } if (object.Equals((object)translation.Y, (object)canonicalTransform.TranslationY)) { return; } this.EditingElement.SetValue(this.EditingElement.Platform.Metadata.CommonProperties.RenderTransformTranslationY, (object)canonicalTransform.TranslationY); }
private void UpdateRotation() { this.actionString = StringTable.UndoUnitLinearGradientRotation; if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } Vector vector = this.dragCurrentPosition - this.centerInRootCoordinates; double num = Math.Atan2(vector.Y, vector.X); if (this.IsShiftDown) { num = Math.Round(num * 57.2957795130823 / 15.0) * 15.0 * (Math.PI / 180.0); } vector = new Vector(this.radiusInRootCoordinates * Math.Cos(num), this.radiusInRootCoordinates * Math.Sin(num)); Point point1 = this.centerInRootCoordinates + vector; Point point2 = this.centerInRootCoordinates - vector; Point point3 = RoundingHelper.RoundPosition(point1 * this.rootToBrushMatrix); Point point4 = RoundingHelper.RoundPosition(point2 * this.rootToBrushMatrix); if (this.ActiveAdorner.Kind == LinearGradientAdornerKind.EndRotation) { Point point5 = point3; point3 = point4; point4 = point5; } this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point3); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point4); this.UpdateEditTransaction(); this.Cursor = this.ActiveAdorner.AdornerSet.GetCursor((IAdorner)this.ActiveAdorner); }
private void UpdateModelFromMouse(Vector mousePositionDelta) { if (this.cameraElement == null || !(this.cameraElement is ProjectionCameraElement)) { return; } if (this.mouseMovementMode == CameraOrbitToolBehavior.MovementMode.Rotate) { this.totalAzimuthDelta += -mousePositionDelta.X / 2.0; this.totalElevationDelta += -mousePositionDelta.Y / 2.0; double angle1 = this.totalAzimuthDelta; if (this.IsShiftDown) { angle1 = CameraOrbitToolBehavior.shiftSnapAngle * Math.Round(angle1 / CameraOrbitToolBehavior.shiftSnapAngle); } RotateTransform3D rotateTransform3D1 = new RotateTransform3D(Vector3D.DotProduct((Vector3D)this.cameraElement.GetComputedValue(ProjectionCameraElement.UpDirectionProperty), this.cameraInitialUp) >= 0.0 ? (Rotation3D) new AxisAngleRotation3D(this.cameraInitialUp, angle1) : (Rotation3D) new AxisAngleRotation3D(-this.cameraInitialUp, angle1), this.cameraInitialLookAt); Point3D point = rotateTransform3D1.Transform(this.cameraInitialPosition); Vector3D vector3D1 = rotateTransform3D1.Transform(this.cameraInitialUp); Vector3D axis = Vector3D.CrossProduct(this.cameraInitialLookAt - point, vector3D1); double angle2 = this.totalElevationDelta; if (this.IsShiftDown) { angle2 = CameraOrbitToolBehavior.shiftSnapAngle * Math.Round(angle2 / CameraOrbitToolBehavior.shiftSnapAngle); } if (axis.LengthSquared == 0.0) { return; } RotateTransform3D rotateTransform3D2 = new RotateTransform3D((Rotation3D) new AxisAngleRotation3D(axis, angle2), this.cameraInitialLookAt); Point3D point3D1 = rotateTransform3D2.Transform(point); Vector3D vector3D2 = rotateTransform3D2.Transform(vector3D1); Point3D point3D2 = RoundingHelper.RoundPosition(point3D1); Vector3D vector3D3 = RoundingHelper.RoundDirection(vector3D2); Vector3D vector3D4 = RoundingHelper.RoundDirection(this.cameraInitialLookAt - point3D2); this.cameraElement.SetValue(ProjectionCameraElement.PositionProperty, (object)point3D2); this.cameraElement.SetValue(ProjectionCameraElement.UpDirectionProperty, (object)vector3D3); this.cameraElement.SetValue(ProjectionCameraElement.LookDirectionProperty, (object)vector3D4); } else { Matrix3D matrix3D = Helper3D.CameraRotationMatrix((Camera)this.cameraElement.ViewObject.PlatformSpecificObject); if (this.mouseMovementMode == CameraOrbitToolBehavior.MovementMode.TranslateXY) { Vector3D vector3D1 = new Vector3D(matrix3D.M11, matrix3D.M21, matrix3D.M31); Vector3D vector3D2 = new Vector3D(matrix3D.M12, matrix3D.M22, matrix3D.M32); this.cameraInitialPosition += this.scale * (-mousePositionDelta.X * vector3D1 + mousePositionDelta.Y * vector3D2); } else { Vector3D vector3D1 = new Vector3D(matrix3D.M13, matrix3D.M23, matrix3D.M33); this.cameraInitialPosition += this.scale * mousePositionDelta.Y * vector3D1; Vector3D vector3D2 = RoundingHelper.RoundDirection(this.cameraInitialLookAt - this.cameraInitialPosition); this.cameraElement.SetValue(ProjectionCameraElement.LookDirectionProperty, (object)vector3D2); } this.cameraInitialPosition = RoundingHelper.RoundPosition(this.cameraInitialPosition); this.cameraElement.SetValue(ProjectionCameraElement.PositionProperty, (object)this.cameraInitialPosition); } }
protected override bool OnClickEnd(Point pointerPosition, int clickCount) { if (clickCount > 1) { this.actionString = StringTable.UndoUnitResetRadialGradient; Point point = new Point(0.5, 0.5); double num1 = 1.0; double num2 = 1.0; if (this.ActiveAdorner.IsStretchedToFitBoundingBox) { point = new Point(0.5, 0.5); num1 = num2 = 0.5; } else { BaseFrameworkElement frameworkElement = this.EditingElement as BaseFrameworkElement; if (frameworkElement == null) { StyleNode styleNode = this.EditingElement as StyleNode; if (styleNode != null) { frameworkElement = styleNode.TargetElement; } } if (frameworkElement != null) { Rect computedTightBounds = frameworkElement.GetComputedTightBounds(); num1 = RoundingHelper.RoundLength(computedTightBounds.Width / 2.0); num2 = RoundingHelper.RoundLength(computedTightBounds.Height / 2.0); point = RoundingHelper.RoundPosition(new Point(computedTightBounds.X + num1, computedTightBounds.Y + num2)); } } this.CopyPrimaryBrushToSelection(); this.ClearBrushTransform(); if ((Point)this.GetBrushValue(RadialGradientBrushNode.GradientOriginProperty) != point) { this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point); } if ((Point)this.GetBrushValue(RadialGradientBrushNode.CenterProperty) != point) { this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point); } if ((double)this.GetBrushValue(RadialGradientBrushNode.RadiusXProperty) != num1) { this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)num1); } if ((double)this.GetBrushValue(RadialGradientBrushNode.RadiusYProperty) != num2) { this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)num2); } } this.CommitEditTransaction(); return(base.OnClickEnd(pointerPosition, clickCount)); }
private void UpdatePosition() { Point positionInBrush = this.dragCurrentPosition * this.rootToBrushMatrix; if (this.IsShiftDown) { Vector vector1 = this.initialEndPoint - this.initialStartPoint; double length = vector1.Length; if (length == 0.0) { positionInBrush = this.initialStartPoint; } else { Vector vector2 = vector1 / length; positionInBrush = this.initialStartPoint + vector2 * (positionInBrush - this.initialStartPoint) * vector2; } } Point point = RoundingHelper.RoundPosition(new Point(this.initialStartPoint.X + this.initialEndPoint.X - positionInBrush.X, this.initialStartPoint.Y + this.initialEndPoint.Y - positionInBrush.Y)); if (this.ActiveAdorner.Kind == LinearGradientAdornerKind.StartPoint) { positionInBrush *= this.brushToRootMatrix; BrushTransformBehavior.OffsetDragPoint(ref positionInBrush, this.initialEndPoint * this.brushToRootMatrix, this.dragOffset, 0.001 / this.ActiveView.Zoom); positionInBrush = RoundingHelper.RoundPosition(positionInBrush * this.rootToBrushMatrix); this.actionString = StringTable.UndoUnitLinearGradientStart; if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)positionInBrush); if (this.IsAltDown) { this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point); } } else { positionInBrush *= this.brushToRootMatrix; BrushTransformBehavior.OffsetDragPoint(ref positionInBrush, this.initialStartPoint * this.brushToRootMatrix, this.dragOffset, 0.001 / this.ActiveView.Zoom); positionInBrush = RoundingHelper.RoundPosition(positionInBrush * this.rootToBrushMatrix); this.actionString = StringTable.UndoUnitLinearGradientEnd; if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)positionInBrush); if (this.IsAltDown) { this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point); } } this.UpdateEditTransaction(); }
protected override bool OnDrag(Point dragStartPosition, Point dragCurrentPosition, bool scrollNow) { switch (this.ActiveAdorner.Kind) { case RadialGradientAdornerKind.GradientOriginPoint: this.actionString = StringTable.UndoUnitRadialGradientOrigin; if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); } Point point = this.initialCenterInBrush; if (Tolerances.HaveMoved(dragCurrentPosition, this.initialCenterInDocument, this.ActiveView.Zoom)) { Point positionInBrush = this.ActiveAdorner.InverseTransformPoint(dragCurrentPosition * this.initialContextToElementMatrix, true) * this.brushToRootMatrix; BrushTransformBehavior.OffsetDragPoint(ref positionInBrush, this.initialCenterInBrush * this.brushToRootMatrix, this.dragOffset, 0.0); point = RoundingHelper.RoundPosition(positionInBrush * this.rootToBrushMatrix); } if (this.ActiveAdorner.GradientOriginPoint != point) { this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point); this.UpdateEditTransaction(); break; } break; case RadialGradientAdornerKind.RadiusPoint: this.actionString = StringTable.UndoUnitScaleRadialGradient; if (!this.HasMouseMovedAfterDown) { this.CopyPrimaryBrushToSelection(); this.radiusX = (double)this.GetBrushValue(RadialGradientBrushNode.RadiusXProperty); this.radiusY = (double)this.GetBrushValue(RadialGradientBrushNode.RadiusYProperty); if (Math.Abs(this.radiusX) < 0.01) { this.radiusX = 0.01; } if (Math.Abs(this.radiusY) < 0.01) { this.radiusY = 0.01; } } Vector perpendicular; double num1 = GradientStopBehavior.VectorProjection(this.ActiveAdorner.BrushCenter * this.brushToRootMatrix, this.initialPointerPosition, dragCurrentPosition, 0.0, out perpendicular); double num2 = RoundingHelper.RoundLength(this.radiusX * num1); double num3 = RoundingHelper.RoundLength(this.radiusY * num1); this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)num2); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)num3); this.UpdateEditTransaction(); break; } this.ActiveView.EnsureVisible((IAdorner)this.ActiveAdorner, scrollNow); return(true); }
internal AnnotationSceneNode CreateAnnotation(IEnumerable <SceneElement> targets) { Artboard artboard = this.sceneViewModel.DefaultView.Artboard; SceneElement sceneElement = Enumerable.First <SceneElement>(targets); int num = Enumerable.Count <SceneElement>(targets); bool treatTopLeftAsCenter = num > 1 || sceneElement.Equals((object)sceneElement.ViewModel.RootNode); AnnotationSceneNode annotation; using (SceneEditTransaction editTransaction = sceneElement.ViewModel.CreateEditTransaction(StringTable.AddAnnotationUndoUnit)) { annotation = AnnotationManagerSceneNode.CreateAnnotation((SceneNode)sceneElement); foreach (SceneElement element in Enumerable.Skip <SceneElement>(targets, 1)) { AnnotationUtils.AddAnnotationReference(element, annotation); } Point point1; if (treatTopLeftAsCenter) { Rect rect = Rect.Empty; if (num > 1 || !sceneElement.Equals((object)annotation.ViewModel.RootNode)) { rect = artboard.GetElementListBounds(targets); } if (rect.IsEmpty) { rect = artboard.ArtboardBounds; } point1 = new Point(rect.Left + rect.Width / 2.0, rect.Top + rect.Height / 2.0); } else { point1 = artboard.GetElementBounds(sceneElement).TopRight; } Point point2 = RoundingHelper.RoundPosition(point1); annotation.Left = point2.X; annotation.Top = point2.Y; string authorName = this.AnnotationService.DesignerContext.AnnotationsOptionsModel.AuthorName; if (!string.IsNullOrEmpty(authorName)) { annotation.Author = authorName; } string authorInitials = this.AnnotationService.DesignerContext.AnnotationsOptionsModel.AuthorInitials; if (!string.IsNullOrEmpty(authorInitials)) { annotation.AuthorInitials = authorInitials; } AnnotationUtils.SetSerialNumber(annotation); editTransaction.Commit(); } this.CreateAnnotationVisual(annotation).Initialize(treatTopLeftAsCenter); return(annotation); }
protected override void UpdateCenterPoint(Point centerPoint) { Rect elementBounds = this.EditingElementSet.ElementBounds; Point renderTransformOrigin = this.EditingElementSet.RenderTransformOrigin; Point point2 = new Point((centerPoint.X - elementBounds.Left) / (elementBounds.Width == 0.0 ? 1.0 : elementBounds.Width), (centerPoint.Y - elementBounds.Top) / (elementBounds.Height == 0.0 ? 1.0 : elementBounds.Height)); point2 = RoundingHelper.RoundPosition(point2); if (Point.Equals(renderTransformOrigin, point2)) { return; } this.EditingElementSet.RenderTransformOrigin = point2; }
private void OnDragWithin(Vector delta) { Matrix matrix = (((UIElement)this.Parent).RenderTransform ?? Transform.Identity).Clone().Value; matrix.Invert(); Vector offset = matrix.Transform(delta); Size size = this.TransformFromRenderToLayout(this.RenderSize); SceneElement sceneElement = this.Annotation.ViewModel.ActiveSceneInsertionPoint.SceneElement; Rect rectSnap = Rect.Transform(new Rect(this.drag.OriginalAnnotationPos, size), sceneElement.TransformFromRoot); Point point = RoundingHelper.RoundPosition(this.drag.OriginalAnnotationPos + offset + this.SnapRect(rectSnap, sceneElement, offset, EdgeFlags.All)); this.Annotation.Left = point.X; this.Annotation.Top = point.Y; this.drag.Undo.Update(); }
protected override bool OnClickEnd(Point pointerPosition, int clickCount) { if (clickCount > 1) { this.CancelEditTransaction(); this.actionString = StringTable.UndoUnitResetLinearGradient; Point point1 = new Point(); Point point2 = new Point(); if (this.ActiveAdorner.IsStretchedToFitBoundingBox) { point1 = new Point(0.5, 0.0); point2 = new Point(0.5, 1.0); } else { BaseFrameworkElement frameworkElement = this.EditingElement as BaseFrameworkElement; if (frameworkElement == null) { StyleNode styleNode = this.EditingElement as StyleNode; if (styleNode != null) { frameworkElement = styleNode.TargetElement; } } if (frameworkElement != null) { Rect computedTightBounds = frameworkElement.GetComputedTightBounds(); point1 = RoundingHelper.RoundPosition(new Point((computedTightBounds.Left + computedTightBounds.Right) / 2.0, computedTightBounds.Top)); point2 = RoundingHelper.RoundPosition(new Point((computedTightBounds.Left + computedTightBounds.Right) / 2.0, computedTightBounds.Bottom)); } } this.CopyPrimaryBrushToSelection(); this.ClearBrushTransform(); if ((Point)this.GetBrushValue(LinearGradientBrushNode.StartPointProperty) != point1) { this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point1); } if ((Point)this.GetBrushValue(LinearGradientBrushNode.EndPointProperty) != point2) { this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point2); } this.UpdateEditTransaction(); } this.CommitEditTransaction(); return(base.OnClickEnd(pointerPosition, clickCount)); }
protected override void ApplyRotation(double angle) { Point point1 = this.initialElementSetCenter; angle -= this.initialSharedTransform.RotationAngle; this.ActiveView.AdornerLayer.FirePropertyChanged("RotateBoundingBoxAdornerRotationAngle", (object)angle); foreach (SceneElement element in this.EditingElementSet.Elements) { if (!(element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty) is Transform)) { Transform identity = Transform.Identity; } Matrix matrix = this.elementsToElement[element]; Point elementCoordinates = ((Base2DElement)element).RenderTransformOriginInElementCoordinates; Point point2 = point1 * matrix; point2 = new Point(point2.X - elementCoordinates.X, point2.Y - elementCoordinates.Y); Point fixedPoint = RoundingHelper.RoundPosition(point2); CanonicalTransform newTransform = (CanonicalTransform)this.initialTransforms[element].Clone(); newTransform.ApplyRotation(angle, fixedPoint); AdornedToolBehavior.UpdateElementTransform(element, newTransform, AdornedToolBehavior.TransformPropertyFlags.Translation | AdornedToolBehavior.TransformPropertyFlags.RotatationAngle); } if (this.EditingElementSet.HasHomogeneousRotation) { return; } this.EditingElementSet.Update(); this.UpdateEditTransaction(); this.EditingElement.ViewModel.DefaultView.UpdateLayout(); Vector vector1 = this.initialArtboardOrigin - this.EditingElement.DesignerContext.ActiveView.Artboard.ArtboardBounds.TopLeft; Rect bounds = this.EditingElementSet.Bounds; Rect rect = this.initialBounds; Point point3 = new Point(0.0, 0.0); Vector vector2 = this.initialBounds.TopLeft + new Point(this.intialRenderTransformOrigin.X * rect.Width, this.intialRenderTransformOrigin.Y * rect.Height) - point3 - bounds.TopLeft + vector1; vector2.X /= bounds.Width; vector2.Y /= bounds.Height; this.EditingElementSet.RenderTransformOrigin = RoundingHelper.RoundPosition(point3 + vector2); }
private void UpdateBrushForMappingModeChange(PropertyReference brushPropertyReference, BrushMappingMode mappingMode) { GradientBrush gradientBrush = this.GetComputedValueAsWpf(brushPropertyReference) as GradientBrush; if (gradientBrush == null || gradientBrush.MappingMode == mappingMode) { return; } Rect computedTightBounds = this.GetComputedTightBounds(); if (computedTightBounds.IsEmpty) { return; } Matrix identity = Matrix.Identity; Matrix matrix = Matrix.Identity; if (BrushAdorner.IsAdorningFillProperty((SceneElement)this)) { matrix = BrushAdorner.GetStrokeTransform((SceneElement)this); } if (mappingMode == BrushMappingMode.Absolute) { identity *= matrix; identity.Scale(computedTightBounds.Width, computedTightBounds.Height); identity.Translate(computedTightBounds.X, computedTightBounds.Y); } else if (mappingMode == BrushMappingMode.RelativeToBoundingBox) { identity.Translate(-computedTightBounds.X, -computedTightBounds.Y); identity.Scale(computedTightBounds.Width == 0.0 ? 1.0 : 1.0 / computedTightBounds.Width, computedTightBounds.Height == 0.0 ? 1.0 : 1.0 / computedTightBounds.Height); matrix.Invert(); identity *= matrix; } if (identity.IsIdentity) { return; } LinearGradientBrush linearGradientBrush; if ((linearGradientBrush = gradientBrush as LinearGradientBrush) != null) { Point point1 = RoundingHelper.RoundPosition(linearGradientBrush.StartPoint * identity); Point point2 = RoundingHelper.RoundPosition(linearGradientBrush.EndPoint * identity); this.SetValueAsWpf(brushPropertyReference.Append(LinearGradientBrushNode.StartPointProperty), (object)point1); this.SetValueAsWpf(brushPropertyReference.Append(LinearGradientBrushNode.EndPointProperty), (object)point2); } else { RadialGradientBrush radialGradientBrush; if ((radialGradientBrush = gradientBrush as RadialGradientBrush) == null) { return; } Point point1 = RoundingHelper.RoundPosition(radialGradientBrush.Center * identity); Point point2 = RoundingHelper.RoundPosition(radialGradientBrush.GradientOrigin * identity); double num1 = RoundingHelper.RoundLength(radialGradientBrush.RadiusX * identity.M11); double num2 = RoundingHelper.RoundLength(radialGradientBrush.RadiusY * identity.M22); this.SetValueAsWpf(brushPropertyReference.Append(RadialGradientBrushNode.CenterProperty), (object)point1); this.SetValueAsWpf(brushPropertyReference.Append(RadialGradientBrushNode.GradientOriginProperty), (object)point2); this.SetValue(brushPropertyReference.Append(RadialGradientBrushNode.RadiusXProperty), (object)num1); this.SetValue(brushPropertyReference.Append(RadialGradientBrushNode.RadiusYProperty), (object)num2); } }
private void UpdateTranslation(bool scrollNow) { SceneView activeView = this.ActiveView; SceneViewModel viewModel = activeView.ViewModel; if (!this.HasMouseMovedAfterDown) { this.hasInitializedBrush = false; } SceneElement primarySelection = this.ActiveView.ElementSelectionSet.PrimarySelection; if (primarySelection == null) { return; } PropertyReference propertyReference = this.GetBrushPropertyReference((SceneNode)primarySelection); if (propertyReference == null || Adorner.NonAffineTransformInParentStack(primarySelection)) { return; } this.EnsureEditTransaction(); if (!this.hasInitializedBrush) { if (!PlatformTypes.IsInstance(this.ActiveView.ElementSelectionSet.PrimarySelection.GetComputedValue(propertyReference), PlatformTypes.GradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { object lastUsed = BrushCategory.GetLastUsed(this.ActiveView.DesignerContext, this.ActiveView.Document.DocumentContext, BrushCategory.Gradient); this.ActiveView.ElementSelectionSet.PrimarySelection.SetValueAsWpf(propertyReference, lastUsed); this.UpdateEditTransaction(); } this.CopyPrimaryBrushToSelection(); this.hasInitializedBrush = true; } object computedValue = primarySelection.GetComputedValue(propertyReference); Matrix matrix = activeView.GetComputedTransformFromRoot(primarySelection) * BrushAdorner.GetCompleteInverseBrushTransformMatrix((Base2DElement)primarySelection, computedValue, true); Point point1 = this.dragStartPosition * matrix; Point point2 = this.dragCurrentPosition * matrix; Point point3 = RoundingHelper.RoundPosition(point1); Point point4 = RoundingHelper.RoundPosition(point2); if (PlatformTypes.IsInstance(computedValue, PlatformTypes.LinearGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(LinearGradientBrushNode.StartPointProperty, (object)point3); this.SetBrushValue(LinearGradientBrushNode.EndPointProperty, (object)point4); } else if (PlatformTypes.IsInstance(computedValue, PlatformTypes.RadialGradientBrush, (ITypeResolver)primarySelection.ProjectContext)) { this.SetBrushValue(RadialGradientBrushNode.CenterProperty, (object)point3); this.SetBrushValue(RadialGradientBrushNode.GradientOriginProperty, (object)point3); if (this.IsShiftDown) { Vector vector = point4 - point3; this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)vector.Length); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)vector.Length); } else { Point point5 = RoundingHelper.RoundPosition(new Point(Math.Abs(point3.X - point4.X), Math.Abs(point3.Y - point4.Y))); this.SetBrushValue(RadialGradientBrushNode.RadiusXProperty, (object)point5.X); this.SetBrushValue(RadialGradientBrushNode.RadiusYProperty, (object)point5.Y); } } activeView.EnsureVisible(this.dragStartPosition + this.dragCurrentPosition - this.dragStartPosition, scrollNow); this.UpdateEditTransaction(); }