예제 #1
0
        protected override void OnDrag(MouseDevice mouseDevice, double zoom)
        {
            Point  point  = PathFigureUtilities.GetPoint(this.PathEditContext.GetPathFigure(this.Path), this.PathEditContext.PartIndex);
            Point  point1 = this.geometryToDocument.Transform(point);
            Point  viewRootCoordinates = this.GetPointInViewRootCoordinates(mouseDevice, true);
            Vector vector = viewRootCoordinates - point1;
            Vector correspondingVector = ElementUtilities.GetCorrespondingVector(vector, this.geometryToDocument, this.IsShiftDown ? this.AxisConstraint : (AxisConstraint)null);

            if (this.hasMoved || Tolerances.HaveMoved(point1, viewRootCoordinates, zoom))
            {
                this.hasMoved = true;
                PathGeometry       path               = this.Path;
                int                figureIndex        = this.PathEditContext.FigureIndex;
                int                partIndex          = this.PathEditContext.PartIndex;
                PathGeometryEditor pathGeometryEditor = this.BeginEditing();
                PathFigureEditor   pathFigureEditor   = new PathFigureEditor(path.Figures[figureIndex]);
                if (partIndex > 0 || PathFigureUtilities.IsClosed(pathFigureEditor.PathFigure))
                {
                    pathGeometryEditor.SetPoint(figureIndex, partIndex - 1, point - correspondingVector);
                }
                if (pathFigureEditor.GetLastIndexOfDownstreamSegment(partIndex) != partIndex)
                {
                    pathGeometryEditor.SetPoint(figureIndex, partIndex + 1, point + correspondingVector);
                }
                if (partIndex == PathFigureUtilities.PointCount(pathFigureEditor.PathFigure) - 1 && PathFigureUtilities.IsOpen(pathFigureEditor.PathFigure))
                {
                    this.LastTangent = vector;
                }
                this.PathEditorTarget.AddCriticalEdit();
            }
            base.OnDrag(mouseDevice, zoom);
        }
예제 #2
0
        private bool TestGeometryAgainstFrustum(MeshGeometry3D rawGeometry, Material frontMaterial, Material backMaterial, BoundingVolume frustum, Matrix3D transform)
        {
            if (rawGeometry == null)
            {
                return(false);
            }
            TriangleEnumerator triangleEnumerator = new TriangleEnumerator(rawGeometry.Positions, rawGeometry.TriangleIndices);

            Point3D[] point3DArray = new Point3D[3];
            foreach (int[] numArray in triangleEnumerator.TriangleList)
            {
                point3DArray[0] = rawGeometry.Positions[numArray[0]];
                point3DArray[1] = rawGeometry.Positions[numArray[1]];
                point3DArray[2] = rawGeometry.Positions[numArray[2]];
                transform.Transform(point3DArray);
                if (frustum.IsPolygonContainedOrIntersecting(point3DArray))
                {
                    double num = Vector3D.DotProduct(Vector3D.CrossProduct(point3DArray[1] - point3DArray[0], point3DArray[2] - point3DArray[0]), point3DArray[0] - this.frustumCenterRay.Origin);
                    if (Tolerances.LessThanOrClose(num, 0.0) && frontMaterial != null || Tolerances.GreaterThan(num, 0.0) && backMaterial != null)
                    {
                        return(true);
                    }
                }
            }
            return(false);
        }
예제 #3
0
        protected override HitTestResult HitTestCore(PointHitTestParameters hitTestParams)
        {
            Point hitPoint = hitTestParams.HitPoint;

            if (Tolerances.AreClose(hitPoint, this.lastPoint))
            {
                return(base.HitTestCore(hitTestParams));
            }
            this.lastPoint = hitPoint;
            double num;

            if (((LayoutBehavior)this.AdornerSet.Behavior).IsNewGridlineEnabled && Mouse.LeftButton != MouseButtonState.Pressed && Mouse.RightButton != MouseButtonState.Pressed)
            {
                Matrix inverseMatrix = ElementUtilities.GetInverseMatrix(this.AdornerSet.Matrix);
                Point  point         = hitPoint * inverseMatrix;
                Point  pointBegin;
                Point  pointEnd;
                this.GetPoints(out pointBegin, out pointEnd, this.AdornerSet.Matrix);
                num = !new Rect(pointBegin, pointEnd).Contains(point) ? double.NaN : (!this.IsX ? point.Y : point.X);
            }
            else
            {
                num = double.NaN;
            }
            if (!this.position.Equals(num))
            {
                this.position = num;
                if (this.isMouseOver)
                {
                    this.InvalidateRender();
                    this.AdornerSet.Update();
                }
            }
            return(base.HitTestCore(hitTestParams));
        }
예제 #4
0
        protected virtual void ComputeMarginOverrides()
        {
            bool   flag   = false;
            double left   = this.Settings.Margin.Left;
            double right  = this.Settings.Margin.Right;
            double top    = this.Settings.Margin.Top;
            double bottom = this.Settings.Margin.Bottom;

            if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Left, this.Settings.Margin.Left) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Right, this.Settings.Margin.Right))
            {
                this.Settings.LayoutOverrides |= LayoutOverrides.HorizontalMargin;
                left  = this.SettingsFromElement.Margin.Left;
                right = this.SettingsFromElement.Margin.Right;
                flag  = true;
            }
            if (!Tolerances.AreClose(this.SettingsFromElement.Margin.Top, this.Settings.Margin.Top) || !Tolerances.AreClose(this.SettingsFromElement.Margin.Bottom, this.Settings.Margin.Bottom))
            {
                this.Settings.LayoutOverrides |= LayoutOverrides.VerticalMargin;
                top    = this.SettingsFromElement.Margin.Top;
                bottom = this.SettingsFromElement.Margin.Bottom;
                flag   = true;
            }
            if (!flag)
            {
                return;
            }
            this.Settings.Margin = new Thickness(left, top, right, bottom);
        }
예제 #5
0
 public void SetTimeRegion(double originalRegionBegin, double originalRegionEnd, double finalRegionBegin, double finalRegionEnd)
 {
     using (SceneEditTransaction editTransaction = this.ViewModel.CreateEditTransaction(StringTable.UndoUnitMoveScheduledProperties))
     {
         double scaleFactor = (finalRegionEnd - finalRegionBegin) / (originalRegionEnd - originalRegionBegin);
         TimeRegionChangeDetails details = TimeRegionChangeDetails.None;
         if (Tolerances.AreClose(originalRegionEnd - originalRegionBegin, 0.0))
         {
             details |= TimeRegionChangeDetails.FromZero;
         }
         if (Tolerances.AreClose(finalRegionEnd - finalRegionBegin, 0.0))
         {
             details |= TimeRegionChangeDetails.ToZero;
         }
         if (!Tolerances.AreClose(scaleFactor, 1.0))
         {
             details |= TimeRegionChangeDetails.Scale;
         }
         if (!Tolerances.AreClose(originalRegionBegin, finalRegionBegin))
         {
             details |= TimeRegionChangeDetails.Translate;
         }
         this.RecursiveSetTimeRegion(details, scaleFactor, originalRegionBegin, originalRegionEnd, finalRegionBegin, finalRegionEnd);
         editTransaction.Commit();
     }
 }
예제 #6
0
        private PathGeometry GetEllipseGeometry(Point left, Point top, Point right, Point bottom, double horizontalScale, double verticalScale)
        {
            Vector vector1 = right - left;

            if (!Tolerances.NearZero(vector1.Length))
            {
                vector1.Normalize();
                vector1 *= horizontalScale;
            }
            Vector vector2 = top - bottom;

            if (!Tolerances.NearZero(vector2.Length))
            {
                vector2.Normalize();
                vector2 *= verticalScale;
            }
            PathFigure pathFigure = new PathFigure();

            pathFigure.StartPoint = left;
            pathFigure.Segments.Add((PathSegment) new BezierSegment(left + vector2, top - vector1, top, true));
            pathFigure.Segments.Add((PathSegment) new BezierSegment(top + vector1, right + vector2, right, true));
            pathFigure.Segments.Add((PathSegment) new BezierSegment(right - vector2, bottom + vector1, bottom, true));
            pathFigure.Segments.Add((PathSegment) new BezierSegment(bottom - vector1, left - vector2, left, true));
            pathFigure.IsClosed = true;
            pathFigure.Freeze();
            PathGeometry pathGeometry = new PathGeometry((IEnumerable <PathFigure>) new PathFigure[1]
            {
                pathFigure
            });

            pathGeometry.Freeze();
            return(pathGeometry);
        }
        public static bool DrawInscribedRoundedRect(DrawingContext drawingContext, Brush fill, Pen stroke, Rect outerBounds, double cornerRadius)
        {
            Point spineLeftTop     = new Point(outerBounds.Left, outerBounds.Top);
            Point spineRightBottom = new Point(outerBounds.Right, outerBounds.Bottom);
            bool  drewSomething    = false;

            if (stroke != null && !Tolerances.NearZero(stroke.Thickness))
            {
                double halfThickness = stroke.Thickness / 2d;
                spineLeftTop.X     += halfThickness;
                spineLeftTop.Y     += halfThickness;
                spineRightBottom.X -= halfThickness;
                spineRightBottom.Y -= halfThickness;
            }

            Rect spineRect = new Rect(spineLeftTop, spineRightBottom);

            if (!Tolerances.NearZero(spineRect.Width) && !Tolerances.NearZero(spineRect.Height))
            {
                drawingContext.DrawRoundedRectangle(fill, stroke, spineRect, cornerRadius, cornerRadius);
                drewSomething = true;
            }

            return(drewSomething);
        }
예제 #8
0
 public static Rect CalculateInnerRect(Rect outerBounds, double strokeThickness)
 {
     if (!Tolerances.NearZero(strokeThickness))
     {
         return(new Rect(new Point(outerBounds.Left + strokeThickness, outerBounds.Top + strokeThickness), new Point(outerBounds.Right - strokeThickness, outerBounds.Bottom - strokeThickness)));
     }
     return(outerBounds);
 }
예제 #9
0
 public static bool GreaterThan(double value1, double value2)
 {
     if (value1 > value2)
     {
         return(!Tolerances.AreClose(value1, value2));
     }
     return(false);
 }
예제 #10
0
 public static bool LessThan(double value1, double value2)
 {
     if (value1 < value2)
     {
         return(!Tolerances.AreClose(value1, value2));
     }
     return(false);
 }
예제 #11
0
 public static bool LessThanOrClose(double value1, double value2)
 {
     if (value1 >= value2)
     {
         return(Tolerances.AreClose(value1, value2));
     }
     return(true);
 }
예제 #12
0
        public static Rotation3D GetRotation3DFromDirection(Vector3D direction)
        {
            direction.Normalize();
            Vector3D axis = Vector3D.CrossProduct(Vector3DEditor.pointingDirection, direction);
            double   d    = Vector3D.DotProduct(Vector3DEditor.pointingDirection, direction);

            return(!Tolerances.AreClose(axis.LengthSquared, 0.0) ? (Rotation3D) new AxisAngleRotation3D(axis, Math.Acos(d) * 57.2957795130823) : (!Tolerances.AreClose(d, 1.0) ? (Rotation3D) new AxisAngleRotation3D(Vector3DEditor.perpendicularDirection, 180.0) : Rotation3D.Identity));
        }
예제 #13
0
 protected override void OnBegin(PathEditContext pathEditContext, MouseDevice mouseDevice)
 {
     if (!Tolerances.AreClose(this.LastTangent, new Vector(0.0, 0.0)))
     {
         this.LastTangent = new Vector(0.0, 0.0);
     }
     base.OnBegin(pathEditContext, mouseDevice);
 }
예제 #14
0
        public void ApplyScale(Vector scale, Point origin, Point fixedPoint)
        {
            this.Translation += new Vector((1.0 - scale.X) * (fixedPoint.X - origin.X), (1.0 - scale.Y) * (fixedPoint.Y - origin.Y)) * this.Value;
            double num1 = Tolerances.NearZero(this.ScaleX) ? 0.001 : this.ScaleX;
            double num2 = Tolerances.NearZero(this.ScaleY) ? 0.001 : this.ScaleY;

            this.Scale = new Vector(num1 * scale.X, num2 * scale.Y);
        }
예제 #15
0
            internal Radii(CornerRadius radii, Thickness borders, bool outer)
            {
                double num1 = 0.5 * borders.Left;
                double num2 = 0.5 * borders.Top;
                double num3 = 0.5 * borders.Right;
                double num4 = 0.5 * borders.Bottom;

                if (outer)
                {
                    if (Tolerances.NearZero(radii.TopLeft))
                    {
                        this.LeftTop = this.TopLeft = 0.0;
                    }
                    else
                    {
                        this.LeftTop = radii.TopLeft + num1;
                        this.TopLeft = radii.TopLeft + num2;
                    }
                    if (Tolerances.NearZero(radii.TopRight))
                    {
                        this.TopRight = this.RightTop = 0.0;
                    }
                    else
                    {
                        this.TopRight = radii.TopRight + num2;
                        this.RightTop = radii.TopRight + num3;
                    }
                    if (Tolerances.NearZero(radii.BottomRight))
                    {
                        this.RightBottom = this.BottomRight = 0.0;
                    }
                    else
                    {
                        this.RightBottom = radii.BottomRight + num3;
                        this.BottomRight = radii.BottomRight + num4;
                    }
                    if (Tolerances.NearZero(radii.BottomLeft))
                    {
                        this.BottomLeft = this.LeftBottom = 0.0;
                    }
                    else
                    {
                        this.BottomLeft = radii.BottomLeft + num4;
                        this.LeftBottom = radii.BottomLeft + num1;
                    }
                }
                else
                {
                    this.LeftTop     = Math.Max(0.0, radii.TopLeft - num1);
                    this.TopLeft     = Math.Max(0.0, radii.TopLeft - num2);
                    this.TopRight    = Math.Max(0.0, radii.TopRight - num2);
                    this.RightTop    = Math.Max(0.0, radii.TopRight - num3);
                    this.RightBottom = Math.Max(0.0, radii.BottomRight - num3);
                    this.BottomRight = Math.Max(0.0, radii.BottomRight - num4);
                    this.BottomLeft  = Math.Max(0.0, radii.BottomLeft - num4);
                    this.LeftBottom  = Math.Max(0.0, radii.BottomLeft - num1);
                }
            }
예제 #16
0
 public void Render(DrawingContext dc, Rect renderRect, Brush brush, CornerRadius cornerRadius)
 {
     if (brush == null || Tolerances.NearZero(renderRect.Width) || Tolerances.NearZero(renderRect.Height))
     {
         return;
     }
     this.ValidateGeometry(renderRect, cornerRadius);
     dc.DrawGeometry(brush, (Pen)null, (Geometry)this.geometry);
 }
 protected override void Finish()
 {
     if (Tolerances.AreClose(this.initialRenderTransformOrigin, this.EditingElementSet.RenderTransformOrigin))
     {
         return;
     }
     this.EnsureEditTransaction();
     this.EditingElement.ViewModel.Document.AddUndoUnit((IUndoUnit) new MultipleElementCenterEditUndoUnit(this.EditingElementSet, this.initialRenderTransformOrigin, this.EditingElementSet.RenderTransformOrigin));
 }
예제 #18
0
            public static bool AreClose(Point point1, Point point2)
            {
                if (Tolerances.AreClose(point1.X, point2.X) && Tolerances.AreClose(point1.Y, point2.Y))
                {
                    return(true);
                }

                return(false);
            }
예제 #19
0
            /// <summary>
            /// Rounds unit value to nearest pixel.
            /// </summary>
            /// <returns>
            /// Rounded value in units.
            /// </returns>
            public static double RoundToPixel(double units, double unitsPerPixel)
            {
                double pixels      = units / unitsPerPixel;
                double floorPixels = (double)Math.Floor(pixels);

                pixels = Tolerances.LessThan(pixels, floorPixels + 0.5) ?
                         floorPixels : (double)Math.Ceiling(pixels);
                return(pixels * unitsPerPixel);
            }
예제 #20
0
        private void SetRotationFromPointer()
        {
            Vector vector = Mouse.GetPosition((IInputElement)this) - new Point(this.RenderSize.Width / 2.0, this.RenderSize.Height / 2.0);

            if (Tolerances.NearZero(vector) || !this.IsEnabled)
            {
                return;
            }
            double num = Math.Atan2(vector.Y, vector.X) * 180.0 / Math.PI;

            this.RotationAngle = this.ClosestAngleTo(Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift) ? Math.Round(num / 15.0) * 15.0 : RoundingHelper.RoundAngle(num));
        }
예제 #21
0
        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);
        }
예제 #22
0
 protected override bool OnButtonDownOverNonAdorner(Point pointerPosition)
 {
     this.IsProjectedInsertionPoint = Adorner.NonAffineTransformInParentStack(this.ActiveSceneInsertionPoint.SceneElement);
     if (!this.IsProjectedInsertionPoint)
     {
         this.pointList.Clear();
         this.pointList.Add(pointerPosition);
         this.vpFitter.Clear();
         this.vpFitter.Add(pointerPosition, 0L);
         this.vpFitter.CurveTolerance = Tolerances.CurveFittingDistanceTolerance(this.ActiveView.Zoom) * Tolerances.CurveFittingDistanceTolerance(this.ActiveView.Zoom);
     }
     return(true);
 }
예제 #23
0
        private static bool IsNextElementStartOfNewLine(Rect currentElementLayoutBounds, Rect nextElementLayoutBounds, Orientation orientation)
        {
            switch (orientation)
            {
            case Orientation.Horizontal:
                return(Tolerances.LessThan(nextElementLayoutBounds.Left, currentElementLayoutBounds.Right));

            case Orientation.Vertical:
                return(Tolerances.LessThan(nextElementLayoutBounds.Top, currentElementLayoutBounds.Bottom));

            default:
                throw new NotImplementedException(ExceptionStringTable.StackPanelUnrecognizedOrientation);
            }
        }
        private static bool ComputeLineTriangleIntersection(Ray3D line, Point3D[] triangle, out Point hitBarycentric)
        {
            hitBarycentric = new Point(double.NaN, double.NaN);
            Vector3D vector3D1 = triangle[1] - triangle[0];
            Vector3D vector3D2 = triangle[2] - triangle[0];

            if (Tolerances.NearZero(Vector3D.CrossProduct(vector3D1, vector3D2).LengthSquared))
            {
                return(false);
            }
            Vector3D vector3D3 = line.Origin - triangle[0];
            Vector3D vector2_1 = Vector3D.CrossProduct(line.Direction, vector3D2);
            double   d         = Vector3D.DotProduct(vector3D1, vector2_1);

            if (Tolerances.NearZero(d))
            {
                return(false);
            }
            Vector3D vector1;

            if (d > 0.0)
            {
                vector1 = line.Origin - triangle[0];
            }
            else
            {
                vector1 = triangle[0] - line.Origin;
                d       = -d;
            }
            double num1 = 1.0 / d;
            double num2 = Vector3D.DotProduct(vector1, vector2_1);

            if (num2 < 0.0 || d < num2)
            {
                return(false);
            }
            Vector3D vector2_2 = Vector3D.CrossProduct(vector1, vector3D1);
            double   num3      = Vector3D.DotProduct(line.Direction, vector2_2);

            if (num3 < 0.0 || d < num2 + num3)
            {
                return(false);
            }
            double num4 = Vector3D.DotProduct(vector3D2, vector2_2) * num1;
            double x    = num2 * num1;
            double y    = num3 * num1;

            hitBarycentric = new Point(x, y);
            return(true);
        }
예제 #25
0
        private void SetOrientationFromPointer()
        {
            Vector3D positionFromPointer = this.GetPositionFromPointer();
            Vector3D axisOfRotation      = Vector3D.CrossProduct(this.initialPosition, positionFromPointer);

            if (!this.IsEnabled || Tolerances.NearZero(axisOfRotation.Length))
            {
                return;
            }
            axisOfRotation.Normalize();
            Quaternion quaternion = new Quaternion(axisOfRotation, Math.Acos(Vector3D.DotProduct(this.initialPosition, positionFromPointer)) * 57.2957795130823) * this.initialOrientation;

            this.Orientation = (Rotation3D) new AxisAngleRotation3D(quaternion.Axis, quaternion.Angle);
        }
예제 #26
0
 protected override bool OnDragEnd(Point dragStartPosition, Point dragEndPosition)
 {
     if (!this.IsProjectedInsertionPoint)
     {
         SceneView      activeView = this.ActiveView;
         SceneViewModel viewModel  = activeView.ViewModel;
         bool           flag       = false;
         if (this.pointList.Count >= 4)
         {
             Point point1 = this.pointList[0];
             Point point2 = this.pointList[this.pointList.Count - 1];
             if (Tolerances.DoPointsHit(point1, point2, activeView.Zoom))
             {
                 this.pointList[this.pointList.Count - 1] = point1;
                 flag = true;
             }
         }
         PropertyManager   propertyManager   = (PropertyManager)this.ToolBehaviorContext.PropertyManager;
         BezierCurveFitter bezierCurveFitter = new BezierCurveFitter();
         PathGeometry      pathGeometry      = !DebugVariables.Instance.EnableRealTimeFitting ? (!flag ? bezierCurveFitter.OpenFit(this.pointList, true, Tolerances.CurveFitCornerThreshold, Tolerances.CurveFittingDistanceTolerance(activeView.Zoom), true) : bezierCurveFitter.ClosedFit(this.pointList, true, Tolerances.CurveFitCornerThreshold, Tolerances.CurveFittingDistanceTolerance(activeView.Zoom), true)) : this.vpFitter.Path;
         try
         {
             this.EnsureEditTransaction();
             Matrix transformFromRoot = activeView.GetComputedTransformFromRoot(this.ActiveSceneInsertionPoint.SceneElement);
             new PathFigureEditor(pathGeometry.Figures[0]).ApplyTransform(transformFromRoot);
             viewModel.ElementSelectionSet.Clear();
             this.CreatePathElement();
             this.UpdateEditTransaction();
             if (this.EditingElement.IsViewObjectValid)
             {
                 using (ScenePathEditorTarget pathEditorTarget = new ScenePathEditorTarget((PathElement)this.EditingElement))
                 {
                     pathEditorTarget.BeginEditing();
                     pathEditorTarget.PathGeometry = pathGeometry;
                     pathEditorTarget.EndEditing(true);
                 }
             }
             this.CommitEditTransaction();
             this.Tool.RebuildAdornerSets();
         }
         finally
         {
             this.CancelEditTransaction();
             this.ClearFeedback();
             this.PreviewInsertionPoint = (ISceneInsertionPoint)null;
         }
     }
     return(true);
 }
예제 #27
0
        private void ScopeElement_MouseMove(object sender, MouseEventArgs args)
        {
            if (this.ActiveBehavior == null)
            {
                return;
            }
            if ((Keyboard.Modifiers & ModifierKeys.Alt) != ModifierKeys.None)
            {
                this.consumeAltKey = true;
            }
            Point position = args.GetPosition((IInputElement)this.scopeElement);

            if (position == this.lastDragPosition)
            {
                return;
            }
            this.lastDragPosition = position;
            FrameworkElement rootElement = this.RootElement;

            if (rootElement == null)
            {
                return;
            }
            GeneralTransform generalTransform = this.scopeElement.TransformToDescendant((Visual)rootElement);

            if (generalTransform == null)
            {
                return;
            }
            Point point = position * VectorUtilities.GetMatrixFromTransform(generalTransform);

            if (this.IsButtonDown && this.buttonDownHandled)
            {
                if (!this.IsDragging && !Tolerances.HaveMoved(this.dragStartPosition, point, this.view.Zoom))
                {
                    return;
                }
                this.isDragging          = true;
                this.dragCurrentPosition = point;
                args.Handled             = this.ActiveBehavior.HandleDrag(this.dragStartPosition, this.dragCurrentPosition);
            }
            else
            {
                args.Handled = this.ActiveBehavior.HandleHover(point);
            }
        }
예제 #28
0
        private bool ReadCanonicalForm(Transform3D transform, bool useIfChangeable)
        {
            if (!CanonicalTransform3D.IsCanonical(transform))
            {
                return(false);
            }
            Transform3DGroup     transform3Dgroup      = (Transform3DGroup)transform;
            ScaleTransform3D     scaleTransform3D      = transform3Dgroup.Children[1] as ScaleTransform3D;
            RotateTransform3D    rotateTransform3D     = transform3Dgroup.Children[2] as RotateTransform3D;
            TranslateTransform3D translateTransform3D1 = transform3Dgroup.Children[3] as TranslateTransform3D;
            TranslateTransform3D translateTransform3D2 = transform3Dgroup.Children[4] as TranslateTransform3D;

            this.center      = new Point3D(translateTransform3D1.OffsetX, translateTransform3D1.OffsetY, translateTransform3D1.OffsetZ);
            this.scale       = new Vector3D(scaleTransform3D.ScaleX, scaleTransform3D.ScaleY, scaleTransform3D.ScaleZ);
            this.translation = new Vector3D(translateTransform3D2.OffsetX, translateTransform3D2.OffsetY, translateTransform3D2.OffsetZ);
            if (useIfChangeable && !transform3Dgroup.IsFrozen)
            {
                this.transformGroup = transform3Dgroup;
            }
            else
            {
                this.InitializeTransformGroup();
                Vector3D?           nullable            = (Vector3D?)rotateTransform3D.GetValue(CanonicalTransform3D.EulerAnglesProperty);
                bool                flag                = nullable.HasValue;
                AxisAngleRotation3D axisAngleRotation3D = rotateTransform3D.Rotation as AxisAngleRotation3D;
                Quaternion          orientation         = Quaternion.Identity;
                if (axisAngleRotation3D != null)
                {
                    orientation = new Quaternion(axisAngleRotation3D.Axis, axisAngleRotation3D.Angle);
                }
                if (flag)
                {
                    Quaternion quaternion = Helper3D.QuaternionFromEulerAngles(nullable.Value);
                    if (!Tolerances.AreClose(quaternion.Angle, orientation.Angle) || !Tolerances.AreClose(quaternion.Axis, orientation.Axis))
                    {
                        flag = false;
                    }
                }
                if (!flag)
                {
                    nullable = new Vector3D?(Helper3D.EulerAnglesFromQuaternion(orientation));
                }
                this.RotationAngles = nullable.Value;
            }
            return(true);
        }
예제 #29
0
        private void GetArcGeometry(Vector3D axis1, Vector3D axis2, Vector3D normal, out PathGeometry frontGeometry, out PathGeometry backGeometry)
        {
            Vector3D vector3D = Vector3D.CrossProduct(normal, new Vector3D(0.0, 0.0, 1.0));

            if (Tolerances.NearZero(vector3D.Length))
            {
                Point  point           = new Point(this.ActualWidth / 2.0, this.ActualHeight / 2.0);
                double num             = this.ActualWidth / 2.0;
                Vector vector1         = new Vector(1.0, 0.0);
                Vector vector2         = new Vector(0.0, -1.0);
                Point  top             = point + vector2 * num;
                Point  bottom          = point - vector2 * num;
                Point  left            = point - vector1 * num;
                Point  right           = point + vector1 * num;
                double horizontalScale = num * ArcBallPresenter.tangentSize;
                double verticalScale   = num * ArcBallPresenter.tangentSize;
                frontGeometry = this.GetEllipseGeometry(left, top, right, bottom, horizontalScale, verticalScale);
                backGeometry  = new PathGeometry();
            }
            else
            {
                vector3D.Normalize();
                axis1 = vector3D;
                axis2 = Vector3D.CrossProduct(normal, axis1);
                if (axis2.Z < 0.0)
                {
                    axis2 = -axis2;
                }
                Vector vector1         = new Vector(axis1.X, -axis1.Y);
                Vector vector2         = new Vector(axis2.X, -axis2.Y);
                Point  center          = new Point(this.ActualWidth / 2.0, this.ActualHeight / 2.0);
                double num             = this.ActualWidth / 2.0;
                Point  top1            = center + vector2 * num;
                Point  top2            = center - vector2 * num;
                Point  point1          = center + vector1 * num;
                Point  point2          = center - vector1 * num;
                double horizontalScale = vector1.Length * num * ArcBallPresenter.tangentSize;
                double verticalScale   = vector2.Length * num * ArcBallPresenter.tangentSize;
                frontGeometry = this.GetSemiEllipseGeometry(point1, top1, point2, center, horizontalScale, verticalScale);
                backGeometry  = this.GetSemiEllipseGeometry(point2, top2, point1, center, horizontalScale, verticalScale);
            }
        }
예제 #30
0
        protected void GetBrushOffsetEndpoints(out Point startPoint, out Point endPoint, double startOffset, double endOffset, Matrix matrix)
        {
            this.GetBrushEndpoints(out startPoint, out endPoint);
            Matrix matrix1 = this.GetCompleteBrushTransformMatrix(true) * matrix;

            startPoint *= matrix1;
            endPoint   *= matrix1;
            Vector vector = startPoint - endPoint;

            if (Tolerances.NearZero(vector.LengthSquared))
            {
                vector = new Vector(1.0, 0.0);
            }
            else
            {
                vector.Normalize();
            }
            startPoint += startOffset * vector;
            endPoint   -= endOffset * vector;
        }